package yaml

import (

	"bytes"

	"encoding/json"

	"fmt"

	"reflect"

	"strconv"

	"gopkg.in/yaml.v2"

)

// Marshals the object into JSON then converts JSON to YAML and returns the

// YAML.

func Marshal(o interface{}) ([]byte, error) {

	j, err := json.Marshal(o)

	if err != nil {

		return nil, fmt.Errorf("error marshaling into JSON: %v", err)

	}

	y, err := JSONToYAML(j)

	if err != nil {

		return nil, fmt.Errorf("error converting JSON to YAML: %v", err)

	}

	return y, nil

}

// Converts YAML to JSON then uses JSON to unmarshal into an object.

func Unmarshal(y []byte, o interface{}) error {

	vo := reflect.ValueOf(o)

	j, err := yamlToJSON(y, &vo)

	if err != nil {

		return fmt.Errorf("error converting YAML to JSON: %v", err)

	}

	err = json.Unmarshal(j, o)

	if err != nil {

		return fmt.Errorf("error unmarshaling JSON: %v", err)

	}

	return nil

}

// Convert JSON to YAML.

func JSONToYAML(j []byte) ([]byte, error) {

	// Convert the JSON to an object.

	var jsonObj interface{}

	// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the

	// Go JSON library doesn't try to pick the right number type (int, float,

	// etc.) when unmarshalling to interface{}, it just picks float64

	// universally. go-yaml does go through the effort of picking the right

	// number type, so we can preserve number type throughout this process.

	err := yaml.Unmarshal(j, &jsonObj)

	if err != nil {

		return nil, err

	}

	// Marshal this object into YAML.

	return yaml.Marshal(jsonObj)

}

// Convert YAML to JSON. Since JSON is a subset of YAML, passing JSON through

// this method should be a no-op.

//

// Things YAML can do that are not supported by JSON:

// * In YAML you can have binary and null keys in your maps. These are invalid

//   in JSON. (int and float keys are converted to strings.)

// * Binary data in YAML with the !!binary tag is not supported. If you want to

//   use binary data with this library, encode the data as base64 as usual but do

//   not use the !!binary tag in your YAML. This will ensure the original base64

//   encoded data makes it all the way through to the JSON.

func YAMLToJSON(y []byte) ([]byte, error) {

	return yamlToJSON(y, nil)

}

func yamlToJSON(y []byte, jsonTarget *reflect.Value) ([]byte, error) {

	// Convert the YAML to an object.

	var yamlObj interface{}

	err := yaml.Unmarshal(y, &yamlObj)

	if err != nil {

		return nil, err

	}

	// YAML objects are not completely compatible with JSON objects (e.g. you

	// can have non-string keys in YAML). So, convert the YAML-compatible object

	// to a JSON-compatible object, failing with an error if irrecoverable

	// incompatibilties happen along the way.

	jsonObj, err := convertToJSONableObject(yamlObj, jsonTarget)

	if err != nil {

		return nil, err

	}

	// Convert this object to JSON and return the data.

	return json.Marshal(jsonObj)

}

