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

	good = d.unmarshal(n.alias, out)

	delete(d.aliases, n)

	return good

}

var zeroValue reflect.Value

func resetMap(out reflect.Value) {

	for _, k := range out.MapKeys() {

		out.SetMapIndex(k, zeroValue)

	}

}

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

	var tag string

	var resolved interface{}

	if n.tag == "" && !n.implicit {

		tag = yaml_STR_TAG

		resolved = n.value

	} else {

		tag, resolved = resolve(n.tag, n.value)

		if tag == yaml_BINARY_TAG {

			data, err := base64.StdEncoding.DecodeString(resolved.(string))

			if err != nil {

				failf("!!binary value contains invalid base64 data")

			}

			resolved = string(data)

		}

	}

	if resolved == nil {

		if out.Kind() == reflect.Map && !out.CanAddr() {

			resetMap(out)

		} else {

			out.Set(reflect.Zero(out.Type()))

		}

		return true

	}

	if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {