package utils

import (
	"bytes"
	"encoding/json"
	"fmt"
	jsonlib "github.com/linmadan/egglib-go/utils/json"
	"io"
	"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
}

// 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 ToArrayInt64(inputs []string) []int64 {
	result := make([]int64, 0)
	for i := range inputs {
		v, _ := strconv.ParseInt(inputs[i], 10, 64)
		result = append(result, v)
	}
	return result
}