// Copyright © 2014 Steve Francia <spf@spf13.com>.

//

// Use of this source code is governed by an MIT-style

// license that can be found in the LICENSE file.

package cast

import (

	"encoding/json"

	"errors"

	"fmt"

	"html/template"

	"reflect"

	"strconv"

	"strings"

	"time"

)

var errNegativeNotAllowed = errors.New("unable to cast negative value")

// ToTimeE casts an interface to a time.Time type.

func ToTimeE(i interface{}) (tim time.Time, err error) {

	i = indirect(i)

	switch v := i.(type) {

	case time.Time:

		return v, nil

	case string:

		return StringToDate(v)

	case int:

		return time.Unix(int64(v), 0), nil

	case int64:

		return time.Unix(v, 0), nil

	case int32:

		return time.Unix(int64(v), 0), nil

	case uint:

		return time.Unix(int64(v), 0), nil

	case uint64:

		return time.Unix(int64(v), 0), nil

	case uint32:

		return time.Unix(int64(v), 0), nil

	default:

		return time.Time{}, fmt.Errorf("unable to cast %#v of type %T to Time", i, i)

	}

}

// ToDurationE casts an interface to a time.Duration type.

func ToDurationE(i interface{}) (d time.Duration, err error) {

	i = indirect(i)

	switch s := i.(type) {

	case time.Duration:

		return s, nil

	case int, int64, int32, int16, int8, uint, uint64, uint32, uint16, uint8:

		d = time.Duration(ToInt64(s))

		return

	case float32, float64:

		d = time.Duration(ToFloat64(s))

		return

	case string:

		if strings.ContainsAny(s, "nsuµmh") {

			d, err = time.ParseDuration(s)

		} else {

			d, err = time.ParseDuration(s + "ns")

		}

		return

	default:

		err = fmt.Errorf("unable to cast %#v of type %T to Duration", i, i)

		return

	}

}

// ToBoolE casts an interface to a bool type.

func ToBoolE(i interface{}) (bool, error) {

	i = indirect(i)

	switch b := i.(type) {

	case bool:

		return b, nil

	case nil:

		return false, nil

	case int:

		if i.(int) != 0 {

			return true, nil

		}

		return false, nil

	case string:

		return strconv.ParseBool(i.(string))

	default:

		return false, fmt.Errorf("unable to cast %#v of type %T to bool", i, i)

	}

}

// ToFloat64E casts an interface to a float64 type.

func ToFloat64E(i interface{}) (float64, error) {

	i = indirect(i)

	switch s := i.(type) {

	case float64:

		return s, nil

	case float32:

		return float64(s), nil

	case int:

		return float64(s), nil

	case int64:

		return float64(s), nil

	case int32:

		return float64(s), nil

	case int16:

		return float64(s), nil

	case int8:

		return float64(s), nil

	case uint:

		return float64(s), nil

	case uint64:

		return float64(s), nil

	case uint32:

		return float64(s), nil

	case uint16:

		return float64(s), nil

	case uint8:

		return float64(s), nil

	case string:

		v, err := strconv.ParseFloat(s, 64)

		if err == nil {

			return v, nil

		}

		return 0, fmt.Errorf("unable to cast %#v of type %T to float64", i, i)

	case bool:

		if s {

			return 1, nil

		}

		return 0, nil

	default:

		return 0, fmt.Errorf("unable to cast %#v of type %T to float64", i, i)

	}

}

// ToFloat32E casts an interface to a float32 type.

func ToFloat32E(i interface{}) (float32, error) {

	i = indirect(i)

	switch s := i.(type) {

	case float64:

		return float32(s), nil

	case float32:

		return s, nil

	case int:

		return float32(s), nil

	case int64:

		return float32(s), nil

	case int32:

		return float32(s), nil

	case int16:

		return float32(s), nil

	case int8:

		return float32(s), nil

	case uint:

		return float32(s), nil

	case uint64:

		return float32(s), nil

	case uint32:

		return float32(s), nil

	case uint16:

		return float32(s), nil

	case uint8:

		return float32(s), nil

	case string:

		v, err := strconv.ParseFloat(s, 32)

		if err == nil {

			return float32(v), nil

		}

		return 0, fmt.Errorf("unable to cast %#v of type %T to float32", i, i)

	case bool:

		if s {

			return 1, nil

		}

		return 0, nil

	default:

		return 0, fmt.Errorf("unable to cast %#v of type %T to float32", i, i)

	}

}

// ToInt64E casts an interface to an int64 type.

