package types

import (
	"errors"
)

var (
	ErrExistKey = errors.New("not exist.")
	ErrFormat   = errors.New("error format.")
)

type Data map[string]interface{}

func (data Data) Get(key string) (interface{}, error) {
	value, exist := data[key]
	if !exist {
		return "", ErrExistKey
	}

	return value, nil
}

func (data Data) GetString(key string) (string, error) {
	value, err := data.Get(key)
	if err != nil {
		return "", err
	}

	switch value.(type) {
	case string:
		return value.(string), nil
	}

	return "", ErrFormat
}

func (data Data) MustGetString(key string) string {
	value, _ := data.GetString(key)
	return value
}

func (data Data) GetSlice(key string) (res []interface{}, err error) {
	value, err := data.Get(key)
	if err != nil {
		return nil, err
	}

	switch value.(type) {
	case []interface{}:
		return value.([]interface{}), nil
	default:
		return nil, ErrFormat
	}
}

func (data Data) MustGetSlice(key string) []interface{} {
	values, _ := data.GetSlice(key)
	return values
}

func (data Data) GetStringSlice(key string) (res []string, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v.(type) {
		case string:
			res = append(res, v.(string))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

func (data Data) MustGetStringSlice(key string) []string {
	values, _ := data.GetStringSlice(key)
	return values
}

func (data Data) GetIntSlice(key string) (res []int, err error) {
	values, err := data.GetSlice(key)
	if err != nil {
		return nil, err
	}

	for _, v := range values {
		switch v.(type) {
		case float64:
			res = append(res, int(v.(float64)))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

func (data Data) MustGetIntSlice(key string) []int {
	values, _ := data.GetIntSlice(key)
	return values
}

func (data Data) GetInt64(key string) (int64, error) {
	value, err := data.Get(key)
	if err != nil {
		return 0, err
	}

	switch value.(type) {
	case int:
		return int64(value.(int)), nil

	case int64:
		return value.(int64), nil

	case float64:
		return int64(value.(float64)), nil
	}

	return 0, ErrFormat
}

func (data Data) MustGetInt64(key string) int64 {
	value, _ := data.GetInt64(key)
	return value
}

func (data Data) GetUint64(key string) (uint64, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint64(value), nil
}

func (data Data) MustGetUint64(key string) uint64 {
	value, _ := data.GetUint64(key)
	return value
}

func (data Data) GetInt(key string) (int, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int(value), nil
}

func (data Data) MustGetInt(key string) int {
	value, _ := data.GetInt(key)
	return value
}

func (data Data) GetUint(key string) (uint, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint(value), nil
}

func (data Data) MustGetUint(key string) uint {
	value, _ := data.GetUint(key)
	return value
}

func (data Data) GetInt16(key string) (int16, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int16(value), nil
}

func (data Data) GetUint16(key string) (uint16, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint16(value), nil
}

func (data Data) MustGetUint16(key string) uint16 {
	value, _ := data.GetUint16(key)
	return value
}

func (data Data) GetInt8(key string) (int8, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int8(value), nil
}

func (data Data) MustGetInt8(key string) int8 {
	value, _ := data.GetInt8(key)
	return value
}

func (data Data) GetUint8(key string) (uint8, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	if value < 0 {
		return 0, ErrFormat
	}

	return uint8(value), nil
}

func (data Data) MustGetUint8(key string) uint8 {
	value, _ := data.GetUint8(key)
	return value
}

func (data Data) GetBool(key string) (bool, error) {
	value, err := data.Get(key)
	if err != nil {
		return false, err
	}

	switch value.(type) {
	case bool:
		return value.(bool), nil
	}

	return false, ErrFormat
}

func (data Data) MustGetBool(key string) bool {
	value, _ := data.GetBool(key)
	return value
}

func (data Data) GetTimestamp(key string) (Timestamp, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return Timestamp(value), nil
}

func (data Data) MustGetTimestamp(key string) Timestamp {
	value, _ := data.GetTimestamp(key)
	return value
}