package model

import (
	"blazing/common/data"
	"blazing/common/data/xmlres"
	"blazing/common/utils"
	"blazing/cool"
	"encoding/json"

	"blazing/modules/config/model"
	"blazing/modules/config/service"
	"errors"
	"fmt"
	"math"
	"time"

	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/grand"
	"github.com/jinzhu/copier"
	"github.com/samber/lo"
)

const TableNamePet = "player_pet"

// Pet mapped from table <pet>
type Pet struct {
	Base
	PlayerID  uint32 `gorm:"not null;index:idx_pet_by_player_id;comment:'所属玩家ID'" json:"player_id"`
	Free      int    `gorm:"not null;default:0;comment:'是否放生'" json:"free"` //"0为放入仓库，1为放生,2为上架
	CatchTime uint32 `gorm:"not null;comment:'捕捉时间'" json:"catch_time"`     //唯一键

	SalePrice uint32 `gorm:"not null;default:0;comment:'出售价格'" json:"sale_price"`
	SaleCount uint32 `gorm:"not null;default:0;comment:'出售次数'" json:"sale_count"`
	// Owner     uint32 `struc:"skip"` //仅作为存储
	// FreedTime uint32 `struc:"skip"` //放生时间
	//是否可交易，这里应该定义在精灵ID里
	//是否上架
	Data PetInfo `gorm:"type:jsonb;not null;comment:'精灵全部数据'" json:"data"`
}

// GetOffShelfFee 计算商品下架扣费规则
// 返回值：allowOffShelf(是否允许下架), feeRate(扣费比例), err(错误信息)
func (tt *Pet) GetOffShelfFee() (bool, float64, error) {
	// 获取当前时间
	now := time.Now()
	// 计算上架到现在的时长（小时）
	duration := now.Sub(tt.UpdateTime.Time)
	hours := duration.Hours()

	// 阶段1：0-24小时（展示期，可下架但阶梯扣费）
	if hours >= 0 && hours < 24 {
		switch {
		case hours < 6:
			// 0-6小时：0扣费，允许下架
			return true, 0.0, nil
		case hours < 12:
			// 6-12小时：扣30%，允许下架
			return true, 0.3, nil
		case hours < 18:
			// 12-18小时：扣60%，允许下架
			return true, 0.6, nil
		case hours < 24:
			// 18-24小时：扣90%，允许下架
			return true, 0.9, nil
		}
	}

	// 阶段2：24-30小时（禁止下架）
	if hours >= 24 && hours < 30 {
		return false, 0.0, errors.New("24-30小时交易期，禁止下架")
	}

	// 阶段3：30小时后（自由下架，0扣费）
	if hours >= 30 {
		return true, 0.0, nil
	}

	// 异常情况（上架时间在未来）
	return false, 0.0, errors.New("商品未到上架时间，无法操作下架")
}

// CalculateOffShelfAmount 根据扣费比例计算实际扣费金额
func (tt *Pet) CalculateOffShelfAmount(feeRate float64) float64 {
	return float64(tt.SalePrice) * feeRate
}

type Attr uint32

func (r Attr) sub() uint32 {
	if r > 0 {
		return uint32(r) - 1

	}
	return 0
}

