package toml

import (

	"bytes"

	"fmt"

	"io"

	"math"

	"math/big"

	"reflect"

	"sort"

	"strconv"

	"strings"

	"time"

)

type valueComplexity int

const (

	valueSimple valueComplexity = iota + 1

	valueComplex

)

type sortNode struct {

	key        string

	complexity valueComplexity

}

// Encodes a string to a TOML-compliant multi-line string value

// This function is a clone of the existing encodeTomlString function, except that whitespace characters

// are preserved. Quotation marks and backslashes are also not escaped.

	var b bytes.Buffer

		switch rr {

		case '\b':

			b.WriteString(`\b`)

		case '\t':

			b.WriteString("\t")

		case '\n':

		case '\f':

			b.WriteString(`\f`)

		case '\r':

			b.WriteString("\r")

		case '"':

		case '\\':

			b.WriteString(`\`)

		default:

			intRr := uint16(rr)

			if intRr < 0x001F {

				b.WriteString(fmt.Sprintf("\\u%0.4X", intRr))

			} else {

				b.WriteRune(rr)

			}

		}

	}

	return b.String()

}

// Encodes a string to a TOML-compliant string value

func encodeTomlString(value string) string {

	var b bytes.Buffer

	for _, rr := range value {

		switch rr {

		case '\b':

			b.WriteString(`\b`)

		case '\t':

			b.WriteString(`\t`)

		case '\n':

			b.WriteString(`\n`)

		case '\f':

			b.WriteString(`\f`)

		case '\r':

			b.WriteString(`\r`)

		case '"':

			b.WriteString(`\"`)

		case '\\':

			b.WriteString(`\\`)

		default:

			intRr := uint16(rr)

			if intRr < 0x001F {

				b.WriteString(fmt.Sprintf("\\u%0.4X", intRr))

			} else {

				b.WriteRune(rr)

			}

		}

	}

	return b.String()

}

	// this interface check is added to dereference the change made in the writeTo function.

	// That change was made to allow this function to see formatting options.

	tv, ok := v.(*tomlValue)

	if ok {

		v = tv.value

	} else {

		tv = &tomlValue{}

	}

	switch value := v.(type) {

	case uint64:

		return strconv.FormatUint(value, 10), nil

	case int64:

		return strconv.FormatInt(value, 10), nil

	case float64:

		// Default bit length is full 64

		bits := 64

		// Float panics if nan is used

		if !math.IsNaN(value) {

			// if 32 bit accuracy is enough to exactly show, use 32

			_, acc := big.NewFloat(value).Float32()

			if acc == big.Exact {

				bits = 32

			}

		}

		if math.Trunc(value) == value {

			return strings.ToLower(strconv.FormatFloat(value, 'f', 1, bits)), nil

		}

		return strings.ToLower(strconv.FormatFloat(value, 'f', -1, bits)), nil

	case string:

		if tv.multiline {

		}

		return "\"" + encodeTomlString(value) + "\"", nil

	case []byte:

		b, _ := v.([]byte)

	case bool:

		if value {

			return "true", nil

		}

		return "false", nil

	case time.Time:

		return value.Format(time.RFC3339), nil

	case LocalDate:

		return value.String(), nil

	case LocalDateTime:

		return value.String(), nil

	case LocalTime:

		return value.String(), nil

	case nil:

		return "", nil

	}

	rv := reflect.ValueOf(v)

	if rv.Kind() == reflect.Slice {

		var values []string

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

			item := rv.Index(i).Interface()

			if err != nil {

				return "", err

			}

			values = append(values, itemRepr)

		}

		if arraysOneElementPerLine && len(values) > 1 {

			stringBuffer := bytes.Buffer{}

			valueIndent := indent + `  ` // TODO: move that to a shared encoder state

			stringBuffer.WriteString("[\n")

			for _, value := range values {

				stringBuffer.WriteString(valueIndent)

				stringBuffer.WriteString(`,`)

				stringBuffer.WriteString("\n")

			}

			return stringBuffer.String(), nil

		}

	}

	return "", fmt.Errorf("unsupported value type %T: %v", v, v)

}

