package toml

import (

	"encoding"

	"errors"

	"fmt"

	"io"

	"io/ioutil"

	"math"

	"reflect"

	"strings"

	"sync/atomic"

	"time"

	"github.com/pelletier/go-toml/v2/internal/ast"

	"github.com/pelletier/go-toml/v2/internal/danger"

	"github.com/pelletier/go-toml/v2/internal/tracker"

)

// Unmarshal deserializes a TOML document into a Go value.

//

// It is a shortcut for Decoder.Decode() with the default options.

func Unmarshal(data []byte, v interface{}) error {

	p := parser{}

	p.Reset(data)

	d := decoder{p: &p}

	return d.FromParser(v)

}

// Decoder reads and decode a TOML document from an input stream.

type Decoder struct {

	// input

	r io.Reader

	// global settings

	strict bool

}

// NewDecoder creates a new Decoder that will read from r.

func NewDecoder(r io.Reader) *Decoder {

	return &Decoder{r: r}

}

// DisallowUnknownFields causes the Decoder to return an error when the

// destination is a struct and the input contains a key that does not match a

// non-ignored field.

//

// In that case, the Decoder returns a StrictMissingError that can be used to

// retrieve the individual errors as well as generate a human readable

// description of the missing fields.

func (d *Decoder) DisallowUnknownFields() *Decoder {

	d.strict = true

	return d

}

// Decode the whole content of r into v.

//

// By default, values in the document that don't exist in the target Go value

// are ignored. See Decoder.DisallowUnknownFields() to change this behavior.

//

// When a TOML local date, time, or date-time is decoded into a time.Time, its

// value is represented in time.Local timezone. Otherwise the approriate Local*

// structure is used. For time values, precision up to the nanosecond is

// supported by truncating extra digits.

//

// Empty tables decoded in an interface{} create an empty initialized

// map[string]interface{}.

//

// Types implementing the encoding.TextUnmarshaler interface are decoded from a

// TOML string.

//

// When decoding a number, go-toml will return an error if the number is out of

// bounds for the target type (which includes negative numbers when decoding

// into an unsigned int).

//

// If an error occurs while decoding the content of the document, this function

// returns a toml.DecodeError, providing context about the issue. When using

// strict mode and a field is missing, a `toml.StrictMissingError` is

// returned. In any other case, this function returns a standard Go error.

//

// # Type mapping

//

// List of supported TOML types and their associated accepted Go types:

//

//	String           -> string

//	Integer          -> uint*, int*, depending on size

//	Float            -> float*, depending on size

//	Boolean          -> bool

//	Offset Date-Time -> time.Time

//	Local Date-time  -> LocalDateTime, time.Time

//	Local Date       -> LocalDate, time.Time

//	Local Time       -> LocalTime, time.Time

//	Array            -> slice and array, depending on elements types

//	Table            -> map and struct

//	Inline Table     -> same as Table

//	Array of Tables  -> same as Array and Table

func (d *Decoder) Decode(v interface{}) error {

	b, err := ioutil.ReadAll(d.r)

	if err != nil {

		return fmt.Errorf("toml: %w", err)

	}

	p := parser{}

	p.Reset(b)

	dec := decoder{

		p: &p,

		strict: strict{

			Enabled: d.strict,

		},

	}

	return dec.FromParser(v)

}

type decoder struct {

	// Which parser instance in use for this decoding session.

	p *parser

	// Flag indicating that the current expression is stashed.

	// If set to true, calling nextExpr will not actually pull a new expression

	// but turn off the flag instead.

	stashedExpr bool

	// Skip expressions until a table is found. This is set to true when a

	// table could not be create (missing field in map), so all KV expressions

	// need to be skipped.

	skipUntilTable bool

	// Tracks position in Go arrays.

	// This is used when decoding [[array tables]] into Go arrays. Given array

	// tables are separate TOML expression, we need to keep track of where we

	// are at in the Go array, as we can't just introspect its size.

	arrayIndexes map[reflect.Value]int

	// Tracks keys that have been seen, with which type.

	seen tracker.SeenTracker

	// Strict mode

	strict strict

	// Current context for the error.

	errorContext *errorContext

}

