import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
import { Attrs, AttrsType, BType, NeAttrs } from "../common/config/HeroAttrs";
import { BuffConf } from "../common/config/SkillSet";
import { HeroInfo, AttrSet } from "../common/config/heroSet";
import { HeroSkillsComp } from "./HeroSkills";
 

interface talTrigger{
    value:number
    count:number
}
@ecs.register('HeroAttrs')
export class HeroAttrsComp extends ecs.Comp {
    Ebus:any=null!
    // ==================== 角色基础信息 ====================
    hero_uuid: number = 1001;
    hero_name: string = "hero";
    lv: number = 1;
    type: number = 0;           // 0近战 1远程 2辅助
    fac: number = 0;            // 0:hero 1:monster
    
    // ==================== 基础属性（有初始值） ====================
    base_ap: number = 0;        // 基础攻击
    base_map: number = 0;       // 基础魔法攻击
    base_def: number = 5;       // 基础防御
    base_hp: number = 100;      // 基础血量
    base_mp: number = 100;      // 基础魔法值
    base_speed: number = 100;   // 基础移动速度
    base_dis: number = 100;     // 基础距离
    
    // ==================== 动态属性值 ====================
    hp: number = 100;           // 当前血量
    mp: number = 100;           // 当前魔法值
    pow: number = 0;            // 当前怒气值
    shield: number = 0;         // 当前护盾
    Attrs: any = [];            // 最终属性数组（经过Buff计算后）
    NeAttrs: any = [];           // 负面状态数组
    Talents: Record<number, talTrigger> = {};
    BUFFS_TAL: Record<number, {count:number,BType:BType,attrIndex:number,value: number}> = {};
    
    // ==================== 技能距离缓存 ====================
    maxSkillDistance: number = 0;  // 最远技能攻击距离（缓存，受MP影响）
    minSkillDistance: number = 0;  // 最近技能攻击距离（缓存，不受MP影响，用于停止位置判断）
    
    // ==================== Buff/Debuff 系统 ====================
    /** 持久型buff数组 - 不会自动过期 */
    BUFFS: Record<number, Array<{value: number, BType: BType}>> = {};
    
    /** 临时型buff数组 - 按时间自动过期 */
    BUFFS_TEMP: Record<number, Array<{value: number, BType: BType, remainTime: number}>> = {};
    

    // ==================== 标记状态 ====================
    is_dead: boolean = false;
    is_count_dead: boolean = false;
    is_atking: boolean = false;  // 是否正在攻击
    is_stop: boolean = false;    // 是否正在停止
    is_boss: boolean = false;
    is_big_boss: boolean = false;
    is_master: boolean = false;
    is_friend: boolean = false;
    is_kalami: boolean = false;
    // ==================== 计数统计 ====================
    atk_count: number = 0;      // 攻击次数
    atked_count: number = 0;    // 被攻击次数
    
    // 注意：技能数据已迁移到 HeroSkillsComp，不再存储在这里
    
    start(){
    }
    // ==================== BUFF 系统初始化 ====================
    /**
     * 初始化角色的 buff debuff
     * 从 HeroInfo 读取初始配置，建立属性系统
     */
    initAttrs() {
        // 清空现有 buff/debuff
        this.BUFFS = {};
        this.BUFFS_TEMP = {};
        this.BUFFS_TAL = {};
        this.Talents = {};
        
        // 获取英雄配置
        const heroInfo = HeroInfo[this.hero_uuid];
        if (!heroInfo) return;

        // 1. 重置为基础值
        this.Attrs[Attrs.HP_MAX] = this.base_hp;
        this.Attrs[Attrs.MP_MAX] = this.base_mp;
        this.Attrs[Attrs.DEF] = this.base_def;
        this.Attrs[Attrs.AP] = this.base_ap;
        this.Attrs[Attrs.MAP] = this.base_map;
        this.Attrs[Attrs.SPEED] = this.base_speed;
        this.Attrs[Attrs.DIS] = this.base_dis;

        // 2. 初始化其他属性（无初始值的）
        for (const attrKey in this.Attrs) {
            const attrIndex = parseInt(attrKey);
            if (
                attrIndex !== Attrs.HP_MAX && 
                attrIndex !== Attrs.MP_MAX && 
                attrIndex !== Attrs.DEF && 
                attrIndex !== Attrs.AP && 
                attrIndex !== Attrs.MAP && 
                attrIndex !== Attrs.SPEED && 
                attrIndex !== Attrs.DIS
            ) {
                this.Attrs[attrIndex] = 0;
            }
        }
        
        // 加载初始 buff
        if (heroInfo.buff && heroInfo.buff.length > 0) {
            for (const buffConf of heroInfo.buff) {
                this.addBuff(buffConf);
            }
        }
    }

