package utils

import (
	"bytes"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"github.com/beego/beego/v2/core/validation"
	"github.com/bwmarrin/snowflake"
	jsonlib "github.com/linmadan/egglib-go/utils/json"
	"github.com/shopspring/decimal"
	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
	"io"
	"io/ioutil"
	"reflect"
	"strconv"
	"strings"
	"time"
)

func CamelCase(name string, firstUpper bool) string {
	array := []byte(name)
	if len(array) == 0 {
		return ""
	}
	rspArray := make([]byte, len(array))
	if firstUpper {
		copy(rspArray[:1], strings.ToUpper(string(array[:1])))
	} else {
		copy(rspArray[:1], strings.ToLower(string(array[:1])))
	}
	copy(rspArray[1:], array[1:])
	return string(rspArray)
}

func ObjectToMap(o interface{}) map[string]interface{} {
	if o == nil {
		return nil
	}
	value := reflect.ValueOf(o)
	if value.Kind() != reflect.Ptr {
		return nil
	}
	elem := value.Elem()
	relType := elem.Type()
	m := make(map[string]interface{})
	for i := 0; i < relType.NumField(); i++ {
		field := relType.Field(i)
		if elem.Field(i).IsZero() {
			continue
		}
		m[CamelCase(field.Name, false)] = elem.Field(i).Interface()
	}
	return m
}

func ToMap(o interface{}) map[string]interface{} {
	if o == nil {
		return nil
	}
	m := make(map[string]interface{})
	data, _ := json.Marshal(o)
	json.Unmarshal(data, &m)
	return m
}

func DeleteMapKeys(options map[string]interface{}, keys ...string) map[string]interface{} {
	for i := range keys {
		if _, ok := options[keys[i]]; ok {
			delete(options, keys[i])
		}
	}
	return options
}

// AssertString convert v to string value
func AssertString(v interface{}) string {
	if v == nil {
		return ""
	}

	// if func (v *Type) String() string, we can't use Elem()
	switch vt := v.(type) {
	case fmt.Stringer:
		return vt.String()
	}

	val := reflect.ValueOf(v)
	if val.Kind() == reflect.Ptr && !val.IsNil() {
		val = val.Elem()
	}

	switch vt := val.Interface().(type) {
	case bool:
		return strconv.FormatBool(vt)
	case error:
		return vt.Error()
	case float32:
		return strconv.FormatFloat(float64(vt), 'f', -1, 32)
	case float64:
		return strconv.FormatFloat(vt, 'f', -1, 64)
	case fmt.Stringer:
		return vt.String()
	case int:
		return strconv.Itoa(vt)
	case int8:
		return strconv.Itoa(int(vt))
	case int16:
		return strconv.Itoa(int(vt))
	case int32:
		return strconv.Itoa(int(vt))
	case int64:
		return strconv.FormatInt(vt, 10)
	case string:
		return vt
	case uint:
		return strconv.FormatUint(uint64(vt), 10)
	case uint8:
		return strconv.FormatUint(uint64(vt), 10)
	case uint16:
		return strconv.FormatUint(uint64(vt), 10)
	case uint32:
		return strconv.FormatUint(uint64(vt), 10)
	case uint64:
		return strconv.FormatUint(vt, 10)
	case []byte:
		return string(vt)
	default:
		return fmt.Sprint(val.Interface())
	}
}

// ValidatePtr validate v is a ptr value
func ValidatePtr(v *reflect.Value) error {
	// sequence is very important, IsNil must be called after checking Kind() with reflect.Ptr,
	// panic otherwise
	if !v.IsValid() || v.Kind() != reflect.Ptr || v.IsNil() {
		return fmt.Errorf("not a valid pointer: %v", v)
	}

	return nil
}

func LoadCustomFieldToMap(src interface{}, fields ...string) map[string]interface{} {
	rsp := LoadCustomField(src, fields...)
	if rsp == nil {
		return map[string]interface{}{}
	}
	return rsp.(map[string]interface{})
}