// PetInfo 精灵信息结构（合并后的优化版本）
type PetInfo struct {
	ID uint32 `fieldDesc:"精灵编号" `

	// 名字：默认为全0，补齐到16字节（固定长度 → [16]byte）
	Name   string `struc:"[16]byte" json:"Name,omitempty"`
	Gender int    `struc:"uint16" fieldDesc:"性别" ` //0：无性别，1：雄性， 2：雌性
	//generation

	Generation uint16 `fieldDesc:"世代" `

	Dv uint32 `struc:"uint32" `

	Nature uint32 `fieldDesc:"性格" `

	Level uint32 `fieldDesc:"等级" `

	Exp int64 `struc:"uint32"`

	LvExp int64 `struc:"uint32"`

	NextLvExp int64 `struc:"uint32"`

	Hp uint32

	MaxHp uint32 `fieldDesc:"最大生命" `
	// * battle_lv: atk(0), def(1), sp_atk(2), sp_def(3), spd(4), accuracy(5)
	Prop [5]uint32 `fieldDesc:"属性" `

	// * ev:生命学习力,攻击学习力,防御学习力,特攻学习力,特防学习力,速度学习力
	Ev [6]uint32 `fieldDesc:"属性" `

	SkillListLen uint32 `struc:"sizeof=SkillList" json:"-"`

	// 技能信息：固定4条，空则赋值0（固定长度List → [4]SkillInfo，零值即符合“赋值0”）
	SkillList []SkillInfo

	CatchTime    uint32 //显式忽略，不参与序列化
	OldCatchTime uint32 `struc:"skip" fieldDesc:"旧捕捉时间" `

	CatchMap uint32 `json:"CatchMap,omitempty"`

	CatchRect uint32 `json:"CatchRect,omitempty"`

	CatchLevel    uint32 `fieldDesc:"捕获等级 默认为0" `
	EffectInfoLen uint16 `struc:"sizeof=EffectInfo" json:"-"`
	// 特性列表：长度用UShort存储（变长List → []PetEffectInfo + 长度前缀规则）  第一个一定是特性
	EffectInfo []PetEffectInfo

	SkinID uint32 `fieldDesc:"皮肤id默认为0" `

	ShinyLen  uint32            `struc:"sizeof=ShinyInfo"`
	ShinyInfo []data.GlowFilter `json:"ShinyInfo,omitempty"`

	//时间轮转，然后effect根据type同时只共存一个，特性是1 特质是1，柱子是两种，魂印是一个，然后异色字段，然后特训技能字段
	ExtSKill []uint32 `struc:"skip"` //特训技能
	ExtSkin  []uint32 `struc:"skip"` //可用皮肤
}

func (pet *PetInfo) ConfigBoss(bm model.PetBaseConfig) {
	var color data.GlowFilter
	err := json.Unmarshal([]byte(bm.Color), &color)
	if err == nil && color.Alpha != 0 {
		pet.ShinyInfo = append(pet.ShinyInfo, color)

	}
	if bm.Hp != 0 {
		pet.Hp = uint32(bm.Hp)
		pet.MaxHp = uint32(bm.Hp)
	}
	if len(bm.Prop) == 5 {
		for i := 0; i < 5; i++ {
			if bm.Prop[i] != 0 {
				pet.Prop[i] = bm.Prop[i]
			}

		}

		//monster.Prop = [5]uint32(bm.Prop)

	}

	if len(bm.SKill) != 0 {

		for i := 0; i < 4; i++ {
			if bm.SKill[i] != 0 {
				pet.SkillList[i].ID = bm.SKill[i]
			}

		}

	}

}

func (pet *PetInfo) Type() int {
	return xmlres.PetMAP[int(pet.ID)].Type

}
func (pet *PetInfo) ModelHP(tt int64) {
	if pet.Hp <= 0 {
		if tt > int64(pet.Hp) {
			pet.Hp = 0
		} else {
			pet.Hp += uint32(tt)

		}

	} else {
		pet.Hp += uint32(tt)
		if pet.Hp > pet.MaxHp {
			pet.Hp = pet.MaxHp
		}
	}

}

func (pet *PetInfo) HealPP(value int) {
	for i := 0; i < len(pet.SkillList); i++ {
		if value == -1 {
			pet.SkillList[i].PP = uint32(xmlres.SkillMap[int(pet.SkillList[i].ID)].MaxPP)
		} else {
			pet.SkillList[i].PP += uint32(value)
			pet.SkillList[i].PP = utils.Min(pet.SkillList[i].PP, uint32(xmlres.SkillMap[int(pet.SkillList[i].ID)].MaxPP))
		}

	}
}

