package toml

import (

	"bytes"

	"encoding"

	"fmt"

	"io"

	"math"

	"reflect"

	"sort"

	"strconv"

	"strings"

	"time"

	"unicode"

)

// Marshal serializes a Go value as a TOML document.

//

// It is a shortcut for Encoder.Encode() with the default options.

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

	var buf bytes.Buffer

	enc := NewEncoder(&buf)

	err := enc.Encode(v)

	if err != nil {

		return nil, err

	}

	return buf.Bytes(), nil

}

// Encoder writes a TOML document to an output stream.

type Encoder struct {

	// output

	w io.Writer

	// global settings

	tablesInline    bool

	arraysMultiline bool

	indentSymbol    string

	indentTables    bool

}

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

func NewEncoder(w io.Writer) *Encoder {

	return &Encoder{

		w:            w,

		indentSymbol: "  ",

	}

}

// SetTablesInline forces the encoder to emit all tables inline.

//

// This behavior can be controlled on an individual struct field basis with the

// inline tag:

//

//	MyField `toml:",inline"`

func (enc *Encoder) SetTablesInline(inline bool) *Encoder {

	enc.tablesInline = inline

	return enc

}

// SetArraysMultiline forces the encoder to emit all arrays with one element per

// line.

//

// This behavior can be controlled on an individual struct field basis with the multiline tag:

//

//	MyField `multiline:"true"`

func (enc *Encoder) SetArraysMultiline(multiline bool) *Encoder {

	enc.arraysMultiline = multiline

	return enc

}

// SetIndentSymbol defines the string that should be used for indentation. The

// provided string is repeated for each indentation level. Defaults to two

// spaces.

func (enc *Encoder) SetIndentSymbol(s string) *Encoder {

	enc.indentSymbol = s

	return enc

}

// SetIndentTables forces the encoder to intent tables and array tables.

func (enc *Encoder) SetIndentTables(indent bool) *Encoder {

	enc.indentTables = indent

	return enc

}

// Encode writes a TOML representation of v to the stream.

//

// If v cannot be represented to TOML it returns an error.

//

// # Encoding rules

//

// A top level slice containing only maps or structs is encoded as [[table

// array]].

//

// All slices not matching rule 1 are encoded as [array]. As a result, any map

// or struct they contain is encoded as an {inline table}.

//

// Nil interfaces and nil pointers are not supported.

//

// Keys in key-values always have one part.

//

// Intermediate tables are always printed.

//

// By default, strings are encoded as literal string, unless they contain either

// a newline character or a single quote. In that case they are emitted as

// quoted strings.

//

// Unsigned integers larger than math.MaxInt64 cannot be encoded. Doing so

// results in an error. This rule exists because the TOML specification only

// requires parsers to support at least the 64 bits integer range. Allowing

// larger numbers would create non-standard TOML documents, which may not be

// readable (at best) by other implementations. To encode such numbers, a

// solution is a custom type that implements encoding.TextMarshaler.

//

// When encoding structs, fields are encoded in order of definition, with their

// exact name.

//

// Tables and array tables are separated by empty lines. However, consecutive

// subtables definitions are not. For example:

//

//	[top1]

//

//	[top2]

//	[top2.child1]

//

//	[[array]]

//

//	[[array]]

//	[array.child2]

//

// # Struct tags

//

// The encoding of each public struct field can be customized by the format

// string in the "toml" key of the struct field's tag. This follows

// encoding/json's convention. The format string starts with the name of the

// field, optionally followed by a comma-separated list of options. The name may

// be empty in order to provide options without overriding the default name.

//

// The "multiline" option emits strings as quoted multi-line TOML strings. It

// has no effect on fields that would not be encoded as strings.

//

// The "inline" option turns fields that would be emitted as tables into inline

// tables instead. It has no effect on other fields.

//

// The "omitempty" option prevents empty values or groups from being emitted.

//

// In addition to the "toml" tag struct tag, a "comment" tag can be used to emit

// a TOML comment before the value being annotated. Comments are ignored inside

// inline tables. For array tables, the comment is only present before the first

// element of the array.

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

	var (

		b   []byte

		ctx encoderCtx

	)

	ctx.inline = enc.tablesInline

	if v == nil {

		return fmt.Errorf("toml: cannot encode a nil interface")

	}

	b, err := enc.encode(b, ctx, reflect.ValueOf(v))

	if err != nil {

		return err

	}

	_, err = enc.w.Write(b)

	if err != nil {

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

	}

	return nil

}

type valueOptions struct {

	multiline bool

	omitempty bool

	comment   string

}

type encoderCtx struct {

	// Current top-level key.

	parentKey []string

	// Key that should be used for a KV.

	key string

	// Extra flag to account for the empty string

	hasKey bool

	// Set to true to indicate that the encoder is inside a KV, so that all

	// tables need to be inlined.

	insideKv bool

	// Set to true to skip the first table header in an array table.

	skipTableHeader bool

	// Should the next table be encoded as inline

	inline bool

	// Indentation level

	indent int

	// Options coming from struct tags

	options valueOptions

}

func (ctx *encoderCtx) shiftKey() {

	if ctx.hasKey {

		ctx.parentKey = append(ctx.parentKey, ctx.key)

		ctx.clearKey()

	}

}

func (ctx *encoderCtx) setKey(k string) {

	ctx.key = k

	ctx.hasKey = true

}

func (ctx *encoderCtx) clearKey() {

	ctx.key = ""

	ctx.hasKey = false

}