func LoadCustomField(src interface{}, fields ...string) interface{} {
	typeSrc := reflect.TypeOf(src)
	valueSrc := reflect.ValueOf(src)

	if v, ok := src.(reflect.Value); ok {
		valueSrc = v
		typeSrc = v.Type()
	}
	if typeSrc.Kind() == reflect.Ptr {
		valueSrc = valueSrc.Elem()
	}
	k := valueSrc.Kind()
	switch k {
	case reflect.Array, reflect.Slice:
		len := valueSrc.Len()
		retSliceMap := make([]map[string]interface{}, 0)
		if len == 0 {
			return retSliceMap
		}
		for i := 0; i < len; i++ {
			v := valueSrc.Index(i)
			retSliceMap = append(retSliceMap, (LoadCustomField(v, fields...)).(map[string]interface{}))
		}
		return retSliceMap
	case reflect.Struct:
		retSliceMap := make(map[string]interface{})
		for _, filed := range fields {
			f := valueSrc.FieldByName(filed)
			if !f.IsValid() {
				continue
			}
			v := f.Interface()
			if t, ok := v.(time.Time); ok {
				v = t.Local().Format("2006-01-02 15:04:05")
			}
			retSliceMap[CamelCase(filed, false)] = v
		}
		return retSliceMap
	default:
		return src
	}
	return src
}

func AppendCustomField(src interface{}, options map[string]interface{}) interface{} {
	var mapSrc map[string]interface{}
	var ok bool
	mapSrc, ok = src.(map[string]interface{})
	if !ok {
		jsonlib.Unmarshal([]byte(jsonlib.MarshalToString(src)), &mapSrc)
	}
	for field, value := range options {
		mapSrc[CamelCase(field, false)] = value
	}
	return mapSrc
}

/*

json 格式化

*/

func Marshal(v interface{}) ([]byte, error) {
	return json.Marshal(v)
}

func Unmarshal(data []byte, v interface{}) error {
	decoder := json.NewDecoder(bytes.NewReader(data))
	if err := unmarshalUseNumber(decoder, v); err != nil {
		return formatError(string(data), err)
	}

	return nil
}

func UnmarshalFromString(str string, v interface{}) error {
	decoder := json.NewDecoder(strings.NewReader(str))
	if err := unmarshalUseNumber(decoder, v); err != nil {
		return formatError(str, err)
	}

	return nil
}

func UnmarshalFromReader(reader io.Reader, v interface{}) error {
	var buf strings.Builder
	teeReader := io.TeeReader(reader, &buf)
	decoder := json.NewDecoder(teeReader)
	if err := unmarshalUseNumber(decoder, v); err != nil {
		return formatError(buf.String(), err)
	}

	return nil
}

func unmarshalUseNumber(decoder *json.Decoder, v interface{}) error {
	decoder.UseNumber()
	return decoder.Decode(v)
}

func formatError(v string, err error) error {
	return fmt.Errorf("string: `%s`, error: `%s`", v, err.Error())
}

type ReflectVal struct {
	T reflect.Type
	V reflect.Value
}

/*
	拷贝当前对象到目标对象，具有相同属性的值
*/
func CopyObject(src, dst interface{}) {
	var srcMap = make(map[string]ReflectVal)

	vs := reflect.ValueOf(src)
	ts := reflect.TypeOf(src)
	vd := reflect.ValueOf(dst)
	td := reflect.TypeOf(dst)

	ls := vs.Elem().NumField()
	for i := 0; i < ls; i++ {
		srcMap[ts.Elem().Field(i).Name] = ReflectVal{
			T: vs.Elem().Field(i).Type(),
			V: vs.Elem().Field(i),
		}
	}

	ld := vd.Elem().NumField()
	for i := 0; i < ld; i++ {
		n := td.Elem().Field(i).Name
		t := vd.Elem().Field(i).Type()
		if v, ok := srcMap[n]; ok && v.T == t && vd.Elem().Field(i).CanSet() {
			vd.Elem().Field(i).Set(v.V)
		}
	}
}

/*
	时间计算
*/

func ValidWorkTime(t string) error {
	ts := strings.Split(t, ":")
	if len(ts) != 2 {
		return fmt.Errorf("时间格式有误")
	}
	ts1, err := strconv.Atoi(ts[0])
	if err != nil {
		return fmt.Errorf("小时格式有误")
	}
	if !(ts1 < 24 && ts1 >= 0) {
		return fmt.Errorf("小时格式有误")
	}
	ts2, err := strconv.Atoi(ts[1])
	if err != nil {
		return fmt.Errorf("分钟格式有误")
	}
	if !(ts2 < 60 && ts2 >= 0) {
		return fmt.Errorf("分钟格式有误")
	}
	return nil
}

