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";

export class PlayerHandler {
    public _player: Player;

    public _playercfg: HeroCfg;

    public _self: PetHandler;

    public _unitcfg: UnitCfg;

    public _pets: PetHandler[] = [];

    public _skills: Skill[] = [];

    public _exskills: Skill[] = [];

    public _owner: BattleHandler;

    _friend: PlayerHandler;

    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.setParam(this._playercfg.herounit_id, ps, lst);
        this._unitcfg = this._playercfg && CfgMan.findUnitCfg(this._playercfg.herounit_id);
    };

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

    public getTotalCardCount(){
        return 0;
    };

    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.ap == 0){
                    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.setParam(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[]{
        let cfg = CfgMan.findSkillCfg(skillid);
        let lst:SkillTarget[] = [];
        if(cfg.skill_typeid == SkillType.MAGIC){
            for(let i = 0; i < count; i++){
                let sk = this.newSkill(skillid);
                sk.checkTrigger(TriggerType.NO_COND, 0, obj, 
                    (sk: Skill, sp: SkillParam, res: SkillTarget[])=>{
                        if(res){
                            lst.concat(res);
                        }else{
                            lst.push()
                        }
                });
                //todo: build json -> client
            }
        }else {
            for(let i = 0; i < count; i++){
                this._self.addSkill(skillid, this.onHaloChanged);
            }
        }
        return lst;
    };
    
    public newSkill(skillid: number): Skill{
        let obj = SkillMan.getSkill(skillid);
        if(obj){
            obj.setOwner(this);
        }
        return obj;
    };

    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.setParam(petid, exparam);
        }
        return n;
    };

    public addCard(count: number){
        return this._owner.onPlayerAddCard(this, count, 0);
    };

    public addCardLimit(maxcount: number){
        return this._owner.onPlayerAddCard(this, 0, maxcount);
    };

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

    public addHP(value: number){
        this._player.hp += value;
        if(value < 0){
            this.die();
        }
        return value;
    };

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

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

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

    public die(){
        //todo:
    };

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

        // 战吼
        let reslst: SkillTarget[] = [];
        apet._bornSkills.forEach((item: Skill)=>{
            item.checkTrigger(TriggerType.NO_COND, 0, param, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
                if(res){
                    reslst = reslst.concat(res);
                }else{
                    let st = new SkillTarget(skill);
                    st.LoadParam(param);
                    reslst.push(st);
                }
            });
        });

        this._owner.onSkillResult(reslst);
    };

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

        // 遗愿
        let ps = new SkillParam(0, 0, 0, this, apet, null, null);
        let reslst: SkillTarget[] = [];
        apet._dieSkills.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.onSkillResult(reslst);
    };

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

    public isMyPet(apet: PetHandler){
        return this._pets.includes(apet);
    };

    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;
    };
}