// Package mapstructure exposes functionality to convert an arbitrary

// map[string]interface{} into a native Go structure.

//

// The Go structure can be arbitrarily complex, containing slices,

// other structs, etc. and the decoder will properly decode nested

// maps and so on into the proper structures in the native Go struct.

// See the examples to see what the decoder is capable of.

package mapstructure

import (

	"encoding/json"

	"errors"

	"fmt"

	"reflect"

	"sort"

	"strconv"

	"strings"

)

// DecodeHookFunc is the callback function that can be used for

// data transformations. See "DecodeHook" in the DecoderConfig

// struct.

//

// The type should be DecodeHookFuncType or DecodeHookFuncKind.

// Either is accepted. Types are a superset of Kinds (Types can return

// Kinds) and are generally a richer thing to use, but Kinds are simpler

// if you only need those.

//

// The reason DecodeHookFunc is multi-typed is for backwards compatibility:

// we started with Kinds and then realized Types were the better solution,

// but have a promise to not break backwards compat so we now support

// both.

type DecodeHookFunc interface{}

// DecodeHookFuncType is a DecodeHookFunc which has complete information about

// the source and target types.

type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)

// DecodeHookFuncKind is a DecodeHookFunc which knows only the Kinds of the

// source and target types.

type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)

// DecoderConfig is the configuration that is used to create a new decoder

// and allows customization of various aspects of decoding.

type DecoderConfig struct {

	// DecodeHook, if set, will be called before any decoding and any

	// type conversion (if WeaklyTypedInput is on). This lets you modify

	// the values before they're set down onto the resulting struct.

	//

	// If an error is returned, the entire decode will fail with that

	// error.

	DecodeHook DecodeHookFunc

	// If ErrorUnused is true, then it is an error for there to exist

	// keys in the original map that were unused in the decoding process

	// (extra keys).

	ErrorUnused bool

	// ZeroFields, if set to true, will zero fields before writing them.

	// For example, a map will be emptied before decoded values are put in

	// it. If this is false, a map will be merged.

	ZeroFields bool

	// If WeaklyTypedInput is true, the decoder will make the following

	// "weak" conversions:

	//

	//   - bools to string (true = "1", false = "0")

	//   - numbers to string (base 10)

	//   - bools to int/uint (true = 1, false = 0)

	//   - strings to int/uint (base implied by prefix)

	//   - int to bool (true if value != 0)

	//   - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,

	//     FALSE, false, False. Anything else is an error)

	//   - empty array = empty map and vice versa

	//   - negative numbers to overflowed uint values (base 10)

	//   - slice of maps to a merged map

	//   - single values are converted to slices if required. Each

	//     element is weakly decoded. For example: "4" can become []int{4}

	//     if the target type is an int slice.

	//

	WeaklyTypedInput bool

	// Metadata is the struct that will contain extra metadata about

	// the decoding. If this is nil, then no metadata will be tracked.

	Metadata *Metadata

	// Result is a pointer to the struct that will contain the decoded

	// value.

	Result interface{}

	// The tag name that mapstructure reads for field names. This

	// defaults to "mapstructure"

	TagName string

}

// A Decoder takes a raw interface value and turns it into structured

// data, keeping track of rich error information along the way in case

// anything goes wrong. Unlike the basic top-level Decode method, you can

// more finely control how the Decoder behaves using the DecoderConfig

// structure. The top-level Decode method is just a convenience that sets

// up the most basic Decoder.

type Decoder struct {

	config *DecoderConfig

}

// Metadata contains information about decoding a structure that

// is tedious or difficult to get otherwise.

type Metadata struct {

	// Keys are the keys of the structure which were successfully decoded

	Keys []string

	// Unused is a slice of keys that were found in the raw value but

	// weren't decoded since there was no matching field in the result interface

	Unused []string

}

// Decode takes an input structure and uses reflection to translate it to

// the output structure. output must be a pointer to a map or struct.