// 计算两个时间间隔的时间
func ComputeTimeDuration(t1, t2 string) (result time.Duration, err error) {
	if err = ValidWorkTime(t1); err != nil {
		return
	}
	if err = ValidWorkTime(t2); err != nil {
		return
	}
	t1s := strings.Split(t1, ":")
	t1sHour, _ := strconv.Atoi(t1s[0])
	t1sMin, _ := strconv.Atoi(t1s[1])

	t2s := strings.Split(t2, ":")
	t2sHour, _ := strconv.Atoi(t2s[0])
	t2sMin, _ := strconv.Atoi(t2s[1])
	var t1t, t2t time.Time
	if t1sHour < t2sHour {
		t1t = time.Date(2006, 1, 1, t1sHour, t1sMin, 0, 0, time.Local)
		t2t = time.Date(2006, 1, 1, t2sHour, t2sMin, 0, 0, time.Local)
	} else {
		t1t = time.Date(2006, 1, 1, t1sHour, t1sMin, 0, 0, time.Local)
		t2t = time.Date(2006, 1, 2, t2sHour, t2sMin, 0, 0, time.Local)
	}
	ts := t2t.Sub(t1t)
	return ts, nil
}

func ToArrayString(inputs []int) []string {
	result := make([]string, 0)
	for i := range inputs {
		result = append(result, strconv.Itoa(inputs[i]))
	}
	return result
}

func ToArrayInt(inputs []string) []int {
	result := make([]int, 0)
	for i := range inputs {
		v, _ := strconv.Atoi(inputs[i])
		result = append(result, v)
	}
	return result
}

func LoadQueryObject(queryOption map[string]interface{}, obj interface{}) error {
	jsonlib.UnmarshalFromString(jsonlib.MarshalToString(queryOption), obj)
	validation := validation.Validation{}
	result, err := validation.Valid(obj)
	if !result && len(validation.Errors) > 0 {
		return validation.Errors[0]
	}
	return err
}

// 字符串截取
func SubStr(str string, start, length int) string {
	rs := []rune(str)
	rl := len(rs)
	end := 0
	if start < 0 {
		start = rl - 1 + start
	}
	end = start + length
	if start > end {
		start, end = end, start
	}
	if start < 0 {
		start = 0
	}
	if start > rl {
		start = rl
	}
	if end < 0 {
		end = 0
	}
	if end > rl {
		end = rl
	}
	return string(rs[start:end])
}

//生成新ID
var snowFlakeNode *snowflake.Node

func NewSnowflakeId() (int64, error) {
	if snowFlakeNode == nil {
		node, err := snowflake.NewNode(1)
		if err != nil {
			return 0, err
		}
		snowFlakeNode = node
	}
	// Generate a snowflake ID.
	id := snowFlakeNode.Generate()
	return id.Int64(), nil
}

// Round 保留数值的精度位 四舍五入
func Round(value float64, places int32) float64 {
	quantity := decimal.NewFromFloat(value)
	d := quantity.Round(places)
	rsp, _ := d.Float64()
	return rsp
}

// Truncate 截取数值固定长度的 eg:Truncate(99.99,1)  Result: 99.9
func Truncate(value float64, places int32) float64 {
	quantity := decimal.NewFromFloat(value).Truncate(places)
	rsp, _ := quantity.Float64()
	return rsp
}

func Utf8ToGbk(s []byte) ([]byte, error) {
	reader := transform.NewReader(bytes.NewReader(s), simplifiedchinese.GBK.NewEncoder())
	d, e := ioutil.ReadAll(reader)
	if e != nil {
		return nil, e
	}
	return d, nil
}

func GbkToUtf8(s []byte) ([]byte, error) {
	reader := transform.NewReader(bytes.NewReader(s), simplifiedchinese.GBK.NewDecoder())
	d, e := ioutil.ReadAll(reader)
	if e != nil {
		return nil, e
	}
	return d, nil
}

// GenMd5 Generate a 32-bit md5 string
func GenMd5(src interface{}) string {
	h := md5.New()
	if s, ok := src.(string); ok {
		h.Write([]byte(s))
	} else {
		h.Write([]byte(fmt.Sprint(src)))
	}

	return hex.EncodeToString(h.Sum(nil))
}