package toml

import (

	"bytes"

	"encoding"

	"errors"

	"fmt"

	"io"

	"reflect"

	"sort"

	"strconv"

	"strings"

	"time"

)

const (

	tagFieldName    = "toml"

	tagFieldComment = "comment"

	tagCommented    = "commented"

	tagMultiline    = "multiline"

	tagLiteral      = "literal"

	tagDefault      = "default"

)

type tomlOpts struct {

	name         string

	nameFromTag  bool

	comment      string

	commented    bool

	multiline    bool

	literal      bool

	include      bool

	omitempty    bool

	defaultValue string

}

type encOpts struct {

	quoteMapKeys            bool

	arraysOneElementPerLine bool

}

var encOptsDefaults = encOpts{

	quoteMapKeys: false,

}

type annotation struct {

	tag          string

	comment      string

	commented    string

	multiline    string

	literal      string

	defaultValue string

}

var annotationDefault = annotation{

	tag:          tagFieldName,

	comment:      tagFieldComment,

	commented:    tagCommented,

	multiline:    tagMultiline,

	literal:      tagLiteral,

	defaultValue: tagDefault,

}

type MarshalOrder int

// Orders the Encoder can write the fields to the output stream.

const (

	// Sort fields alphabetically.

	OrderAlphabetical MarshalOrder = iota + 1

	// Preserve the order the fields are encountered. For example, the order of fields in

	// a struct.

	OrderPreserve

)

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

var marshalerType = reflect.TypeOf(new(Marshaler)).Elem()

var unmarshalerType = reflect.TypeOf(new(Unmarshaler)).Elem()

var textMarshalerType = reflect.TypeOf(new(encoding.TextMarshaler)).Elem()

var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()

var localDateType = reflect.TypeOf(LocalDate{})

var localTimeType = reflect.TypeOf(LocalTime{})

var localDateTimeType = reflect.TypeOf(LocalDateTime{})

var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})

// Check if the given marshal type maps to a Tree primitive

func isPrimitive(mtype reflect.Type) bool {

	switch mtype.Kind() {

	case reflect.Ptr:

		return isPrimitive(mtype.Elem())

	case reflect.Bool:

		return true

	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

		return true

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:

		return true

	case reflect.Float32, reflect.Float64:

		return true

	case reflect.String:

		return true

	case reflect.Struct:

		return isTimeType(mtype)

	default:

		return false

	}

}

func isTimeType(mtype reflect.Type) bool {

	return mtype == timeType || mtype == localDateType || mtype == localDateTimeType || mtype == localTimeType

}

// Check if the given marshal type maps to a Tree slice or array

func isTreeSequence(mtype reflect.Type) bool {

	switch mtype.Kind() {

	case reflect.Ptr:

		return isTreeSequence(mtype.Elem())

	case reflect.Slice, reflect.Array:

		return isTree(mtype.Elem())

	default:

		return false

	}

}

// Check if the given marshal type maps to a slice or array of a custom marshaler type

func isCustomMarshalerSequence(mtype reflect.Type) bool {

	switch mtype.Kind() {

	case reflect.Ptr:

		return isCustomMarshalerSequence(mtype.Elem())

	case reflect.Slice, reflect.Array:

		return isCustomMarshaler(mtype.Elem()) || isCustomMarshaler(reflect.New(mtype.Elem()).Type())

	default:

		return false

	}

}

// Check if the given marshal type maps to a slice or array of a text marshaler type

func isTextMarshalerSequence(mtype reflect.Type) bool {

	switch mtype.Kind() {

	case reflect.Ptr:

		return isTextMarshalerSequence(mtype.Elem())

	case reflect.Slice, reflect.Array:

		return isTextMarshaler(mtype.Elem()) || isTextMarshaler(reflect.New(mtype.Elem()).Type())

	default:

		return false

	}

}

// Check if the given marshal type maps to a non-Tree slice or array

