import { Player } from "../../schema/Player";
import { PetHandler } from "./PetHandler";
import { HeroCfg } from "../../../cfg/parsers/HeroCfg";
import { BattleHandler } from "./BattleHandler";
import CfgMan from "../CfgMan";
import { Pet } from "rooms/schema/Pet";
import { EffectCardType, GameUnitType, SkillType, TriggerType } from "../skill/SkillConst";
import { UnitCfg } from "cfg/parsers/UnitCfg";
import { Skill } from "../skill/Skill";
import { SkillParam, SkillTarget } from "../skill/SkillParam";
import SkillMan from "../skill/SkillMan";
import { Card } from "rooms/schema/Card";

export class PlayerHandler {
    public _player: Player;

    public _playercfg: HeroCfg;

    public _self: PetHandler;

    public _unitcfg: UnitCfg;

    public _pets: PetHandler[] = [];

    public _owner: BattleHandler;

    public _friend: PlayerHandler;

    _totalcc: number = 0;

    public init(aplayer: Player, owner: BattleHandler){
        this._owner = owner;
        this._player = aplayer;
        this._playercfg = CfgMan.findPlayerCfg(this._player.heroId);
        this._self = new PetHandler();
        this._self.init(null, this, 0);
        this._self._isHero = true;
        let lst = this._playercfg.ex_skill? [this._playercfg.ex_skill]: null;
        let ps = new SkillParam(0, 0, 0, this, this._self, null, null);
        this._self.loadData(this._playercfg.herounit_id, ps, lst);
        this._unitcfg = this._playercfg && CfgMan.findUnitCfg(this._playercfg.herounit_id);
    };

    public clear(){
        this._self = null;
        this._pets.length = 0;
    };

    public getCurrCardCount(){
        return this._player.cards.size;
    };

    public getTotalCardCount(){
        return this._totalcc;
    };

    public getId(): string{
        return this._player.id + '';
    };

    public newPet(): PetHandler {
        let res = null;
        let pr = null;
        let n = 0;
        for(let [key, obj] of this._player.pets){
            if(n != 0){
                if(obj.state == 0 || obj.state == 2){
                    res = obj;
                    break;
                }
            }
            ++n;
        }

        if(res){
            pr = new PetHandler;
            pr.init(res, this, n);
            this._pets.push(pr);
        }

        return pr;
    };

    public getPet(pet: Pet){
        return this._pets.find((item:PetHandler)=>{
            return item._pet == pet;
        })
    };

