import { SkillCfg } from "cfg/parsers/SkillCfg";
import { SKillEffectData } from "message/SkillInfo";
import CfgMan from "../CfgMan";
import { PetHandler } from "../Handler/PetHandler";
import { PlayerHandler } from "../Handler/PlayerHandler";
import { GameCampType, GameUnitType, SkillEffectType, SkillEffectValueType, SkillRangeUnitType, SkillType, TriggerType } from "./SkillConst";
import { SkillParam, SkillTarget } from "./SkillParam";
import { TriggerCtrl } from "./TriggerCtrl";
import TriggerManager from "./TriggerMan";

export class Skill {
    _currCount: number;
    _roundCount: number;
    _startround: number;
    _delayround: number;
    _id: number;
    _data: SkillCfg;
    _type: any;
    _param: number;
    _tgctrl: TriggerCtrl;
    _man: any;
    _owner: PlayerHandler;
    _start: boolean;
    _cb: any;

    ap: number = 0;
    rd: number = 0;
    // LIFE-CYCLE CALLBACKS:

    // onLoad () {};

    // start () {};

    // update (dt) {};

    init(skillid: number, skilldata: SkillCfg, manager: any) {
        this._currCount = 0; // 当前计数
        this._roundCount = 0; // 回合数
        this._startround = 0; // 触发后回合数
        this._delayround = 0; // 延迟回合数
        this._id = skillid;
        this._data = skilldata;
        this._type = skilldata.skill_typeid;

        // todo: 根据bufftype处理paramlst
        this._param = TriggerManager.handleEffectParam(this._type, skilldata.eff_num);
        this._tgctrl = TriggerManager.addSkillTrigger(this._id, skilldata.tigger_typeid, 
            skilldata.cond_typeid, skilldata.cond_rangeid, skilldata.cond_num);

        this._man = manager;
    };

    triggerType() {
        return this._data.tigger_typeid;
    };

    skillname() {
        return this._data.name;
    };

    clear() {
        this._id = 0;
        this._data = null;
    };

    removeSelf() {

    };

    isSkill() {
        return true;
    };

    isOver() {
        return false;
    };

    isSame(id: number) {
        return this._id == id;
    };

    isBornSkill(){
        return this._type == SkillType.BORN;
    };

    isDieSkill(){
        return this._type == SkillType.DEAD;
    };

    isHaloSkill(){
        return this._type == SkillType.HALO;
    };

    isTauntSkill(){
        return this._data.effect_typeid == SkillEffectType.TAUNT;
    };

    isTransEffCardSkill(){
        return this._data.effect_typeid == SkillEffectType.CARD_CHG_EN;
    };

    isSingleTarget(){
        switch(this._data.rangeid){
            case SkillRangeUnitType.SELF:
            case SkillRangeUnitType.SINGLE:
            case SkillRangeUnitType.OTHER:
                return true;
            default:
                return false;
        }
    };

    isAllTarget(){
        return this._data.rangeid == SkillRangeUnitType.ALL;
    };

    isInRange(srcpet: PetHandler, dstpet: PetHandler){
        switch(this._data.rangeid){
            case SkillRangeUnitType.SELF:
                return srcpet == dstpet;
            case SkillRangeUnitType.SINGLE:
                return false;
            case SkillRangeUnitType.OTHER:
                return false;
            case SkillRangeUnitType.ALL:
                return true;
            case SkillRangeUnitType.ALL_EXSELF:
                return srcpet != dstpet;
            default:
                return false;
        }
    };

    isEffSelfPet(srcpet: PetHandler, dstpet: PetHandler){
        if(this._data.friendlyid != GameCampType.SELF){
            return false;
        }
        let tgok = false;
        switch(this._data.targetid){
            case GameUnitType.BATTLEUNIT:
                tgok = this.isInRange(srcpet, dstpet);
            case GameUnitType.HERO:
                tgok = dstpet._isHero;
            case GameUnitType.PET:
                if(!dstpet._isHero){
                    tgok = this.isInRange(srcpet, dstpet);
                }
        }
        return tgok;
    };

    getTargets(param: SkillParam): SkillTarget[]{
        return this._owner._owner.getSkillTargets(this, param);
    };

    getEnhanceValue(param: SkillParam): number{
        return CfgMan.calcEnhanceValue(this._data.edd_effid, this._data.edd_effnum, param.edd_cnt, param.cardpoint);
    };

    getEffValue(ap?: number): number{
        return CfgMan.calcEffectValue(this._data.eff_numtypeid, 
            this._data.num_signid, this._data.eff_num, ap? ap: this._data.eff_num);
    };

    trigger(param: SkillParam, cb?: any) {
        //触发buff效果
        let res = TriggerManager.onTrigger(this, param);

        this._currCount++;

        if (!this._start) {
            this._start = true;
        }

        cb && cb(this, param, res);

        this._cb && this._cb(this, param, res);

        this._man && this._man.onSkillTrigger(this, param, res);

        if(this.isTotalCardSkill()){
            this._owner && this._owner.resetTotalCard();
        }
        return res;
    };

