//go:generate genny -in=ordered_map_template.go -pkg=types -out=../types/gen_ordered_map.go gen "OrderedMapKey=string OrderedMapVal=FieldFragment"
//go:generate genny -in=ordered_map_template.go -pkg=parse -out=../parse/gen_ordered_map.go gen "OrderedMapKey=string OrderedMapVal=fieldFragment"

package utils

import (
	"errors"

	"github.com/cheekybits/genny/generic"
	"gopkg.in/yaml.v2"
)

// OrderedMapKey ...
type OrderedMapKey generic.Type

// OrderedMapVal ...
type OrderedMapVal struct{ generic.Type }

// OrderedMapValOrderedMapEntity key value pair
type OrderedMapValOrderedMapEntity struct {
	Key OrderedMapKey
	Val OrderedMapVal
}

// OrderedMapValOrderedMap preserve insert order
type OrderedMapValOrderedMap struct {
	m     map[OrderedMapKey]OrderedMapVal
	elems []OrderedMapValOrderedMapEntity
}

// MakeOrderedMapValOrderedMap ...
func MakeOrderedMapValOrderedMap() OrderedMapValOrderedMap {
	return OrderedMapValOrderedMap{
		m:     map[OrderedMapKey]OrderedMapVal{},
		elems: []OrderedMapValOrderedMapEntity{},
	}
}

// Entities return entities
func (om *OrderedMapValOrderedMap) Entities() []OrderedMapValOrderedMapEntity {
	res := []OrderedMapValOrderedMapEntity{}
	for _, v := range om.elems {
		res = append(res, v)
	}
	return res
}

// Values get values
func (om *OrderedMapValOrderedMap) Values() []OrderedMapVal {
	res := []OrderedMapVal{}

	for _, v := range om.elems {
		res = append(res, v.Val)
	}
	return res
}

// Size ...
func (om *OrderedMapValOrderedMap) Size() int {
	return len(om.m)
}

// Index ...
func (om *OrderedMapValOrderedMap) Index(i int) OrderedMapVal {
	return om.elems[i].Val
}

// Get gets ...
func (om *OrderedMapValOrderedMap) Get(key OrderedMapKey) OrderedMapVal {
	v, ok := om.m[key]
	if !ok {
		panic("not exist")
	}
	return v
}

// Has check key exists
func (om *OrderedMapValOrderedMap) Has(key OrderedMapKey) bool {
	_, ok := om.m[key]
	return ok
}

// Set sets ...
func (om *OrderedMapValOrderedMap) Set(key OrderedMapKey, val OrderedMapVal) {

	err := om.SetDuplicate(key, val)
	if err != nil {
		panic(err)
	}
}

// SetDuplicate set but error if duplicate
func (om *OrderedMapValOrderedMap) SetDuplicate(key OrderedMapKey, val OrderedMapVal) error {
	_, ok := om.m[key]
	if ok {
		return errors.New("duplicated insert")
	}
	om.m[key] = val
	om.elems = append(om.elems, OrderedMapValOrderedMapEntity{
		Key: key,
		Val: val,
	})
	return nil
}

// MarshalYAML ...
func (om *OrderedMapValOrderedMap) MarshalYAML() (interface{}, error) {
	ms := yaml.MapSlice{}
	for _, elem := range om.elems {
		ms = append(ms, yaml.MapItem{
			Key:   elem.Key,
			Value: elem.Val,
		})
	}
	return yaml.Marshal(ms)
}

// UnmarshalYAML ...
func (om *OrderedMapValOrderedMap) UnmarshalYAML(unmarshal func(interface{}) error) error {
	ms := yaml.MapSlice{}

	err := unmarshal(&ms)
	if err != nil {
		return err
	}

	for _, v := range ms {
		key := v.Key.(OrderedMapKey)
		value := OrderedMapVal{}
		err := unmarshalFromMapSlice(v.Value.(yaml.MapSlice), &value)
		if err != nil {
			return err
		}
		om.Set(key, value)
	}
	return nil
}

func unmarshalFromMapSlice(ms yaml.MapSlice, v interface{}) error {
	data, err := yaml.Marshal(ms)
	if err != nil {
		return err
	}
	err = yaml.Unmarshal(data, v)
	if err != nil {
		return err
	}
	return nil
}