"math/big"

type valueComplexity int

const (

	valueSimple valueComplexity = iota + 1

	valueComplex

)

type sortNode struct {

	key        string

	complexity valueComplexity

}

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

			}

		}

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

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

	case LocalDate:

		return value.String(), nil

	case LocalDateTime:

		return value.String(), nil

	case LocalTime:

		return value.String(), nil

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

	// get lowest line number that is not 0

	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)

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

			compVals = append(compVals, node.key)

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

	return t.writeToOrdered(w, indent, keyspace, bytesCount, arraysOneElementPerLine, OrderAlphabetical)

}

func (t *Tree) writeToOrdered(w io.Writer, indent, keyspace string, bytesCount int64, arraysOneElementPerLine bool, ord marshalOrder) (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]

			combinedKey := k

			if keyspace != "" {

				combinedKey = keyspace + "." + combinedKey

			var commented string

			if t.commented {

				commented = "# "

			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

				}

				bytesCount, err = node.writeToOrdered(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine, ord)

				if err != nil {

					return bytesCount, err

				}

			case []*Tree:

				for _, subTree := range node {

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

					bytesCount += int64(writtenBytesCount)

					if err != nil {

						return bytesCount, err

					}

					bytesCount, err = subTree.writeToOrdered(w, indent+"  ", combinedKey, bytesCount, arraysOneElementPerLine, ord)

					if err != nil {

						return bytesCount, err

					}

				}

			}

		default: // Simple

			k := node.key

			v, ok := t.values[k].(*tomlValue)

			repr, err := tomlValueStringRepresentation(v, indent, arraysOneElementPerLine)

			if err != nil {

				return bytesCount, err

			}

			if v.comment != "" {

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

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

			var commented string

			if v.commented {

				commented = "# "

			}

			quotedKey := quoteKeyIfNeeded(k)

			writtenBytesCount, err := writeStrings(w, indent, commented, quotedKey, " = ", repr, "\n")

// quote a key if it does not fit the bare key format (A-Za-z0-9_-)

// quoted keys use the same rules as strings

func quoteKeyIfNeeded(k string) string {

	// when encoding a map with the 'quoteMapKeys' option enabled, the tree will contain