package entity

import (
	"admin/apps/game/model"
	"admin/apps/game/model/dto"
	"admin/lib/xlog"
	"fmt"
	"gorm.io/gorm"
	"reflect"
	"strconv"
	"strings"
	"time"
)

func poToCommonDtoNo(po any) dto.CommonDtoValues {
	obj := make(dto.CommonDtoValues)

	to := reflect.TypeOf(po).Elem()
	vo := reflect.ValueOf(po).Elem()
	for i := 0; i < vo.NumField(); i++ {
		ft := to.Field(i)
		fo := vo.Field(i)

		if ft.Name == "ProjectId" {
			if _, ok := po.(*model.Project); !ok {
				continue
			}
		}

		obj[ft.Name] = fo.Interface()

		if ft.Type.Name() == "Time" && ft.Type.PkgPath() == "time" {
			obj[ft.Name] = fo.Interface().(time.Time).Format(time.DateTime)
		}
	}

	return obj
}

func getFieldTypeDtoDescInfo(projectId string, poValue reflect.Value, fieldType reflect.StructField) *dto.CommonDtoFieldDesc {
	name := fieldType.Tag.Get("name")
	if name == "" {
		name = fieldType.Name
	}
	f1 := &dto.CommonDtoFieldDesc{
		Name:        name,
		Key:         fieldType.Name,
		Type:        fieldType.Type.Name(),
		HelpText:    fieldType.Tag.Get("desc"),
		Readonly:    fieldType.Tag.Get("readonly") == "true",
		Required:    fieldType.Tag.Get("required") == "true",
		Choices:     make([]*dto.CommonDtoFieldChoice, 0),
		MultiChoice: fieldType.Tag.Get("multi_choice") == "true",
		Uneditable:  fieldType.Tag.Get("uneditable") == "true",
	}

	if f1.Key == "CreatedAt" {
		f1.Name = "创建时间"
	}

	if tagType := fieldType.Tag.Get("type"); tagType != "" {
		f1.Type = tagType
	}

	cf := fieldType.Tag.Get("choices")
	if cf != "" {
		method := poValue.MethodByName(cf)
		if !method.IsValid() {
			xlog.Warnf("po %v choices %v function not found in model", poValue.Type().Name(), cf)
		} else {
			rets := method.Call([]reflect.Value{reflect.ValueOf(projectId)})
			f1.Choices = rets[0].Interface().([]*dto.CommonDtoFieldChoice)
		}

	}

	return f1
}

func parseStr2FieldValue(field reflect.StructField, rawValue any) (realSetValue reflect.Value) {
	setValue := fmt.Sprintf("%v", rawValue)
	var parsedValue any
	switch field.Type.Kind() {
	case reflect.Int:
		v, _ := strconv.Atoi(setValue)
		parsedValue = int(v)
	case reflect.Int32:
		v, _ := strconv.Atoi(setValue)
		parsedValue = int32(v)
	case reflect.Int8:
		v, _ := strconv.Atoi(setValue)
		parsedValue = int8(v)
	case reflect.Int16:
		v, _ := strconv.Atoi(setValue)
		parsedValue = int16(v)
	case reflect.Int64:
		v, _ := strconv.Atoi(setValue)
		parsedValue = int64(v)
	case reflect.Uint:
		v, _ := strconv.Atoi(setValue)
		parsedValue = uint(v)
	case reflect.Uint8:
		v, _ := strconv.Atoi(setValue)
		parsedValue = uint(v)
	case reflect.Uint16:
		v, _ := strconv.Atoi(setValue)
		parsedValue = uint16(v)
	case reflect.Uint32:
		v, _ := strconv.Atoi(setValue)
		parsedValue = uint32(v)
	case reflect.Uint64:
		v, _ := strconv.Atoi(setValue)
		parsedValue = uint64(v)
	case reflect.Bool:
		parsedValue = setValue == "true"
	case reflect.String:
		parsedValue = setValue
	case reflect.Float32:
		v, _ := strconv.ParseFloat(setValue, 10)
		parsedValue = float32(v)
	case reflect.Float64:
		v, _ := strconv.ParseFloat(setValue, 10)
		parsedValue = float64(v)
	case reflect.Struct:
		typeName := field.Type.Name()
		if typeName == "Time" {
			xlog.Debugf("time content:%v", setValue)
			t, _ := time.ParseInLocation("2006/01/02 15:04:05", setValue, time.Local)
			return reflect.ValueOf(t)
		}
		if typeName == "DeletedAt" {
			return reflect.ValueOf(gorm.DeletedAt{})
		}
		fallthrough
	case reflect.Slice:
		typeName := field.Type.String()
		if typeName == "[]string" {
			list := make([]string, 0)
			if rawValueStr, ok := rawValue.(string); ok {
				elems := strings.Split(rawValueStr, ",")
				list = append(list, elems...)
				// 空的字符串
			} else {
				if rawValueList, ok := rawValue.([]string); ok {
					for _, v := range rawValueList {
						list = append(list, v)
					}
				} else {
					for _, v := range rawValue.([]interface{}) {
						list = append(list, v.(string))
					}
				}
			}
			parsedValue = list
		} else if typeName == "[]*model.MailAttachItem" {
			items := make([]*model.MailAttachItem, 0)
			if rawValueList, ok := rawValue.([]*model.MailAttachItem); ok {
				for _, item := range rawValueList {
					items = append(items, item)
				}
			} else {
				for _, itemI := range rawValue.([]interface{}) {
					item := &model.MailAttachItem{}
					for k, vI := range itemI.(map[string]any) {
						v := vI.(float64)
						if k == "id" {
							item.ID = int32(v)
						} else if k == "num" {
							item.Num = int64(v)
						} else if k == "item_type" {
							item.ItemType = int(v)
						}
					}
					items = append(items, item)
				}
			}

			parsedValue = items
		}
	default:
		panic(fmt.Errorf("暂时不支持的前后端交互字段类型:%v, 类型名:%v", field.Type.Kind(), field.Type.Name()))
	}
	return reflect.ValueOf(parsedValue)
}