import { _decorator,Button,EventHandler,EventTouch,Label,NodeEventType,resources,Sprite,SpriteAtlas,tween,UITransform,v3, Vec3,Animation, UI } 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 { smc } from "../common/SingletonModuleComp";
import { oops } from "../../../../extensions/oops-plugin-framework/assets/core/Oops";
import { RandomManager } from "../../../../extensions/oops-plugin-framework/assets/core/common/random/RandomManager";
import { HeroModelComp } from "../hero/HeroModelComp";
import { BoxSet } from "../common/config/BoxSet";
import { Hero } from "../hero/Hero";
import {  HeroSet } from "../common/config/heroSet";
import { MonModelComp } from "../hero/MonModelComp";
import {  MBSet, Missions,} from "../common/config/MissionSet";
import { Timer } from "../../../../extensions/oops-plugin-framework/assets/core/common/timer/Timer";
import { HCard } from "./HCard";
import { HCardComp } from "./HCardComp";
import { VictoryComp } from "./VictoryComp";
import { ItemComp } from "./ItemComp";
import { MSkillComp } from "./MSkillComp";
import { Monster } from "../hero/Mon";
import { UIID } from "../common/config/GameUIConfig";
import { CardControllerComp } from "./CardController";
import { MissionHomeComp } from "./MissionHomeComp";
import { GameEvent } from "../common/config/GameEvent";
import { HeroViewComp } from "../hero/HeroViewComp";
import { MoveToComp } from "../hero/MoveToComp";
import { HeroSkillComp } from "../hero/HeroSkillComp";
import { HeroStateComp } from "../hero/HeroStateComp";
import { instantiate } from "cc";
const { ccclass, property } = _decorator;

/** 视图层对象 */
@ccclass('MissionComp')
@ecs.register('Mission', false)
export class MissionComp extends CCComp {
    VictoryComp:any = null;
    mon_list:any = []
    call_hero_timer: Timer = new Timer(0.3);
    target_timer: Timer = new Timer(0.1);
    reward:number = 0;
    reward_num:number = 0;
    game_over:boolean = false;
    fight_start:boolean = false;
    mission_buff_type:number = 1 // 1 攻击 2 防御 3 HP
    m_mission_buff_type:number = 1 // 1 攻击 2 防御 3 HP
    mission_buff_up_exp:number = 99999999
    MSComp:MSkillComp=null
    MMSComp:MSkillComp=null
    
    onLoad(){
        // this.MSComp=this.node.getChildByName("msk").getComponent(MSkillComp)
        // this.MMSComp=this.node.getChildByName("mmsk").getComponent(MSkillComp)
        // this.MSComp.group=BoxSet.HERO
        // this.MSComp.s_uuid=smc.mission.mskill
        // this.MMSComp.group=BoxSet.MONSTER
        // this.MMSComp.s_uuid=smc.mission.mmskill
    }
    start() {
        // this.VictoryComp=this.node.getChildByName("victory").getComponent(VictoryComp)
    }
    
    protected update(dt: number): void {
        if(!smc.mission.play||smc.mission.pause){
            return
        }
        if(this.fight_start){
            this.check_mon_num()
        }
        this.count_hero_pos()
        this.count_mon_pos()
        this.check_buff()
        // if (this.game_timer.update(dt)) {
        //     smc.vmdata.game.g_time += 1;
        // }
        // this.shuaxin(dt)
    } 
    mission_start(){
        /* todo   关卡设定完善*/
        console.log("mission_start Missions mons:",Missions[smc.mission.lv])
        this.colose_victory()
        this.mission_init()
        // this.mskill_init()
        this.mon_refresh()
        this.heros_call()
    }