// 定义常量，提升可维护性（避免魔法数字）
const (
	maxSingleEV  uint32 = 255 // 单个EV最大值
	maxTotalEV   uint32 = 510 // 6个EV总和最大值
	evFieldCount        = 6   // EV字段数量（固定6个）
)

// AddEV 优化后的EV值增加方法（符合Go命名规范：大写导出，动词开头）
// 功能：为宠物6个EV值增加增量，保证单个≤255、总和≤510
// 参数：evadd - 6个EV字段的增量数组（长度必须为6）
// 返回：error - 参数非法/逻辑异常时返回错误；bool - 是否触发了超额削减（方便业务监控）
func (pet *PetInfo) AddEV(ev_add []int64) (bool, error) {
	// 1. 参数安全校验：避免数组越界panic
	if len(ev_add) != evFieldCount {
		return false, fmt.Errorf("evadd长度必须为%d，当前为%d", evFieldCount, len(ev_add))
	}
	if len(pet.Ev) != evFieldCount {
		return false, errors.New("pet.Ev未初始化或长度不为6")
	}

	// 2. 第一步：直接添加并限制单项最大值（按索引顺序处理）
	var tempEV [evFieldCount]uint32
	for i := 0; i < evFieldCount; i++ {
		// 直接累加增量
		tempEV[i] = pet.Ev[i] + uint32(ev_add[i])
		// 单项不超过255
		if tempEV[i] > maxSingleEV {
			tempEV[i] = maxSingleEV
		}
	}

	// 3. 计算增量后的总和，检查是否超过510
	totalTemp := lo.Sum(tempEV[:])

	// 4. 若总和超额，按索引顺序（0→5）削减（优先削减前面的字段）
	hasCut := false
	if totalTemp > maxTotalEV {
		overTotal := totalTemp - maxTotalEV // 需要削减的总量
		hasCut = true

		// 按索引顺序遍历削减（从第0个字段开始，依次处理）
		for i := 0; i < evFieldCount && overTotal > 0; i++ {
			// 可削减的最大值：最多削减到原始值（不触碰添加前的基础EV）
			cutAble := tempEV[i] - pet.Ev[i]
			if cutAble <= 0 {
				continue // 该字段无增量可削减，跳过
			}

			// 实际削减量：取"可削减量"和"剩余需削减量"的较小值
			cut := cutAble
			if cut > overTotal {
				cut = overTotal
			}

			// 执行削减
			tempEV[i] -= cut
			overTotal -= cut
		}

		// 极端情况：即使削减所有增量后仍超额（如原始EV总和已超510），继续按顺序削减原始值
		if overTotal > 0 {
			for i := 0; i < evFieldCount && overTotal > 0; i++ {
				// 此时可削减到0（根据业务需求调整，也可返回错误）
				cutAble := tempEV[i]
				if cutAble <= 0 {
					continue
				}

				cut := cutAble
				if cut > overTotal {
					cut = overTotal
				}

				tempEV[i] -= cut
				overTotal -= cut
			}
		}
	}

	// 5. 将处理后的结果赋值给原EV数组
	copy(pet.Ev[:], tempEV[:])

	return hasCut, nil
}
func (pet *PetInfo) Cure() {
	pet.Hp = pet.MaxHp
	for i := 0; i < len(pet.SkillList); i++ {
		maxPP, ok := xmlres.SkillMap[int(pet.SkillList[i].ID)]
		// 恢复至最大PP值（从配置表获取）
		if pet.SkillList[i].ID != 0 && ok {
			pet.SkillList[i].PP = uint32(maxPP.MaxPP)

		}
	}
}

// 强制选色，这个是给熔炉用的
func (pet *PetInfo) FixShiny() bool {

	co := service.NewShinyService().RandShiny(pet.ID)
	if co != nil {
		pet.ShinyInfo = []data.GlowFilter{*co}
		return true
	}
	return false
}