func Decode(input interface{}, output interface{}) error {

	config := &DecoderConfig{

		Metadata: nil,

		Result:   output,

	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// WeakDecode is the same as Decode but is shorthand to enable

// WeaklyTypedInput. See DecoderConfig for more info.

func WeakDecode(input, output interface{}) error {

	config := &DecoderConfig{

		Metadata:         nil,

		Result:           output,

		WeaklyTypedInput: true,

	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// DecodeMetadata is the same as Decode, but is shorthand to

// enable metadata collection. See DecoderConfig for more info.

func DecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {

	config := &DecoderConfig{

		Metadata: metadata,

		Result:   output,

	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// WeakDecodeMetadata is the same as Decode, but is shorthand to

// enable both WeaklyTypedInput and metadata collection. See

// DecoderConfig for more info.

func WeakDecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {

	config := &DecoderConfig{

		Metadata:         metadata,

		Result:           output,

		WeaklyTypedInput: true,

	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// NewDecoder returns a new decoder for the given configuration. Once

// a decoder has been returned, the same configuration must not be used

// again.

func NewDecoder(config *DecoderConfig) (*Decoder, error) {

	val := reflect.ValueOf(config.Result)

	if val.Kind() != reflect.Ptr {

		return nil, errors.New("result must be a pointer")

	}

	val = val.Elem()

	if !val.CanAddr() {

		return nil, errors.New("result must be addressable (a pointer)")

	}

	if config.Metadata != nil {

		if config.Metadata.Keys == nil {

			config.Metadata.Keys = make([]string, 0)

		}

		if config.Metadata.Unused == nil {

			config.Metadata.Unused = make([]string, 0)

		}

	}

	if config.TagName == "" {

		config.TagName = "mapstructure"

	}

	result := &Decoder{

		config: config,

	}

	return result, nil

}

// Decode decodes the given raw interface to the target pointer specified

// by the configuration.

func (d *Decoder) Decode(input interface{}) error {

	return d.decode("", input, reflect.ValueOf(d.config.Result).Elem())

}

// Decodes an unknown data type into a specific reflection value.

func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) error {

	if input == nil {

		// If the data is nil, then we don't set anything, unless ZeroFields is set

		// to true.

		if d.config.ZeroFields {

			outVal.Set(reflect.Zero(outVal.Type()))

			if d.config.Metadata != nil && name != "" {

				d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)

			}

		}

		return nil

	}

	inputVal := reflect.ValueOf(input)

	if !inputVal.IsValid() {

		// If the input value is invalid, then we just set the value

		// to be the zero value.

		outVal.Set(reflect.Zero(outVal.Type()))

		if d.config.Metadata != nil && name != "" {

			d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)

		}

		return nil

	}

	if d.config.DecodeHook != nil {

		// We have a DecodeHook, so let's pre-process the input.

		var err error

		input, err = DecodeHookExec(

			d.config.DecodeHook,

			inputVal.Type(), outVal.Type(), input)

		if err != nil {

			return fmt.Errorf("error decoding '%s': %s", name, err)

		}

	}

	var err error

	inputKind := getKind(outVal)

	switch inputKind {

	case reflect.Bool:

		err = d.decodeBool(name, input, outVal)

	case reflect.Interface:

		err = d.decodeBasic(name, input, outVal)

	case reflect.String:

		err = d.decodeString(name, input, outVal)

	case reflect.Int:

		err = d.decodeInt(name, input, outVal)

	case reflect.Uint:

		err = d.decodeUint(name, input, outVal)

	case reflect.Float32:

		err = d.decodeFloat(name, input, outVal)

	case reflect.Struct:

		err = d.decodeStruct(name, input, outVal)

	case reflect.Map:

		err = d.decodeMap(name, input, outVal)

	case reflect.Ptr:

		err = d.decodePtr(name, input, outVal)

	case reflect.Slice:

		err = d.decodeSlice(name, input, outVal)

	case reflect.Array:

		err = d.decodeArray(name, input, outVal)

	case reflect.Func:

		err = d.decodeFunc(name, input, outVal)

	default:

		// If we reached this point then we weren't able to decode it

		return fmt.Errorf("%s: unsupported type: %s", name, inputKind)

	}

	// If we reached here, then we successfully decoded SOMETHING, so

	// mark the key as used if we're tracking metainput.

	if d.config.Metadata != nil && name != "" {

		d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)

	}

	return err

}

// This decodes a basic type (bool, int, string, etc.) and sets the

// value to "data" of that type.

func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {

	if val.IsValid() && val.Elem().IsValid() {

		return d.decode(name, data, val.Elem())

	}

	dataVal := reflect.ValueOf(data)

	if !dataVal.IsValid() {

		dataVal = reflect.Zero(val.Type())

	}

	dataValType := dataVal.Type()

	if !dataValType.AssignableTo(val.Type()) {

		return fmt.Errorf(

			"'%s' expected type '%s', got '%s'",

			name, val.Type(), dataValType)

	}

	val.Set(dataVal)

	return nil

}

func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.ValueOf(data)

	dataKind := getKind(dataVal)

	converted := true

	switch {

	case dataKind == reflect.String:

		val.SetString(dataVal.String())

	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:

		if dataVal.Bool() {

			val.SetString("1")

		} else {

			val.SetString("0")

		}

	case dataKind == reflect.Int && d.config.WeaklyTypedInput:

		val.SetString(strconv.FormatInt(dataVal.Int(), 10))

	case dataKind == reflect.Uint && d.config.WeaklyTypedInput:

		val.SetString(strconv.FormatUint(dataVal.Uint(), 10))

	case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:

		val.SetString(strconv.FormatFloat(dataVal.Float(), 'f', -1, 64))

	case dataKind == reflect.Slice && d.config.WeaklyTypedInput,

		dataKind == reflect.Array && d.config.WeaklyTypedInput:

		dataType := dataVal.Type()

		elemKind := dataType.Elem().Kind()

		switch elemKind {

		case reflect.Uint8:

			var uints []uint8

			if dataKind == reflect.Array {

				uints = make([]uint8, dataVal.Len(), dataVal.Len())

				for i := range uints {

					uints[i] = dataVal.Index(i).Interface().(uint8)

				}

			} else {

				uints = dataVal.Interface().([]uint8)

			}

			val.SetString(string(uints))

		default:

			converted = false

		}

	default:

		converted = false

	}

	if !converted {

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s'",

			name, val.Type(), dataVal.Type())

	}

	return nil

}

func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.ValueOf(data)

	dataKind := getKind(dataVal)

	dataType := dataVal.Type()

	switch {

	case dataKind == reflect.Int:

		val.SetInt(dataVal.Int())

	case dataKind == reflect.Uint:

		val.SetInt(int64(dataVal.Uint()))

	case dataKind == reflect.Float32:

		val.SetInt(int64(dataVal.Float()))

	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:

		if dataVal.Bool() {

			val.SetInt(1)

		} else {

			val.SetInt(0)

		}

	case dataKind == reflect.String && d.config.WeaklyTypedInput:

		i, err := strconv.ParseInt(dataVal.String(), 0, val.Type().Bits())

		if err == nil {

			val.SetInt(i)

		} else {

			return fmt.Errorf("cannot parse '%s' as int: %s", name, err)

		}

	case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":

		jn := data.(json.Number)

		i, err := jn.Int64()

		if err != nil {

			return fmt.Errorf(

				"error decoding json.Number into %s: %s", name, err)

		}

		val.SetInt(i)

	default:

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s'",