package main

import (
	"fmt"
	"reflect"
	"strconv"
	"strings"

	yaml "gopkg.in/mikefarah/yaml.v2"
)

func matchesKey(key string, actual interface{}) bool {
	var actualString = fmt.Sprintf("%v", actual)
	var prefixMatch = strings.TrimSuffix(key, "*")
	if prefixMatch != key {
		return strings.HasPrefix(actualString, prefixMatch)
	}
	return actualString == key
}

func entriesInSlice(context yaml.MapSlice, key string) []*yaml.MapItem {
	var matches = make([]*yaml.MapItem, 0)
	for idx := range context {
		var entry = &context[idx]
		if matchesKey(key, entry.Key) {
			matches = append(matches, entry)
		}
	}
	return matches
}

func getMapSlice(context interface{}) yaml.MapSlice {
	var mapSlice yaml.MapSlice
	switch context := context.(type) {
	case yaml.MapSlice:
		mapSlice = context
	default:
		mapSlice = make(yaml.MapSlice, 0)
	}
	return mapSlice
}

func getArray(context interface{}) (array []interface{}, ok bool) {
	switch context := context.(type) {
	case []interface{}:
		array = context
		ok = true
	default:
		array = make([]interface{}, 0)
		ok = false
	}
	return
}

func writeMap(context interface{}, paths []string, value interface{}) interface{} {
	log.Debugf("writeMap with path %v for %v to set value %v\n", paths, context, value)

	mapSlice := getMapSlice(context)

	if len(paths) == 0 {
		return context
	}

	children := entriesInSlice(mapSlice, paths[0])

	if len(children) == 0 && paths[0] == "*" {
		log.Debugf("\tNo matches, return map as is")
		return context
	}

	if len(children) == 0 {
		newChild := yaml.MapItem{Key: paths[0]}
		mapSlice = append(mapSlice, newChild)
		children = entriesInSlice(mapSlice, paths[0])
		log.Debugf("\tAppended child at %v for mapSlice %v\n", paths[0], mapSlice)
	}

	remainingPaths := paths[1:]
	for _, child := range children {
		child.Value = updatedChildValue(child.Value, remainingPaths, value)
	}
	log.Debugf("\tReturning mapSlice %v\n", mapSlice)
	return mapSlice
}

func updatedChildValue(child interface{}, remainingPaths []string, value interface{}) interface{} {
	if len(remainingPaths) == 0 {
		return value
	}
	log.Debugf("updatedChildValue for child %v with path %v to set value %v", child, remainingPaths, value)
	log.Debugf("type of child is %v", reflect.TypeOf(child))

	switch child := child.(type) {
	case nil:
		if remainingPaths[0] == "+" || remainingPaths[0] == "*" {
			return writeArray(child, remainingPaths, value)
		}
	case []interface{}:
		_, nextIndexErr := strconv.ParseInt(remainingPaths[0], 10, 64)
		arrayCommand := nextIndexErr == nil || remainingPaths[0] == "+" || remainingPaths[0] == "*"
		if arrayCommand {
			return writeArray(child, remainingPaths, value)
		}
	}
	return writeMap(child, remainingPaths, value)
}

func writeArray(context interface{}, paths []string, value interface{}) []interface{} {
	log.Debugf("writeArray with path %v for %v to set value %v\n", paths, context, value)
	array, _ := getArray(context)

	if len(paths) == 0 {
		return array
	}

	log.Debugf("\tarray %v\n", array)

	rawIndex := paths[0]
	remainingPaths := paths[1:]
	var index int64
	// the append array indicator
	if rawIndex == "+" {
		index = int64(len(array))
	} else if rawIndex == "*" {
		for index, oldChild := range array {
			array[index] = updatedChildValue(oldChild, remainingPaths, value)
		}
		return array
	} else {
		index, _ = strconv.ParseInt(rawIndex, 10, 64) // nolint
		// writeArray is only called by updatedChildValue which handles parsing the
		// index, as such this renders this dead code.
	}

	for index >= int64(len(array)) {
		array = append(array, nil)
	}
	currentChild := array[index]

	log.Debugf("\tcurrentChild %v\n", currentChild)

	array[index] = updatedChildValue(currentChild, remainingPaths, value)
	log.Debugf("\tReturning array %v\n", array)
	return array
}

func readMap(context yaml.MapSlice, head string, tail []string) (interface{}, error) {
	log.Debugf("readingMap %v with key %v\n", context, head)
	if head == "*" {
		return readMapSplat(context, tail)
	}

	entries := entriesInSlice(context, head)
	if len(entries) == 1 {
		return calculateValue(entries[0].Value, tail)
	} else if len(entries) == 0 {
		return nil, nil
	}
	var errInIdx error
	values := make([]interface{}, len(entries))
	for idx, entry := range entries {
		values[idx], errInIdx = calculateValue(entry.Value, tail)
		if errInIdx != nil {
			log.Errorf("Error updating index %v in %v", idx, context)
			return nil, errInIdx
		}

	}
	return values, nil
}

