import Main from "../Main";
import GameM from "../manager/GameM";
import RedPointM, { RedPointType } from "../manager/RedPointM";
import UiM from "../manager/UiM";
import TalentIconItem from "../other/item/TalentIconItem";
import TalentDetaile from "../prefabs/TalentDetaile";
import { PlayerPrefs } from "../tools/MyExtends";
import MatePanel from "../ui/MatePanel";
import UIMng, { PanelType } from "../uiFrames/UIMng";
import { Utils } from "../utils/Utils";
import { ConfigOnLine } from "./CommonData";

export class MateData {
    //伙伴模块数据管理类
    private static _ins: MateData = null;
    public static get Ins(): MateData {
        if (this._ins == null) {
            this._ins = new MateData();
        }
        return this._ins;
    }

    /**天赋石*/
    talentCoin: number = 100000;

    /**伙伴解锁数据*/
    mateUnlockAry: number[] = null;

    //天赋 effect_type 1 值 2 百分比

    /**唐僧天赋*/
    mate1talentData: TalentDataItem[] = null;
    /**孙悟空天赋*/
    mate2talentData: TalentDataItem[] = null;
    /**白龙马天赋*/
    mate3talentData: TalentDataItem[] = null;
    /**八戒天赋*/
    mate4talentData: TalentDataItem[] = null;
    /**沙僧天赋*/
    mate5talentData: TalentDataItem[] = null;


    //private mate1Talent1: number = 0;
    /**唐僧1 禅杖清音 武将每次产出金币 +X %*/
    get Mate1Talent1(): number {
        if (this.mateUnlockAry[0] == 1 && this.mate1talentData[0].isUnlock)
            return this.mate1talentData[0].value;
        else
            return 0;
    }
    //private mate1Talent2: number = 0;
    /**唐僧2 如来真经 武将产出金币的CD时间减少 X%*/
    get Mate1Talent2(): number {
        if (this.mateUnlockAry[0] == 1 && this.mate1talentData[1].isUnlock)
            return this.mate1talentData[1].value;
        else
            return 0;
    }
    //private mate1Talent3: number = 0;
    /**唐僧3 如来真经 观看视频得金币增加 X%*/
    get Mate1Talent3(): number {
        if (this.mateUnlockAry[0] == 1 && this.mate1talentData[2].isUnlock)
            return this.mate1talentData[2].value;
        else
            return 0;
    }


    //private mate2Talent1: number = 0;
    /**悟空1 如意金箍 对武将伤害 +X*/
    get Mate2Talent1(): number {
        if (this.mateUnlockAry[1] == 1 && this.mate2talentData[0].isUnlock)
            return this.mate2talentData[0].value;
        else
            return 0;
    }
    //private mate2Talent2: number = 0;
    /**悟空2 大圣神威 有 X%概率对武将造成暴击伤害*/
    get Mate2Talent2(): number {
        if (this.mateUnlockAry[1] == 1 && this.mate2talentData[1].isUnlock)
            return this.mate2talentData[1].value;
        else
            return 0;
    }

    //待完成。。。
    //private mate2Talent3: number = 0;
    /**悟空3 火眼金睛 每天获得宝箱的次数增加 X 次*/
    get Mate2Talent3(): number {
        if (this.mateUnlockAry[1] == 1 && this.mate2talentData[2].isUnlock)
            return this.mate2talentData[2].value;
        else
            return 0;
    }


    //private mate3Talent1: number = 0;
    /**白龙马1 威严震慑 武将罢工几率降低 X%*/
    get Mate3Talent1(): number {
        if (this.mateUnlockAry[2] == 1 && this.mate3talentData[0].isUnlock)
            return this.mate3talentData[0].value;
        else
            return 0;
    }
    //private mate3Talent2: number = 0;
    /**白龙马2 天降甘露 挂机离线收益产出+ X%*/
    get Mate3Talent2(): number {
        if (this.mateUnlockAry[2] == 1 && this.mate3talentData[1].isUnlock)
            return this.mate3talentData[1].value;
        else
            return 0;
    }
    //private mate3Talent3: number = 0;
    /**白龙马3 精打细算 买怪费用降低 X%*/
    get Mate3Talent3(): number {
        if (this.mateUnlockAry[2] == 1 && this.mate3talentData[2].isUnlock)
            return this.mate3talentData[2].value;
        else
            return 0;
    }