    mission_end(){
        oops.message.dispatchEvent(GameEvent.MissionEnd)
        smc.mission.play=false
        smc.mission.pause=false
        let heros:any= this.get_heros();;
        let monsters:any= this.get_mons();
        let hcards:any= ecs.query(ecs.allOf(HCardComp));
        let rewards:any= ecs.query(ecs.allOf(ItemComp));
        // let hcns=this.node.getChildByName("hcards")
        // for(let i=0;i<hcns.children.length;i++){
        //     hcns.children[i].destroy()
        // }
        for(let i=0;i<heros.length;i++){
            heros[i].HeroView.reset()
            heros[i].HeroView.ent.destroy()
        }
        for(let i=0;i<hcards.length;i++){
            hcards[i].HCardComp.reset()
            hcards[i].HCardComp.ent.destroy()
        }
        for(let i=0;i<monsters.length;i++){
            monsters[i].HeroView.reset()
            monsters[i].HeroView.ent.destroy()
        }
     
        // this.to_mission_home()
        this.open_victory()
    }
    open_victory(){
        this.node.getChildByName("victory").active=true
        this.node.getChildByName("victory").getComponent(VictoryComp).open()
    }
    colose_victory(){
        this.node.getChildByName("victory").active=false
    }
    to_mission_home(){
        this.colose_victory()
        let home =this.node.parent.getComponent(CardControllerComp);
        let mission_home=home.node.getChildByName("mission_home").getComponent(MissionHomeComp)
        home.bar_change(null,"home")
        home.node.getChildByName("bar").active=true;
        mission_home.load_ui_heros()
    }
    mission_init(){
        //局内数据初始化
        this.fight_start=false
        smc.mission.is_victory=false
        smc.mission.is_defeat=false
        smc.vmdata.mission.exp=0 //局内经验
        smc.vmdata.mission.mexp=0 //敌方局内经验
        smc.vmdata.mission.exp_max= smc.vmdata.mission.mexp_max=MBSet.exp
        smc.vmdata.mission.ap=0
        smc.vmdata.mission.hp=0
        smc.vmdata.mission.def=0
        smc.vmdata.mission.crit=0
        smc.vmdata.mission.dodge=0
        smc.vmdata.mission.dead=0
        smc.vmdata.mission.map=0
        smc.vmdata.mission.mhp=0
        smc.vmdata.mission.mdef=0
        smc.vmdata.mission.mcrit=0
        smc.vmdata.mission.mdead=0
        smc.vmdata.mission.mdodge=0
        // smc.vmdata.mission.ap_up=0
        // smc.vmdata.mission.hp_up=0
        // smc.vmdata.mission.def_up=0
        // smc.vmdata.mission.crit_up=0
        // smc.vmdata.mission.dodge_up=0
        // smc.vmdata.mission.map_up=0
        // smc.vmdata.mission.mhp_up=0
        // smc.vmdata.mission.mdef_up=0
        // smc.vmdata.mission.mcrit_up=0
        // smc.vmdata.mission.mdodge_up=0
        // this.clear_x1()
    }
    clear_x1(){
        for (let i in smc.items) {
            smc.items[i].x1=0
        }
        // for (let i in smc.skills) {
        //     smc.skills[i].x1=0
        // }
        for (let i in smc.heros) {
            smc.heros[i].x1=0
        }
        // console.log("clear_x1",smc.items,smc.heros)
    }
    mskill_init(){
        this.MSComp.group=BoxSet.HERO
        this.MMSComp.group=BoxSet.MONSTER
        this.MSComp.init()
        this.MMSComp.init()
    }
    check_buff(){
        if(smc.vmdata.mission.exp >= smc.vmdata.mission.exp_max){
            smc.vmdata.mission.exp-=smc.vmdata.mission.exp_max
            this.do_buff()
        }
        // if(smc.mission.mexp >= smc.vmdata.mission.mexp_max){
        //     smc.vmdata.mission.mexp-=smc.vmdata.mission.mexp_max
        //     this.do_mbuff()
        // }
    }
    do_buff(){
        smc.vmdata.mission.ap+=smc.vmdata.mission.ap_up
        smc.vmdata.mission.hp+=smc.vmdata.mission.hp_up
        smc.vmdata.mission.def+=smc.vmdata.mission.def_up
        smc.vmdata.mission.crit+=smc.vmdata.mission.crit_up
        smc.vmdata.mission.dodge+=smc.vmdata.mission.dodge_up
        if(smc.vmdata.mission.hp_up > 0 ){
            let heros:any =ecs.query(ecs.allOf(HeroModelComp));
            for (let i = 0; i < heros.length; i++) {
                heros[i].HeroView.add_hp2(smc.vmdata.mission.hp_up)
            }
        }
        
    }
    // do_mbuff(){
    //     smc.vmdata.mission.map+=smc.vmdata.mission.map_up
    //     smc.vmdata.mission.mhp+=smc.vmdata.mission.mhp_up
    //     //todo hp 需要特殊处理
    //     smc.vmdata.mission.mdef+=smc.vmdata.mission.mdef_up
    //     smc.vmdata.mission.mcrit+=smc.vmdata.mission.mcrit_up
    //     smc.vmdata.mission.mdodge+=smc.vmdata.mission.mdodge_up
    // }
    check_mon_num(){
        let mons:any = this.get_mons()
        let heros:any= this.get_heros()
        let h_alive=false
        let m_alive=false
        for (let i = 0; i < heros.length; i++) {
            if ( !heros[i].HeroView.is_dead) {
                h_alive=true
            }
        }
        for (let i = 0; i < mons.length; i++) {
            if ( !mons[i].HeroView.is_dead) {
                m_alive=true
            }
        }
        if (!m_alive||!h_alive) this.mission_end()
    }

