package qcode

import (
	"errors"
	"fmt"

	"github.com/dosco/super-graph/util"
)

var (
	errEOT = errors.New("end of tokens")
)

type parserType int16

const (
	maxNested = 50

	parserError parserType = iota
	parserEOF
	opQuery
	opMutate
	opSub
	nodeStr
	nodeInt
	nodeFloat
	nodeBool
	nodeObj
	nodeList
	nodeVar
)

func (t parserType) String() string {
	var v string

	switch t {
	case parserEOF:
		v = "EOF"
	case parserError:
		v = "error"
	case opQuery:
		v = "query"
	case opMutate:
		v = "mutation"
	case opSub:
		v = "subscription"
	case nodeStr:
		v = "node-string"
	case nodeInt:
		v = "node-int"
	case nodeFloat:
		v = "node-float"
	case nodeBool:
		v = "node-bool"
	case nodeVar:
		v = "node-var"
	case nodeObj:
		v = "node-obj"
	case nodeList:
		v = "node-list"
	}
	return fmt.Sprintf("<%s>", v)
}

type Operation struct {
	Type     parserType
	Name     string
	Args     []*Arg
	Fields   []*Field
	FieldLen int16
}

type Field struct {
	ID       int16
	Name     string
	Alias    string
	Args     []*Arg
	Parent   *Field
	Children []*Field
}

type Arg struct {
	Name string
	Val  *Node
}

type Node struct {
	Type     parserType
	Name     string
	Val      string
	Parent   *Node
	Children []*Node
}

type Parser struct {
	pos   int
	items []item
	depth int
	err   error
}

func Parse(gql string) (*Operation, error) {
	if len(gql) == 0 {
		return nil, errors.New("blank query")
	}

	l, err := lex(gql)
	if err != nil {
		return nil, err
	}
	p := &Parser{
		pos:   -1,
		items: l.items,
	}
	return p.parseOp()
}

func ParseQuery(gql string) (*Operation, error) {
	return parseByType(gql, opQuery)
}

func ParseArgValue(argVal string) (*Node, error) {
	l, err := lex(argVal)
	if err != nil {
		return nil, err
	}
	p := &Parser{
		pos:   -1,
		items: l.items,
	}

	return p.parseValue()
}

func parseByType(gql string, ty parserType) (*Operation, error) {
	l, err := lex(gql)
	if err != nil {
		return nil, err
	}
	p := &Parser{
		pos:   -1,
		items: l.items,
	}
	return p.parseOpByType(ty)
}

func (p *Parser) next() item {
	n := p.pos + 1
	if n >= len(p.items) {
		p.err = errEOT
		return item{typ: itemEOF}
	}
	p.pos = n
	return p.items[p.pos]
}

func (p *Parser) ignore() {
	n := p.pos + 1
	if n >= len(p.items) {
		p.err = errEOT
		return
	}
	p.pos = n
}

func (p *Parser) current() item {
	return p.items[p.pos]
}

func (p *Parser) eof() bool {
	n := p.pos + 1
	return p.items[n].typ == itemEOF
}

func (p *Parser) peek(types ...itemType) bool {
	n := p.pos + 1
	if p.items[n].typ == itemEOF {
		return false
	}
	if n >= len(p.items) {
		return false
	}
	for i := 0; i < len(types); i++ {
		if p.items[n].typ == types[i] {
			return true
		}
	}
	return false
}

func (p *Parser) parseOpByType(ty parserType) (*Operation, error) {
	op := &Operation{Type: ty}
	var err error

	if p.peek(itemName) {
		op.Name = p.next().val
	}

	if p.peek(itemArgsOpen) {
		p.ignore()
		op.Args, err = p.parseArgs()
		if err != nil {
			return nil, err
		}
	}

	if p.peek(itemObjOpen) {
		p.ignore()
		n := int16(0)
		op.Fields, n, err = p.parseFields()
		if err != nil {
			return nil, err
		}
		op.FieldLen = n
	}

	if p.peek(itemObjClose) {
		p.ignore()
	}

	return op, nil
}

func (p *Parser) parseOp() (*Operation, error) {
	if p.peek(itemQuery, itemMutation, itemSub) == false {
		err := fmt.Errorf("expecting a query, mutation or subscription (not '%s')", p.next().val)
		return nil, err
	}

	item := p.next()

	switch item.typ {
	case itemQuery:
		return p.parseOpByType(opQuery)
	case itemMutation:
		return p.parseOpByType(opMutate)
	case itemSub:
		return p.parseOpByType(opSub)
	}

	return nil, errors.New("unknown operation type")
}