    //private mate4Talent1: number = 0;
    /**八戒1 玉树临风 探索功能中产出金币 +X%*/
    get Mate4Talent1(): number {
        if (this.mateUnlockAry[3] == 1 && this.mate4talentData[0].isUnlock)
            return this.mate4talentData[0].value;
        else
            return 0;
    }
    //private mate4Talent2: number = 0;
    /**八戒2 急速旋风 探索功能中探索时间减 X%*/
    get Mate4Talent2(): number {
        if (this.mateUnlockAry[3] == 1 && this.mate4talentData[1].isUnlock)
            return this.mate4talentData[1].value;
        else
            return 0;
    }
    //private mate4Talent3: number = 0;
    /**八戒2 最佳人缘 探索次数增加 X 次*/
    get Mate4Talent3(): number {
        if (this.mateUnlockAry[3] == 1 && this.mate4talentData[2].isUnlock)
            return this.mate4talentData[2].value;
        else
            return 0;
    }


    //private mate5Talent1: number = 0;
    /**沙僧1 不知疲倦 在钱庄中累计登陆天数减少 X 天*/
    get Mate5Talent1(): number {
        if (this.mateUnlockAry[4] == 1 && this.mate5talentData[0].isUnlock)
            return this.mate5talentData[0].value;
        else
            return 0;
    }
    //private mate5Talent2: number = 0;
    /**沙僧2 任劳任怨 有 在钱庄中看视频次数减少 X 条*/
    get Mate5Talent2(): number {
        if (this.mateUnlockAry[4] == 1 && this.mate5talentData[1].isUnlock)
            return this.mate5talentData[1].value;
        else
            return 0;
    }



    /*
    唐僧1 武将产出金币            %      mate1Talent1     √
    唐僧2 武将产出金币CD时间减少   %      mate1Talent2     √
    唐僧3 观看视频获得金币增加     %      mate1Talent3     √

    孙悟空1 对武将伤害增加（攻击力） num    mate2Talent1     √
    孙悟空2 对武将造成暴击伤害几率   %      mate2Talent2     √
    孙悟空3 战斗宝箱每天获得次数增加  num   mate2Talent3

    白龙马1 武将罢工几率降低         %     mate3Talent1     √
    白龙马2 挂机收益增加             %     mate3Talent2     √
    白龙马3 买怪费用降低             %     mate3Talent3     √

    猪八戒1 探索产出金币增加         %      mate4Talent1    后台算
    猪八戒2 探索时间减少             %      mate4Talent2    后台算
    猪八戒3 探索次数增加             num     mate4Talent3   后台算

    沙僧1 钱庄累计登陆天数减少     num     mate5Talent1     后台算
    沙僧2 钱庄看视频次数减少条数    num    mate5Talent2     后台算
    */






    matePosAry1: cc.Vec2[] = [];
    matePosAry2: cc.Vec2[] = [];
    matePosAry3: cc.Vec2[] = [];
    matePosAry4: cc.Vec2[] = [];
    matePosAry5: cc.Vec2[] = [];

    private isInit: boolean = false;

    constructor() {
        this.Init();
    }

    Init() {
        //this.mateUnlockAry = PlayerPrefs.GetObject("MateUnlockAry", [1, 0, 0, 1, 0]);

        this.mateUnlockAry = PlayerPrefs.GetObject("MateUnlockAry", [1, 1, 1, 1, 1]);
        this.mate1talentData = PlayerPrefs.GetObject("MateTalent1", null);
        this.mate2talentData = PlayerPrefs.GetObject("MateTalent2", null);
        this.mate3talentData = PlayerPrefs.GetObject("MateTalent3", null);
        this.mate4talentData = PlayerPrefs.GetObject("MateTalent4", null);
        this.mate5talentData = PlayerPrefs.GetObject("MateTalent5", null);
        if (GameM.commonData.useLocalData) {
            for (let i = 0; i < 5; i++) {
                this.LocalMateDataInit(i + 1);
            }
            console.log("Mate1:", this.mate1talentData);
            console.log("Mate2:", this.mate2talentData);
            console.log("Mate3:", this.mate3talentData);
            console.log("Mate4:", this.mate4talentData);
            console.log("Mate5:", this.mate5talentData);
        } else {
            //CommondData 中初始化
        }

        //坐标解析
        let p1 = GameM.commonData.mateCfg.mate_pos.posAry1;
        for (let i = 0; i < p1.length; i++) {
            let temps = p1[i].split(',');
            this.matePosAry1.push(cc.v2(Number(temps[0]), Number(temps[1])));
        }
        let p2 = GameM.commonData.mateCfg.mate_pos.posAry2;
        for (let i = 0; i < p2.length; i++) {
            let temps = p2[i].split(',');
            this.matePosAry2.push(cc.v2(Number(temps[0]), Number(temps[1])));
        }
        let p3 = GameM.commonData.mateCfg.mate_pos.posAry3;
        for (let i = 0; i < p3.length; i++) {
            let temps = p3[i].split(',');
            this.matePosAry3.push(cc.v2(Number(temps[0]), Number(temps[1])));
        }
        let p4 = GameM.commonData.mateCfg.mate_pos.posAry4;
        for (let i = 0; i < p4.length; i++) {
            let temps = p4[i].split(',');
            this.matePosAry4.push(cc.v2(Number(temps[0]), Number(temps[1])));
        }
        let p5 = GameM.commonData.mateCfg.mate_pos.posAry5;
        for (let i = 0; i < p5.length; i++) {
            let temps = p5[i].split(',');
            this.matePosAry5.push(cc.v2(Number(temps[0]), Number(temps[1])));
        }


        this.isInit = true;



        // console.log("Mate5 Pos:", this.matePosAry5);
        //获取伙伴信息 天赋数据
    }