    // ==================== BUFF 管理 ====================
    /**
     * 添加 buff 效果（支持多次叠加）
     * @param buffConf buff 配置 (来自 SkillSet.BuffConf heroSet.buff)
     */
    addBuff(buffConf: BuffConf) {
        const isPermanent = buffConf.time === 0;
        const attrIndex = buffConf.buff;
        
        if (isPermanent) {
            // 添加持久buff到BUFFS - 直接追加到数组
            if (!this.BUFFS[attrIndex]) {
                this.BUFFS[attrIndex] = [];
            }
            this.BUFFS[attrIndex].push({ value: buffConf.value, BType: buffConf.BType });
        } else {
            // 添加临时buff到BUFFS_TEMP - 直接追加到数组
            if (!this.BUFFS_TEMP[attrIndex]) {
                this.BUFFS_TEMP[attrIndex] = [];
            }
            this.BUFFS_TEMP[attrIndex].push({
                value: buffConf.value,
                BType: buffConf.BType,
                remainTime: buffConf.time
            });
        }
        
        // 重新计算受影响的属性
        this.recalculateSingleAttr(attrIndex);
    }

    // ==================== 属性计算系统 ====================
    /**
     * 重新计算单个属性
     * @param attrIndex 属性索引
     */
    recalculateSingleAttr(attrIndex: number) {
        // 1. 获取基础值
        const baseValues: Record<number, number> = {
            [Attrs.HP_MAX]: this.base_hp,
            [Attrs.MP_MAX]: this.base_mp,
            [Attrs.DEF]: this.base_def,
            [Attrs.AP]: this.base_ap,
            [Attrs.MAP]: this.base_map,
            [Attrs.SPEED]: this.base_speed,
            [Attrs.SHIELD_MAX]: 0
        };
        
        const baseVal = baseValues[attrIndex] !== undefined ? baseValues[attrIndex] : 0;

        // 2. 收集所有数值型 buff/debuff
        let totalValue = baseVal;
        
        // 遍历持久buff数组
        if (this.BUFFS[attrIndex] && this.BUFFS[attrIndex].length > 0) {
            for (const buff of this.BUFFS[attrIndex]) {
                if (buff.BType === BType.VALUE) {
                    totalValue += buff.value;
                }
            }
        }
        // 遍历临时buff数组
        if (this.BUFFS_TEMP[attrIndex] && this.BUFFS_TEMP[attrIndex].length > 0) {
            for (const buff of this.BUFFS_TEMP[attrIndex]) {
                if (buff.BType === BType.VALUE) {
                    totalValue += buff.value;
                }
            }
        }
        for (const key in this.BUFFS_TAL) {
            const buff = this.BUFFS_TAL[Number(key)];
            if (buff.attrIndex === attrIndex && buff.BType === BType.VALUE) {
                totalValue += buff.value;
            }
        }

        // 3. 收集所有百分比型 buff/debuff
        let totalRatio = 0;
        
        // 遍历持久buff数组
        if (this.BUFFS[attrIndex] && this.BUFFS[attrIndex].length > 0) {
            for (const buff of this.BUFFS[attrIndex]) {
                if (buff.BType === BType.RATIO) {
                    totalRatio += buff.value;
                }
            }
        }
        // 遍历临时buff数组
        if (this.BUFFS_TEMP[attrIndex] && this.BUFFS_TEMP[attrIndex].length > 0) {
            for (const buff of this.BUFFS_TEMP[attrIndex]) {
                if (buff.BType === BType.RATIO) {
                    totalRatio += buff.value;
                }
            }
        }
        for (const key in this.BUFFS_TAL) {
            const buff = this.BUFFS_TAL[Number(key)];
            if (buff.attrIndex === attrIndex && buff.BType === BType.RATIO) {
                totalRatio += buff.value;
            }
        }
    
        // 4. 根据属性类型计算最终值
        const attrType = AttrsType[attrIndex];
        const isRatioAttr = attrType === BType.RATIO;

        if (isRatioAttr) {
            // 百分比型属性：直接加减
            this.Attrs[attrIndex] = totalValue + totalRatio;
        } else {
            // 数值型属性：(基础值+数值) × (1 + 百分比/100)
            this.Attrs[attrIndex] = Math.floor(totalValue * (1 + totalRatio / 100));
        }

        // 5. 确保属性值合理
        this.clampSingleAttr(attrIndex);
    }