func ToInt64E(i interface{}) (int64, error) {

	i = indirect(i)

	switch s := i.(type) {

	case int:

		return int64(s), nil

	case int64:

		return s, nil

	case int32:

		return int64(s), nil

	case int16:

		return int64(s), nil

	case int8:

		return int64(s), nil

	case uint:

		return int64(s), nil

	case uint64:

		return int64(s), nil

	case uint32:

		return int64(s), nil

	case uint16:

		return int64(s), nil

	case uint8:

		return int64(s), nil

	case float64:

		return int64(s), nil

	case float32:

		return int64(s), nil

	case string:

		v, err := strconv.ParseInt(s, 0, 0)

		if err == nil {

			return v, nil

		}

		return 0, fmt.Errorf("unable to cast %#v of type %T to int64", i, i)

	case bool:

		if s {

			return 1, nil

		}

		return 0, nil

	case nil:

		return 0, nil

	default:

		return 0, fmt.Errorf("unable to cast %#v of type %T to int64", i, i)

	}

}

// ToInt32E casts an interface to an int32 type.

func ToInt32E(i interface{}) (int32, error) {

	i = indirect(i)

	switch s := i.(type) {

	case int:

		return int32(s), nil

	case int64:

		return int32(s), nil

	case int32:

		return s, nil

	case int16:

		return int32(s), nil

	case int8:

		return int32(s), nil

	case uint:

		return int32(s), nil

	case uint64:

		return int32(s), nil

	case uint32:

		return int32(s), nil

	case uint16:

		return int32(s), nil

	case uint8:

		return int32(s), nil

	case float64:

		return int32(s), nil

	case float32:

		return int32(s), nil

	case string:

		v, err := strconv.ParseInt(s, 0, 0)

		if err == nil {

			return int32(v), nil

		}

		return 0, fmt.Errorf("unable to cast %#v of type %T to int32", i, i)

	case bool:

		if s {

			return 1, nil

		}

		return 0, nil

	case nil:

		return 0, nil

	default:

		return 0, fmt.Errorf("unable to cast %#v of type %T to int32", i, i)

	}

}

// ToInt16E casts an interface to an int16 type.

func ToInt16E(i interface{}) (int16, error) {

	i = indirect(i)

	switch s := i.(type) {

	case int:

		return int16(s), nil

	case int64:

		return int16(s), nil

	case int32:

		return int16(s), nil

	case int16:

		return s, nil

	case int8:

		return int16(s), nil

	case uint:

		return int16(s), nil

	case uint64:

		return int16(s), nil

	case uint32:

		return int16(s), nil

	case uint16:

		return int16(s), nil

	case uint8:

		return int16(s), nil

	case float64:

		return int16(s), nil

	case float32:

		return int16(s), nil

	case string:

		v, err := strconv.ParseInt(s, 0, 0)

		if err == nil {

			return int16(v), nil

		}

		return 0, fmt.Errorf("unable to cast %#v of type %T to int16", i, i)

	case bool:

		if s {

			return 1, nil

		}

		return 0, nil

	case nil:

		return 0, nil

	default:

		return 0, fmt.Errorf("unable to cast %#v of type %T to int16", i, i)

	}

}

// ToInt8E casts an interface to an int8 type.

func ToInt8E(i interface{}) (int8, error) {

	i = indirect(i)

	switch s := i.(type) {

	case int:

		return int8(s), nil

	case int64:

		return int8(s), nil

	case int32:

		return int8(s), nil

	case int16:

		return int8(s), nil

	case int8:

		return s, nil

	case uint:

		return int8(s), nil

	case uint64:

		return int8(s), nil

	case uint32:

		return int8(s), nil

	case uint16:

		return int8(s), nil

	case uint8:

		return int8(s), nil

	case float64:

		return int8(s), nil

	case float32:

		return int8(s), nil

	case string:

		v, err := strconv.ParseInt(s, 0, 0)

		if err == nil {

			return int8(v), nil

		}

		return 0, fmt.Errorf("unable to cast %#v of type %T to int8", i, i)

	case bool:

		if s {

			return 1, nil

		}

		return 0, nil

	case nil:

		return 0, nil

	default:

		return 0, fmt.Errorf("unable to cast %#v of type %T to int8", i, i)

	}

}

// ToIntE casts an interface to an int type.

func ToIntE(i interface{}) (int, error) {

	i = indirect(i)

	switch s := i.(type) {

	case int:

		return s, nil

	case int64:

		return int(s), nil

	case int32:

		return int(s), nil

	case int16:

		return int(s), nil

	case int8:

		return int(s), nil

	case uint:

		return int(s), nil

	case uint64:

		return int(s), nil

	case uint32:

		return int(s), nil

	case uint16:

		return int(s), nil

	case uint8:

		return int(s), nil

	case float64:

		return int(s), nil

	case float32:

		return int(s), nil

	case string:

		v, err := strconv.ParseInt(s, 0, 0)

		if err == nil {

			return int(v), nil

		}

		return 0, fmt.Errorf("unable to cast %#v of type %T to int", i, i)