type errorContext struct {

	Struct reflect.Type

	Field  []int

}

func (d *decoder) typeMismatchError(toml string, target reflect.Type) error {

	if d.errorContext != nil && d.errorContext.Struct != nil {

		ctx := d.errorContext

		f := ctx.Struct.FieldByIndex(ctx.Field)

		return fmt.Errorf("toml: cannot decode TOML %s into struct field %s.%s of type %s", toml, ctx.Struct, f.Name, f.Type)

	}

	return fmt.Errorf("toml: cannot decode TOML %s into a Go value of type %s", toml, target)

}

func (d *decoder) expr() *ast.Node {

	return d.p.Expression()

}

func (d *decoder) nextExpr() bool {

	if d.stashedExpr {

		d.stashedExpr = false

		return true

	}

	return d.p.NextExpression()

}

func (d *decoder) stashExpr() {

	d.stashedExpr = true

}

func (d *decoder) arrayIndex(shouldAppend bool, v reflect.Value) int {

	if d.arrayIndexes == nil {

		d.arrayIndexes = make(map[reflect.Value]int, 1)

	}

	idx, ok := d.arrayIndexes[v]

	if !ok {

		d.arrayIndexes[v] = 0

	} else if shouldAppend {

		idx++

		d.arrayIndexes[v] = idx

	}

	return idx

}

func (d *decoder) FromParser(v interface{}) error {

	r := reflect.ValueOf(v)

	if r.Kind() != reflect.Ptr {

		return fmt.Errorf("toml: decoding can only be performed into a pointer, not %s", r.Kind())

	}

	if r.IsNil() {

		return fmt.Errorf("toml: decoding pointer target cannot be nil")

	}

	r = r.Elem()

	if r.Kind() == reflect.Interface && r.IsNil() {

		newMap := map[string]interface{}{}

		r.Set(reflect.ValueOf(newMap))

	}

	err := d.fromParser(r)

	if err == nil {

		return d.strict.Error(d.p.data)

	}

	var e *decodeError

	if errors.As(err, &e) {

		return wrapDecodeError(d.p.data, e)

	}

	return err

}

func (d *decoder) fromParser(root reflect.Value) error {

	for d.nextExpr() {

		err := d.handleRootExpression(d.expr(), root)

		if err != nil {

			return err

		}

	}

	return d.p.Error()

}

/*

Rules for the unmarshal code:

- The stack is used to keep track of which values need to be set where.

- handle* functions <=> switch on a given ast.Kind.

- unmarshalX* functions need to unmarshal a node of kind X.

- An "object" is either a struct or a map.

*/

func (d *decoder) handleRootExpression(expr *ast.Node, v reflect.Value) error {

	var x reflect.Value

	var err error

	if !(d.skipUntilTable && expr.Kind == ast.KeyValue) {

		err = d.seen.CheckExpression(expr)

		if err != nil {

			return err

		}

	}

	switch expr.Kind {

	case ast.KeyValue:

		if d.skipUntilTable {

			return nil

		}

		x, err = d.handleKeyValue(expr, v)

	case ast.Table:

		d.skipUntilTable = false

		d.strict.EnterTable(expr)

		x, err = d.handleTable(expr.Key(), v)

	case ast.ArrayTable:

		d.skipUntilTable = false

		d.strict.EnterArrayTable(expr)

		x, err = d.handleArrayTable(expr.Key(), v)

	default:

		panic(fmt.Errorf("parser should not permit expression of kind %s at document root", expr.Kind))

	}

	if d.skipUntilTable {

		if expr.Kind == ast.Table || expr.Kind == ast.ArrayTable {

			d.strict.MissingTable(expr)

		}

	} else if err == nil && x.IsValid() {

		v.Set(x)

	}

	return err

}

func (d *decoder) handleArrayTable(key ast.Iterator, v reflect.Value) (reflect.Value, error) {

	if key.Next() {

		return d.handleArrayTablePart(key, v)

	}

	return d.handleKeyValues(v)

}