    /**
     * 确保单个属性值合理
     */
    private clampSingleAttr(attrIndex: number) {
        switch(attrIndex) {
            case Attrs.HP_MAX:
            case Attrs.MP_MAX:
                this.Attrs[attrIndex] = Math.max(1, this.Attrs[attrIndex]);
                break;
            case Attrs.DEF:
            case Attrs.AP:
            case Attrs.MAP:
                this.Attrs[attrIndex] = Math.max(1, this.Attrs[attrIndex]);
                break;
            case Attrs.CRITICAL:
            case Attrs.DODGE:
            case Attrs.HIT:
                this.Attrs[attrIndex] = Math.max(0, Math.min(AttrSet.ATTR_MAX, this.Attrs[attrIndex]));
                break;
        }
    }

    // ==================== 临时 BUFF/DEBUFF 更新 ====================
    /**
     * 更新临时 buff/debuff 的剩余时间
     * @param dt 时间增量
     */
    updateTemporaryBuffsDebuffs(dt: number) {
        const affectedAttrs = new Set<number>();
        
        // 更新临时型buff
        for (const attrIndex in this.BUFFS_TEMP) {
            const buffs = this.BUFFS_TEMP[attrIndex];
            buffs.forEach(buff => {
                buff.remainTime -= dt;
                if (buff.remainTime <= 0) {
                    const index = buffs.indexOf(buff);
                    if (index > -1) {
                        buffs.splice(index, 1);
                    }
                }
            });
            if (buffs.length === 0) {
                delete this.BUFFS_TEMP[attrIndex];
                affectedAttrs.add(parseInt(attrIndex));
            }
        }

        // 负面状态更新
        for (const key in this.NeAttrs) {
            const debuff = this.NeAttrs[key];
            debuff.remainTime -= dt;
            if (debuff.remainTime <= 0) {
                debuff.remainTime = 0;
            }
        }

        // 只重新计算受影响的属性
        affectedAttrs.forEach(attrIndex => {
            this.recalculateSingleAttr(attrIndex);
        });
    }

    // ==================== BUFF 辅助方法 ====================
    /**
     * 清空buff
     * @param attrIndex 属性索引，如果为空则清理所有buff
     * @param isBuff true时清理value>0的增益buff，false时清理value<0的减益buff
     */
    clearBuffs(attrIndex?: number, isBuff: boolean = true): void {
        if (attrIndex === undefined) {
            for (const attrIndex in this.BUFFS_TEMP) {
                this.clearBuffsForAttr(parseInt(attrIndex), isBuff);
            }
        } else {
            this.clearBuffsForAttr(attrIndex, isBuff);
        }
    }

    /**
     * 清理指定属性的buff
     * @param attrIndex 属性索引
     * @param isBuff true清理增益buff，false清理减益buff
     */
    private clearBuffsForAttr(attrIndex: number, isBuff: boolean): void {
        const buffContainer = this.BUFFS_TEMP;
        
        if (!buffContainer[attrIndex]) return;

        buffContainer[attrIndex] = buffContainer[attrIndex].filter(buff => {
            const shouldClear = isBuff ? buff.value > 0 : buff.value < 0;
            return !shouldClear;
        });

        if (buffContainer[attrIndex].length === 0) {
            delete buffContainer[attrIndex];
        }

        this.recalculateSingleAttr(attrIndex);
    }

    // ==================== NeAttrs（负面状态）管理 ====================
    /**
     * 清理单个NeAttr（负面状态）
     */
    clearNeAttr(neAttrIndex: number): void {
        if (this.NeAttrs[neAttrIndex]) {
            this.NeAttrs[neAttrIndex].value = 0;
            this.NeAttrs[neAttrIndex].time = 0;
        }
    }

