import { _decorator, UI, UITransform } from "cc";
import { ecs } from "../../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
import { CCComp } from "../../../../../extensions/oops-plugin-framework/assets/module/common/CCComp";
import { HeroViewComp } from "../../hero/HeroViewComp";
import { SkillCom } from "../SkillCom";

const { ccclass, property } = _decorator;

/** 视图层对象 */
@ccclass('AtkComComp')
@ecs.register('AtkCom', false)
export class AtkComComp extends CCComp {
    /** 视图层逻辑代码分离演示 */
    start() {
        // var entity = this.ent as ecs.Entity;         // ecs.Entity 可转为当前模块的具体实体对象
        // this.on(ModuleEvent.Cmd, this.onHandler, this);
    }

    public  atk(args:any){
        let skill=this.node.getComponent(SkillCom)
        let dis=this.node.getComponent(UITransform).width/2
        let targetsInRange: HeroViewComp[] = []
        
        // 收集范围内所有敌方目标
        ecs.query(ecs.allOf(HeroViewComp)).some(e => {
            const view = e.get(HeroViewComp);
            if(view.fac!=skill.fac) {
                const distance = Math.abs(skill.node.position.x - view.node.position.x);
                if(distance <= dis) {
                    targetsInRange.push(view);
                }
            }
        });
        
        // 根据配置的hit_num决定攻击模式
        const hitNum = skill.skillConfig?.hit_num || 0;
        if(hitNum > 0) {
            // 限制目标数量：按距离排序，选择最近的N个目标
            if(targetsInRange.length > 0) {
                // 按距离排序（从近到远）
                targetsInRange.sort((a, b) => {
                    const distanceA = Math.abs(skill.node.position.x - a.node.position.x);
                    const distanceB = Math.abs(skill.node.position.x - b.node.position.x);
                    return distanceA - distanceB;
                });
                
                // 限制目标数量
                const maxTargets = Math.min(hitNum, targetsInRange.length);
                const selectedTargets = targetsInRange.slice(0, maxTargets);
                
                selectedTargets.forEach(target => {
                    skill.single_damage(target, false);
                });
            }
        } else {
            // 范围伤害：对所有范围内目标造成伤害
            if(targetsInRange.length > 0) {
                targetsInRange.forEach(target => {
                    skill.single_damage(target, false);
                });
            }
        }
    }
    /** 全局消息逻辑处理 */
    // private onHandler(event: string, args: any) {
    //     switch (event) {
    //         case ModuleEvent.Cmd:
    //             break;
    //     }
    // }

    /** 视图对象通过 ecs.Entity.remove(ModuleViewComp) 删除组件是触发组件处理自定义释放逻辑 */
    reset() {
        this.node.destroy();
    }
}