package resmap

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"reflect"
	"sort"

	"github.com/ghodss/yaml"
	"github.com/golang/glog"
	"github.com/kubernetes-sigs/kustomize/pkg/loader"
	"github.com/kubernetes-sigs/kustomize/pkg/resource"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime"
	k8syaml "k8s.io/apimachinery/pkg/util/yaml"
)

// ResMap is a map from ResId to Resource
type ResMap map[resource.ResId]*resource.Resource

// EncodeAsYaml encodes a ResMap to YAML; encoded objects separated by `---`.
func (m ResMap) EncodeAsYaml() ([]byte, error) {
	ids := []resource.ResId{}
	for gvkn := range m {
		ids = append(ids, gvkn)
	}
	sort.Sort(IdSlice(ids))

	firstObj := true
	var b []byte
	buf := bytes.NewBuffer(b)
	for _, id := range ids {
		obj := m[id].Unstruct()
		out, err := yaml.Marshal(obj)
		if err != nil {
			return nil, err
		}
		if firstObj {
			firstObj = false
		} else {
			_, err = buf.WriteString("---\n")
			if err != nil {
				return nil, err
			}
		}
		_, err = buf.Write(out)
		if err != nil {
			return nil, err
		}
	}
	return buf.Bytes(), nil
}

func (m1 ResMap) ErrorIfNotEqual(m2 ResMap) error {
	if len(m1) != len(m2) {
		keySet1 := []resource.ResId{}
		keySet2 := []resource.ResId{}
		for id := range m1 {
			keySet1 = append(keySet1, id)
		}
		for id := range m2 {
			keySet2 = append(keySet2, id)
		}
		return fmt.Errorf("maps has different number of entries: %#v doesn't equals %#v", keySet1, keySet2)
	}
	for id, obj1 := range m1 {
		obj2, found := m2[id]
		if !found {
			return fmt.Errorf("%#v doesn't exist in %#v", id, m2)
		}
		if !reflect.DeepEqual(obj1.Unstruct(), obj2.Unstruct()) {
			return fmt.Errorf("%#v doesn't match %#v", obj1.Unstruct(), obj2.Unstruct())
		}
	}
	return nil
}

func (m ResMap) insert(newName string, obj *unstructured.Unstructured) error {
	oldName := obj.GetName()
	gvk := obj.GroupVersionKind()
	id := resource.NewResId(gvk, oldName)

	if _, found := m[id]; found {
		return fmt.Errorf("The <name: %q, GroupVersionKind: %v> already exists in the map", oldName, gvk)
	}
	obj.SetName(newName)
	m[id] = resource.NewBehaviorlessResource(obj)
	return nil
}

// NewResourceSliceFromPatches returns a slice of Resources given a patch path slice from kustomization file.
func NewResourceSliceFromPatches(
	loader loader.Loader, paths []string) ([]*resource.Resource, error) {
	result := []*resource.Resource{}
	for _, path := range paths {
		content, err := loader.Load(path)
		if err != nil {
			return nil, err
		}

		res, err := newResourceSliceFromBytes(content)
		if err != nil {
			return nil, err
		}
		result = append(result, res...)
	}
	return result, nil
}

// NewResMapFromFiles returns a ResMap given a resource path slice.
func NewResMapFromFiles(loader loader.Loader, paths []string) (ResMap, error) {
	result := []ResMap{}
	for _, path := range paths {
		content, err := loader.Load(path)
		if err != nil {
			return nil, err
		}

		res, err := newResMapFromBytes(content)
		if err != nil {
			return nil, err
		}
		result = append(result, res)
	}
	return Merge(result...)
}

// newResMapFromBytes decodes a list of objects in byte array format.
func newResMapFromBytes(b []byte) (ResMap, error) {
	resources, err := newResourceSliceFromBytes(b)
	if err != nil {
		return nil, err
	}

	result := ResMap{}
	for _, res := range resources {
		gvkn := res.Id()
		if _, found := result[gvkn]; found {
			return result, fmt.Errorf("GroupVersionKindName: %#v already exists b the map", gvkn)
		}
		result[gvkn] = res
	}
	return result, nil
}

func newResMapFromResourceSlice(resources []*resource.Resource) (ResMap, error) {
	result := ResMap{}
	for _, res := range resources {
		gvkn := res.Id()
		if _, found := result[gvkn]; found {
			return nil, fmt.Errorf("duplicated %#v is not allowed", gvkn)
		}
		result[gvkn] = res
	}
	return result, nil
}

func newResourceSliceFromBytes(in []byte) ([]*resource.Resource, error) {
	decoder := k8syaml.NewYAMLOrJSONDecoder(bytes.NewReader(in), 1024)
	result := []*resource.Resource{}

	var err error
	for {
		var out unstructured.Unstructured
		err = decoder.Decode(&out)
		if err != nil {
			break
		}
		result = append(result, resource.NewBehaviorlessResource(&out))
	}
	if err != io.EOF {
		return nil, err
	}
	return result, nil
}

// Merge combines many maps to one.
func Merge(maps ...ResMap) (ResMap, error) {
	result := ResMap{}
	for _, m := range maps {
		for gvkn, obj := range m {
			if _, found := result[gvkn]; found {
				return nil, fmt.Errorf("there is already an entry: %q", gvkn)
			}
			result[gvkn] = obj
		}
	}

	return result, nil
}

const behaviorCreate = "create"
const behaviorReplace = "replace"
const behaviorMerge = "merge"

// MergeWithOverride merges the entries in the ResMap slice with Override.
// If there is already an entry with the same Id , different actions are performed
// according to value of behavior field:
// 'create': create a new one;
// 'replace': replace the data only; keep the labels and annotations
// 'merge': merge the data; keep the labels and annotations
func MergeWithOverride(maps ...ResMap) (ResMap, error) {
	result := ResMap{}
	for _, m := range maps {
		for gvkn, resource := range m {
			if _, found := result[gvkn]; found {
				switch resource.Behavior() {
				case "", behaviorCreate:
					return nil, fmt.Errorf("Create an existing gvkn %#v is not allowed", gvkn)
				case behaviorReplace:
					glog.V(4).Infof("Replace object %v by %v", result[gvkn].Unstruct().Object, resource.Unstruct().Object)
					resource.Replace(result[gvkn])
					result[gvkn] = resource
				case behaviorMerge:
					glog.V(4).Infof("Merge object %v with %v", result[gvkn].Unstruct().Object, resource.Unstruct().Object)
					resource.Merge(result[gvkn])
					result[gvkn] = resource
					glog.V(4).Infof("The merged object is %v", result[gvkn].Unstruct().Object)
				default:
					return nil, fmt.Errorf("The behavior of %#v must be one of merge and replace since it already exists in the base", gvkn)
				}
			} else {
				switch resource.Behavior() {
				case "", behaviorCreate:
					result[gvkn] = resource
				case behaviorMerge, behaviorReplace:
					return nil, fmt.Errorf("No merge or replace is allowed for non existing gvkn %#v", gvkn)
				default:
					return nil, fmt.Errorf("The behavior of %#v must be create since it doesn't exist", gvkn)
				}
			}
		}
	}
	return result, nil
}

func newUnstructuredFromObject(in runtime.Object) (*unstructured.Unstructured, error) {
	marshaled, err := json.Marshal(in)
	if err != nil {
		return nil, err
	}
	var out unstructured.Unstructured
	err = out.UnmarshalJSON(marshaled)
	return &out, err
}