package jk

import (
	"encoding/base64"
	"reflect"
	"strconv"
)

// isPointerType 判断是否为地址类型（结构体指针类型）
func isPointerType(v any) bool {
	rv := reflect.ValueOf(v)
	if rv.Kind() != reflect.Pointer || rv.IsNil() {
		return false
	}
	return true
}

// fieldDecode 将src的值，解码到dst上面
func fieldDecode(tag string, dst any, src map[string][]string) {
	tf := reflect.TypeOf(dst)
	vf := reflect.ValueOf(dst)
	for i := 0; i < tf.Elem().NumField(); i++ {
		fTag := tf.Elem().Field(i).Tag.Get(tag)
		if fTag == "" {
			continue
		}
		if v, ok := src[fTag]; ok {
			if len(v) < 0 {
				continue
			}
			field := vf.Elem().Field(i)
			autoSetValue(field, v)
		}
	}
}

// autoSetValue 自动为字段赋值value
func autoSetValue(field reflect.Value, value []string) {
	if len(value) <= 0 {
		return
	}
	switch field.Kind() {
	case reflect.Array:
		if field.Type().Elem().Kind() == reflect.Uint8 {
			for i, val := range value[0] {
				index := field.Index(i)
				index.SetUint(uint64(val))
			}
		} else {
			for i, val := range value {
				index := field.Index(i)
				autoSetValueOne(index, val)
			}
		}
	case reflect.Slice:
		if field.Type().Elem().Kind() == reflect.Uint8 {
			b := make([]byte, base64.StdEncoding.DecodedLen(len(value[0])))
			n, err := base64.StdEncoding.Decode(b, []byte(value[0]))
			if err == nil {
				field.SetBytes(b[:n])
			}
		} else {
			slice := reflect.MakeSlice(field.Type(), len(value), len(value))
			for i, val := range value {
				index := slice.Index(i)
				autoSetValueOne(index, val)
			}
			field.Set(slice)
		}
	default:
		autoSetValueOne(field, value[0])
	}
}

func autoSetValueOne(field reflect.Value, value string) {
	switch field.Kind() {
	case reflect.Bool:
		rt, err := strconv.ParseBool(value)
		if err == nil {
			field.SetBool(rt)
		}
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		rt, err := strconv.ParseInt(value, 10, 64)
		if err == nil && false == field.OverflowInt(rt) {
			field.SetInt(rt)
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		rt, err := strconv.ParseUint(value, 10, 64)
		if err == nil && false == field.OverflowUint(rt) {
			field.SetUint(rt)
		}
	case reflect.Float32, reflect.Float64:
		rt, err := strconv.ParseFloat(value, field.Type().Bits())
		if err == nil && false == field.OverflowFloat(rt) {
			field.SetFloat(rt)
		}
	case reflect.String:
		field.SetString(value)
	default:
		if value == "null" {
			field.SetZero()
		} else if field.NumMethod() == 0 {
			field.Set(reflect.ValueOf(value))
		}
	}
}