func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) {

	var err error

	// Resolve jsonTarget to a concrete value (i.e. not a pointer or an

	// interface). We pass decodingNull as false because we're not actually

	// decoding into the value, we're just checking if the ultimate target is a

	// string.

	if jsonTarget != nil {

		ju, tu, pv := indirect(*jsonTarget, false)

		// We have a JSON or Text Umarshaler at this level, so we can't be trying

		// to decode into a string.

		if ju != nil || tu != nil {

			jsonTarget = nil

		} else {

			jsonTarget = &pv

		}

	}

	// If yamlObj is a number or a boolean, check if jsonTarget is a string -

	// if so, coerce.  Else return normal.

	// If yamlObj is a map or array, find the field that each key is

	// unmarshaling to, and when you recurse pass the reflect.Value for that

	// field back into this function.

	switch typedYAMLObj := yamlObj.(type) {

	case map[interface{}]interface{}:

		// JSON does not support arbitrary keys in a map, so we must convert

		// these keys to strings.

		//

		// From my reading of go-yaml v2 (specifically the resolve function),

		// keys can only have the types string, int, int64, float64, binary

		// (unsupported), or null (unsupported).

		strMap := make(map[string]interface{})

		for k, v := range typedYAMLObj {

			// Resolve the key to a string first.

			var keyString string

			switch typedKey := k.(type) {

			case string:

				keyString = typedKey

			case int:

				keyString = strconv.Itoa(typedKey)

			case int64:

				// go-yaml will only return an int64 as a key if the system

				// architecture is 32-bit and the key's value is between 32-bit

				// and 64-bit. Otherwise the key type will simply be int.

				keyString = strconv.FormatInt(typedKey, 10)

			case float64:

				// Stolen from go-yaml to use the same conversion to string as

				// the go-yaml library uses to convert float to string when

				// Marshaling.

				s := strconv.FormatFloat(typedKey, 'g', -1, 32)

				switch s {

				case "+Inf":

					s = ".inf"

				case "-Inf":

					s = "-.inf"

				case "NaN":

					s = ".nan"

				}

				keyString = s

			case bool:

				if typedKey {

					keyString = "true"

				} else {

					keyString = "false"

				}

			default:

				return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v",

					reflect.TypeOf(k), k, v)

			}

			// jsonTarget should be a struct or a map. If it's a struct, find

			// the field it's going to map to and pass its reflect.Value. If

			// it's a map, find the element type of the map and pass the

			// reflect.Value created from that type. If it's neither, just pass

			// nil - JSON conversion will error for us if it's a real issue.

			if jsonTarget != nil {

				t := *jsonTarget

				if t.Kind() == reflect.Struct {

					keyBytes := []byte(keyString)

					// Find the field that the JSON library would use.

					var f *field

					fields := cachedTypeFields(t.Type())

					for i := range fields {

						ff := &fields[i]

						if bytes.Equal(ff.nameBytes, keyBytes) {

							f = ff

							break

						}

						// Do case-insensitive comparison.

						if f == nil && ff.equalFold(ff.nameBytes, keyBytes) {

							f = ff

						}

					}

					if f != nil {

						// Find the reflect.Value of the most preferential

						// struct field.

						jtf := t.Field(f.index[0])

						strMap[keyString], err = convertToJSONableObject(v, &jtf)

						if err != nil {

							return nil, err

						}

						continue

					}

				} else if t.Kind() == reflect.Map {

					// Create a zero value of the map's element type to use as

					// the JSON target.

					jtv := reflect.Zero(t.Type().Elem())

					strMap[keyString], err = convertToJSONableObject(v, &jtv)

					if err != nil {

						return nil, err

					}

					continue

				}

			}

			strMap[keyString], err = convertToJSONableObject(v, nil)

			if err != nil {

				return nil, err

			}

		}

		return strMap, nil

	case []interface{}:

		// We need to recurse into arrays in case there are any

		// map[interface{}]interface{}'s inside and to convert any

		// numbers to strings.

		// If jsonTarget is a slice (which it really should be), find the

		// thing it's going to map to. If it's not a slice, just pass nil

		// - JSON conversion will error for us if it's a real issue.

		var jsonSliceElemValue *reflect.Value

		if jsonTarget != nil {

			t := *jsonTarget

			if t.Kind() == reflect.Slice {

				// By default slices point to nil, but we need a reflect.Value

				// pointing to a value of the slice type, so we create one here.

				ev := reflect.Indirect(reflect.New(t.Type().Elem()))

				jsonSliceElemValue = &ev

			}

		}

		// Make and use a new array.

		arr := make([]interface{}, len(typedYAMLObj))

		for i, v := range typedYAMLObj {

			arr[i], err = convertToJSONableObject(v, jsonSliceElemValue)

			if err != nil {

				return nil, err

			}

		}

		return arr, nil

	default:

		// If the target type is a string and the YAML type is a number,

		// convert the YAML type to a string.

		if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String {

			// Based on my reading of go-yaml, it may return int, int64,

			// float64, or uint64.

			var s string

			switch typedVal := typedYAMLObj.(type) {

			case int:

				s = strconv.FormatInt(int64(typedVal), 10)

			case int64:

				s = strconv.FormatInt(typedVal, 10)

			case float64:

				s = strconv.FormatFloat(typedVal, 'g', -1, 32)

			case uint64:

				s = strconv.FormatUint(typedVal, 10)

			case bool:

				if typedVal {

					s = "true"

				} else {

					s = "false"

				}

			}

			if len(s) > 0 {

				yamlObj = interface{}(s)

			}

		}

		return yamlObj, nil

	}

	return nil, nil

}