    LocalMateDataInit(mateid: number) {
        if (mateid == 1) {
            if (this.mate1talentData == null) {
                this.mate1talentData = this.LocalMateData(mateid);
            }
        } else if (mateid == 2) {
            if (this.mate2talentData == null) {
                this.mate2talentData = this.LocalMateData(mateid);
            }
        } else if (mateid == 3) {
            if (this.mate3talentData == null) {
                this.mate3talentData = this.LocalMateData(mateid);
            }
        } else if (mateid == 4) {
            if (this.mate4talentData == null) {
                this.mate4talentData = this.LocalMateData(mateid);
            }
        } else if (mateid == 5) {
            if (this.mate5talentData == null) {
                this.mate5talentData = this.LocalMateData(mateid);
            }
        }
    }

    LocalMateData(mateid: number): TalentDataItem[] {
        let matedata: TalentDataItem[] = [];
        let matecfg = GameM.commonData.mateTalentCfg[mateid - 1].talents;
        for (let i = 0; i < matecfg.length; i++) {
            let talentdata = new TalentDataItem();
            talentdata.id = matecfg[i].id;
            talentdata.isUnlock = i == 0 && mateid == 1;
            talentdata.lv = 1;
            talentdata.mateId = mateid;
            talentdata.value = matecfg[i].uplevel_effect[0];
            matedata.push(talentdata);
        }
        return matedata;
    }

    MateDataServerInit(data: any) {
        for (let i = 0; i < data.length; i++) {
            this.mateUnlockAry[i] = data[i].isUnlock;
            //this.mateUnlockAry[i] = 1;       //TEST

            let tempMatedata: TalentDataItem[] = [];
            let talents = data[i].talents;
            for (let j = 0; j < talents.length; j++) {
                let talentdata = new TalentDataItem();
                talentdata.id = talents[j].id;
                talentdata.isUnlock = talents[j].isUnlock == 1;
                talentdata.lv = talents[j].lv;
                if (i == 0) {
                    talentdata.mateId = 1;
                } else if (i == 1) {
                    talentdata.mateId = 2;
                } else if (i == 2) {
                    talentdata.mateId = 3;
                } else if (i == 3) {
                    talentdata.mateId = 4;
                } else if (i == 4) {
                    talentdata.mateId = 5;
                }
                talentdata.value = talents[j].value;
                tempMatedata.push(talentdata);
            }

            if (i == 0) {
                this.mate1talentData = tempMatedata;
            } else if (i == 1) {
                this.mate2talentData = tempMatedata;
            } else if (i == 2) {
                this.mate3talentData = tempMatedata;
            } else if (i == 3) {
                this.mate4talentData = tempMatedata;
            } else if (i == 4) {
                this.mate5talentData = tempMatedata;
            }
        }

        // console.log("Mate Server 1:", this.mate1talentData);
        // console.log("Mate Server 2:", this.mate2talentData);
        // console.log("Mate Server 3:", this.mate3talentData);
        // console.log("Mate Server 4:", this.mate4talentData);
        // console.log("Mate Server 5:", this.mate5talentData);
        //this.UpdateTalentLv(false);      //三国战戟
        
        //console.log("Mate1: ",this.mate1talentData);
        //console.log("Mate2: ",this.mate2talentData);
        //console.log("Mate3: ",this.mate3talentData);
        //console.log("Mate4: ",this.mate4talentData);
        //console.log("Mate5: ",this.mate5talentData);
    }