func readMapSplat(context yaml.MapSlice, tail []string) (interface{}, error) {
	var newArray = make([]interface{}, len(context))
	var i = 0
	for _, entry := range context {
		if len(tail) > 0 {
			val, err := recurse(entry.Value, tail[0], tail[1:])
			if err != nil {
				return nil, err
			}
			newArray[i] = val
		} else {
			newArray[i] = entry.Value
		}
		i++
	}
	return newArray, nil
}

func recurse(value interface{}, head string, tail []string) (interface{}, error) {
	switch value := value.(type) {
	case []interface{}:
		if head == "*" {
			return readArraySplat(value, tail)
		}
		index, err := strconv.ParseInt(head, 10, 64)
		if err != nil {
			return nil, fmt.Errorf("error accessing array: %v", err)
		}
		return readArray(value, index, tail)
	case yaml.MapSlice:
		return readMap(value, head, tail)
	default:
		return nil, nil
	}
}

func readArray(array []interface{}, head int64, tail []string) (interface{}, error) {
	if head >= int64(len(array)) {
		return nil, nil
	}

	value := array[head]
	return calculateValue(value, tail)
}

func readArraySplat(array []interface{}, tail []string) (interface{}, error) {
	var newArray = make([]interface{}, len(array))
	for index, value := range array {
		val, err := calculateValue(value, tail)
		if err != nil {
			return nil, err
		}
		newArray[index] = val
	}
	return newArray, nil
}

func calculateValue(value interface{}, tail []string) (interface{}, error) {
	if len(tail) > 0 {
		return recurse(value, tail[0], tail[1:])
	}
	return value, nil
}

func deleteMap(context interface{}, paths []string) (yaml.MapSlice, error) {
	log.Debugf("deleteMap for %v for %v\n", paths, context)

	mapSlice := getMapSlice(context)

	if len(paths) == 0 {
		return mapSlice, nil
	}

	var index int
	var child yaml.MapItem
	for index, child = range mapSlice {
		if matchesKey(paths[0], child.Key) {
			log.Debugf("\tMatched [%v] with [%v] at index %v", paths[0], child.Key, index)
			var badDelete error
			mapSlice, badDelete = deleteEntryInMap(mapSlice, child, index, paths)
			if badDelete != nil {
				return nil, badDelete
			}
		}
	}

	return mapSlice, nil

}

func deleteEntryInMap(original yaml.MapSlice, child yaml.MapItem, index int, paths []string) (yaml.MapSlice, error) {
	remainingPaths := paths[1:]

	var newSlice yaml.MapSlice
	if len(remainingPaths) > 0 {
		newChild := yaml.MapItem{Key: child.Key}
		var errorDeleting error
		newChild.Value, errorDeleting = deleteChildValue(child.Value, remainingPaths)
		if errorDeleting != nil {
			return nil, errorDeleting
		}

		newSlice = make(yaml.MapSlice, len(original))
		for i := range original {
			item := original[i]
			if i == index {
				item = newChild
			}
			newSlice[i] = item
		}
	} else {
		// Delete item from slice at index
		newSlice = append(original[:index], original[index+1:]...)
		log.Debugf("\tDeleted item index %d from original", index)
	}

	log.Debugf("\tReturning original %v\n", original)
	return newSlice, nil
}

func deleteArraySplat(array []interface{}, tail []string) (interface{}, error) {
	log.Debugf("deleteArraySplat for %v for %v\n", tail, array)
	var newArray = make([]interface{}, len(array))
	for index, value := range array {
		val, err := deleteChildValue(value, tail)
		if err != nil {
			return nil, err
		}
		newArray[index] = val
	}
	return newArray, nil
}

func deleteArray(array []interface{}, paths []string, index int64) (interface{}, error) {
	log.Debugf("deleteArray for %v for %v\n", paths, array)

	if index >= int64(len(array)) {
		return array, nil
	}

	remainingPaths := paths[1:]
	if len(remainingPaths) > 0 {
		// Recurse into the array element at index
		var errorDeleting error
		array[index], errorDeleting = deleteMap(array[index], remainingPaths)
		if errorDeleting != nil {
			return nil, errorDeleting
		}

	} else {
		// Delete the array element at index
		array = append(array[:index], array[index+1:]...)
		log.Debugf("\tDeleted item index %d from array, leaving %v", index, array)
	}

	log.Debugf("\tReturning array: %v\n", array)
	return array, nil
}

func deleteChildValue(child interface{}, remainingPaths []string) (interface{}, error) {
	log.Debugf("deleteChildValue for %v for %v\n", remainingPaths, child)
	var head = remainingPaths[0]
	var tail = remainingPaths[1:]
	switch child := child.(type) {
	case yaml.MapSlice:
		return deleteMap(child, remainingPaths)
	case []interface{}:
		if head == "*" {
			return deleteArraySplat(child, tail)
		}
		index, err := strconv.ParseInt(head, 10, 64)
		if err != nil {
			return nil, fmt.Errorf("error accessing array: %v", err)
		}
		return deleteArray(child, remainingPaths, index)
	}
	return child, nil
}