package entity

import (
	"admin/apps/game/model"
	"admin/internal/model/dto"
	"admin/lib/xlog"
	"database/sql"
	"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("2006/01/02 15:04:05")
		} else if ft.Type.Name() == "NullTime" {
			t := fo.Interface().(sql.NullTime)
			if t.Valid {
				obj[ft.Name] = t.Time.Format("2006/01/02 15:04:05")
			} else {
				obj[ft.Name] = ""
			}
		}
	}

	return obj
}

func getFieldTypeDtoDescInfo(project *Project, 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",
		BigColumn:   fieldType.Tag.Get("big_column") == "true",
		Where:       fieldType.Tag.Get("where"),
	}

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

	if f1.Key == "UpdatedAt" {
		f1.Name = "更新时间"
	}

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

	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(project.Po)})
			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)
		} else if typeName == "NullTime" {
			t, err := time.ParseInLocation("2006/01/02 15:04:05", setValue, time.Local)
			if err != nil {
				return reflect.ValueOf(sql.NullTime{Time: t})
			}
			return reflect.ValueOf(sql.NullTime{Time: t, Valid: true})
		}
		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 if rawValueList1, ok := rawValue.([]interface{}); ok {
					for _, v := range rawValueList1 {
						list = append(list, v.(string))
					}
				} else if rawValue == nil {

				} else {

				}
			}
			i := 0
			for {
				if i >= len(list) {
					break
				}
				if list[i] == "" {
					list = append(list[:i], list[i+1:]...)
				}
				i++
			}
			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)
						} else if k == "desc" {
							item.Desc = vI.(string)
						}
					}
					items = append(items, item)
				}
			}

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