func isOtherSequence(mtype reflect.Type) bool {

	switch mtype.Kind() {

	case reflect.Ptr:

		return isOtherSequence(mtype.Elem())

	case reflect.Slice, reflect.Array:

		return !isTreeSequence(mtype)

	default:

		return false

	}

}

// Check if the given marshal type maps to a Tree

func isTree(mtype reflect.Type) bool {

	switch mtype.Kind() {

	case reflect.Ptr:

		return isTree(mtype.Elem())

	case reflect.Map:

		return true

	case reflect.Struct:

		return !isPrimitive(mtype)

	default:

		return false

	}

}

func isCustomMarshaler(mtype reflect.Type) bool {

	return mtype.Implements(marshalerType)

}

func callCustomMarshaler(mval reflect.Value) ([]byte, error) {

	return mval.Interface().(Marshaler).MarshalTOML()

}

func isTextMarshaler(mtype reflect.Type) bool {

	return mtype.Implements(textMarshalerType) && !isTimeType(mtype)

}

func callTextMarshaler(mval reflect.Value) ([]byte, error) {

	return mval.Interface().(encoding.TextMarshaler).MarshalText()

}

func isCustomUnmarshaler(mtype reflect.Type) bool {

	return mtype.Implements(unmarshalerType)

}

func callCustomUnmarshaler(mval reflect.Value, tval interface{}) error {

	return mval.Interface().(Unmarshaler).UnmarshalTOML(tval)

}

func isTextUnmarshaler(mtype reflect.Type) bool {

	return mtype.Implements(textUnmarshalerType)

}

func callTextUnmarshaler(mval reflect.Value, text []byte) error {

	return mval.Interface().(encoding.TextUnmarshaler).UnmarshalText(text)

}

// Marshaler is the interface implemented by types that

// can marshal themselves into valid TOML.

type Marshaler interface {

	MarshalTOML() ([]byte, error)

}

// Unmarshaler is the interface implemented by types that

// can unmarshal a TOML description of themselves.

type Unmarshaler interface {

	UnmarshalTOML(interface{}) error

}

/*

Marshal returns the TOML encoding of v.  Behavior is similar to the Go json

encoder, except that there is no concept of a Marshaler interface or MarshalTOML

function for sub-structs, and currently only definite types can be marshaled

(i.e. no `interface{}`).

The following struct annotations are supported:

  toml:"Field"      Overrides the field's name to output.

  omitempty         When set, empty values and groups are not emitted.

  comment:"comment" Emits a # comment on the same line. This supports new lines.

  commented:"true"  Emits the value as commented.

Note that pointers are automatically assigned the "omitempty" option, as TOML

explicitly does not handle null values (saying instead the label should be

dropped).

Tree structural types and corresponding marshal types:

  *Tree                            (*)struct, (*)map[string]interface{}

  []*Tree                          (*)[](*)struct, (*)[](*)map[string]interface{}

  []interface{} (as interface{})   (*)[]primitive, (*)[]([]interface{})

  interface{}                      (*)primitive

Tree primitive types and corresponding marshal types:

  uint64     uint, uint8-uint64, pointers to same

  int64      int, int8-uint64, pointers to same

  float64    float32, float64, pointers to same

  string     string, pointers to same

  bool       bool, pointers to same

  time.LocalTime  time.LocalTime{}, pointers to same

For additional flexibility, use the Encoder API.

*/

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

	return NewEncoder(nil).marshal(v)

}

// Encoder writes TOML values to an output stream.

type Encoder struct {

	w io.Writer

	encOpts

	annotation

	line            int

	col             int

	order           MarshalOrder

	promoteAnon     bool

	compactComments bool

	indentation     string

}

// NewEncoder returns a new encoder that writes to w.

func NewEncoder(w io.Writer) *Encoder {

	return &Encoder{

		w:           w,

		encOpts:     encOptsDefaults,

		annotation:  annotationDefault,

		line:        0,

		col:         1,

		order:       OrderAlphabetical,

		indentation: "  ",

	}

}