    /**
     * 清理所有NeAttrs（负面状态）
     */
    clearAllNeAttrs(): void {
        for (const key in this.NeAttrs) {
            this.NeAttrs[key].value = 0;
            this.NeAttrs[key].time = 0;
        }
    }

    /**
     * 检查是否处于眩晕状态
     */
    public isStun(): boolean {
        return this.NeAttrs[NeAttrs.IN_STUN]?.time > 0;
    }

    /**
     * 检查是否处于冰冻状态
     */
    public isFrost(): boolean {
        return this.NeAttrs[NeAttrs.IN_FROST]?.time > 0;
    }
    
    // ==================== 技能距离缓存管理 ====================
    /**
     * 更新技能距离缓存
     * 在技能初始化、新增技能、MP变化时调用
     * @param skillsComp 技能组件
     */
    public updateSkillDistanceCache(skillsComp: HeroSkillsComp): void {
        if (!skillsComp) {
            this.maxSkillDistance = 0;
            this.minSkillDistance = 0;
            return;
        }
        
        // 最远距离使用当前MP可施放的技能
        this.maxSkillDistance = skillsComp.getMaxSkillDistance(this.mp);
        // 最近距离使用所有技能中的最小距离，不考虑MP限制，用于停止位置判断
        this.minSkillDistance = skillsComp.getAbsoluteMinSkillDistance();
    }
    
    /**
     * 获取缓存的最远技能攻击距离
     * @returns 最远攻击距离
     */
    public getCachedMaxSkillDistance(): number {
        return this.maxSkillDistance;
    }
    
    /**
     * 获取缓存的最近技能攻击距离
     * @returns 最近攻击距离
     */
    public getCachedMinSkillDistance(): number {
        return this.minSkillDistance;
    }
    
 
    addTalBuff(t_uuid: number, attrIndex?: number, bType?: BType, value: number = 0) {
        if (attrIndex === undefined || bType === undefined) return;
        const buff = this.BUFFS_TAL[t_uuid];
        if (!buff) {
            this.BUFFS_TAL[t_uuid] = { count: 1, BType: bType, attrIndex, value };
        } else {
            buff.count += 1;
            buff.value += value;
        }
        this.recalculateSingleAttr(attrIndex);
    }
    clearTalBuff(t_uuid: number) {
        const buff = this.BUFFS_TAL[t_uuid];
        if (!buff) return;
        const attrIndex = buff.attrIndex;
        delete this.BUFFS_TAL[t_uuid];
        this.recalculateSingleAttr(attrIndex);
    }
    clearTalBuffByAttr(attrIndex: number) {
        let changed = false;
        for (const key in this.BUFFS_TAL) {
            const b = this.BUFFS_TAL[Number(key)];
            if (b && b.attrIndex === attrIndex) {
                delete this.BUFFS_TAL[Number(key)];
                changed = true;
            }
        }
        if (changed) this.recalculateSingleAttr(attrIndex);
    }
    
    addTalent(eff: number, value: number) {
        const t = this.Talents[eff] || { value: 0, count: 0 };
        t.value = value;
        t.count += 1;
        this.Talents[eff] = t;
    }
    consumeTalent(eff: number): boolean {
        const t = this.Talents[eff];
        if (!t || t.count <= 0) return false;
        t.count -= 1;
        return true;
    }

    reset() {
        // 重置为初始状态
        this.hero_uuid = 1001;
        this.hero_name = "hero";
        this.lv = 1;
        this.type = 0;
        this.fac = 0;
        this.base_ap = 0;
        this.base_map = 0;
        this.base_def = 5;
        this.base_hp = 100;
        this.base_mp = 100;
        this.base_speed = 100;
        this.base_dis = 100;
        this.hp = 100;
        this.mp = 100;
        this.shield = 0;
        this.Attrs = [];
        this.NeAttrs = [];
        this.BUFFS = {};
        this.BUFFS_TEMP = {};
        this.BUFFS_TAL = {};
        this.Talents = {};
        // 重置技能距离缓存
        this.maxSkillDistance = 0;
        this.minSkillDistance = 0;
        this.is_dead = false;
        this.is_count_dead = false;
        this.is_atking = false;
        this.is_stop = false;
        this.is_boss = false;
        this.is_big_boss = false;
        this.is_master = false;
        this.is_friend = false;
        this.is_kalami = false;
        this.atk_count = 0;
        this.atked_count = 0;
    }

 
    
}