import { _decorator, Vec3, v3, tween } from "cc";
import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
import { oops } from "../../../../extensions/oops-plugin-framework/assets/core/Oops";
import { GameEvent } from "../common/config/GameEvent";
import { SkillCom } from "./SkillCom";
import { SkillSet, AnimType, endType } from "../common/config/SkillSet";
import { Animation, sp } from "cc";

/** 技能运动系统 */
@ecs.register('SkillSystem')
export class SkillSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
    
    filter(): ecs.IMatcher {
        return ecs.allOf(SkillCom);
    }

   

    update(entity: ecs.Entity) {
        const skill = entity.get(SkillCom);
        if (!skill || skill.is_destroy) return;

        this.updateSkillMovement(skill);
        this.checkDestroy(skill);
    }

    private updateSkillMovement(skill: SkillCom) {
        switch(skill.animType) {
            case AnimType.linear:
                this.linearMove(skill);
                break;
            case AnimType.parabolic:
                this.bezierMove(skill);
                break;
            case AnimType.fixed:
                this.fixedMove(skill);
                break;
            default:
                console.warn(`未知运动类型: ${skill.animType}`);
        }
    }

    private checkDestroy(skill: SkillCom) {
        let shouldDestroy = false;
        
        switch(skill.endType) {
            case endType.animationEnd:
                // 同时检测普通动画和Spine动画
                const anim = skill.node.getComponent(Animation);
                const spine = skill.node.getComponentInChildren(sp.Skeleton);
                
                if (anim) {
                    const state = anim.getState(skill.animName);
                    shouldDestroy = state?.isPlaying === false;
                } 
                else if (spine) {
                    shouldDestroy = spine.animation === 'end';
                }
                break;
            case endType.timeEnd:
                skill.duration -= this.dt;
                shouldDestroy = skill.duration <= 0;
                break;
            case endType.distanceEnd:
                shouldDestroy = skill.targetPos && 
                    Vec3.distance(skill.node.position, skill.targetPos) < 10;
                break;
        }

        if (shouldDestroy) {
            skill.is_destroy = true;
            skill.node.destroy();
        }
    }

    private linearMove(skill: SkillCom) {
        if (!skill.targetPos) return;

        // 计算移动方向
        const dir = skill.targetPos.clone().subtract(skill.node.position).normalize();
        
        // 计算新位置
        const newPos = skill.node.position.clone().add(
            dir.multiplyScalar(skill.speed * this.dt)
        );
        
        // 更新位置和角度
        skill.node.setPosition(newPos);

        // 自动处理距离销毁
        if (skill.endType === endType.distanceEnd) {
            const remaining = Vec3.distance(newPos, skill.targetPos);
            if (remaining < 10) {
                skill.is_destroy = true;
            }
        }
    }

    private bezierMove(skill: SkillCom) {
        if (!skill.targetPos) return;

        // 计算控制点（拱顶位置）
        const startPos = skill.startPos;
        const endPos = skill.targetPos;
        const controlHeight = Math.max(startPos.y, endPos.y) + 200;
        const controlPos = v3(
            (startPos.x + endPos.x) / 2,
            controlHeight
        );

        // 计算当前进度
        skill.duration += this.dt * skill.speed;
        const t = skill.duration / skill.inTime;

        // 使用二阶贝塞尔曲线公式计算位置
        const newPos = this.twoBezier(t, startPos, controlPos, endPos);

        skill.node.setPosition(newPos);

        // 自动结束判断
        if (t >= 1) {
            skill.is_destroy = true;
        }
    }

    private twoBezier(t: number, p1: Vec3, cp: Vec3, p2: Vec3): Vec3 {
        const x = (1 - t) * (1 - t) * p1.x + 2 * t * (1 - t) * cp.x + t * t * p2.x;
        const y = (1 - t) * (1 - t) * p1.y + 2 * t * (1 - t) * cp.y + t * t * p2.y;
        return v3(x, y, 0);
    }

    private fixedMove(skill: SkillCom) {
        // 仅处理时间结束逻辑
        skill.duration += this.dt * skill.speed;
        
        // 示例：在固定位置播放动画
        if (skill.endType === endType.timeEnd && skill.duration >= skill.inTime) {
            skill.is_destroy = true;
        }
    }

  
}