import {PlayerHandler} from "../Handler/PlayerHandler";
import {PetHandler} from "../Handler/PetHandler";
import { Skill } from "./Skill";
import { GameUnitType, SkillEffectType, SkillUserType } from "./SkillConst";
import { SKillEffectData, SkillInfoData, SkillInfoMsg } from "../../../message/SkillInfo";
import { PetInfo } from "message/PetInfo";

export class SkillParam{
    cardid: number;
    cardpoint: number;
    edd_cnt: number;
    srcplayer: PlayerHandler;
    dstplayer: PlayerHandler;
    dstpet: PetHandler;

    srcpet: PetHandler;

    constructor(cardid: number, cardpoint: number, effcnt: number, srcplayer: PlayerHandler, srcpet: PetHandler,
         dstplayer: PlayerHandler, dstpet: PetHandler){
        this.cardid = cardid;
        this.cardpoint = cardpoint;
        this.edd_cnt = effcnt;
        this.srcplayer = srcplayer;
        this.srcpet = srcpet;
        this.dstplayer = dstplayer;
        this.dstpet = dstpet;
    };

    clone(){
        return new SkillParam(this.cardid, this.cardpoint, this.edd_cnt, 
            this.srcplayer, this.srcpet, this.dstplayer, this.dstpet);
    };

    oppClone(){
        return new SkillParam(this.cardid, this.cardpoint, this.edd_cnt, 
            this.dstplayer, this.dstpet, this.srcplayer, this.srcpet);
    };

    reverse(){
        let tmpplayer = this.srcplayer;
        let tmppet = this.srcpet;
        this.srcplayer = this.dstplayer;
        this.srcpet = this.dstpet;
        this.dstpet = tmppet;
        this.dstplayer = tmpplayer;
    }
};

export class SkillResult{
    effect_type: number;
    effect_res: number;
    err: number;
    bsuccess: boolean;
    beffsrc: boolean;

    constructor(efftype: number, effres: number, issuccess: boolean, err: number = 0, issrc: boolean = false) {
        this.effect_type = efftype;
        this.effect_res = effres;
        this.err = err;
        this.bsuccess = issuccess;
        this.beffsrc = issrc;
    }
};

export class SkillTarget{
    srcplayer: PlayerHandler;
    srcpet: PetHandler;
    srcskill: Skill;
    srcskillid: number;
    srcskilltype: number;
    dst: PlayerHandler | PetHandler;
    dsttype: GameUnitType;

    lasttime: number;
    bresok: boolean = false;

    res: SkillResult[];

    constructor(skill: Skill, splayer?: PlayerHandler, spet?: PetHandler, dstobj?: any, dsttype?: GameUnitType) {
        this.srcplayer = splayer;
        this.srcpet = spet;
        this.srcskill = skill;
        this.srcskillid = skill._id;
        this.srcskilltype = skill._data.effect_typeid;
        this.dst = dstobj;
        this.dsttype = dsttype;
        this.lasttime = skill._data.indicate_time;
    };

    public LoadParam(sp: SkillParam){
        this.srcplayer = sp.srcplayer;
        this.srcpet = sp.srcpet;
        if(sp.dstpet){
            this.dsttype = sp.dstpet._isHero? GameUnitType.HERO: GameUnitType.PET;
            this.dst = sp.dstpet;
        }else if(sp.dstplayer){
            this.dsttype = GameUnitType.PLAYER;
            this.dst = sp.dstplayer;
        }
    };

    public isHurtSkill(){
        let effctid = this.srcskilltype;
        return effctid == SkillEffectType.HURT_POWER || effctid == SkillEffectType.HURT_HP || 
            effctid == SkillEffectType.HURT_ALL || effctid == SkillEffectType.ATTACK ||
            effctid == SkillEffectType.ATTACK_BACK;
    };

    public targetIsPet(){
        return this.dsttype == GameUnitType.PET || this.dsttype == GameUnitType.BATTLEUNIT;
    };

    public targetPlayer(): PlayerHandler{
        if(this.dsttype == GameUnitType.NONE || !this.dst){
            return null;
        }
        
        if(this.dsttype == GameUnitType.PLAYER){
            return (this.dst as PlayerHandler);
        }

        return (this.dst as PetHandler)._owner;
    };

    public getTarget(usertype: SkillUserType): PlayerHandler | PetHandler{
        let obj;
        switch(usertype){
            case SkillUserType.NONE:
                obj = this.srcpet? this.srcpet: this.srcplayer;    
                break;
            case SkillUserType.TARGET:
                obj = this.dst;
                break;
            case SkillUserType.SRC_HERO:
                obj = this.srcplayer? this.srcplayer: this.srcpet._owner;
                break;
            case SkillUserType.SRC_PLAYER:
                obj = this.srcplayer;
                break;
        }
        return obj;
    };

    public srcPet(): PetHandler{
        if(this.srcpet){
            return this.srcpet;
        }
        if(this.srcplayer){
            return this.srcplayer._self;
        }
        return null;
    };

    public srcPlayer(): PlayerHandler{
        if(this.srcplayer){
            return this.srcplayer;
        }
        if(this.srcpet){
            return this.srcpet._owner;
        }
        return null;
    };

