// Copyright 2014 Unknwon

//

// Licensed under the Apache License, Version 2.0 (the "License"): you may

// not use this file except in compliance with the License. You may obtain

// a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

// License for the specific language governing permissions and limitations

// under the License.

package ini

import (

	"bytes"

	"errors"

	"fmt"

	"strconv"

	"strings"

	"time"

)

// Key represents a key under a section.

type Key struct {

	s               *Section

	Comment         string

	name            string

	value           string

	isAutoIncrement bool

	isBooleanType   bool

	isShadow bool

	shadows  []*Key

	nestedValues []string

}

// newKey simply return a key object with given values.

func newKey(s *Section, name, val string) *Key {

	return &Key{

		s:     s,

		name:  name,

		value: val,

	}

}

func (k *Key) addShadow(val string) error {

	if k.isShadow {

		return errors.New("cannot add shadow to another shadow key")

	} else if k.isAutoIncrement || k.isBooleanType {

		return errors.New("cannot add shadow to auto-increment or boolean key")

	}

	// Deduplicate shadows based on their values.

	if k.value == val {

		return nil

	}

	for i := range k.shadows {

		if k.shadows[i].value == val {

			return nil

		}

	}

	shadow := newKey(k.s, k.name, val)

	shadow.isShadow = true

	k.shadows = append(k.shadows, shadow)

	return nil

}

// AddShadow adds a new shadow key to itself.

func (k *Key) AddShadow(val string) error {

	if !k.s.f.options.AllowShadows {

		return errors.New("shadow key is not allowed")

	}

	return k.addShadow(val)

}

func (k *Key) addNestedValue(val string) error {

	if k.isAutoIncrement || k.isBooleanType {

		return errors.New("cannot add nested value to auto-increment or boolean key")

	}

	k.nestedValues = append(k.nestedValues, val)

	return nil

}

// AddNestedValue adds a nested value to the key.

func (k *Key) AddNestedValue(val string) error {

	if !k.s.f.options.AllowNestedValues {

		return errors.New("nested value is not allowed")

	}

	return k.addNestedValue(val)

}

// ValueMapper represents a mapping function for values, e.g. os.ExpandEnv

type ValueMapper func(string) string

// Name returns name of key.

func (k *Key) Name() string {

	return k.name

}

// Value returns raw value of key for performance purpose.

func (k *Key) Value() string {

	return k.value

}

// ValueWithShadows returns raw values of key and its shadows if any.

func (k *Key) ValueWithShadows() []string {

	if len(k.shadows) == 0 {

		return []string{k.value}

	}

	vals := make([]string, len(k.shadows)+1)

	vals[0] = k.value

	for i := range k.shadows {

		vals[i+1] = k.shadows[i].value

	}

	return vals

}

// NestedValues returns nested values stored in the key.

// It is possible returned value is nil if no nested values stored in the key.

func (k *Key) NestedValues() []string {

	return k.nestedValues

}

// transformValue takes a raw value and transforms to its final string.

func (k *Key) transformValue(val string) string {

	if k.s.f.ValueMapper != nil {

		val = k.s.f.ValueMapper(val)

	}

	// Fail-fast if no indicate char found for recursive value

	if !strings.Contains(val, "%") {

		return val

	}

	for i := 0; i < depthValues; i++ {

		vr := varPattern.FindString(val)

		if len(vr) == 0 {

			break

		}

		// Take off leading '%(' and trailing ')s'.

		noption := vr[2 : len(vr)-2]

		// Search in the same section.

		// If not found or found the key itself, then search again in default section.

		nk, err := k.s.GetKey(noption)

		if err != nil || k == nk {

			nk, _ = k.s.f.Section("").GetKey(noption)

			if nk == nil {

				// Stop when no results found in the default section,

				// and returns the value as-is.

				break

			}

		}

		// Substitute by new value and take off leading '%(' and trailing ')s'.

		val = strings.Replace(val, vr, nk.value, -1)

	}

	return val

}

// String returns string representation of value.

func (k *Key) String() string {

	return k.transformValue(k.value)

}

// Validate accepts a validate function which can

// return modifed result as key value.

func (k *Key) Validate(fn func(string) string) string {

	return fn(k.String())

}

// parseBool returns the boolean value represented by the string.

//

// It accepts 1, t, T, TRUE, true, True, YES, yes, Yes, y, ON, on, On,

// 0, f, F, FALSE, false, False, NO, no, No, n, OFF, off, Off.

// Any other value returns an error.

func parseBool(str string) (value bool, err error) {

	switch str {

	case "1", "t", "T", "true", "TRUE", "True", "YES", "yes", "Yes", "y", "ON", "on", "On":

		return true, nil

	case "0", "f", "F", "false", "FALSE", "False", "NO", "no", "No", "n", "OFF", "off", "Off":

		return false, nil

	}

	return false, fmt.Errorf("parsing \"%s\": invalid syntax", str)

}

// Bool returns bool type value.

func (k *Key) Bool() (bool, error) {

	return parseBool(k.String())

}

// Float64 returns float64 type value.

func (k *Key) Float64() (float64, error) {

	return strconv.ParseFloat(k.String(), 64)

}

// Int returns int type value.

func (k *Key) Int() (int, error) {

	v, err := strconv.ParseInt(k.String(), 0, 64)

	return int(v), err

}

// Int64 returns int64 type value.

func (k *Key) Int64() (int64, error) {

	return strconv.ParseInt(k.String(), 0, 64)

}

// Uint returns uint type valued.

func (k *Key) Uint() (uint, error) {

	u, e := strconv.ParseUint(k.String(), 0, 64)

	return uint(u), e

}

