// Package mapstructure exposes functionality to convert one arbitrary

// Go type into another, typically to convert a 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.

//

// The simplest function to start with is Decode.

//

// Field Tags

//

// When decoding to a struct, mapstructure will use the field name by

// default to perform the mapping. For example, if a struct has a field

// "Username" then mapstructure will look for a key in the source value

// of "username" (case insensitive).

//

//     type User struct {

//         Username string

//     }

//

// You can change the behavior of mapstructure by using struct tags.

// The default struct tag that mapstructure looks for is "mapstructure"

// but you can customize it using DecoderConfig.

//

// Renaming Fields

//

// To rename the key that mapstructure looks for, use the "mapstructure"

// tag and set a value directly. For example, to change the "username" example

// above to "user":

//

//     type User struct {

//         Username string `mapstructure:"user"`

//     }

//

// Embedded Structs and Squashing

//

// Embedded structs are treated as if they're another field with that name.

// By default, the two structs below are equivalent when decoding with

// mapstructure:

//

//     type Person struct {

//         Name string

//     }

//

//     type Friend struct {

//         Person

//     }

//

//     type Friend struct {

//         Person Person

//     }

//

// This would require an input that looks like below:

//

//     map[string]interface{}{

//         "person": map[string]interface{}{"name": "alice"},

//     }

//

// If your "person" value is NOT nested, then you can append ",squash" to

// your tag value and mapstructure will treat it as if the embedded struct

// were part of the struct directly. Example:

//

//     type Friend struct {

//         Person `mapstructure:",squash"`

//     }

//

// Now the following input would be accepted:

//

//     map[string]interface{}{

//         "name": "alice",

//     }

//

// When decoding from a struct to a map, the squash tag squashes the struct

// fields into a single map. Using the example structs from above:

//

//     Friend{Person: Person{Name: "alice"}}

//

// Will be decoded into a map:

//

//     map[string]interface{}{

//         "name": "alice",

//     }

//

// DecoderConfig has a field that changes the behavior of mapstructure

// to always squash embedded structs.

//

// Remainder Values

//

// If there are any unmapped keys in the source value, mapstructure by

// default will silently ignore them. You can error by setting ErrorUnused

// in DecoderConfig. If you're using Metadata you can also maintain a slice

// of the unused keys.

//

// You can also use the ",remain" suffix on your tag to collect all unused

// values in a map. The field with this tag MUST be a map type and should

// probably be a "map[string]interface{}" or "map[interface{}]interface{}".

// See example below:

//

//     type Friend struct {

//         Name  string

//         Other map[string]interface{} `mapstructure:",remain"`

//     }

//

// Given the input below, Other would be populated with the other

// values that weren't used (everything but "name"):

//

//     map[string]interface{}{

//         "name":    "bob",

//         "address": "123 Maple St.",

//     }

//

// Omit Empty Values

//

// When decoding from a struct to any other value, you may use the

// ",omitempty" suffix on your tag to omit that value if it equates to

// the zero value. The zero value of all types is specified in the Go

// specification.

//

// For example, the zero type of a numeric type is zero ("0"). If the struct

// field value is zero and a numeric type, the field is empty, and it won't

// be encoded into the destination type.

//

//         Age int `mapstructure:",omitempty"`

//     }

//

// Unexported fields

//

// Since unexported (private) struct fields cannot be set outside the package

// where they are defined, the decoder will simply skip them.

//

// For this output type definition:

//

//     type Exported struct {

//         private string // this unexported field will be skipped

//         Public string

//     }

//

// Using this map as input:

//

//     map[string]interface{}{

//         "private": "I will be ignored",

//         "Public":  "I made it through!",

//     }

//

// The following struct will be decoded:

//

//     type Exported struct {

//         private: "" // field is left with an empty string (zero value)

//         Public: "I made it through!"

//     }

//

// Other Configuration

//

// mapstructure is highly configurable. See the DecoderConfig struct

// for other features and options that are supported.

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 must be one of DecodeHookFuncType, DecodeHookFuncKind, or

// DecodeHookFuncValue.

// Values are a superset of Types (Values can return types), and 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)

// values.

type DecodeHookFuncValue func(from reflect.Value, to reflect.Value) (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. The

	// DecodeHook is called for every map and value in the input. This means

	// that if a struct has embedded fields with squash tags the decode hook

	// is called only once with all of the input data, not once for each

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

	// Squash will squash embedded structs.  A squash tag may also be

	// added to an individual struct field using a tag.  For example:

	//

	//  type Parent struct {

	//      Child `mapstructure:",squash"`

	//  }

	Squash 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()))