    get_mons(){
        return ecs.query(ecs.allOf(MonModelComp));
    }
    get_heros(){
        return ecs.query(ecs.allOf(HeroModelComp))
    }
    count_mon_pos(){
        let right_x:number=360
        let left_x:number=-360
        let monsters:any= this.get_mons()
        for(let i=0;i<monsters.length;i++){
            if(monsters[i].HeroView == undefined) return
            if(monsters[i].HeroView.node.position.x > 400) continue
            let mon:any = monsters[i].HeroView.node.position
            smc.enemy_pos[i]= mon
            if(monsters[i].HeroView.node.position.x > left_x){
                left_x = monsters[i].HeroView.node.position.x
            }
            if(monsters[i].HeroView.node.position.x < right_x){
                right_x = monsters[i].HeroView.node.position.x
            }
        }
        smc.mon_front_x=right_x
        smc.mon_back_x=left_x
        // console.log("count_mon_pos",smc.mon_pos,smc.mon_front_x,smc.mon_back_x)
    }
    count_hero_pos(){
        let right_x:number=360
        let left_x:number=-360
        let heros:any= this.get_heros()
        for(let i=0;i<heros.length;i++){
            if(heros[i].HeroView == undefined) return
            if(heros[i].HeroView.node.position.x < -400) continue

            let ho:any = heros[i].HeroView.node.position
            smc.hero_pos[i]= ho
            if(heros[i].HeroView.node.position.x > left_x){
                left_x = heros[i].HeroView.node.position.x
            }
            if(heros[i].HeroView.node.position.x < right_x){
                right_x = heros[i].HeroView.node.position.x
            }
        }
        smc.hero_front_x=left_x
        smc.hero_back_x=right_x
        // console.log("count_hero_pos",smc.hero_pos,smc.hero_front_x,smc.mon_front_x)
    }