    /**
     * 解锁伙伴
     * @param mateid 伙伴id
    */
    UnlockMate(mateid: number) {
        if (this.mateUnlockAry[mateid - 1] == 0) {
            this.mateUnlockAry[mateid - 1] = 1;


            //if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
            //    (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockMate(mateid);
            //}
            //console.log("--------------Log:", this.GetMateTalent(mateid, 1));
            //this.GetMateTalent(mateid, 1).isUnlock = true;
//
            ////this.UpdateTalentLv();      //三国战戟
            //this.SaveMateTalent(mateid);
            //PlayerPrefs.SetObject("MateUnlockAry", this.mateUnlockAry);
        }
    }

    /**获取已解锁伙伴数*/
    GetUnlcokMateNum() {
        let num = 0;
        for (let i = 0; i < this.mateUnlockAry.length; i++) {
            if (this.mateUnlockAry[i] == 1)
                num++;
        }
        return num;
    }


    /**获取伙伴天赋
     * @param mateid 伙伴id
     * @param talentid 天赋id
    */
    GetMateTalent(mateid: number, talentid: number): TalentDataItem {
        switch (mateid) {
            case 1:
                return this.mate1talentData[talentid - 1];
            case 2:
                return this.mate2talentData[talentid - 1];
            case 3:
                return this.mate3talentData[talentid - 1];
            case 4:
                return this.mate4talentData[talentid - 1];
            case 5:
                return this.mate5talentData[talentid - 1];
        }
        return null;
    }

