package jpath

import (
	"fmt"
  "math"
	"strconv"
)

type parser struct {
	flow          chan token
	tokensBuffer  []token
  path          []PathFn
}

type parserStateFn func(*parser) parserStateFn

// Formats and panics an error message based on a token
func (p *parser) raiseError(tok *token, msg string, args ...interface{}) {
	panic(tok.Position.String() + ": " + fmt.Sprintf(msg, args...))
}

func (p *parser) run() {
	for state := parseStart; state != nil; {
		state = state(p)
	}
}

func (p *parser) backup(tok *token) {
	p.tokensBuffer = append(p.tokensBuffer, *tok)
}

func (p *parser) peek() *token {
	if len(p.tokensBuffer) != 0 {
		return &(p.tokensBuffer[0])
	}

	tok, ok := <-p.flow
	if !ok {
		return nil
	}
  p.backup(&tok)
	return &tok
}

func (p *parser) getToken() *token {
	if len(p.tokensBuffer) != 0 {
		tok := p.tokensBuffer[0]
		p.tokensBuffer = p.tokensBuffer[1:]
		return &tok
	}
	tok, ok := <-p.flow
	if !ok {
		return nil
	}
	return &tok
}


func (p *parser) appendPath(fn PathFn) {
  p.path = append(p.path, fn)
}

func parseStart(p *parser) parserStateFn {
	tok := p.getToken()

	if tok == nil || tok.typ == tokenEOF {
		return nil
	}

  if tok.typ != tokenDollar {
    p.raiseError(tok, "Expected '$' at start of expression")
  }

  return parseMatchExpr
}

func parseMatchExpr(p *parser) parserStateFn {
	tok := p.getToken()
	switch tok.typ {
	case tokenDot:
    p.appendPath(matchKeyFn(tok.val))
    return parseMatchExpr
  case tokenDotDot:
    p.appendPath(matchRecurseFn())
		return parseSimpleMatchExpr
	case tokenLBracket:
		return parseBracketExpr
  case tokenStar:
    p.appendPath(matchAnyFn())
    return parseMatchExpr
  case tokenEOF:
    return nil  // allow EOF at this stage
	}
	p.raiseError(tok, "expected match expression")
	return nil
}

func parseSimpleMatchExpr(p *parser) parserStateFn {
	tok := p.getToken()
	switch tok.typ {
	case tokenLBracket:
		return parseBracketExpr
	case tokenKey:
    p.appendPath(matchKeyFn(tok.val))
    return parseMatchExpr
  case tokenStar:
    p.appendPath(matchAnyFn())
    return parseMatchExpr
	}
	p.raiseError(tok, "expected match expression")
	return nil
}

func parseBracketExpr(p *parser) parserStateFn {
  tok := p.peek()
  switch tok.typ {
  case tokenInteger:
    // look ahead for a ':'
    p.getToken()
    next := p.peek()
    p.backup(tok)
    if next.typ == tokenColon {
      return parseSliceExpr
    }
    return parseUnionExpr
  case tokenColon:
    return parseSliceExpr
	}
	return parseUnionExpr
}

func parseUnionExpr(p *parser) parserStateFn {
  union := []PathFn{}
  for {
    // parse sub expression
    tok := p.getToken()
    switch tok.typ {
    case tokenInteger:
      idx, _ := strconv.Atoi(tok.val)
      union = append(union, matchIndexFn(idx))
    case tokenKey:
      union = append(union, matchKeyFn(tok.val))
    case tokenQuestion:
      return parseFilterExpr
    case tokenLParen:
      return parseScriptExpr
    default:
      p.raiseError(tok, "expected union sub expression")
    }
    // parse delimiter or terminator
    tok = p.getToken()
    switch tok.typ {
    case tokenComma:
      continue
    case tokenRBracket:
      break
    default:
      p.raiseError(tok, "expected ',' or ']'")
    }
  }
  p.appendPath(matchUnionFn(union))
  return parseMatchExpr
}

func parseSliceExpr(p *parser) parserStateFn {
  // init slice to grab all elements
  start, end, step := 0, math.MaxInt64, 1

  // parse optional start
  tok := p.getToken()
  if tok.typ == tokenInteger {
    start, _ = strconv.Atoi(tok.val)
    tok = p.getToken()
  }
  if tok.typ != tokenColon {
    p.raiseError(tok, "expected ':'")
  }

  // parse optional end
  tok = p.getToken()
  if tok.typ == tokenInteger {
    end, _ = strconv.Atoi(tok.val)
    tok = p.getToken()
  }
  if tok.typ != tokenColon || tok.typ != tokenRBracket {
    p.raiseError(tok, "expected ']' or ':'")
  }

  // parse optional step
  tok = p.getToken()
  if tok.typ == tokenInteger {
    step, _ = strconv.Atoi(tok.val)
    if step < 0 {
      p.raiseError(tok, "step must be a positive value")
    }
    tok = p.getToken()
  }
  if tok.typ != tokenRBracket {
    p.raiseError(tok, "expected ']'")
  }

  p.appendPath(matchSliceFn(start, end, step))
  return parseMatchExpr
}

func parseFilterExpr(p *parser) parserStateFn {
	p.raiseError(p.peek(), "filter expressions are unsupported")
  return nil
}

func parseScriptExpr(p *parser) parserStateFn {
	p.raiseError(p.peek(), "script expressions are unsupported")
  return nil
}

func parse(flow chan token) []PathFn {
	result := []PathFn{}
	parser := &parser{
		flow:          flow,
		tokensBuffer:  []token{},
    path:          result,
	}
	parser.run()
	return result
}