package yaml

import (

	"encoding"

	"encoding/base64"

	"fmt"

	"io"

	"math"

	"reflect"

	"strconv"

	"time"

)

const (

	documentNode = 1 << iota

	mappingNode

	sequenceNode

	scalarNode

	aliasNode

)

type node struct {

	kind         int

	line, column int

	tag          string

	// For an alias node, alias holds the resolved alias.

	alias    *node

	value    string

	implicit bool

	children []*node

	anchors  map[string]*node

}

// ----------------------------------------------------------------------------

// Parser, produces a node tree out of a libyaml event stream.

type parser struct {

	parser   yaml_parser_t

	event    yaml_event_t

	doc      *node

	doneInit bool

}

func newParser(b []byte) *parser {

	p := parser{}

	if !yaml_parser_initialize(&p.parser) {

		panic("failed to initialize YAML emitter")

	}

	if len(b) == 0 {

		b = []byte{'\n'}

	}

	yaml_parser_set_input_string(&p.parser, b)

	return &p

}

func newParserFromReader(r io.Reader) *parser {

	p := parser{}

	if !yaml_parser_initialize(&p.parser) {

		panic("failed to initialize YAML emitter")

	}

	yaml_parser_set_input_reader(&p.parser, r)

	return &p

}

func (p *parser) init() {

	if p.doneInit {

		return

	}

	p.expect(yaml_STREAM_START_EVENT)

	p.doneInit = true

}

func (p *parser) destroy() {

	if p.event.typ != yaml_NO_EVENT {

		yaml_event_delete(&p.event)

	}

	yaml_parser_delete(&p.parser)

}

// expect consumes an event from the event stream and

// checks that it's of the expected type.

func (p *parser) expect(e yaml_event_type_t) {

	if p.event.typ == yaml_NO_EVENT {

		if !yaml_parser_parse(&p.parser, &p.event) {

			p.fail()

		}

	}

	if p.event.typ == yaml_STREAM_END_EVENT {

		failf("attempted to go past the end of stream; corrupted value?")

	}

	if p.event.typ != e {

		p.parser.problem = fmt.Sprintf("expected %s event but got %s", e, p.event.typ)

		p.fail()

	}

	yaml_event_delete(&p.event)

	p.event.typ = yaml_NO_EVENT

}

// peek peeks at the next event in the event stream,

// puts the results into p.event and returns the event type.

func (p *parser) peek() yaml_event_type_t {

	if p.event.typ != yaml_NO_EVENT {

		return p.event.typ

	}

	if !yaml_parser_parse(&p.parser, &p.event) {

		p.fail()

	}

	return p.event.typ

}

func (p *parser) fail() {

	var where string

	var line int

	if p.parser.problem_mark.line != 0 {

		line = p.parser.problem_mark.line

		// Scanner errors don't iterate line before returning error

		if p.parser.error == yaml_SCANNER_ERROR {

			line++

		}

	} else if p.parser.context_mark.line != 0 {

		line = p.parser.context_mark.line

	}

	if line != 0 {

		where = "line " + strconv.Itoa(line) + ": "

	}

	var msg string

	if len(p.parser.problem) > 0 {

		msg = p.parser.problem

	} else {

		msg = "unknown problem parsing YAML content"

	}

	failf("%s%s", where, msg)

}

func (p *parser) anchor(n *node, anchor []byte) {

	if anchor != nil {

		p.doc.anchors[string(anchor)] = n

	}

}

func (p *parser) parse() *node {

	p.init()

	switch p.peek() {

	case yaml_SCALAR_EVENT:

		return p.scalar()

	case yaml_ALIAS_EVENT:

		return p.alias()

	case yaml_MAPPING_START_EVENT:

		return p.mapping()

	case yaml_SEQUENCE_START_EVENT:

		return p.sequence()

	case yaml_DOCUMENT_START_EVENT:

		return p.document()

	case yaml_STREAM_END_EVENT:

		// Happens when attempting to decode an empty buffer.

		return nil

	default:

		panic("attempted to parse unknown event: " + p.event.typ.String())

	}

}

func (p *parser) node(kind int) *node {

	return &node{

		kind:   kind,

		line:   p.event.start_mark.line,

		column: p.event.start_mark.column,

	}

}

func (p *parser) document() *node {

	n := p.node(documentNode)

	n.anchors = make(map[string]*node)

	p.doc = n

	p.expect(yaml_DOCUMENT_START_EVENT)

	n.children = append(n.children, p.parse())

	p.expect(yaml_DOCUMENT_END_EVENT)

	return n

}

func (p *parser) alias() *node {

	n := p.node(aliasNode)

	n.value = string(p.event.anchor)

	n.alias = p.doc.anchors[n.value]

	if n.alias == nil {

		failf("unknown anchor '%s' referenced", n.value)

	}

	p.expect(yaml_ALIAS_EVENT)

	return n

}