func (d *decoder) handleArrayTableCollectionLast(key ast.Iterator, v reflect.Value) (reflect.Value, error) {

	switch v.Kind() {

	case reflect.Interface:

		elem := v.Elem()

		if !elem.IsValid() {

			elem = reflect.New(sliceInterfaceType).Elem()

			elem.Set(reflect.MakeSlice(sliceInterfaceType, 0, 16))

		} else if elem.Kind() == reflect.Slice {

			if elem.Type() != sliceInterfaceType {

				elem = reflect.New(sliceInterfaceType).Elem()

				elem.Set(reflect.MakeSlice(sliceInterfaceType, 0, 16))

			} else if !elem.CanSet() {

				nelem := reflect.New(sliceInterfaceType).Elem()

				nelem.Set(reflect.MakeSlice(sliceInterfaceType, elem.Len(), elem.Cap()))

				reflect.Copy(nelem, elem)

				elem = nelem

			}

		}

		return d.handleArrayTableCollectionLast(key, elem)

	case reflect.Ptr:

		elem := v.Elem()

		if !elem.IsValid() {

			ptr := reflect.New(v.Type().Elem())

			v.Set(ptr)

			elem = ptr.Elem()

		}

		elem, err := d.handleArrayTableCollectionLast(key, elem)

		if err != nil {

			return reflect.Value{}, err

		}

		v.Elem().Set(elem)

		return v, nil

	case reflect.Slice:

		elemType := v.Type().Elem()

		var elem reflect.Value

		if elemType.Kind() == reflect.Interface {

			elem = makeMapStringInterface()

		} else {

			elem = reflect.New(elemType).Elem()

		}

		elem2, err := d.handleArrayTable(key, elem)

		if err != nil {

			return reflect.Value{}, err

		}

		if elem2.IsValid() {

			elem = elem2

		}

		return reflect.Append(v, elem), nil

	case reflect.Array:

		idx := d.arrayIndex(true, v)

		if idx >= v.Len() {

			return v, fmt.Errorf("toml: cannot decode array table into %s at position %d", v.Type(), idx)

		}

		elem := v.Index(idx)

		_, err := d.handleArrayTable(key, elem)

		return v, err

	default:

		return reflect.Value{}, fmt.Errorf("toml: cannot decode array table into a %s", v.Type())

	}

}

// When parsing an array table expression, each part of the key needs to be

// evaluated like a normal key, but if it returns a collection, it also needs to

// point to the last element of the collection. Unless it is the last part of

// the key, then it needs to create a new element at the end.

func (d *decoder) handleArrayTableCollection(key ast.Iterator, v reflect.Value) (reflect.Value, error) {

	if key.IsLast() {

		return d.handleArrayTableCollectionLast(key, v)

	}

	switch v.Kind() {

	case reflect.Ptr:

		elem := v.Elem()

		if !elem.IsValid() {

			ptr := reflect.New(v.Type().Elem())

			v.Set(ptr)

			elem = ptr.Elem()

		}

		elem, err := d.handleArrayTableCollection(key, elem)

		if err != nil {

			return reflect.Value{}, err

		}

		if elem.IsValid() {

			v.Elem().Set(elem)

		}

		return v, nil

	case reflect.Slice:

		elem := v.Index(v.Len() - 1)

		x, err := d.handleArrayTable(key, elem)

		if err != nil || d.skipUntilTable {

			return reflect.Value{}, err

		}

		if x.IsValid() {

			elem.Set(x)

		}

		return v, err

	case reflect.Array:

		idx := d.arrayIndex(false, v)

		if idx >= v.Len() {

			return v, fmt.Errorf("toml: cannot decode array table into %s at position %d", v.Type(), idx)

		}

		elem := v.Index(idx)

		_, err := d.handleArrayTable(key, elem)

		return v, err

	}

	return d.handleArrayTable(key, v)

}

func (d *decoder) handleKeyPart(key ast.Iterator, v reflect.Value, nextFn handlerFn, makeFn valueMakerFn) (reflect.Value, error) {

	var rv reflect.Value

	// First, dispatch over v to make sure it is a valid object.

	// There is no guarantee over what it could be.

	switch v.Kind() {

	case reflect.Ptr:

		elem := v.Elem()