func (ctx *encoderCtx) isRoot() bool {

	return len(ctx.parentKey) == 0 && !ctx.hasKey

}

func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {

	i := v.Interface()

	switch x := i.(type) {

	case time.Time:

		if x.Nanosecond() > 0 {

			return x.AppendFormat(b, time.RFC3339Nano), nil

		}

		return x.AppendFormat(b, time.RFC3339), nil

	case LocalTime:

		return append(b, x.String()...), nil

	case LocalDate:

		return append(b, x.String()...), nil

	case LocalDateTime:

		return append(b, x.String()...), nil

	}

	hasTextMarshaler := v.Type().Implements(textMarshalerType)

	if hasTextMarshaler || (v.CanAddr() && reflect.PtrTo(v.Type()).Implements(textMarshalerType)) {

		if !hasTextMarshaler {

			v = v.Addr()

		}

		if ctx.isRoot() {

			return nil, fmt.Errorf("toml: type %s implementing the TextMarshaler interface cannot be a root element", v.Type())

		}

		text, err := v.Interface().(encoding.TextMarshaler).MarshalText()

		if err != nil {

			return nil, err

		}

		b = enc.encodeString(b, string(text), ctx.options)

		return b, nil

	}

	switch v.Kind() {

	// containers

	case reflect.Map:

		return enc.encodeMap(b, ctx, v)

	case reflect.Struct:

		return enc.encodeStruct(b, ctx, v)

	case reflect.Slice:

		return enc.encodeSlice(b, ctx, v)

	case reflect.Interface:

		if v.IsNil() {

			return nil, fmt.Errorf("toml: encoding a nil interface is not supported")

		}

		return enc.encode(b, ctx, v.Elem())

	case reflect.Ptr:

		if v.IsNil() {

			return enc.encode(b, ctx, reflect.Zero(v.Type().Elem()))

		}

		return enc.encode(b, ctx, v.Elem())

	// values

	case reflect.String:

		b = enc.encodeString(b, v.String(), ctx.options)

	case reflect.Float32:

		f := v.Float()

		if math.IsNaN(f) {

			b = append(b, "nan"...)

		} else if f > math.MaxFloat32 {

			b = append(b, "inf"...)

		} else if f < -math.MaxFloat32 {

			b = append(b, "-inf"...)

		} else if math.Trunc(f) == f {

			b = strconv.AppendFloat(b, f, 'f', 1, 32)

		} else {

			b = strconv.AppendFloat(b, f, 'f', -1, 32)

		}

	case reflect.Float64:

		f := v.Float()

		if math.IsNaN(f) {

			b = append(b, "nan"...)

		} else if f > math.MaxFloat64 {

			b = append(b, "inf"...)

		} else if f < -math.MaxFloat64 {

			b = append(b, "-inf"...)

		} else if math.Trunc(f) == f {

			b = strconv.AppendFloat(b, f, 'f', 1, 64)

		} else {

			b = strconv.AppendFloat(b, f, 'f', -1, 64)

		}

	case reflect.Bool:

		if v.Bool() {

			b = append(b, "true"...)

		} else {

			b = append(b, "false"...)

		}

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

		x := v.Uint()

		if x > uint64(math.MaxInt64) {

			return nil, fmt.Errorf("toml: not encoding uint (%d) greater than max int64 (%d)", x, int64(math.MaxInt64))

		}

		b = strconv.AppendUint(b, x, 10)

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

		b = strconv.AppendInt(b, v.Int(), 10)

	default:

		return nil, fmt.Errorf("toml: cannot encode value of type %s", v.Kind())

	}

	return b, nil

}

func isNil(v reflect.Value) bool {

	switch v.Kind() {

	case reflect.Ptr, reflect.Interface, reflect.Map:

		return v.IsNil()

	default:

		return false

	}

}

func shouldOmitEmpty(options valueOptions, v reflect.Value) bool {

	return options.omitempty && isEmptyValue(v)

}

func (enc *Encoder) encodeKv(b []byte, ctx encoderCtx, options valueOptions, v reflect.Value) ([]byte, error) {

	var err error

	if !ctx.inline {

		b = enc.encodeComment(ctx.indent, options.comment, b)

	}

	b = enc.indent(ctx.indent, b)

	b = enc.encodeKey(b, ctx.key)

	b = append(b, " = "...)

	// create a copy of the context because the value of a KV shouldn't

	// modify the global context.

	subctx := ctx

	subctx.insideKv = true

	subctx.shiftKey()

	subctx.options = options

	b, err = enc.encode(b, subctx, v)

	if err != nil {

		return nil, err

	}

	return b, nil

}

func isEmptyValue(v reflect.Value) bool {

	switch v.Kind() {

	case reflect.Struct:

		return isEmptyStruct(v)

	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:

		return v.Len() == 0

	case reflect.Bool:

		return !v.Bool()

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

		return v.Int() == 0

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

		return v.Uint() == 0

	case reflect.Float32, reflect.Float64:

		return v.Float() == 0

	case reflect.Interface, reflect.Ptr:

		return v.IsNil()

	}

	return false

}

func isEmptyStruct(v reflect.Value) bool {

	// TODO: merge with walkStruct and cache.

	typ := v.Type()

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

		fieldType := typ.Field(i)

		// only consider exported fields

		if fieldType.PkgPath != "" {

			continue

		}

		tag := fieldType.Tag.Get("toml")

		// special field name to skip field