//

// 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 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

	//

	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 {

	var inputVal reflect.Value

	if input != nil {

		inputVal = reflect.ValueOf(input)

		// We need to check here if input is a typed nil. Typed nils won't

		// match the "input == nil" below so we check that here.

		if inputVal.Kind() == reflect.Ptr && inputVal.IsNil() {

			input = nil

		}

	}

	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

	}

	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

		if err != nil {

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

		}

	}

	var err error

	outputKind := getKind(outVal)

	switch outputKind {

	case reflect.Bool:

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

	case reflect.Interface:

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

	case reflect.String: