package info

import (
	element "blazing/common/data/Element"
	"blazing/common/data/xmlres"

	"blazing/modules/blazing/model"
	"math/rand"
	"sync"

	"github.com/shopspring/decimal"
	"github.com/tnnmigga/enum"
)

// 战斗属性类型
type EnumAttrType int

// 精灵
const Pet_O_Ctx = "PET_O"
const Pet_T_Ctx = "PET_T"

// 这里获得攻击,防御,特工,特防,速度
// * battle_lv: atk(0), def(1), sp_atk(2), sp_def(3), spd(4), accuracy(5)
// * battle_attr: 0:hp, 1:atk, 2:def, 3:sp_atk, 4:sp_def, 5:spd
// func (a *BattlePetEntity) Value(tt uint32) uint32 {

// 	offsetAtk := unsafe.Offsetof(a.Info.Attack) // c字段的偏移量（通常为4+16=20）
// 	// 2. 将结构体指针转换为原始内存地址（uintptr）
// 	baseAddr := uintptr(unsafe.Pointer(&offsetAtk))
// 	fmt.Println(*(*uint32)(unsafe.Pointer(&baseAddr)))
// 	addrA := unsafe.Pointer(baseAddr + 4*uintptr(tt)) //根据0是攻击
// 	offsetAtkP := unsafe.Offsetof(a.Prop.Attack)      // c字段的偏移量（通常为4+16=20）
// 	// 2. 将结构体指针转换为原始内存地址（uintptr）
// 	baseAddrp := uintptr(unsafe.Pointer(&offsetAtkP))
// 	fmt.Println(*(*uint32)(unsafe.Pointer(&offsetAtkP)))
// 	addrB := unsafe.Pointer(baseAddrp + 4*uintptr(tt)) //根据0是攻击
// 	fmt.Println(*(*uint32)(addrA))
// 	ret := uint32(calculateRealValue(int64(*(*uint32)(addrA)), int(*(*byte)(addrB))))
// 	return ret
// }
// func (a *BattlePetEntity) Speed() uint32 {
// 	return uint32(calculateRealValue(int64(a.Info.Speed), int(a.Prop.Speed)))

// }
// func (a *BattlePetEntity) Attack() uint32 {
// 	return uint32(calculateRealValue(int64(a.Info.Attack), int(a.Prop.Attack)))

// }
// func (a *BattlePetEntity) Defense() uint32 {
// 	return uint32(calculateRealValue(int64(a.Info.Defence), int(a.Prop.Defence)))

// }
// func (a *BattlePetEntity) SAttack() uint32 {
// 	return uint32(calculateRealValue(int64(a.Info.SpecialAttack), int(a.Prop.SpecialAttack)))

// }
// func (a *BattlePetEntity) SDefense() uint32 {
// 	return uint32(calculateRealValue(int64(a.Info.SpecialDefence), int(a.Prop.SpecialDefence)))

// }

// 辅助函数：取整数绝对值（处理负等级）
func abs(x int8) int8 {
	if x < 0 {
		return -x
	}
	return x
}

type BattlePetEntity struct {
	xmlres.PetInfo
	Info *model.PetInfo //通过偏移赋值
	//*input.Input

	statusConditions sync.Map        // key: StatusCondition, value: int (剩余回合)
	Skills           [4]*SkillEntity // 技能槽（最多4个技能）
	//Status           StatusDict      //精灵的状态
	//能力提升属性
	//Prop       PropDict
	NotAlive   bool                                                           `struc:"skip"`
	DamageZone map[EnumCategory]map[EnumsZoneType]map[EnumsZoneType][]float64 // 三维map 伤害类型-》增还是减-》加还是乘-》值
}

// 获得指定的+-区
func (s *BattlePetEntity) GetAddValue(e EnumCategory, c EnumsZoneType) decimal.Decimal {

	t, ok := s.DamageZone[e][c][DamageZone.add]
	if ok {
		var ttt decimal.Decimal

		for _, v := range t {
			t1 := decimal.NewFromFloat(v)
			ttt.Add(t1)
		}
		return ttt
	}
	return decimal.NewFromFloat(0)
}

// 获得指定的*/区
func (s *BattlePetEntity) GetMulValue(e EnumCategory, c EnumsZoneType) decimal.Decimal {

	t, ok := s.DamageZone[e][c][DamageZone.nul]
	if ok {
		var ttt decimal.Decimal

		for _, v := range t {
			t1 := decimal.NewFromFloat(v)
			ttt.Mul(t1)
		}
		return ttt
	}

	return decimal.NewFromFloat(0)

}

// 设置指定的值
// 三维map 伤害类型-》增还是减-》加还是乘-》值
func (s *BattlePetEntity) PutDamageZone(e EnumCategory, dtype EnumsZoneType, value float64, ftype EnumsZoneType) {
	s.DamageZone[e][dtype][ftype] = append(s.DamageZone[e][dtype][ftype], value)
	// switch dtype { //判断伤害节点段

	// //case Zone.Power: //特判乘算区的乘运算

	// default:
	// 	switch ftype { //判断设置哪个算区

	// 	case true: // 乘算区
	// 		old := s.GetAddValue(e)

	// 		new := decimal.NewFromFloat(value)
	// 		s.DamageZone[dtype] = float64(old.Add(new).IntPart())

	// 	case false: //  加算区
	// 		old := s.GetMulValue(e)

	// 		new := decimal.NewFromFloat(value)
	// 		s.DamageZone[dtype] = float64(old.Add(new).IntPart())

	// 	}
	// }

}

// 创建精灵实例
func CreateBattlePetEntity(info *model.PetInfo, rand *rand.Rand) *BattlePetEntity {
	ret := &BattlePetEntity{}

	ret.PetInfo = xmlres.PetMAP[int(info.ID)] //注入精灵信息
	ret.Info = info
	for i := 0; i < 4; i++ {
		//todo  技能信息应该每回合进行深拷贝,保证每次的技能效果都是不一样的
		ret.Skills[i] = CreateSkill(&info.SkillList[i], rand, ret)
	}
	ret.DamageZone = make(map[EnumCategory]map[EnumsZoneType]map[EnumsZoneType][]float64) //初始化第一层类型

	for _, v := range enum.Values[EnumCategory](Category) {
		ret.DamageZone[v] = make(map[EnumsZoneType]map[EnumsZoneType][]float64) //初始化第二层是否是加还是减
		for _, t := range enum.Values[EnumsZoneType](DamageC) {
			ret.DamageZone[v][t] = make(map[EnumsZoneType][]float64) //初始化第三层时乘还是加
			for _, s := range enum.Values[EnumsZoneType](DamageC) {
				ret.DamageZone[v][t][s] = make([]float64, 0) //初始化第四层 数组

			}
		}
	}
	return ret

}

// calculateRealValue 计算实际属性值根据状态变化计算实际值
// value 基础属性值
// stat 状态变化值（可正可负）
// 返回// 返回计算后的实际属性值，确保结果至少为1
func CalculateRealValue(value int, stat int) int {
	if stat == 0 {
		if value <= 0 {
			return 1
		}
		return value
	} else if stat > 0 {
		r := int(float64(value) * (float64(stat+2) / 2.0))
		if r <= 0 {
			return 1
		}
		return r
	} else {
		r := int(float64(value) * (2.0 / float64(2-stat)))
		if r <= 0 {
			return 1
		}
		return r
	}
}

func (u *BattlePetEntity) Type() *element.ElementCombination {
	var ff *element.ElementCombination
	for _, v := range xmlres.PetMAP {
		if v.ID == int(u.Info.ID) {
			ff, _ = element.NewElementCombination(v.Type)
		}

	}

	//todo  待实现获取精灵的类型

	return ff
}