    checkTrigger(tg_type: TriggerType, tg_value: any, tg_target: SkillParam, cb?: any) {
        if (tg_type == TriggerType.ROUND_START_MYSELF) {
            this._roundCount++;
            if (this._start) {
                this._startround++;
            }
        }
        if(this._tgctrl.checkTrigger(tg_type, tg_value, this._owner)){
            this.trigger(tg_target, cb);
            return 1;
        }else{
            return 0;
        }
    };

    handleCard(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
        let res = effvalue;
        switch(efftype){
            case SkillEffectType.CARD_ADD:
                if(tgt.dsttype == GameUnitType.PLAYER){
                    let n = tgt.dst.addCard(res);
                    if(n >= 0){
                        tgt.success(efftype, n);
                    }
                }else{
                    tgt.fail(efftype, -1);
                }
                break;
            case SkillEffectType.CARD_ADD_LIMIT:
                if(tgt.dsttype == GameUnitType.PLAYER){
                    let n = tgt.dst.addCardLimit(res);
                    if(n >= 0){
                        tgt.success(efftype, n);
                    }
                }else{
                    tgt.fail(efftype, -1);
                }
                break;
            case SkillEffectType.CARD_STEAL:
                if(tgt.dsttype == GameUnitType.PLAYER){
                    let n = tgt.srcplayer.stealCard(tgt.dst, res);
                    if(n >= 0){
                        tgt.success(efftype, n);
                    }
                }else{
                    tgt.fail(efftype, -1);
                }
                break;
            case SkillEffectType.CARD_CHG_EN:
                //todo: 暂不处理
                break;
            default:
                break;
        }
    };

    handlePower(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
        switch(efftype){
            case SkillEffectType.POWER_ENHANCE:
            case SkillEffectType.POWEREX_ENHANCE:
                if(tgt.dsttype != GameUnitType.NONE && tgt.dsttype != GameUnitType.PLAYER){
                    let n = efftype == SkillEffectType.POWER_ENHANCE? tgt.dst.addBaseAP(effvalue): tgt.dst.addExAP(effvalue);
                    tgt.success(efftype, n);
                }else{
                    tgt.fail(efftype, -1);
                }
                break;
            case SkillEffectType.HURT_POWER:
                if(tgt.dsttype != GameUnitType.NONE && tgt.dsttype != GameUnitType.PLAYER){
                    let n = tgt.dst.beHurt(effvalue);
                    tgt.success(efftype, n);
                }else{
                    tgt.fail(efftype, -1);
                }
                break;
            default:
                break;                
        }
    };

    handleHP(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
        if(efftype == SkillEffectType.HURT_HP){
            if(tgt.dsttype == GameUnitType.PLAYER){
                let n = tgt.dst.addHp(effvalue);
                tgt.success(efftype, n);
            }else{
                tgt.fail(efftype, -1);
            }
        }
    };

    summon(efftype: SkillEffectType, exparam: SkillParam, tgt: SkillTarget){
        let ncount = 1 + exparam.edd_cnt;
        switch(efftype){
            case SkillEffectType.SUMMON_NPC:
                let n = tgt.srcplayer.summonPet(this._data.quoteunitid, ncount, exparam);
                if(n >= 0){
                    tgt.success(efftype, n);
                }
                break;
            case SkillEffectType.SUMMON_SKILL:
                let res = tgt.srcplayer.useSkill(this._data.quoteskillid, ncount, exparam);
                if(res){
                    tgt.success(efftype, res.length);
                }
                break;
            default:
                break;
        }
    };

    addBuff(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){

    };

    reduceHurt(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
        if(efftype == SkillEffectType.HURT_REDUCE){
            if(tgt.dsttype != GameUnitType.NONE && tgt.dsttype != GameUnitType.PLAYER){
                let n = tgt.dst.addReduceHurt(effvalue);
                tgt.success(efftype, n);
            }else{
                tgt.fail(efftype, -1);
            }
        }
    };

    setOwner(owner: PlayerHandler) {
        this._owner = owner;
    };

    setTriggerCallback(cb: any) {
        this._cb = cb;
    };

    isTotalCardSkill(){
        return this._tgctrl._cond.isTempTotalCard();
    };

    clone() {
        let obj = new Skill();
        obj._currCount = 0; // 当前计数
        obj._roundCount = 0; // 回合数
        obj._startround = 0; // 触发后回合数
        obj._delayround = 0; // 延迟回合数
        obj._id = this._id;
        obj._data = this._data;
        obj._type = this._type;
        obj._param = this._param;
        obj._tgctrl = this._tgctrl;
        obj._man = this._man;
        return obj;
    };
};