package helper

import (
	"reflect"
	"strings"
)

type Result struct {
	val interface{}
}

func NewResult(val interface{}) *Result {
	return &Result{val: val}
}

func (r *Result) String(defaultval ...string) string {
	switch val := r.val.(type) {
	case string:
		return val
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return ""
	}
}

func (r *Result) Val() interface{} {
	return r.val
}

func (r *Result) Result() interface{} {
	return r.val
}

func (r *Result) Int(defaultval ...int) int {
	switch val := r.val.(type) {
	case int:
		return val
	case string:
		return NewStr(val).ToInt()
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return 0
	}
}

func (r *Result) Int64(defaultval ...int64) int64 {
	switch val := r.val.(type) {
	case int64:
		return val
	case string:
		return NewStr(val).ToInt64()
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return 0
	}
}

func (r *Result) Uint64(defaultval ...uint64) uint64 {
	switch val := r.val.(type) {
	case uint64:
		return val
	case string:
		return NewStr(val).ToUint64()
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return 0
	}
}

func (r *Result) Float32(defaultval ...float32) float32 {
	switch val := r.val.(type) {
	case float32:
		return val
	case string:
		return NewStr(val).ToFloat32()
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return 0
	}
}

func (r *Result) Float64(defaultval ...float64) float64 {
	switch val := r.val.(type) {
	case float64:
		return val
	case string:
		return NewStr(val).ToFloat64()
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return 0
	}
}

func (r *Result) Bool(defaultval ...bool) bool {
	switch val := r.val.(type) {
	case bool:
		return val
	case string:
		return NewStr(val).ToBool()
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return false
	}
}

func (r *Result) Bytes(defaultval ...[]byte) []byte {
	switch val := r.val.(type) {
	case []byte:
		return val
	case string:
		return NewStr(val).ToBytes()
	default:
		for k, v := range defaultval {
			if k == 0 {
				return v
			}
		}
		return nil
	}
}

//是否为空
func (r *Result) Empty() bool {
	if r.val == nil {
		return true
	}
	v := reflect.ValueOf(r.val)
	switch v.Kind() {
	case reflect.String, reflect.Array:
		return v.Len() == 0
	case reflect.Map, reflect.Slice:
		return v.Len() == 0 || v.IsNil()
	case reflect.Bool:
		return !v.Bool()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return v.Int() == 0
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return v.Uint() == 0
	case reflect.Float32, reflect.Float64:
		return v.Float() == 0
	case reflect.Interface, reflect.Ptr:
		return v.IsNil()
	}
	return reflect.DeepEqual(r.val, reflect.Zero(v.Type()).Interface())
}

//判断是否为数字
func (r *Result) IsNumeric() bool {
	switch r.val.(type) {
	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
		return true
	case float32, float64, complex64, complex128:
		return true
	case string:
		str := r.val.(string)
		if str == "" {
			return false
		}
		str = strings.TrimSpace(str)
		if str[0] == '-' || str[0] == '+' {
			if len(str) == 1 {
				return false
			}
			str = str[1:]
		}
		if len(str) > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X') {
			for _, h := range str[2:] {
				if !((h >= '0' && h <= '9') || (h >= 'a' && h <= 'f') || (h >= 'A' && h <= 'F')) {
					return false
				}
			}
			return true
		}
		p, s, l := 0, 0, len(str)
		for i, v := range str {
			if v == '.' {
				if p > 0 || s > 0 || i+1 == l {
					return false
				}
				p = i
			} else if v == 'e' || v == 'E' {
				if i == 0 || s > 0 || i+1 == l {
					return false
				}
				s = i
			} else if v < '0' || v > '9' {
				return false
			}
		}
		return true
	}
	return false
}