func (p *parser) scalar() *node {

	n := p.node(scalarNode)

	n.value = string(p.event.value)

	n.tag = string(p.event.tag)

	n.implicit = p.event.implicit

	p.anchor(n, p.event.anchor)

	p.expect(yaml_SCALAR_EVENT)

	return n

}

func (p *parser) sequence() *node {

	n := p.node(sequenceNode)

	p.anchor(n, p.event.anchor)

	p.expect(yaml_SEQUENCE_START_EVENT)

	for p.peek() != yaml_SEQUENCE_END_EVENT {

		n.children = append(n.children, p.parse())

	}

	p.expect(yaml_SEQUENCE_END_EVENT)

	return n

}

func (p *parser) mapping() *node {

	n := p.node(mappingNode)

	p.anchor(n, p.event.anchor)

	p.expect(yaml_MAPPING_START_EVENT)

	for p.peek() != yaml_MAPPING_END_EVENT {

		n.children = append(n.children, p.parse(), p.parse())

	}

	p.expect(yaml_MAPPING_END_EVENT)

	return n

}

// ----------------------------------------------------------------------------

// Decoder, unmarshals a node into a provided value.

type decoder struct {

	doc     *node

	aliases map[*node]bool

	mapType reflect.Type

	terrors []string

	strict  bool

}

var (

	mapItemType    = reflect.TypeOf(MapItem{})

	durationType   = reflect.TypeOf(time.Duration(0))

	defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})

	ifaceType      = defaultMapType.Elem()

	timeType       = reflect.TypeOf(time.Time{})

	ptrTimeType    = reflect.TypeOf(&time.Time{})

)

func newDecoder(strict bool) *decoder {

	d := &decoder{mapType: defaultMapType, strict: strict}

	d.aliases = make(map[*node]bool)

	return d

}

func (d *decoder) terror(n *node, tag string, out reflect.Value) {

	if n.tag != "" {

		tag = n.tag

	}

	value := n.value

	if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG {

		if len(value) > 10 {

			value = " `" + value[:7] + "...`"

		} else {

			value = " `" + value + "`"

		}

	}

	d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))

}

func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {

	terrlen := len(d.terrors)

	err := u.UnmarshalYAML(func(v interface{}) (err error) {

		defer handleErr(&err)

		d.unmarshal(n, reflect.ValueOf(v))

		if len(d.terrors) > terrlen {

			issues := d.terrors[terrlen:]

			d.terrors = d.terrors[:terrlen]

			return &TypeError{issues}

		}

		return nil

	})

	if e, ok := err.(*TypeError); ok {

		d.terrors = append(d.terrors, e.Errors...)

		return false

	}

	if err != nil {

		fail(err)

	}

	return true

}

// d.prepare initializes and dereferences pointers and calls UnmarshalYAML

// if a value is found to implement it.

// It returns the initialized and dereferenced out value, whether

// unmarshalling was already done by UnmarshalYAML, and if so whether

// its types unmarshalled appropriately.

//

// If n holds a null value, prepare returns before doing anything.

func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {

	if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "~" || n.value == "" && n.implicit) {

		return out, false, false

	}

	again := true

	for again {

		again = false

		if out.Kind() == reflect.Ptr {

			if out.IsNil() {

				out.Set(reflect.New(out.Type().Elem()))

			}

			out = out.Elem()

			again = true

		}

		if out.CanAddr() {

			if u, ok := out.Addr().Interface().(Unmarshaler); ok {

				good = d.callUnmarshaler(n, u)

				return out, true, good

			}

		}

	}

	return out, false, false

}

func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {

	switch n.kind {

	case documentNode:

		return d.document(n, out)

	case aliasNode:

		return d.alias(n, out)

	}

	out, unmarshaled, good := d.prepare(n, out)

	if unmarshaled {

		return good

	}

	switch n.kind {

	case scalarNode:

		good = d.scalar(n, out)

	case mappingNode:

		good = d.mapping(n, out)

	case sequenceNode:

		good = d.sequence(n, out)

	default:

		panic("internal error: unknown node kind: " + strconv.Itoa(n.kind))

	}

	return good

}

func (d *decoder) document(n *node, out reflect.Value) (good bool) {

	if len(n.children) == 1 {

		d.doc = n

		d.unmarshal(n.children[0], out)

		return true

	}

	return false

}

func (d *decoder) alias(n *node, out reflect.Value) (good bool) {

	if d.aliases[n] {

		// TODO this could actually be allowed in some circumstances.

		failf("anchor '%s' value contains itself", n.value)

	}

	d.aliases[n] = true