    mon_refresh(){
        let num =3
        let t_num= Missions[0].length
        let y_num= Missions[1].length
        let b_num= Missions[2].length
        let tc=1
        let yc=2
        let bc=1
        for(let i=0;i<tc;i++){
            let x=RandomManager.instance.getRandomInt(0,t_num,1)
            this.addMonster(Missions[0][x],i)
            console.log("Missions t:"+x,Missions[0][x])
        }
        for(let i=0;i<yc;i++){
            let x=RandomManager.instance.getRandomInt(0,y_num,1)
            this.addMonster(Missions[1][x],i)
            console.log("Missions y:"+x,Missions[1][x])
        }
        for(let i=0;i<bc;i++){
            let x=RandomManager.instance.getRandomInt(0,b_num,1)
            console.log("Missions b:"+x,Missions[2][x])
            x=RandomManager.instance.getRandomInt(0,b_num,1)
            console.log("Missions b:"+x,Missions[2][x])
            x=RandomManager.instance.getRandomInt(0,b_num,1)
            console.log("Missions b:"+x,Missions[2][x])
            x=RandomManager.instance.getRandomInt(0,b_num,1)
            console.log("Missions b:"+x,Missions[2][x])
            x=RandomManager.instance.getRandomInt(0,b_num,1)
            console.log("Missions b:"+x,Missions[2][x])
            x=RandomManager.instance.getRandomInt(0,b_num,1)
            console.log("Missions b:"+x,Missions[2][x])
            this.addMonster(Missions[2][x],i,true)
        }
    }
    heros_call(){
        let heros=smc.fight_heros
        console.log("heros_call",heros)
        for(let i=0;i<heros.length;i++){
            this.addHero(heros[i],i)
        }
        this.hcard_call()
    }
    hcard_call(){
        let node =this.node.getChildByName("hcards")
        let heros:any= this.get_heros();

        for(let i=0;i<heros.length;i++){
            let hcard = ecs.getEntity<HCard>(HCard)
            // console.log("hcard:",hcard)
            hcard.load(heros[i].HeroView.hero_uuid,i,node)
        }
        this.fight_start= true
    }
       /** 添加玩家 */
    private createEntity<T extends ecs.Entity>(
        entityClass: ecs.TypedConstructor<T>,
        components: ecs.Comp[]
    ): T {
        const entity = ecs.Entity.create(entityClass);
        components.forEach(comp => entity.add(comp));
        return entity;
    }

    private addHero(uuid: number = 1001, index: number = 0) {
        // 组件初始化
        const components = [
            this.createHeroModel(uuid),
            this.createHeroView(index),
            new MoveToComp()
        ];

        // 创建实体
        const hero = this.createEntity(Hero, components);
        
        // 初始化技能系统
        hero.get(HeroSkillComp)?.initSkills();
    }

    private createHeroModel(uuid: number): HeroModelComp {
        const model = new HeroModelComp();
        model.uuid = uuid;
        model.level = 1;
        return model;
    }

    private createHeroView(index: number): HeroViewComp {
        const view = new HeroViewComp();
        const pos = v3(HeroSet.StartPos[1] - index * 10, BoxSet.GAME_LINE);
        view.initPosition(pos, 1);
        return view;
    }

    private addMonster(uuid: number = 2001, index: number = 0, isBoss: boolean = false) {
        const components = [
            this.createMonsterModel(uuid, isBoss),
            this.createMonsterView(index),
            new MoveToComp()
        ];

        this.createEntity(Monster, components);
    }

    private createMonsterModel(uuid: number, isBoss: boolean): MonModelComp {
        const model = new MonModelComp();
        model.uuid = uuid;
        model.isBoss = isBoss;
        return model;
    }

    private createMonsterView(index: number): HeroViewComp {
        const view = new HeroViewComp();
        const pos = v3(-HeroSet.StartPos[1] + index * 10, BoxSet.GAME_LINE);
        view.initPosition(pos, -1);
        return view;
    }

    
    /** 视图层逻辑代码分离演示 */

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

    private clearEntities() {
        // 使用类型安全的方式销毁实体
        this.destroyEntities<Hero>(ecs.allOf(HeroModelComp));
        this.destroyEntities<Monster>(ecs.allOf(MonModelComp));
    }

    private destroyEntities<T extends ecs.Entity>(matcher: ecs.IMatcher) {
        ecs.query(matcher).forEach(entity => {
            const view = entity.get(HeroViewComp);
            view?.destroyNode();
            entity.destroy();
        });
    }

    // 添加实体类型守卫
    private isHero(entity: ecs.Entity): entity is Hero {
        return entity.has(HeroModelComp);
    }

    private isMonster(entity: ecs.Entity): entity is Monster {
        return entity.has(MonModelComp);
    }

    // 统一实体处理
    private updateEntities() {
        ecs.query(ecs.allOf(HeroModelComp)).forEach(entity => {
            if (this.isHero(entity)) {
                entity.HeroModel.updateState();
            }
        });
    }
}