func getTreeArrayLine(trees []*Tree) (line int) {

	for _, tv := range trees {

		if tv.position.Line < line || line == 0 {

			line = tv.position.Line

		}

	}

	return

}

func sortByLines(t *Tree) (vals []sortNode) {

	var (

		line  int

		lines []int

		tv    *Tree

		tom   *tomlValue

		node  sortNode

	)

	vals = make([]sortNode, 0)

	m := make(map[int]sortNode)

	for k := range t.values {

		v := t.values[k]

		switch v.(type) {

		case *Tree:

			tv = v.(*Tree)

			line = tv.position.Line

			node = sortNode{key: k, complexity: valueComplex}

		case []*Tree:

			line = getTreeArrayLine(v.([]*Tree))

			node = sortNode{key: k, complexity: valueComplex}

		default:

			tom = v.(*tomlValue)

			line = tom.position.Line

			node = sortNode{key: k, complexity: valueSimple}

		}

		lines = append(lines, line)

		vals = append(vals, node)

		m[line] = node

	}

	sort.Ints(lines)

	for i, line := range lines {

		vals[i] = m[line]

	}

	return vals

}

func sortAlphabetical(t *Tree) (vals []sortNode) {

	var (

		node     sortNode

		simpVals []string

		compVals []string

	)

	vals = make([]sortNode, 0)

	m := make(map[string]sortNode)

	for k := range t.values {

		v := t.values[k]

		switch v.(type) {

		case *Tree, []*Tree:

			node = sortNode{key: k, complexity: valueComplex}

			compVals = append(compVals, node.key)

		default:

			node = sortNode{key: k, complexity: valueSimple}

			simpVals = append(simpVals, node.key)

		}

		vals = append(vals, node)

		m[node.key] = node

	}

	// Simples first to match previous implementation

	sort.Strings(simpVals)

	i := 0

	for _, key := range simpVals {

		vals[i] = m[key]

		i++

	}

	sort.Strings(compVals)

	for _, key := range compVals {

		vals[i] = m[key]

		i++

	}

	return vals

}

func (t *Tree) writeTo(w io.Writer, indent, keyspace string, bytesCount int64, arraysOneElementPerLine bool) (int64, error) {

}

	var orderedVals []sortNode

	switch ord {

	case OrderPreserve:

		orderedVals = sortByLines(t)

	default:

		orderedVals = sortAlphabetical(t)

	}

	for _, node := range orderedVals {

		switch node.complexity {

		case valueComplex:

			k := node.key

			v := t.values[k]

			if keyspace != "" {

				combinedKey = keyspace + "." + combinedKey

			}

			switch node := v.(type) {

			// node has to be of those two types given how keys are sorted above

			case *Tree:

				tv, ok := t.values[k].(*Tree)

				if !ok {

					return bytesCount, fmt.Errorf("invalid value type at %s: %T", k, t.values[k])

				}

				if tv.comment != "" {

					comment := strings.Replace(tv.comment, "\n", "\n"+indent+"#", -1)

					start := "# "

					if strings.HasPrefix(comment, "#") {

						start = ""

					}

					writtenBytesCountComment, errc := writeStrings(w, "\n", indent, start, comment)

					bytesCount += int64(writtenBytesCountComment)

					if errc != nil {

						return bytesCount, errc

					}

				}

				writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[", combinedKey, "]\n")

				bytesCount += int64(writtenBytesCount)

				if err != nil {

					return bytesCount, err

				}

				if err != nil {

					return bytesCount, err

				}

			case []*Tree:

				for _, subTree := range node {

					writtenBytesCount, err := writeStrings(w, "\n", indent, commented, "[[", combinedKey, "]]\n")