// 比重融合
func (pet *PetInfo) RandomByWeightShiny() {

	co := service.NewShinyService().RandomByWeightShiny(pet.ID)
	if co != nil {
		pet.ShinyInfo = []data.GlowFilter{*co}
	}

}
func (pet *PetInfo) IsShiny() bool {

	return len(pet.ShinyInfo) > 0

}

// 随机特性
func (pet *PetInfo) RnadEffect() {

	for _, v := range xmlres.PlayerEffectMAP {
		if gconv.Int(v.StarLevel) == 0 {
			ret := &PetEffectInfo{
				Idx:    uint16(gconv.Int16(v.Idx)),
				Status: 1,
				EID:    uint16(gconv.Int16(v.Eid)),
				Args:   v.ArgsS,
			}
			_, eff, ok := pet.GetEffect(1)
			if ok {
				if eff.Idx == ret.Idx {
					continue
				}

				copier.Copy(eff, ret)
			} else {
				pet.EffectInfo = append(pet.EffectInfo, *ret)
			}

			break
		}

	}
}

// 0: Boss特性
// 1: 特性
// 2: 能量珠
// 3: 爆发特效
// 4: 异能精灵特质
// 5: 特训
// 6: 魂印
// 7 :繁殖加成
// 8 :体力提升加成

const (
	maxHPUpEffectIdx       uint16 = 60000
	maxHPUpEffectStatus    byte   = 8
	maxHPUpEffectEID       uint16 = 26
	maxHPUpEffectCap              = 20
	trainingEffectStatus   byte   = 5
	trainingAttrEffectIdx  uint16 = 60001
	trainingPowerEffectIdx uint16 = 60002
	trainingAttrEffectEID  uint16 = 247
	trainingPowerEffectEID uint16 = 239
)

// 繁殖加成，体力提升加成 ,这里是防止和其他重复所以定义不同类别,但是实际上,能量珠那些事调用不同id的effect实现
// <!-- Stat: 精灵特效Stat: 0: 无效(默认值), 1: 永久, 2: 有`有效次数'的特效 3: 爆发特效 4: 异能精灵特质，5特训，6魂印-->
func (pet *PetInfo) GetEffect(ptype int) (int, *PetEffectInfo, bool) {

	return utils.FindWithIndex(pet.EffectInfo, func(item PetEffectInfo) bool {
		return int(item.Status) == ptype
	})

}

func (pet *PetInfo) getEffectByStatusAndEID(status byte, eid uint16) (int, *PetEffectInfo, bool) {
	return utils.FindWithIndex(pet.EffectInfo, func(item PetEffectInfo) bool {
		return item.Status == status && item.EID == eid
	})
}

func ensureEffectArgsLen(args []int, size int) []int {
	if len(args) >= size {
		return args
	}
	next := make([]int, size)
	copy(next, args)
	return next
}

func (pet *PetInfo) addTrainingEffectDelta(idx uint16, eid uint16, argsLen int, argIndex int, value int) bool {
	if pet == nil || value <= 0 || argIndex < 0 || argIndex >= argsLen {
		return false
	}

	if _, eff, ok := pet.getEffectByStatusAndEID(trainingEffectStatus, eid); ok {
		if eff.Idx == 0 {
			eff.Idx = idx
		}
		eff.Status = trainingEffectStatus
		eff.EID = eid
		eff.Args = ensureEffectArgsLen(eff.Args, argsLen)
		eff.Args[argIndex] += value
		return true
	}

	args := make([]int, argsLen)
	args[argIndex] = value
	pet.EffectInfo = append(pet.EffectInfo, PetEffectInfo{
		Idx:    idx,
		Status: trainingEffectStatus,
		EID:    eid,
		Args:   args,
	})
	return true
}

func (pet *PetInfo) AddTrainingAttrBonus(attr int, value int) bool {
	return pet.addTrainingEffectDelta(trainingAttrEffectIdx, trainingAttrEffectEID, 6, attr, value)
}

func (pet *PetInfo) AddTrainingPowerBonus(value int) bool {
	return pet.addTrainingEffectDelta(trainingPowerEffectIdx, trainingPowerEffectEID, 2, 0, value)
}

func (pet *PetInfo) AddMaxHPUpEffect(itemID uint32, value int) bool {
	if pet == nil || value <= 0 {
		return false
	}

	if _, eff, ok := pet.GetEffect(int(maxHPUpEffectStatus)); ok {
		current := 0
		if len(eff.Args) >= 2 && eff.Args[0] == 0 && eff.Args[1] > 0 {
			current = eff.Args[1]
		}
		if current >= maxHPUpEffectCap {
			return false
		}

		next := current + value
		if next > maxHPUpEffectCap {
			next = maxHPUpEffectCap
		}

		eff.ItemID = itemID
		eff.Idx = maxHPUpEffectIdx
		eff.Status = maxHPUpEffectStatus
		eff.EID = maxHPUpEffectEID
		eff.Args = []int{0, next}
		return next > current
	}

	if value > maxHPUpEffectCap {
		value = maxHPUpEffectCap
	}

	pet.EffectInfo = append(pet.EffectInfo, PetEffectInfo{
		ItemID: itemID,
		Idx:    maxHPUpEffectIdx,
		Status: maxHPUpEffectStatus,
		EID:    maxHPUpEffectEID,
		Args:   []int{0, value},
	})
	return true
}

func (pet *PetInfo) Downgrade(level uint32) {

	for pet.Level > uint32(level) {
		basic, ok := xmlres.PetMAP[int(pet.ID)]

		if ok {

			if basic.EvolvesFrom != 0 && xmlres.PetMAP[int(basic.EvolvesFrom)].EvolvFlag == 0 {

				pet.ID = uint32(basic.EvolvesFrom)

			}

		}
		pet.Level--
		//进行降级操作

	}
	pet.NextLvExp = 0
	pet.Update(false)

}

// 执行进化逻辑   ,是否进化
func (petinfo *PetInfo) Update(isup bool) {

	// 最大进化次数限制（防止配置表闭环导致死循环）
	maxEvolveTimes := 1
	evolveCount := 0

	// 循环进化：直到不满足进化条件 或 达到最大进化次数
	for {
		// 防止死循环，超出次数直接退出
		if evolveCount >= maxEvolveTimes {
			break
		}
		// 获取当前宠物形态的配置
		basic, ok := xmlres.PetMAP[int(petinfo.ID)]
		// 配置不存在，直接退出循环
		if !ok {
			break
		}
		if !isup {
			petinfo.LvExp = calculatePreviousLevelExperience(petinfo.Level, basic.GetBasic())
			petinfo.NextLvExp = calculateExperience(petinfo.Level, basic.GetBasic())
			return
		}
		// 升级时保留上一等级需求，供经验结算使用。
		petinfo.LvExp = petinfo.NextLvExp
		petinfo.NextLvExp = calculateExperience(petinfo.Level, basic.GetBasic())
		// 检查是否满足进化条件
		canEvolve := basic.EvolvesTo != 0 && // 有明确的进化目标
			int(petinfo.Level) >= basic.EvolvingLv && // 等级达到进化要求
			basic.IsLarge == 0 // 非最终形态

		// 不满足进化条件，退出循环
		if !canEvolve {
			break
		}

		// 执行进化：更新宠物ID为进化后形态
		petinfo.ID = uint32(basic.EvolvesTo)
		evolveCount++ // 进化次数+1
	}

}

func calculatePreviousLevelExperience(level uint32, baseValue uint32) int64 {
	if level <= 1 {
		return 0
	}
	return calculateExperience(level-1, baseValue)
}

