package toml

import (

	"bytes"

	"errors"

	"fmt"

	"io"

	"reflect"

	"strconv"

	"strings"

	"time"

)

type tomlOpts struct {

}

type encOpts struct {

	quoteMapKeys            bool

	arraysOneElementPerLine bool

}

var encOptsDefaults = encOpts{

	quoteMapKeys: false,

}

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

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

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:

	default:

		return false

	}

}

	switch mtype.Kind() {

	default:

		return false

	}

}

	switch mtype.Kind() {

	case reflect.Ptr:

	default:

		return false

	}

}

func isTree(mtype reflect.Type) bool {

	switch mtype.Kind() {

	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()

}

// Marshaler is the interface implemented by types that

// can marshal themselves into valid TOML.

type Marshaler interface {

	MarshalTOML() ([]byte, 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

*/

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

}

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

func NewEncoder(w io.Writer) *Encoder {

	return &Encoder{

	}

}

// 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

}

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

	mtype := reflect.TypeOf(v)

	}

	sval := reflect.ValueOf(v)

	if isCustomMarshaler(mtype) {

		return callCustomMarshaler(sval)

	}

	t, err := e.valueToTree(mtype, sval)

	if err != nil {

		return []byte{}, err

	}

	var buf bytes.Buffer

	return buf.Bytes(), err

}

// Convert given marshal struct or map value to toml tree

func (e *Encoder) valueToTree(mtype reflect.Type, mval reflect.Value) (*Tree, error) {

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

		return e.valueToTree(mtype.Elem(), mval.Elem())

	}

	switch mtype.Kind() {

	case reflect.Struct:

		for i := 0; i < mtype.NumField(); i++ {

			mtypef, mvalf := mtype.Field(i), mval.Field(i)

			if opts.include && (!opts.omitempty || !isZero(mvalf)) {

				val, err := e.valueToToml(mtypef.Type, mvalf)

				if err != nil {

					return nil, err

				}

				tval.SetWithOptions(opts.name, SetOptions{

					Comment:   opts.comment,

					Commented: opts.commented,

					Multiline: opts.multiline,

				}, val)

			}

		}

	case reflect.Map:

			mvalf := mval.MapIndex(key)

			val, err := e.valueToToml(mtype.Elem(), mvalf)

			if err != nil {

				return nil, err

			}

			if e.quoteMapKeys {

				keyStr, err := tomlValueStringRepresentation(key.String(), "", e.arraysOneElementPerLine)

				if err != nil {

					return nil, err

				}

				tval.SetPath([]string{keyStr}, val)

			} else {

				tval.Set(key.String(), val)

			}

		}

	}

	return tval, nil

}

// Convert given marshal slice to slice of Toml trees

func (e *Encoder) valueToTreeSlice(mtype reflect.Type, mval reflect.Value) ([]*Tree, error) {

	tval := make([]*Tree, mval.Len(), mval.Len())

	for i := 0; i < mval.Len(); i++ {

		val, err := e.valueToTree(mtype.Elem(), mval.Index(i))

		if err != nil {

			return nil, err

		}

		tval[i] = val

	}

	return tval, nil

}

// Convert given marshal slice to slice of toml values

func (e *Encoder) valueToOtherSlice(mtype reflect.Type, mval reflect.Value) (interface{}, error) {

	tval := make([]interface{}, mval.Len(), mval.Len())

	for i := 0; i < mval.Len(); i++ {

		val, err := e.valueToToml(mtype.Elem(), mval.Index(i))

		if err != nil {

			return nil, err

		}

		tval[i] = val

	}

	return tval, nil

}

// Convert given marshal value to toml value

func (e *Encoder) valueToToml(mtype reflect.Type, mval reflect.Value) (interface{}, error) {