    public exportAllPets(ct: GameUnitType, param: SkillParam, expet: PetHandler, dst: SkillTarget[]): SkillTarget[]{
        if(!dst){
            return null;
        }
        switch(ct){
            case GameUnitType.BATTLEUNIT:
                let lst = this._pets.reverse();
                lst.forEach(element => {
                    if(expet != element){
                        dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, element, GameUnitType.PET));
                    }
                });
                (expet != this._self) && dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, this._self, GameUnitType.PET));
                break;
            case GameUnitType.HERO:
                (expet != this._self) && dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, this._self, GameUnitType.PET));
                break;
            case GameUnitType.PET:
                lst.forEach(element => {
                    if(expet != element){
                        dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, element, GameUnitType.PET));
                    }
                });
                break;
            default:
                break;
        }
        return dst;
    };

    public useCard(obj: SkillParam)
    {
        let cfg = CfgMan.findEffCardCfg(obj.cardid);
        if(!cfg){
            return false;
        }

        if(cfg.type_id == EffectCardType.NPC){
            let pet = this.newPet();
            if(!pet){
                return false;
            }
            obj.srcpet = pet;
            pet.loadData(cfg.stageunit_id, obj, 
                [cfg.quoteskill1id, cfg.quoteskill2id, cfg.quoteskill3id, cfg.quoteskill4id]);
        }else if(cfg.type_id == EffectCardType.MAGIC){
            this.useSkills([cfg.quoteskill1id, cfg.quoteskill2id, cfg.quoteskill3id, cfg.quoteskill4id], obj);
        }
    };

    public useSkills(skills: number[], obj: SkillParam)
    {
        if(!skills){
            return;
        }

        skills.forEach((item: number)=>{
            this.useSkill(item, 1, obj);
        });
    };

    public useSkill(skillid: number, count: number, obj: SkillParam): SkillTarget[]{
        return this.handleSkill(skillid, count, obj, this._self);
    };
    
    public newSkill(skillid: number): Skill{
        let obj = SkillMan.getSkill(skillid);
        if(obj){
            obj.setOwner(this);
        }
        return obj;
    };

    public handleSkill(skillid: number, count: number, param: SkillParam, pet: PetHandler):SkillTarget[]{
        let cfg = CfgMan.findSkillCfg(skillid);
        let lst: Skill[] = [];
        if(cfg.skill_typeid == SkillType.MAGIC){
            for(let i = 0; i < count; i++){
                let sk = this.newSkill(skillid);
                lst.push(sk);
            }
            // this._owner.onSkillResultNotify(lst);
        }else {
            let bhalo = false;
            for(let i = 0; i < count; i++){
                let obj = pet.addSkill(skillid);
                if(obj.isBornSkill()){
                    lst.push(obj);
                }else if(obj.isDieSkill()){
                    
                }else if(obj.isHaloSkill()){
                    bhalo = true;
                }else{
                    lst.push(obj);
                }
            }
            if(bhalo){
                this.onHaloChanged(pet);
            }
        }
        return this.simpleCheckSkills(lst, pet, param);
    };

    public summonPet(petid: number, count: number = 1, exparam: SkillParam):number{
        let n = -1;
        for(let i = 0; i < count; i++){
            let pet = this.newPet();
            if(!pet){
                break;
            }
            n++;
            pet.loadData(petid, exparam);
        }
        return n;
    };

    public addCard(count: number, from?: PlayerHandler){
        return this._owner.onPlayerAddCardNotify(this, count, 0, from);
    };

    public addCardLimit(maxcount: number, from?: PlayerHandler){
        return this._owner.onPlayerAddCardNotify(this, 0, maxcount, from);
    };

    public stealCard(dstplayer: PlayerHandler, count: number){
        return this._owner.onPlayerStealCardNotify(this, dstplayer, count);
    };

    public addHP(value: number){
        return this._owner.onPlayerAddHPNotify(this, value);
    };

    public getHP(){
        return this._player.hp;
    };

    public checkHalo(apet:PetHandler){
        this._self.clearEffHalos();
        this._pets.forEach((obj:PetHandler)=>{
            obj.clearEffHalos();
        });
        this._pets.forEach((obj: PetHandler)=>{
            if(obj != apet){
                obj.checkHalo(apet);
            }
            apet.checkHalo(obj);
        });
        if(this._self != apet){
            this._self.checkHalo(apet);
            apet.checkHalo(this._self);
        }
    };

    public setFriend(aplayer: PlayerHandler){
        this._friend = aplayer;
    };

    public die(){
        this.clear();
        //todo:
    };

    public isAlive(): boolean{
        return this._player.state != 2;
    };

    public onPetBorned(apet: PetHandler, param: SkillParam){
        this._owner.onAddPetNotify(apet);

        // 战吼
        this.simpleCheckSkills(apet._bornSkills, apet, param);
    };

    public onPetDied(apet: PetHandler){
        this._owner.onDelPetNotify(apet);

        // 遗愿
        this.simpleCheckSkills(apet._dieSkills, apet);
    };

    public onHaloChanged(apet: PetHandler){
        this.checkHalo(apet);
    };

    public isMyPet(apet: PetHandler){
        if(apet == this._self){
            return true;
        }
        return this._pets.includes(apet);
    };

    public findTauntPet(): PetHandler{
        if(this._self && this._self._istaunt){
            return this._self;
        }
        return this._pets.find((item: PetHandler) =>{
            return item._istaunt;
        })
    };

    public hasTransEffCardSkill(): boolean{
        if(!this._self){
            return false;
        }
        
        let bok = false;
        for(let [key, val] of this._self._skills){
            if(val.isTransEffCardSkill()){
                bok = true;
                break;
            }
        }
        return bok;
    };

    onCardLinkReady(fromplayer: PlayerHandler){
        this.checkSkills(TriggerType.CARD_LINK_BEFORE);
    };

    onCardLinkEnd(linkcards: Card[], fromplayer: PlayerHandler){
        this.checkSkills(TriggerType.CARD_LINK_AFTER);
    };

    onCardDroped(dropcards: Card[], srcplayer: PlayerHandler){
        this.checkSkills(TriggerType.CARD_DROP_MYROUND);
    };

    onCardGetted(getcards: Card[], srcplayer: PlayerHandler){
        getcards && (this._totalcc += getcards.length);
        this.checkSkills(TriggerType.CARD_GETTED);
    };

    onUseCardEnd(sp: SkillParam){
        this.checkSkills(TriggerType.CARD_USED, 0, sp);
    };

    onRoundStart(){
        this.checkSkills(TriggerType.ROUND_START_MYSELF);
    };

    onRoundEnd(){
        this.checkSkills(TriggerType.ROUND_END_MYSELF);
    };

    checkSkills(tgttype: TriggerType, tgtvalue?: any, tgtsp?: SkillParam){
        let sp = tgtsp;
        if(!sp){
            sp = new SkillParam(0, 0, 0, this, this._self, null, null);
        }
        let reslst: SkillTarget[] = [];
        this._self.checkSkills(tgttype, tgtvalue, sp, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
            if(res){
                reslst = reslst.concat(res);
            }else{
                let st = new SkillTarget(skill);
                st.LoadParam(sp);
                reslst.push(st);
            }
        });

        this._pets.forEach((item: PetHandler) => {
            item.checkSkills(tgttype, tgtvalue, sp, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
                if(res){
                    reslst = reslst.concat(res);
                }else{
                    let st = new SkillTarget(skill);
                    st.LoadParam(sp);
                    reslst.push(st);
                }
            });
        });

        this._owner.onSkillResultNotify(reslst);
    };

    simpleCheckSkills(skills: Skill[], apet?: PetHandler, param?: SkillParam): SkillTarget[]{
        let ps = param? param: new SkillParam(0, 0, 0, this, apet, null, null);
        let reslst: SkillTarget[] = [];
        skills.forEach((item: Skill)=>{
            item.checkTrigger(TriggerType.NO_COND, 0, ps, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
                if(res){
                    reslst = reslst.concat(res);
                }else{
                    let st = new SkillTarget(skill);
                    st.LoadParam(ps);
                    reslst.push(st);
                }
            });
        });

        this._owner.onSkillResultNotify(reslst);

        return reslst;
    };

    resetTotalCard(){
        this._totalcc = 0;
    }
}