    /**升级天赋
     * @param mateid 伙伴id
     * @param talentid 天赋id
    */
    LeveUpTalent(mateid: number, talentid: number) {
        switch (mateid) {
            case 1:
                this.mate1talentData[talentid - 1].lv++;
                this.mate1talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate1talentData[talentid - 1].lv - 1];
                break;
            case 2:
                this.mate2talentData[talentid - 1].lv++;
                this.mate2talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate2talentData[talentid - 1].lv - 1];
                break;
            case 3:
                this.mate3talentData[talentid - 1].lv++;
                this.mate3talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate3talentData[talentid - 1].lv - 1];
                break;
            case 4:
                this.mate4talentData[talentid - 1].lv++;
                this.mate4talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate4talentData[talentid - 1].lv - 1];
                break;
            case 5:
                this.mate5talentData[talentid - 1].lv++;
                this.mate5talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate5talentData[talentid - 1].lv - 1];
                break;
        }
    }


    /**
     * 三国战戟 获取天赋值 根据最高武将等级获取
     * @param mateid 伙伴id
     * @param talentid 天赋id
    */
    GetTalent(mateid: number, talentid: number) {
        switch (mateid) {
            case 1:
                this.mate1talentData[talentid - 1].lv++;
                this.mate1talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate1talentData[talentid - 1].lv - 1];
                break;
            case 2:
                this.mate2talentData[talentid - 1].lv++;
                this.mate2talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate2talentData[talentid - 1].lv - 1];
                break;
            case 3:
                this.mate3talentData[talentid - 1].lv++;
                this.mate3talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate3talentData[talentid - 1].lv - 1];
                break;
            case 4:
                this.mate4talentData[talentid - 1].lv++;
                this.mate4talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate4talentData[talentid - 1].lv - 1];
                break;
            case 5:
                this.mate5talentData[talentid - 1].lv++;
                this.mate5talentData[talentid - 1].value
                    = GameM.commonData.mateTalentCfg[mateid - 1]
                        .talents[talentid - 1]
                        .uplevel_effect[this.mate5talentData[talentid - 1].lv - 1];
                break;
        }
    }


    /**
     * 三国战戟 更新天赋等级 弃用
    */
    UpdateTalentLv(isUpdateInfo = true) {
        for (let i = 0; i < this.mate1talentData.length; i++) {
            this.mate1talentData[i].lv = GameM.commonData.mateTalentDataCfg[0].talents[i][GameM.commonData.maxCarLevel - 1];
            this.mate1talentData[i].isUnlock = this.mate1talentData[i].lv > 0;
            if (this.mate1talentData[i].lv > 0)
                this.mateUnlockAry[0] = 1;
            this.mate1talentData[i].value = GameM.commonData.mateTalentCfg[0]
                .talents[i]
                .uplevel_effect[this.mate1talentData[i].lv - 1];
        }

        for (let i = 0; i < this.mate2talentData.length; i++) {
            this.mate2talentData[i].lv = GameM.commonData.mateTalentDataCfg[1].talents[i][GameM.commonData.maxCarLevel - 1];
            this.mate2talentData[i].isUnlock = this.mate2talentData[i].lv > 0;
            if (this.mate2talentData[i].lv > 0)
                this.mateUnlockAry[1] = 1;
            this.mate2talentData[i].value = GameM.commonData.mateTalentCfg[1]
                .talents[i]
                .uplevel_effect[this.mate2talentData[i].lv - 1];
        }

        for (let i = 0; i < this.mate3talentData.length; i++) {
            this.mate3talentData[i].lv = GameM.commonData.mateTalentDataCfg[2].talents[i][GameM.commonData.maxCarLevel - 1];
            this.mate3talentData[i].isUnlock = this.mate3talentData[i].lv > 0;
            if (this.mate3talentData[i].lv > 0)
                this.mateUnlockAry[2] = 1;
            this.mate3talentData[i].value = GameM.commonData.mateTalentCfg[2]
                .talents[i]
                .uplevel_effect[this.mate3talentData[i].lv - 1];
        }

        for (let i = 0; i < this.mate4talentData.length; i++) {
            this.mate4talentData[i].lv = GameM.commonData.mateTalentDataCfg[3].talents[i][GameM.commonData.maxCarLevel - 1];
            this.mate4talentData[i].isUnlock = this.mate4talentData[i].lv > 0;
            if (this.mate4talentData[i].lv > 0)
                this.mateUnlockAry[3] = 1;
            this.mate4talentData[i].value = GameM.commonData.mateTalentCfg[3]
                .talents[i]
                .uplevel_effect[this.mate4talentData[i].lv - 1];
        }

        for (let i = 0; i < this.mate5talentData.length; i++) {
            this.mate5talentData[i].lv = GameM.commonData.mateTalentDataCfg[4].talents[i][GameM.commonData.maxCarLevel - 1];
            this.mate5talentData[i].isUnlock = this.mate5talentData[i].lv > 0;
            if (this.mate5talentData[i].lv > 0)
                this.mateUnlockAry[4] = 1;
            this.mate5talentData[i].value = GameM.commonData.mateTalentCfg[4]
                .talents[i]
                .uplevel_effect[this.mate5talentData[i].lv - 1];
        }

        if (isUpdateInfo) {
            UiM.Instance.hallNode.getComponent(Main).UpdateTalentDetaile();
            console.log("--------UpdateTalentLv");
        }
    }


    /*
    [
        {
            partner_id:1,
            talent_id:1
        },
        {
            partner_id:1,
            talent_id:1
        }
        ...
    ]
    */
    /**
     * 检查解锁天赋 服务端
     * @param data 解锁的伙伴天赋信息
    */
    CheckUnlockTalentServer(data: any[]) {
        for (let i = 0; i < data.length; i++) {
            let mateid = Number(data[i].partner_id);
            let talentid = Number(data[i].talent_id);
            if (mateid == 1) {
                this.mate1talentData[talentid - 1].isUnlock = true;
                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                    (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(mateid, talentid);
                }
            } else if (mateid == 2) {
                this.mate2talentData[talentid - 1].isUnlock = true;
                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                    (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(mateid, talentid);
                }
            } else if (mateid == 3) {
                this.mate3talentData[talentid - 1].isUnlock = true;
                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                    (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(mateid, talentid);
                }
            } else if (mateid == 4) {
                this.mate4talentData[talentid - 1].isUnlock = true;
                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                    (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(mateid, talentid);
                }
            } else if (mateid == 5) {
                this.mate5talentData[talentid - 1].isUnlock = true;
                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                    (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(mateid, talentid);
                }
            }
            console.log("————>解锁天赋：" + talentid + " Mate:" + mateid);
        }
        this.SaveTalentData();

        UiM.Instance.hallNode.getComponent(Main).UpdateTalentDetaile();
    }

    /**
     * 三国战戟 检查解锁天赋 服务端
     * @param data 解锁的伙伴天赋信息
    */
    CheckUnlockTalentServerSanGuo(data: any[]) {
        for (let i = 0; i < data.length; i++) {
            let mateid = Number(data[i].partner_id);
            let talentid = Number(data[i].talent_id);
            let talentlv = Number(data[i].talent_level);
            if (mateid == 1) {
                this.mate1talentData[talentid - 1].lv = talentlv;
                this.mate1talentData[talentid - 1].isUnlock = talentlv > 0;
                if (talentlv > 0)
                    this.mateUnlockAry[0] = 1;
                this.mate1talentData[talentid - 1].value = GameM.commonData.mateTalentCfg[0]
                    .talents[talentid - 1]
                    .uplevel_effect[talentlv - 1];
            } else if (mateid == 2) {
                this.mate2talentData[talentid - 1].lv = talentlv;
                this.mate2talentData[talentid - 1].isUnlock = talentlv > 0;
                if (talentlv > 0)
                    this.mateUnlockAry[1] = 1;
                this.mate2talentData[talentid - 1].value = GameM.commonData.mateTalentCfg[1]
                    .talents[talentid - 1]
                    .uplevel_effect[talentlv - 1];
            } else if (mateid == 3) {
                this.mate3talentData[talentid - 1].lv = talentlv;
                this.mate3talentData[talentid - 1].isUnlock = talentlv > 0;
                if (talentlv > 0)
                    this.mateUnlockAry[2] = 1;
                this.mate3talentData[talentid - 1].value = GameM.commonData.mateTalentCfg[2]
                    .talents[talentid - 1]
                    .uplevel_effect[talentlv - 1];
            } else if (mateid == 4) {
                this.mate4talentData[talentid - 1].lv = talentlv;
                this.mate4talentData[talentid - 1].isUnlock = talentlv > 0;
                if (talentlv > 0)
                    this.mateUnlockAry[3] = 1;
                this.mate4talentData[talentid - 1].value = GameM.commonData.mateTalentCfg[3]
                    .talents[talentid - 1]
                    .uplevel_effect[talentlv - 1];
            } else if (mateid == 5) {
                this.mate5talentData[talentid - 1].lv = talentlv;
                this.mate5talentData[talentid - 1].isUnlock = talentlv > 0;
                if (talentlv > 0)
                    this.mateUnlockAry[4] = 1;
                this.mate5talentData[talentid - 1].value = GameM.commonData.mateTalentCfg[4]
                    .talents[talentid - 1]
                    .uplevel_effect[talentlv - 1];
            }
            console.log("————>解锁天赋：" + talentid + " Mate:" + mateid);
        }
        this.SaveTalentData();

        UiM.Instance.hallNode.getComponent(Main).UpdateTalentDetaile();

        //console.log("Mate1: ",this.mate1talentData);
        //console.log("Mate2: ",this.mate2talentData);
        //console.log("Mate3: ",this.mate3talentData);
        //console.log("Mate4: ",this.mate4talentData);
        //console.log("Mate5: ",this.mate5talentData);
    }

    /**
     * (弃用) 检查是否解锁天赋
     * @param maxlv 当前已解锁得最大等级
    */
    CheckUnlockTalent(maxlv: number) {
        let ischange = false;
        let mateid = 1;
        for (let i = 0; i < this.mateUnlockAry.length; i++) {
            if (i == 0) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate1talentData.length; i++) {
                        if (!this.mate1talentData[i].isUnlock) {

                            if (maxlv >= GameM.commonData.mateTalentCfg[0].talents[i].unlock_lv) {
                                this.mate1talentData[i].isUnlock = true;
                                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                                    ischange = (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(1, i + 1);
                                    mateid = 1;
                                }
                                console.log("MateTalentData:", this.mate1talentData[i]);
                            }
                        }
                    }
                }
            } else if (i == 1) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate2talentData.length; i++) {
                        if (!this.mate2talentData[i].isUnlock) {
                            if (maxlv >= GameM.commonData.mateTalentCfg[1].talents[i].unlock_lv) {
                                this.mate2talentData[i].isUnlock = true;
                                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                                    ischange = (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(2, i + 1);
                                    mateid = 2;
                                }
                            }
                        }
                    }
                }
            } else if (i == 2) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate3talentData.length; i++) {
                        if (!this.mate3talentData[i].isUnlock) {
                            if (maxlv >= GameM.commonData.mateTalentCfg[2].talents[i].unlock_lv) {
                                this.mate3talentData[i].isUnlock = true;
                                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                                    ischange = (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(3, i + 1);
                                    mateid = 3;
                                }
                            }
                        }
                    }
                }
            } else if (i == 3) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate4talentData.length; i++) {
                        if (!this.mate4talentData[i].isUnlock) {
                            if (maxlv >= GameM.commonData.mateTalentCfg[3].talents[i].unlock_lv) {
                                this.mate4talentData[i].isUnlock = true;
                                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                                    ischange = (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(4, i + 1);
                                    mateid = 4;
                                }
                            }
                        }
                    }
                }
            } else if (i == 4) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate5talentData.length; i++) {
                        if (!this.mate5talentData[i].isUnlock) {
                            if (maxlv >= GameM.commonData.mateTalentCfg[4].talents[i].unlock_lv) {
                                this.mate5talentData[i].isUnlock = true;
                                if (UIMng.Ins.IsExistPanel(PanelType.MatePanel)) {
                                    ischange = (UIMng.Ins.GetPanel(PanelType.MatePanel) as MatePanel).UnlockTalent(5, i + 1);
                                    mateid = 5;
                                }
                            }
                        }
                    }
                }
            }
        }
        if (!ischange)
            this.SaveMateTalent(mateid);
    }

    /**保存天赋
     * @param mateid 伙伴id
    */
    SaveMateTalent(mateid: number) {
        switch (mateid) {
            case 1:
                PlayerPrefs.SetObject("MateTalent" + mateid, this.mate1talentData);
                break;
            case 2:
                PlayerPrefs.SetObject("MateTalent" + mateid, this.mate2talentData);
                break;
            case 3:
                PlayerPrefs.SetObject("MateTalent" + mateid, this.mate3talentData);
                break;
            case 4:
                PlayerPrefs.SetObject("MateTalent" + mateid, this.mate4talentData);
                break;
            case 5:
                PlayerPrefs.SetObject("MateTalent" + mateid, this.mate5talentData);
                break;
        }
        PlayerPrefs.SetObject("MateUnlockAry", this.mateUnlockAry);
    }

    SaveTalentData() {
        PlayerPrefs.SetObject("MateTalent1", this.mate1talentData);
        PlayerPrefs.SetObject("MateTalent2", this.mate2talentData);
        PlayerPrefs.SetObject("MateTalent3", this.mate3talentData);
        PlayerPrefs.SetObject("MateTalent4", this.mate4talentData);
        PlayerPrefs.SetObject("MateTalent5", this.mate5talentData);
    }


    /**显示解锁并有效的天赋icon*/
    DisplayTalent(parent: cc.Node, talent_pfb: cc.Prefab) {
        return
        parent.removeAllChildren();

        for (let i = 0; i < this.mateUnlockAry.length; i++) {
            if (i == 0) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate1talentData.length; i++) {
                        if (this.mate1talentData[i].isUnlock) {
                            let temp = cc.instantiate(talent_pfb);
                            temp.getComponent(TalentIconItem).Init(1, i + 1);
                            parent.addChild(temp);
                        }
                    }
                }
            } else if (i == 1) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate2talentData.length; i++) {
                        if (this.mate2talentData[i].isUnlock) {
                            let temp = cc.instantiate(talent_pfb);
                            temp.getComponent(TalentIconItem).Init(2, i + 1);
                            parent.addChild(temp);
                        }
                    }
                }
            } else if (i == 2) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate3talentData.length; i++) {
                        if (this.mate3talentData[i].isUnlock) {
                            let temp = cc.instantiate(talent_pfb);
                            temp.getComponent(TalentIconItem).Init(3, i + 1);
                            parent.addChild(temp);
                        }
                    }
                }
            } else if (i == 3) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate4talentData.length; i++) {
                        if (this.mate4talentData[i].isUnlock) {
                            let temp = cc.instantiate(talent_pfb);
                            temp.getComponent(TalentIconItem).Init(4, i + 1);
                            parent.addChild(temp);
                        }
                    }
                }
            } else if (i == 4) {
                if (this.mateUnlockAry[i] == 1) {
                    for (let i = 0; i < this.mate5talentData.length; i++) {
                        if (this.mate5talentData[i].isUnlock) {
                            let temp = cc.instantiate(talent_pfb);
                            temp.getComponent(TalentIconItem).Init(5, i + 1);
                            parent.addChild(temp);
                        }
                    }
                }
            }
        }
    }

    /**获取伙伴天赋打点信息*/
    GetMateInfo() {
        let info = "";
        info += this.talentCoin + ";";
        for (let i = 0; i < this.mate1talentData.length; i++) {
            info += this.mate1talentData[i].lv + ";";
        }
        for (let i = 0; i < this.mate2talentData.length; i++) {
            info += this.mate2talentData[i].lv + ";";
        }
        for (let i = 0; i < this.mate3talentData.length; i++) {
            info += this.mate3talentData[i].lv + ";";
        }
        for (let i = 0; i < this.mate4talentData.length; i++) {
            info += this.mate4talentData[i].lv + ";";
        }
        for (let i = 0; i < this.mate5talentData.length; i++) {
            info += this.mate5talentData[i].lv + ";";
        }
        return info;
    }



    talentDetaile: cc.Node = null;

    /**
     * 显示天赋详情
     * @param mateid 伙伴id
     * @param talentid 天赋id
    */
    async DisplayTalentDetaile(mateid: number, talentid: number, pos: cc.Vec2) {
        if (this.talentDetaile == null) {
            this.talentDetaile = cc.instantiate(await Utils.loadResPromise("prefabs/TalentDetaile"));
            this.talentDetaile.parent = cc.find("Canvas");
        }

        //this.talentDetaile.getComponent(TalentDetaile).DisplayTalentDetaile(mateid, talentid, pos);
        this.talentDetaile.getComponent(TalentDetaile).DisplayTalentDetaile();
    }

    //是否有可以升级的天赋
    checkMateRedPoint() {
        let hasUpTalent = false
        let resultTangsen = this.checkTalentIconEnouth(this.mate1talentData, 1)
        if (resultTangsen > 0) {
            hasUpTalent = true
        }

        let resultWukong = this.checkTalentIconEnouth(this.mate2talentData, 2)
        if (resultWukong > 0) {
            hasUpTalent = true
        }

        let resultBailong = this.checkTalentIconEnouth(this.mate3talentData, 3)
        if (resultBailong > 0) {
            hasUpTalent = true
        }

        let resultBajie = this.checkTalentIconEnouth(this.mate4talentData, 4)
        if (resultBajie > 0) {
            hasUpTalent = true
        }

        let resultShasen = this.checkTalentIconEnouth(this.mate5talentData, 5)
        if (resultShasen > 0) {
            hasUpTalent = true
        }

        RedPointM.instance.ActiveRedPoint(RedPointType.Mate, hasUpTalent)

    }

    checkTalentIconEnouth(talentDataItem: Array<TalentDataItem>, index: number): number {
        for (let entry of talentDataItem) {
            if (entry.isUnlock) {
                let character = GameM.commonData.mateTalentCfg[index - 1]
                let talent = character.talents //获取对应人物的技能列表
                let info = talent[entry.id - 1]
                if (entry.lv < info.uplevel_coin.length && this.talentCoin >= info.uplevel_coin[entry.lv]) {
                    return 1
                }
            }
        }
        return 0
    }





    /*
    async http_post(url, params) {
        return new Promise((resolve, reject) => {
            var xhr = cc.loader.getXMLHttpRequest();
            var time = false;//是否超时
            var timer = setTimeout(function () {
                time = true;
                xhr.abort();//请求中止
                resolve(‘timeout’);
            }, 5000);
            xhr.onreadystatechange = function () {
                console.log(‘xhr.readyState =’+xhr.readyState +’ xhr.status =’+xhr.status);
                if (xhr.readyState === 4 && (xhr.status >= 200 && xhr.status < 300)) {
                    var respone = xhr.responseText;
                    if (time) return;//请求已经超时，忽略中止请求
                    clearTimeout(timer);//取消等待的超时
                    console.log(“url: ”, url, respone);
                    resolve(respone);
                }
            };
            let url_temp: string;
            if (orc.game_config.DEBUG == true) {
                url_temp = orc.game_config.HTTP_TEST_URL;
            }
            else {
                url_temp = orc.game_config.HTTP_ONLINE_URL;
            }
            url_temp = url_temp + url;
            xhr.open(“POST”, url_temp, true);
            // note: In Internet Explorer, the timeout property may be set only after calling the open()
            // method and before calling the send() method.
            xhr.timeout = 5000;// 5 seconds for timeout
            //xhr.setRequestHeader(“Content-Type”,“application/x-www-form-urlencoded”);
            xhr.send(params);
        })
    }
    */
}