// calculateExperience 计算指定等级和种族值所需的经验值
// level: 当前等级
// baseValue: 种族值
func calculateExperience(level uint32, baseValue uint32) int64 {
	// 计算 A 部分：向上取整(3.75 * a * (a + 1))
	partA := math.Ceil(3.75 * float64(level) * float64(level+1))

	// 计算 B 部分：向上取整(b * log(1 + a / 100))
	// 这里使用自然对数 math.Log，如果想换底数可以用换底公式
	partB := math.Log(1.0 + float64(level)/100.0)
	partB = float64(baseValue) * partB
	partB = math.Ceil(partB)

	// 总经验是两部分之和，并向上取整
	totalExp := math.Ceil(partA + partB)
	return int64(totalExp)
}

// PetEffectInfo 精灵特性信息结构
// <!-- NewSeIdx: 精灵特效索引 (默认0: 无效) -->
// <!-- Type: 0 - 仅单人战斗; 1 - 仅组队战斗; 2 - both; (默认0: 仅单人) -->
// <!-- Eid: 精灵特效eid (默认0: 无效) -->
// <!-- Stat: 精灵特效Stat: 0: 无效(默认值), 1: 永久, 2: 有`有效次数'的特效 3: 爆发特效 4: 异能精灵特质-->
// <!-- Times: 精灵特效可使用次数: 当type==2时有效 (默认值:0) -->
// <!-- Args: 特效参数, 不超过8个 (注意: 每个参数不能超过 65535) -->
// <!-- AdditionType:特效加成类型 1 种族值加成 2 技能威力加成 -->
type PetEffectInfo struct {
	ItemID uint32 `struc:"uint32" json:"item_id"` //如果是能量珠,就显示
	Idx    uint16 `struc:"skip" json:"new_se_idx"`
	//Type      byte   `struc:"skip" json:"type"`        //pvp pve特性区分,通过具体effect实现
	Status    byte   `struc:"byte" json:"status"`      //特性为1,能量珠为2
	LeftCount byte   `struc:"byte" json:"left_count"`  //剩余次数
	EID       uint16 `struc:"uint16" json:"effect_id"` //特效ID
	ArgsLen   uint32 `struc:"sizeof=Args" json:"-"`

	Args []int ` json:"Args"` //自定义参数装载

}

// SkillInfo 精灵技能信息结构（SkillInfo）
type SkillInfo struct {
	ID uint32
	PP uint32
}

func (s *SkillInfo) Use(count int) {
	s.PP -= uint32(count)
}

// TableName Pet's table name
func (*Pet) TableName() string {
	return TableNamePet
}

// GroupName Pet's table group
func (*Pet) GroupName() string {
	return "default"
}

// NewPet create a new Pet
func NewPet() *Pet {
	return &Pet{
		Base: *NewBase(),
	}
}

// init 创建表
func init() {
	_ = cool.CreateTable(&Pet{})

	//	fmt.Println(err)
}