func (p *Parser) parseFields() ([]*Field, int16, error) {
	var roots []*Field
	st := util.NewStack()
	i := int16(0)

	for {
		if p.peek(itemObjClose) {
			p.ignore()
			st.Pop()

			if st.Len() == 0 {
				break
			}
			continue
		}

		if i > maxNested {
			return nil, 0, errors.New("too many fields")
		}

		if p.peek(itemName) == false {
			return nil, 0, errors.New("expecting an alias or field name")
		}

		field, err := p.parseField()
		if err != nil {
			return nil, 0, err
		}
		field.ID = i
		i++

		if st.Len() == 0 {
			roots = append(roots, field)

		} else {
			intf := st.Peek()
			parent, ok := intf.(*Field)
			if !ok || parent == nil {
				return nil, 0, fmt.Errorf("unexpected value encountered %v", intf)
			}
			field.Parent = parent
			parent.Children = append(parent.Children, field)
		}

		if p.peek(itemObjOpen) {
			p.ignore()
			st.Push(field)
		}
	}

	return roots, i, nil
}

func (p *Parser) parseField() (*Field, error) {
	var err error
	field := &Field{Name: p.next().val}

	if p.peek(itemColon) {
		p.ignore()

		if p.peek(itemName) {
			field.Alias = field.Name
			field.Name = p.next().val
		} else {
			return nil, errors.New("expecting an aliased field name")
		}
	}

	if p.peek(itemArgsOpen) {
		p.ignore()
		if field.Args, err = p.parseArgs(); err != nil {
			return nil, err
		}
	}

	return field, nil
}

func (p *Parser) parseArgs() ([]*Arg, error) {
	var args []*Arg
	var err error

	for {
		if p.peek(itemArgsClose) {
			p.ignore()
			break
		}
		if p.peek(itemName) == false {
			return nil, errors.New("expecting an argument name")
		}
		arg := &Arg{Name: p.next().val}

		if p.peek(itemColon) == false {
			return nil, errors.New("missing ':' after argument name")
		}
		p.ignore()

		arg.Val, err = p.parseValue()
		if err != nil {
			return nil, err
		}
		args = append(args, arg)
	}
	return args, nil
}

func (p *Parser) parseList() (*Node, error) {
	parent := &Node{}
	var nodes []*Node
	var ty parserType

	for {
		if p.peek(itemListClose) {
			p.ignore()
			break
		}
		node, err := p.parseValue()
		if err != nil {
			return nil, err
		}
		if ty == 0 {
			ty = node.Type
		} else {
			if ty != node.Type {
				return nil, errors.New("All values in a list must be of the same type")
			}
		}
		node.Parent = parent
		nodes = append(nodes, node)
	}
	if len(nodes) == 0 {
		return nil, errors.New("List cannot be empty")
	}

	parent.Type = nodeList
	parent.Children = nodes

	return parent, nil
}

func (p *Parser) parseObj() (*Node, error) {
	parent := &Node{}
	var nodes []*Node

	for {
		if p.peek(itemObjClose) {
			p.ignore()
			break
		}

		if p.peek(itemName) == false {
			return nil, errors.New("expecting an argument name")
		}
		nodeName := p.next().val

		if p.peek(itemColon) == false {
			return nil, errors.New("missing ':' after Field argument name")
		}
		p.ignore()

		node, err := p.parseValue()
		if err != nil {
			return nil, err
		}
		node.Name = nodeName
		node.Parent = parent
		nodes = append(nodes, node)
	}

	parent.Type = nodeObj
	parent.Children = nodes

	return parent, nil
}

func (p *Parser) parseValue() (*Node, error) {
	if p.peek(itemListOpen) {
		p.ignore()
		return p.parseList()
	}

	if p.peek(itemObjOpen) {
		p.ignore()
		return p.parseObj()
	}

	item := p.next()
	node := &Node{}

	switch item.typ {
	case itemIntVal:
		node.Type = nodeInt
	case itemFloatVal:
		node.Type = nodeFloat
	case itemStringVal:
		node.Type = nodeStr
	case itemBoolVal:
		node.Type = nodeBool
	case itemName:
		node.Type = nodeStr
	case itemVariable:
		node.Type = nodeVar
	default:
		return nil, fmt.Errorf("expecting a number, string, object, list or variable as an argument value (not %s)", p.next().val)
	}
	node.Val = item.val

	return node, nil
}