// Encode writes the TOML encoding of v to the stream.

//

// See the documentation for Marshal for details.

func (e *Encoder) Encode(v interface{}) error {

	b, err := e.marshal(v)

	if err != nil {

		return err

	}

	if _, err := e.w.Write(b); err != nil {

		return err

	}

	return nil

}

// QuoteMapKeys sets up the encoder to encode

// maps with string type keys with quoted TOML keys.

//

// This relieves the character limitations on map keys.

func (e *Encoder) QuoteMapKeys(v bool) *Encoder {

	e.quoteMapKeys = v

	return e

}

// ArraysWithOneElementPerLine sets up the encoder to encode arrays

// with more than one element on multiple lines instead of one.

//

// For example:

//

//   A = [1,2,3]

//

// Becomes

//

//   A = [

//     1,

//     2,

//     3,

//   ]

func (e *Encoder) ArraysWithOneElementPerLine(v bool) *Encoder {

	e.arraysOneElementPerLine = v

	return e

}

// Order allows to change in which order fields will be written to the output stream.

func (e *Encoder) Order(ord MarshalOrder) *Encoder {

	e.order = ord

	return e

}

// Indentation allows to change indentation when marshalling.

func (e *Encoder) Indentation(indent string) *Encoder {

	e.indentation = indent

	return e

}

// SetTagName allows changing default tag "toml"

func (e *Encoder) SetTagName(v string) *Encoder {

	e.tag = v

	return e

}

// SetTagComment allows changing default tag "comment"

func (e *Encoder) SetTagComment(v string) *Encoder {

	e.comment = v

	return e

}

// SetTagCommented allows changing default tag "commented"

func (e *Encoder) SetTagCommented(v string) *Encoder {

	e.commented = v

	return e

}

// SetTagMultiline allows changing default tag "multiline"

func (e *Encoder) SetTagMultiline(v string) *Encoder {

	e.multiline = v

	return e

}

// PromoteAnonymous allows to change how anonymous struct fields are marshaled.

// Usually, they are marshaled as if the inner exported fields were fields in

// the outer struct. However, if an anonymous struct field is given a name in

// its TOML tag, it is treated like a regular struct field with that name.

// rather than being anonymous.

//

// In case anonymous promotion is enabled, all anonymous structs are promoted

// and treated like regular struct fields.

func (e *Encoder) PromoteAnonymous(promote bool) *Encoder {

	e.promoteAnon = promote

	return e

}

// CompactComments removes the new line before each comment in the tree.

func (e *Encoder) CompactComments(cc bool) *Encoder {

	e.compactComments = cc

	return e

}

func (e *Encoder) marshal(v interface{}) ([]byte, error) {

	// Check if indentation is valid

	for _, char := range e.indentation {

		if !isSpace(char) {

			return []byte{}, fmt.Errorf("invalid indentation: must only contains space or tab characters")

		}

	}

	mtype := reflect.TypeOf(v)

	if mtype == nil {

		return []byte{}, errors.New("nil cannot be marshaled to TOML")

	}

	switch mtype.Kind() {

	case reflect.Struct, reflect.Map:

	case reflect.Ptr:

		if mtype.Elem().Kind() != reflect.Struct {

			return []byte{}, errors.New("Only pointer to struct can be marshaled to TOML")

		}

		if reflect.ValueOf(v).IsNil() {

			return []byte{}, errors.New("nil pointer cannot be marshaled to TOML")

		}

	default:

		return []byte{}, errors.New("Only a struct or map can be marshaled to TOML")

	}

	sval := reflect.ValueOf(v)

	if isCustomMarshaler(mtype) {

		return callCustomMarshaler(sval)

	}

	if isTextMarshaler(mtype) {

		return callTextMarshaler(sval)