// Uint64 returns uint64 type value.

func (k *Key) Uint64() (uint64, error) {

	return strconv.ParseUint(k.String(), 0, 64)

}

// Duration returns time.Duration type value.

func (k *Key) Duration() (time.Duration, error) {

	return time.ParseDuration(k.String())

}

// TimeFormat parses with given format and returns time.Time type value.

func (k *Key) TimeFormat(format string) (time.Time, error) {

	return time.Parse(format, k.String())

}

// Time parses with RFC3339 format and returns time.Time type value.

func (k *Key) Time() (time.Time, error) {

	return k.TimeFormat(time.RFC3339)

}

// MustString returns default value if key value is empty.

func (k *Key) MustString(defaultVal string) string {

	val := k.String()

	if len(val) == 0 {

		k.value = defaultVal

		return defaultVal

	}

	return val

}

// MustBool always returns value without error,

// it returns false if error occurs.

func (k *Key) MustBool(defaultVal ...bool) bool {

	val, err := k.Bool()

	if len(defaultVal) > 0 && err != nil {

		k.value = strconv.FormatBool(defaultVal[0])

		return defaultVal[0]

	}

	return val

}

// MustFloat64 always returns value without error,

// it returns 0.0 if error occurs.

func (k *Key) MustFloat64(defaultVal ...float64) float64 {

	val, err := k.Float64()

	if len(defaultVal) > 0 && err != nil {

		k.value = strconv.FormatFloat(defaultVal[0], 'f', -1, 64)

		return defaultVal[0]

	}

	return val

}

// MustInt always returns value without error,

// it returns 0 if error occurs.

func (k *Key) MustInt(defaultVal ...int) int {

	val, err := k.Int()

	if len(defaultVal) > 0 && err != nil {

		k.value = strconv.FormatInt(int64(defaultVal[0]), 10)

		return defaultVal[0]

	}

	return val

}

// MustInt64 always returns value without error,

// it returns 0 if error occurs.

func (k *Key) MustInt64(defaultVal ...int64) int64 {

	val, err := k.Int64()

	if len(defaultVal) > 0 && err != nil {

		k.value = strconv.FormatInt(defaultVal[0], 10)

		return defaultVal[0]

	}

	return val

}

// MustUint always returns value without error,

// it returns 0 if error occurs.

func (k *Key) MustUint(defaultVal ...uint) uint {

	val, err := k.Uint()

	if len(defaultVal) > 0 && err != nil {

		k.value = strconv.FormatUint(uint64(defaultVal[0]), 10)

		return defaultVal[0]

	}

	return val

}

// MustUint64 always returns value without error,

// it returns 0 if error occurs.

func (k *Key) MustUint64(defaultVal ...uint64) uint64 {

	val, err := k.Uint64()

	if len(defaultVal) > 0 && err != nil {

		k.value = strconv.FormatUint(defaultVal[0], 10)

		return defaultVal[0]

	}

	return val

}

// MustDuration always returns value without error,

// it returns zero value if error occurs.

func (k *Key) MustDuration(defaultVal ...time.Duration) time.Duration {

	val, err := k.Duration()

	if len(defaultVal) > 0 && err != nil {

		k.value = defaultVal[0].String()

		return defaultVal[0]

	}

	return val

}

// MustTimeFormat always parses with given format and returns value without error,

// it returns zero value if error occurs.

func (k *Key) MustTimeFormat(format string, defaultVal ...time.Time) time.Time {

	val, err := k.TimeFormat(format)

	if len(defaultVal) > 0 && err != nil {

		k.value = defaultVal[0].Format(format)

		return defaultVal[0]

	}

	return val

}

// MustTime always parses with RFC3339 format and returns value without error,

// it returns zero value if error occurs.

func (k *Key) MustTime(defaultVal ...time.Time) time.Time {

	return k.MustTimeFormat(time.RFC3339, defaultVal...)

}

// In always returns value without error,

// it returns default value if error occurs or doesn't fit into candidates.

func (k *Key) In(defaultVal string, candidates []string) string {

	val := k.String()

	for _, cand := range candidates {

		if val == cand {

			return val

		}

	}

	return defaultVal

}

// InFloat64 always returns value without error,

// it returns default value if error occurs or doesn't fit into candidates.

func (k *Key) InFloat64(defaultVal float64, candidates []float64) float64 {

	val := k.MustFloat64()

	for _, cand := range candidates {

		if val == cand {

			return val

		}

	}

	return defaultVal

}

// InInt always returns value without error,

// it returns default value if error occurs or doesn't fit into candidates.

func (k *Key) InInt(defaultVal int, candidates []int) int {

	val := k.MustInt()

	for _, cand := range candidates {

		if val == cand {

			return val

		}

	}

	return defaultVal

}

// InInt64 always returns value without error,

// it returns default value if error occurs or doesn't fit into candidates.

func (k *Key) InInt64(defaultVal int64, candidates []int64) int64 {

	val := k.MustInt64()

	for _, cand := range candidates {

		if val == cand {

			return val

		}

	}

	return defaultVal

}

// InUint always returns value without error,

// it returns default value if error occurs or doesn't fit into candidates.

func (k *Key) InUint(defaultVal uint, candidates []uint) uint {

	val := k.MustUint()

	for _, cand := range candidates {

		if val == cand {

			return val

		}

	}

	return defaultVal

}

// InUint64 always returns value without error,

// it returns default value if error occurs or doesn't fit into candidates.

func (k *Key) InUint64(defaultVal uint64, candidates []uint64) uint64 {