package javaproperties

import (
	"bytes"
	"sort"
	"strings"

	"github.com/magiconair/properties"
	"github.com/spf13/cast"
)

// Codec implements the encoding.Encoder and encoding.Decoder interfaces for Java properties encoding.
type Codec struct {
	KeyDelimiter string

	// Store read properties on the object so that we can write back in order with comments.
	// This will only be used if the configuration read is a properties file.
	// TODO: drop this feature in v2
	// TODO: make use of the global properties object optional
	Properties *properties.Properties
}

func (c *Codec) Encode(v map[string]interface{}) ([]byte, error) {
	if c.Properties == nil {
		c.Properties = properties.NewProperties()
	}

	flattened := map[string]interface{}{}

	flattened = flattenAndMergeMap(flattened, v, "", c.keyDelimiter())

	keys := make([]string, 0, len(flattened))

	for key := range flattened {
		keys = append(keys, key)
	}

	sort.Strings(keys)

	for _, key := range keys {
		_, _, err := c.Properties.Set(key, cast.ToString(flattened[key]))
		if err != nil {
			return nil, err
		}
	}

	var buf bytes.Buffer

	_, err := c.Properties.WriteComment(&buf, "#", properties.UTF8)
	if err != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

func (c *Codec) Decode(b []byte, v map[string]interface{}) error {
	var err error
	c.Properties, err = properties.Load(b, properties.UTF8)
	if err != nil {
		return err
	}

	for _, key := range c.Properties.Keys() {
		// ignore existence check: we know it's there
		value, _ := c.Properties.Get(key)

		// recursively build nested maps
		path := strings.Split(key, c.keyDelimiter())
		lastKey := strings.ToLower(path[len(path)-1])
		deepestMap := deepSearch(v, path[0:len(path)-1])

		// set innermost value
		deepestMap[lastKey] = value
	}

	return nil
}

func (c Codec) keyDelimiter() string {
	if c.KeyDelimiter == "" {
		return "."
	}

	return c.KeyDelimiter
}