    oppClone(){
        let st = new SkillTarget(this.srcskill);

        if(this.dsttype != GameUnitType.NONE){
            if(this.dsttype == GameUnitType.PLAYER){
                st.srcplayer = (this.dst as PlayerHandler);
                st.srcpet = st.srcplayer._self;
            }else {
                st.srcpet = (this.dst as PetHandler);
                st.srcplayer = st.srcpet._owner;
            }
        }
        if(this.srcpet){
            st.dst = this.srcpet;
            st.dsttype = this.srcpet._isHero? GameUnitType.HERO: GameUnitType.PET;
        }else{
            st.dst = this.srcplayer;
            st.dsttype = GameUnitType.PLAYER;
        }
        return st;
    };

    public checkRes(){
        if(!this.res){
            this.res = [];
        }
    };

    public success(efftype: number, effres: number, effsrc: boolean = false){
        this.checkRes();
        this.res.push(new SkillResult(efftype, effres, true, 0, effsrc));
        this.bresok = true;
    };

    public fail(efftype: number, err: number){
        this.checkRes();
        this.res.push(new SkillResult(efftype, 0, false, err));
    };

    public getLastTime(){
        return this.bresok? this.lasttime: 0;
    };

    // 暂无用
    public exportData(): SkillInfoMsg{
        let msg = new SkillInfoMsg();
        msg.data = new SkillInfoData();
        let obj = msg.data;
        obj.skill_id = this.srcskillid;
        obj.player = this.srcplayer.getId(),
        obj.pos = this.srcpet? this.srcpet._idx: 0;
        obj.datas = [];
        if(!this.res){
            msg.errcode = -1;
        }else{
            this.res.forEach((item: SkillResult) => {
                let ed = this.exportResData(item);
                ed && obj.datas.push(ed);
            });
        }
        return msg;
    };

    public exportMsg(lst: SkillTarget[]): SkillInfoMsg{
        if(!lst || lst.length == 0){
            return null;
        }
        let st = lst[0];
        let msg = new SkillInfoMsg();
        msg.data = new SkillInfoData();
        let obj = msg.data;
        obj.skill_id = st.srcskillid;
        obj.player = st.srcplayer.getId(),
        obj.pos = st.srcpet? st.srcpet._idx: 0;
        obj.datas = [];
        lst.forEach((item: SkillTarget) => {
            let eds = item.exportEffDatas();
            eds && obj.datas.push(...eds);
            // item.res && item.res.forEach((skres: SkillResult) => {
            //     let ed = item.exportResData(skres);
            //     ed && obj.datas.push(ed);
            // });
        });
        return msg;
    };

    public exportResData(skres: SkillResult, sk?: SkillTarget): SKillEffectData{
        let item = sk? sk: this;
        let res = skres;

        if(res){
            let ed = new SKillEffectData();
            if(res.beffsrc){
                ed.pos = item.srcPet()._idx;
                ed.player = item.srcPlayer().getId();
            }else{
                if(item.dsttype == GameUnitType.PLAYER){
                    ed.pos = 0;
                    ed.player = (item.dst as PlayerHandler).getId();
                }else {
                    ed.pos = (item.dst as PetHandler)._idx;
                    ed.player = (item.dst as PetHandler)._owner.getId();
                }
            }

            ed.effect_id = res.effect_type;
            ed.val = res.bsuccess? res.effect_res: res.err;
            ed.result = res.bsuccess? 0: -1;
            
            return ed;
        }

        return null;
    };

    public exportEffData(reslst: SkillResult[], bopp: boolean = false): SKillEffectData{
        if(!reslst || reslst.length <= 0){
            return null;
        }
        let ed = new SKillEffectData();
        let item = this;
        if(bopp){
            ed.pos = item.srcPet()._idx;
            ed.player = item.srcPlayer().getId();
        }else{
            if(item.dsttype == GameUnitType.PLAYER){
                ed.pos = 0;
                ed.player = (item.dst as PlayerHandler).getId();
            }else {
                ed.pos = (item.dst as PetHandler)._idx;
                ed.player = (item.dst as PetHandler)._owner.getId();
            }
        }
        
        reslst.forEach((item: SkillResult) => {
            let obj = {
                effect_id: item.effect_type,
                val: item.bsuccess? item.effect_res: item.err,
                result: item.bsuccess? 0: -1,
            };
            if(!ed.data){
                ed.data = [obj];
            }else{
                ed.data.push(obj);
            }
        });
        
        return ed;
    };

    public exportEffDatas(): SKillEffectData[]{
        if(!this.res){
            return null;
        }
        let r1: SkillResult[] = [];
        let r2: SkillResult[] = [];

        this.res.forEach((item: SkillResult) => {
            if(item.beffsrc){
                r2.push(item);
            }else{
                r1.push(item);
            }
        });

        let reslst = [];
        
        let res = this.exportEffData(r1);
        res && reslst.push(res);

        res = this.exportEffData(r2, true);
        res && reslst.push(res);

        return reslst;
    }
};


export class PetUpdateProcess{
    info: PetInfo;
    from: PetHandler;

    constructor(pet: PetHandler, from: PetHandler){
        this.from = from;
        this.info = pet.exportInfo();
    };
};