package utils

import (
	"fmt"
	"reflect"
	"strconv"
)

/*
ObjForList
  - 集合实体对象映射（私有方法）
  - @param v reflect.Value 填充数据的对象
  - @return error 错误信息，正常时，该值为nil
*/
func ObjForList(m []map[string]string, v reflect.Value) error {

	// 1.reflect.ValueOf->获取接口保管的具体值(实例化)
	// 2.Indirect->获取该值的指针值
	sliceValue := reflect.Indirect(v)

	// 如果该对象类型不是切片类型，则返回类型错误

	// 获取切片集合中的类型
	sliceElementType := sliceValue.Type().Elem()

	for _, results := range m {
		// 根据切片集合中的类型，创建新的实体
		newValue := reflect.New(sliceElementType)

		// --类型为结构体，返回参数映射到结构体中
		if newValue.Elem().Kind() == reflect.Struct {
			StructMapping(results, newValue)
		} else if newValue.Elem().Kind() == reflect.Map {
			// --类型为Map
			newValue = reflect.ValueOf(results)
		} else {
			// --类型为基础类型：int,string,float,boolean
			for _, result := range results {
				BaseTypeMapping(result, newValue.Elem())
			}
		}

		// 获取映射后的对象实例的指针值
		rTemp := reflect.Indirect(reflect.ValueOf(newValue.Interface()))

		// 将映射后的对象实例的指针值复制到源对象指针中
		sliceValue.Set(reflect.Append(sliceValue, rTemp))
	}

	return nil
}

/*
BaseTypeMapping
  - 针对基本类型的数据映射
  - @m string 数据源
  - v reflect.value 目标对象
*/
func BaseTypeMapping(result string, newValue reflect.Value) {
	// 根据返回参数类型进行设置返回值：string,,float
	switch newValue.Kind() {
	// 返回类型为int,int8,int32,int64
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		i, _ := strconv.ParseInt(result, 10, 64)
		newValue.SetInt(i)
	case reflect.Float32:
		f, _ := strconv.ParseFloat(result, 32)
		newValue.SetFloat(f)
	case reflect.Float64:
		f, _ := strconv.ParseFloat(result, 64)
		newValue.SetFloat(f)
	case reflect.String:
		newValue.SetString(result)
	case reflect.Bool:
		b, _ := strconv.ParseBool(result)
		newValue.SetBool(b)
	default:
		panic("没有匹配到对应的类型")
	}
}

/*
StructMapping
  - 针对结构体映射，将返回值映射到结构体属性
  - @m map[string]string 数据源
  - v reflect.value 目标对象
*/
func StructMapping(m map[string]string, v reflect.Value) {
	t := v.Type()
	val := v.Elem()
	typ := t.Elem()

	// 检查结构体的数据类型
	if !val.IsValid() {
		panic("数据类型不正确")
	}

	for i := 0; i < val.NumField(); i++ {
		value := val.Field(i)

		// 获取字段注解
		tag := typ.Field(i).Tag.Get("col")

		if len(tag) > 0 {
			meta, ok := m[tag]
			if !ok {
				continue
			}
			// 判断字段是否有读写权限
			if !value.CanSet() {
				panic("结构体字段没有读写权限")
			}

			if len(meta) == 0 {
				continue
			}
			// 判读填充的数据类型，将值转换成对应的数据类型
			BaseTypeMapping(meta, value)
		}
	}
}

func IsBlank(value reflect.Value) bool {
	fmt.Println(value.Kind())
	switch value.Kind() {
	case reflect.String:
		return value.Len() == 0
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return value.Int() == 0
	case reflect.Float32, reflect.Float64:
		return value.Float() == 0
	case reflect.Interface, reflect.Ptr:
		return value.IsNil()
	}

	return reflect.DeepEqual(value.Interface(), reflect.Zero(value.Type()).Interface())
}