// GenPetInfo 生成一个新的精灵实例
// - 参数为 -1 时表示随机生成对应属性
// * @param petTypeId 精灵类型ID
// * @param individualValue 个体值（0-31）
// * @param natureId 性格ID（0-24）
// * @param abilityTypeEnum 特性类型ID（0=无, >0=指定, -1=随机）
// * @param shinyid 闪光ID（-1=随机）
// * @param level 等级（1-100）
// * @return 生成的精灵实体
func GenPetInfo(
	id int,
	dv, natureId, abilityTypeEnum, level int, shinyid []data.GlowFilter,
	gen int,
) *PetInfo {
	if id == 0 {
		return nil
	}
	// 创建随机源
	//rng := rand.New(rand.NewSource(time.Now().UnixNano()))

	// 初始化精灵
	p := &PetInfo{
		ID:         uint32(id),
		CatchTime:  uint32(time.Now().Unix()),
		Level:      uint32(level),
		EffectInfo: make([]PetEffectInfo, 0),
	}

	// ---- 处理闪光 ----
	if shinyid != nil {
		//todo 待实现异色字段
		p.ShinyInfo = shinyid
		// r := service.NewShinyService().GetShiny(shinyid)
		// if r != nil {
		// 	p.ShinyInfo = append(p.ShinyInfo, *r)
		// }

		//	p.Shiny = uint32(shinyid)
	}
	if gen == -1 {

		p.Gender = grand.N(1, 4)
		if cool.Config.ServerInfo.IsVip != 0 {
			p.Gender = grand.N(1, 2)
		}
		if p.Gender == 3 || p.Gender == 4 {
			p.Gender = 0

		}
	}

	// ---- 性格 ----
	if natureId == -1 {
		p.Nature = uint32(grand.Intn(25))
	} else {
		p.Nature = uint32(natureId)
	}

	// ---- 个体值（DV）----
	if dv == -1 {
		p.Dv = uint32(CalculateIndividualValue())
	} else {
		if dv < 0 {
			dv = 0
		} else if dv > 31 {
			dv = 31
		}
		p.Dv = uint32(dv)
	}

	// ---- 特性 ----
	switch {
	case abilityTypeEnum == 0:
		// 无特性
	case abilityTypeEnum > 0:
		// 指定特性
		if v, ok := xmlres.PlayerEffectMAP[int(abilityTypeEnum)]; ok {
			p.EffectInfo = append(p.EffectInfo, PetEffectInfo{
				Idx:    uint16(gconv.Int16(v.Idx)),
				Status: 1,
				EID:    uint16(gconv.Int16(v.Eid)),
				Args:   v.ArgsS,
			})
		}
	case abilityTypeEnum == -1:

		for _, v := range xmlres.PlayerEffectMAP {
			if gconv.Int(v.StarLevel) == 0 {
				p.EffectInfo = append(p.EffectInfo, PetEffectInfo{
					Idx:    uint16(gconv.Int16(v.Idx)),
					Status: 1,
					EID:    uint16(gconv.Int16(v.Eid)),
					Args:   v.ArgsS,
				})
				break
			}

		}
	}

	// ---- 技能学习 ----
	skills := utils.LastFourElements(p.GetLevelRangeCanLearningSkills(0, p.Level), 4) // 最后四个技能

	for i := 0; i < len(skills) && i < 4; i++ {
		skillID := skills[i]
		if info, ok := xmlres.SkillMap[int(skillID)]; ok {
			p.SkillList = append(p.SkillList, SkillInfo{ID: skillID, PP: uint32(info.MaxPP)})

		}
	}
	if len(p.SkillList) > 4 {
		p.SkillList = p.SkillList[:4]
	}

	// ---- 属性计算 ----
	p.CalculatePetPane(0)

	p.Update(false)

	return p
}

// 除数数组（放大100倍）
// 数组按递增顺序排列，用于判断个体值等级
var divisors = []int{
	600, 1200, 1900, 2700, 3600, 4600, 5700, 6900, 8200, 9600,
	11100, 12700, 14400, 16200, 18100, 20100, 22100, 24000,
	25800, 27500, 29100, 30600, 32000, 33300, 34500, 35600,
	36600, 37500, 38300, 39000, 39600,
}

// CalculateIndividual 根据给定的a值计算个体值
// 返回值表示a大于等于多少个除数（范围：0-31）
func CalculateIndividual(a int) int {
	individual := 0
	for _, divisor := range divisors {
		if a >= divisor {
			individual++
		} else {
			break // 数组是递增的，可提前跳出循环
		}
	}
	return individual
}

// CalculateIndividualValue 计算个体值（0-31）
// 接收外部随机数生成器，便于控制随机性和复用
func CalculateIndividualValue() int {
	// 生成0-40000的随机数，作为个体值计算的输入
	a := grand.Intn(40001)
	return CalculateIndividual(a)
}