export class TalentDataItem {
    /**伙伴id 1 唐僧 2 悟空 3 白龙马 4 八戒 5 沙僧*/
    mateId: number;
    /**天赋id 1 2 或3 */
    id: number;
    /**是否解锁*/
    isUnlock: boolean;
    /**当前等级 不管是否解锁 默认1级*/
    lv: number;
    /**天赋效果值 1 数值 2 百分比*/
    value: number;
}

/**天赋参数*/
export class TalentItemParam {
    /**伙伴id 1 唐僧 2 悟空 3 白龙马 4 八戒 5 沙僧*/
    mateId: number;
    /**天赋id 1 2 或3 */
    id: number;
    /**是否解锁*/
    isUnlock: boolean;
    /**当前等级 不管是否解锁 默认1级*/
    lv: number;

    /**天赋图*/
    img: cc.SpriteFrame;

    /**天赋名*/
    name: string;
    /**天赋描述 now_value 当前天赋效果值 next_value 下一级天赋效果值*/
    des: string[];
    /**解锁条件 上一个技能达到的等级*/
    unlock_lv: number;
    /**升级所需天赋币*/
    uplevel_coin: number[];
    /**天赋效果类型 1 百分比 2 具体值*/
    effect_type: number;
    /**升级对应的 天赋值*/
    uplevel_effect: number[]
}