using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;

/// <summary>
/// 英雄Proxy
/// </summary>
class HeroProxy : ProxyBase<HeroProxy>
{
    /// <summary>
    /// init
    /// </summary>
    public HeroProxy() => this.opeCode = OpeCode.ope_hero;


    #region   数值 计算公式 变化 升阶  升级


    /// <summary>
    ///  获得  角色某个等级 等阶 状态下的属性值
    /// </summary>
    /// <param name="atype"></param>
    /// <param name="level">等级</param>
    /// <param name="gradeLevel">品阶(SCBD)</param>
    /// <returns></returns>
    public float getHeroProperty(string modelId, EHeroProperties attType,
        int level, string gradeLevel)
    {
        float result = 0;                              // 结果

        float gradeF = 0;                              // 品阶加成    

        sm_hero heroMo = sm_hero.GetMoByID(modelId);
        if (heroMo == null)                            // 找不到英雄模板数据
        {
            return 0;
        }


        ////========================================  

        #region 属性成长
        //第一步， 根据玩家的等阶，来找出，对应的等阶，的各个属性成长的曲线类型，也就是说0阶的时候， 各个属性的成长系数是SABCD的哪搞一个。
        //然后 根据  SABCD的类型以及 想查找的属性， 找出对应的 这个属性的成长系数
        var gradeLevelMo = sm_heroextra_level.GetMoById(heroMo.heroId, gradeLevel);
        if (gradeLevelMo != null)
        {
            switch (attType)
            {
                case EHeroProperties.HP:
                    gradeF = gradeLevelMo.hp;
                    break;
                case EHeroProperties.MOFAKANGXING:
                    gradeF = gradeLevelMo.mofakangxing;
                    break;
                case EHeroProperties.FASHUQIANGDU:
                    gradeF = gradeLevelMo.fashuqiangdu;
                    break;
                case EHeroProperties.WULIGONGJI:
                    gradeF = gradeLevelMo.wuligongji;
                    break;
                case EHeroProperties.FANGYUHUJIA:
                    gradeF = gradeLevelMo.fangyuhujia;
                    break;
                case EHeroProperties.NENGLIANGZHI:
                    gradeF = gradeLevelMo.nengliangzhi;
                    break;
                case EHeroProperties.GONGJISUDU:
                    gradeF = gradeLevelMo.gongjisudu;
                    break;
                case EHeroProperties.CRICITAL:
                    gradeF = gradeLevelMo.baoji;
                    break;
                case EHeroProperties.KANGBAOJI:
                    gradeF = gradeLevelMo.kangbaoji;
                    break;
                case EHeroProperties.YANLI:
                    gradeF = gradeLevelMo.yanli;
                    break;
            }
        }
        else
        {
            gradeF = 0;
        }
        #endregion

        /* 角色成长公式					
生命=初始生命+生命成长*（角色等级-1））+武器加成+言灵加成					
言能=初始言能+言能成长*（角色等级-1））					
物攻=初始物攻+物攻成长*（角色等级-1））+武器加成+言灵加成					
护甲=初始护甲+护甲成长*（角色等级-1））+武器加成+言灵加成					
言攻=初始言攻+言攻成长*（角色等级-1））+武器加成+言灵加成					
言抗=初始言抗+言抗成长*（角色等级-1））+武器加成+言灵加成					
暴击=初始暴击+暴击成长*（角色等级-1））+武器加成+言灵加成					
暴击率=暴击/(75+角色等级*5)	
         */
        // 武器成长 和 言灵成长都是直接数值, 所以放到外面再做加法也可以.

        ////========================================
        if (heroMo != null)
        {
            switch (attType)
            {
                case EHeroProperties.HP:
                    result += heroMo.hp + gradeF * (level - 1);
                    break;
                case EHeroProperties.NENGLIANGZHI:
                    result += heroMo.nengliangzhi + gradeF * (level - 1);
                    break;
                case EHeroProperties.WULIGONGJI:
                    result += heroMo.wuligongji + gradeF * (level - 1);
                    break;
                case EHeroProperties.FANGYUHUJIA:
                    result += heroMo.fangyuhujia + gradeF * (level - 1);
                    break;
                case EHeroProperties.FASHUQIANGDU:
                    result += heroMo.fashuqiangdu + gradeF * (level - 1);
                    break;
                case EHeroProperties.MOFAKANGXING:
                    result += heroMo.mofakangxing + gradeF * (level - 1);
                    break;
                case EHeroProperties.GONGJISUDU:
                    result += heroMo.gongjisudu + gradeF * (level - 1);
                    break;
                case EHeroProperties.CRICITAL:
                    //result += heroMo.baoji / (75 + level * 5);            // 2020.6.3 修正暴击算法, 暴击率是暴击值/(75+level*5) 而此处只计算暴击值,战斗中根据这个公式计算暴击率
                    result += heroMo.baoji + gradeF * (level - 1);
                    break;
                case EHeroProperties.KANGBAOJI:
                    //result += heroMo.baoji / (75 + level * 5);            // 2020.6.3 修正暴击算法, 暴击率是暴击值/(75+level*5) 而此处只计算暴击值,战斗中根据这个公式计算暴击率
                    result += heroMo.kangbaoji + gradeF * (level - 1);
                    break;
                case EHeroProperties.YANLI:
                    //result += heroMo.baoji / (75 + level * 5);            // 2020.6.3 修正暴击算法, 暴击率是暴击值/(75+level*5) 而此处只计算暴击值,战斗中根据这个公式计算暴击率
                    result += heroMo.yanli + gradeF * (level - 1);
                    break;
            }
        }

        return result;
    }


    #endregion

    #region '    API    '

    #region 注释掉内容
    /////// <summary>
    /////// [6301] 升级英雄   消耗其他英雄卡牌来升级【功能一模式】
    /////// </summary>
    /////// <param name="uid">玩家ID</param>
    /////// <param name="zoneid">分区ID</param>
    /////// <param name="heroId">英雄ID</param>
    /////// <param name="costHeroListStr">消耗的英雄UID字符组</param>
    /////// <param name="costGold">消耗金币</param>
    /////// <param name="callback">成功回调(无返回参数)</param>
    ////public void HeroLevelUpgrade(string uid, int zoneid, string heroId, string costHeroListStr, int costGold, Action<JObject> callback)
    ////{
    ////    Post(CmdCode.hero_levelup, uid, zoneid, new object[] { heroId, costHeroListStr, costGold },
    ////        resp =>
    ////        {
    ////            if (callback != null)
    ////            {
    ////                callback.Invoke(resp.result);
    ////            }
    ////        });
    ////}

    ///// <summary>
    /////   [6301] 升级英雄 消耗经验卡 碎片等来升级 【功能二模式】
    ///// </summary>
    ///// <param name="uid"></param>
    ///// <param name="zoneid"></param>
    ///// <param name="heroId"></param>
    ///// <param name="costHeroListStr"></param>
    ///// <param name="costGold"></param>
    ///// <param name="callback"></param>
    //public void HeroLevelUpgradeCostItem(string uid, int zoneid, string heroId, string costItemListStr, int costGold, Action<JObject> callback)
    //{
    //    Post(CmdCode.hero_levelup, uid, zoneid, new object[] { heroId, costItemListStr, costGold },
    //        resp =>
    //        {
    //            if (callback != null)
    //            {
    //                callback.Invoke(resp.result);
    //            }
    //        });
    //}
    #endregion

    /// <summary>
    /// [6304] 英雄升阶 (消耗碎片 
    /// version:  2020.1.15  调试对接
    ///           2019.12.10 代码整理按照策划要求修改第一版.
    /// </summary> 
    /// <param name="heroUid"></param>
    /// <param name="costItemId">消耗道具(经验丹)Id</param>
    /// <param name="costNum">消耗数量</param>
    /// <param name="callback"></param>
    public void HeroUpgrade(string heroUid, string nextGrade, Action<GameHeroVo> callback)
    {
        Post(CmdCode.hero_stageup, new object[] { heroUid, nextGrade },
            resp =>
            {
                if (callback != null)
                {
                    //undone: 扣减碎片数量 -wg 2019年12月10日
                    var hero = UserProxy.Instance.player.collectHero.UpdateHero(resp.result);
                    var mo = sm_heroextra_level.GetMoById(int.Parse(hero.typeId), nextGrade);
                    UserProxy.Instance.player.collectItem.ConsumePacketItem(mo.segID.ToString(), mo.segNum);
                    callback.Invoke(hero);
                }
            });
    }
    /// <summary>
    /// [6301] 升级英雄 消耗经验丹 等来提升经验升级 
    /// version:  2020.1.15   调试对接
    ///           2019.12.10  代码整理按照策划要求修改第一版
    /// </summary> 
    /// <param name="heroUid"></param>
    /// <param name="costItemId">消耗道具(经验丹)Id</param>
    /// <param name="costNum">消耗数量</param>
    /// <param name="callback"></param>
    public void HeroLevelUpCostItem(string heroUid, int costItemId, int costNum, Action<GameHeroVo> callback)
    {
        Post(CmdCode.hero_levelup, new object[] { heroUid, costItemId, costNum },
            resp =>
            {
                // undone: 扣减相应的 经验丹数量 -王刚 2019年12月10日09:24:21
                //UserProxy.Instance.player.collectItem.ConsumePacketItem(costItemId.ToString(), costNum);
                //UserProxy.Instance.player.InitFromStore(JObject.FromObject(resp.result["store"]));
                UserProxy.Instance.player.baseInfo.gold = int.Parse(resp.result["gold"].ToString());

                var hero = UserProxy.Instance.player.collectHero.UpdateHero(JObject.FromObject( resp.result["hero"]));
                callback?.Invoke(hero);
            });
    }



    #region 已注释掉内容
    /////// <summary>
    ///////  [6306] 更改英雄的锁定状态
    /////// </summary>
    /////// <param name="uid">玩家UID</param>
    /////// <param name="zoneid">玩家分区ID</param>
    /////// <param name="heroUID">英雄唯一ID</param>
    /////// <param name="isLock">是否锁定</param>
    /////// <param name="callback">成功回调处理</param>
    ////public void ChangeHeroLockState(string uid, int zoneid, string heroUID, bool isLock, Action callback)
    ////{
    ////    Post(CmdCode.hero_changelockstate, uid, zoneid, new object[] { heroUID, isLock },
    ////          resp =>
    ////          {
    ////              if (callback != null)
    ////              {
    ////                  callback.Invoke();
    ////              }
    ////          });
    ////}

    ///////// <summary>
    /////////  获得一个英雄
    ///////// </summary>
    ///////// <param name="uid">玩家UID</param>
    ///////// <param name="zoneid">玩家分区ID</param>
    ///////// <param name="heroid">模板ID</param>
    ///////// <param name="callback">成功回调处理</param>
    //////public void GetHero(string uid, int zoneid, string heroid, Action<JObject> callback)
    //////{
    //////    Post(CmdCode.cmd_hero_gethero, uid, zoneid, new object[] { heroid },
    //////          resp =>
    //////          {
    //////              if (callback != null)
    //////              {
    //////                  callback.Invoke(resp.result);
    //////              }
    //////          });
    //////}

    #endregion

    /// <summary>
    /// 6321 花费钻石或者金币或者 人民币购买一个 英雄
    /// </summary> 
    /// <param name="heroid"></param>
    /// <param name="callback"></param>
    public void BuyHero(string heroid, string type, int price, int piecesId, int piecesNum, Action<JObject> callback)
    {
        Post(CmdCode.cmd_hero_buyHero, new object[] { heroid, type, price, piecesId, piecesNum }, resp => callback?.Invoke(resp.result));
    }


    #region  已注释内容

    /////// <summary>
    /////// [6309]对英雄进行强化升阶
    /////// </summary>
    /////// <param name="uid">玩家UID</param>
    /////// <param name="zoneid">玩家分区ID</param>
    /////// <param name="herouid">突破的英雄UID</param>
    /////// <param name="costHeros">消耗的英雄UID字符组</param>
    /////// <param name="costGold">消耗金币</param>
    /////// <param name="callback">成功回调处理</param>
    ////public void HeroStrength(string uid, int zoneid, string herouid, string costHeros, int costGold, Action<JObject> callback)
    ////{
    ////    Post(CmdCode.cmd_hero_strength, uid, zoneid, new object[] { herouid, costHeros, costGold },
    ////          resp =>
    ////          {
    ////              if (callback != null)
    ////              {
    ////                  callback.Invoke(resp.result);
    ////              }
    ////          });
    ////}

    /////// <summary>
    /////// [6305 ]对英雄进行升星
    /////// </summary>
    /////// <param name="uid">玩家UID</param>
    /////// <param name="zoneid">玩家分区ID</param>
    /////// <param name="herouid">操作的英雄UID</param>
    /////// <param name="costHeros">消耗的英雄UID字符组合</param>
    /////// <param name="costGold">消耗金币</param>
    /////// <param name="callback">成功回调处理</param>
    ////public void HeroUpStar(string uid, int zoneid, string herouid, string costHeros, int costGold, Action<JObject> callback)
    ////{
    ////    Post(CmdCode.hero_upstar, uid, zoneid, new object[] { herouid, costHeros, costGold },
    ////          resp =>
    ////          {
    ////              if (callback != null)
    ////              {
    ////                  callback.Invoke(resp.result);
    ////              }
    ////          });
    ////}
    /////// <summary>
    /////// [6305 ]对英雄进行升星
    /////// </summary>
    ////public void HeroUpStar(string uid, int zoneid, string herouid, string costpieces, int piecesNum, string costIitems, int itemNum, string moneyType, int num, Action<JObject> callback)
    ////{
    ////    Post(CmdCode.hero_upstar, uid, zoneid, new object[] { herouid, costpieces, piecesNum, costIitems, itemNum, moneyType, num },
    ////         resp =>
    ////         {
    ////             if (callback != null)
    ////             {
    ////                 callback.Invoke(resp.result);
    ////             }
    ////         });
    ////}
    #endregion

    /// <summary>
    ///   6322 英雄神血升级
    /// </summary> 
    /// <param name="herouid"></param>
    /// <param name="costpieces"></param>
    /// <param name="piecesNum"></param>
    /// <param name="moneyType"></param>
    /// <param name="num"></param>
    /// <param name="callback"></param>
    [Obsolete("升级神血", true)]
    public void HeroUpGodBlood(string herouid, string costpieces, int piecesNum, string moneyType, int num, Action<JObject> callback)
    {
        Post(CmdCode.cmd_hero_upGodBlood, new object[] { herouid, costpieces, piecesNum, moneyType, num }, resp => callback?.Invoke(resp.result));
    }


    #region 已注释内容
    /////// <summary>
    /////// [6310 ]对英雄进行结算好感度
    /////// </summary>
    /////// <param name="uid">玩家UID</param>
    /////// <param name="zoneid">玩家分区ID</param>
    /////// <param name="herouid">操作的英雄UID</param>
    /////// <param name="favorId">解锁的好感度</param>
    /////// <param name="callback">成功回调处理</param>
    ////public void HeroOpenFavor(string uid, int zoneid, string herouid, int favorId, Action<JObject> callback)
    ////{
    ////    Post(CmdCode.cmd_hero_openFavor, uid, zoneid, new object[] { herouid, favorId },
    ////          resp =>
    ////          {
    ////              if (callback != null)
    ////              {
    ////                  callback.Invoke(resp.result);
    ////              }
    ////          });
    ////}

    /////// <summary>
    /////// [6311 ]对英雄分解.进而获得晶石
    /////// </summary>
    /////// <param name="uid">玩家UID</param>
    /////// <param name="zoneid">玩家分区ID</param>   
    /////// <param name="costHeros">分解消耗的英雄id列表</param>
    /////// <param name="callback">成功回调处理</param>
    ////public void HeroSeparate(string uid, int zoneid, string costHeros, Action<JObject> callback)
    ////{
    ////    Post(CmdCode.cmd_hero_separate, uid, zoneid, new object[] { costHeros },
    ////          resp =>
    ////          {
    ////              if (callback != null)
    ////              {
    ////                  callback.Invoke(resp.result);
    ////              }
    ////          });
    ////}

    ///////// <summary>
    ///////// 6312　购买玩家可以收集的英雄的数量上限
    ///////// </summary>
    ///////// <param name="uid">玩家UID</param>
    ///////// <param name="zoneid">玩家分区ID</param>
    ///////// <param name="buyNum">购买数量</param>
    ///////// <param name="costCash">消耗钻石</param>
    ///////// <param name="callback">成功回调处理</param>
    //////public void BuyHeroMaxCountLimt(string uid, int zoneid, int buyNum, int costCash, Action<JObject> callback)
    //////{
    //////    Post(CmdCode.cmd_hero_buyCollectHeroLimtCount, uid, zoneid, new object[] { buyNum, costCash },
    //////            resp =>
    //////            {
    //////                if (callback != null)
    //////                {
    //////                    callback.Invoke(resp.result);
    //////                }
    //////            });
    //////}

    ///////// <summary>
    ///////// 6313    更改好友支援的英雄ID
    ///////// </summary>
    ///////// <param name="uid">玩家UID</param>
    ///////// <param name="zoneid">玩家分区ID</param>
    ///////// <param name="heroUId">操作的英雄UID</param>
    ///////// <param name="callback">成功回调处理</param>
    //////public void ChangeFriendSupport(string uid, int zoneid, string heroUId, Action<JObject> callback)
    //////{
    //////    Post(CmdCode.cmd_hero_changefriendsupport, uid, zoneid, new object[] { heroUId },
    //////            resp =>
    //////            {
    //////                if (callback != null)
    //////                {
    //////                    callback.Invoke(resp.result);
    //////                }
    //////            });
    //////}
    #endregion

    /// <summary>
    /// 6314  对英雄的技能进行升级
    /// </summary> 
    /// <param name="heroUId">操作的英雄UID</param>
    /// <param name="mainSkillId">升级的技能ID</param>
    /// <param name="subskillID">升级的技能类型</param>
    /// <param name="callback">成功回调处理</param> 
    public void HeroUpgradeSkillLevel(int heroUId, int mainSkillId, int subskillID, Action<GameHeroVo> callback)
    {
        Post(CmdCode.cmd_hero_upgradeSkillLevel, new object[] { heroUId, mainSkillId, subskillID }, resp =>
        {
            var sm = sm_subSkill.GetMoById(sm_subSkill.GetMoById(subskillID).nextLevel_Id);       // 扣除金币
            UserProxy.Instance.player.ChangeUserAccount(AccountType.gold, -int.Parse(sm.upgradeCost));
            var hero = UserProxy.Instance.player.collectHero.UpdateHero(resp.result);           // 更新英雄  
            callback?.Invoke(hero);
        });
    }
    /// <summary>
    /// 6325 英雄 - 一键升级某个子技能
    /// </summary>
    /// <param name="heroUID">英雄实例ID</param>
    /// <param name="mainSkillId">主技能id</param>
    /// <param name="subSkillId">子技能ID</param>
    /// <param name="targetSubSkillID">将要升级到的子技能ID</param>
    /// <param name="costGold">花费金币</param>
    /// <param name="callback"></param>
    public void HeroOnekeyUpgradeSkillLevel(int heroUID, int mainSkillId, int subSkillId, int targetSubSkillID, int costGold, Action<GameHeroVo> callback)
    {
        Post(CmdCode.cmd_hero_onekeyUpgradeSkill, new object[] { heroUID, mainSkillId, subSkillId, targetSubSkillID, costGold }, resp =>
        {
            UserProxy.Instance.player.ChangeUserAccount(AccountType.gold, -costGold);            // 扣除金币 
            var hero = UserProxy.Instance.player.collectHero.UpdateHero(resp.result);           // 更新英雄
            callback?.Invoke(hero);
        });
    }
    /// <summary>
    /// 6324 英雄 - 解锁某个子技能
    /// </summary>
    /// <param name="heroUID">英雄实例ID</param>
    /// <param name="mainSkillId">主机能ID</param>
    /// <param name="subSkillId">子技能ID</param>
    /// <param name="callback"></param>
    public void HeroUnlockSkill(int heroUID, int mainSkillId, int subSkillId, Action<GameHeroVo> callback)
    {
        Post(CmdCode.cmd_hero_unlockSkill, new object[] { heroUID, mainSkillId, subSkillId }, resp =>
        {

            var sm = sm_subSkill.GetMoById(subSkillId);                                       // 扣除金币
            UserProxy.Instance.player.ChangeUserAccount(AccountType.gold, -int.Parse(sm.unlockCost));
            var hero = UserProxy.Instance.player.collectHero.UpdateHero(resp.result);           // 更新英雄
            callback?.Invoke(hero);
        });
    }

    /// <summary>
    /// 6315 对英雄的战队配置存储文件
    /// </summary> 
    /// <param name="teamconfig">队伍配置的字符串文件</param> 
    /// <param name="callback">成功回调处理</param>
    public void SaveHeroTeamConfig(string teamconfig, Action<JObject> callback)
    {
        Post(CmdCode.cmd_hero_saveHeroTeamConfig, new object[] { teamconfig }, resp => callback?.Invoke(resp.result));
    }

    /// <summary>
    /// 6327 言灵升级
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="wuqiList"></param>
    /// <param name="items"></param>
    /// <param name="callback"></param>
    public void YanLingUpgrade(int uid, List<ItemVo> itemList, Action<UserYanlingVo> callback)
    {
        List<string> yanlingList = new List<string>();
        Dictionary<string, int> items = new Dictionary<string, int>();
        foreach (ItemVo vo in itemList)
        {
            if (vo.nMo.subType == (int)EItemSubType.YanLing)
            {
                yanlingList.Add(vo.uid);
            }
            else
            {
                items[vo.typeId] = vo.count;
            }
        }

        Post(CmdCode.cmd_hero_YanlinUpLevel, new object[] { uid, yanlingList, items }, resp =>
        {
            var p = UserProxy.Instance.player;
            p.InitFromStore((JObject)resp.result["store"]);
            UserProxy.Instance.player.baseInfo.gold = int.Parse(resp.result["gold"].ToString());

            
            callback?.Invoke(p.collectYanling.items[uid]);
        });
    }

    /// <summary>
    /// 言灵突破
    /// </summary>
    /// <param name="yanlingUID"></param>
    /// <param name="callback"></param>
    public void YanLingTupo(int uid, Action callback)
    {
        Post(CmdCode.cmd_hero_StrengthenStar, new object[] { uid }, resp =>
        {
            //var p = UserProxy.Instance.player;
            //p.InitFromStore((JObject)resp.result["store"]);
            UserProxy.Instance.player.baseInfo.gold = int.Parse(resp.result["gold"].ToString());
            callback?.Invoke();
        });
    }

    /// <summary>
    /// 6326 言灵强化升星---废弃
    /// </summary>
    /// <param name="callback"></param>
    /// <param name="faild"></param>
    [Obsolete("请清理调用此方法的旧模块,有问题找-gwang", true)]
    public void StrengthenStar(int yanlingUid,List<int> uidList,Action<UserYanlingVo> callback, Action faild = null)
    {
        Post(CmdCode.cmd_hero_StrengthenStar, new object[] { yanlingUid, uidList},
         resp =>
         {
             //var p = UserProxy.Instance.player;            
             //p.InitFromStore((JObject)resp.result["store"]);
           
             UserYanlingVo vo = UserProxy.Instance.player.collectYanling.items[yanlingUid];
             if (callback != null)
             {
                 callback.Invoke(vo);
             }
         });
    }
    /// <summary>
    /// 6327 言灵等级升级---废弃
    /// </summary>
    /// <param name="yanlingUid"></param>
    /// <param name="type"></param>
    /// <param name="callback"></param>
    /// <param name="faild"></param>
     [Obsolete("请清理调用此方法的旧模块,有问题找-gwang",true)]
    public void YanlinUpLevel(int yanlingUid,int type, Action<UserYanlingVo> callback, Action faild = null)
    {
        Post(CmdCode.cmd_hero_YanlinUpLevel, new object[] { yanlingUid, type },
         resp =>
         {
             var p = UserProxy.Instance.player;
             //p.InitFromStore((JObject)resp.result["store"]);
             p.baseInfo.gold = int.Parse(resp.result["gold"].ToString());
             p.baseInfo.resPoint = int.Parse(resp.result["resPoint"].ToString());

             UserYanlingVo vo = UserProxy.Instance.player.collectYanling.items[yanlingUid];
             if (callback != null)
             {
                 callback.Invoke(vo);
             }
         });
    }
    /// <summary>
    /// 突破
    /// </summary>
    /// <param name="id"></param>
    /// <param name="callback"></param>
    public void HuanlingshiTuPo(int id,Action<GameHeroVo> callback)
    {
        Post(CmdCode.cmd_hero_tupo, new object[] { id },
         resp =>
         {
             var p = UserProxy.Instance.player;
             //p.InitFromStore((JObject)resp.result["store"]);
             p.baseInfo.gold = int.Parse(resp.result["gold"].ToString());
             var vo = UserProxy.Instance.player.collectHero.UpdateHero(JObject.FromObject(resp.result["hero"]));
             
             if (callback != null)
             {
                 callback.Invoke(vo);
             }
         });
    }

    /// <summary>
    /// 选择一件添加后的加成的星级经验
    /// </summary>
    /// <param name="uidList"></param>
    /// <returns></returns>
    public int GetAddStarExp(List<int> uidList)
    {
        Dictionary<int, UserYanlingVo> items = UserProxy.Instance.player.collectYanling.items;
        int addExp = 0;
        foreach (int uid in uidList)
        {
            if (items.ContainsKey(uid))
            {
                sm_item_yanling mo = sm_item_yanling.GetMoById(int.Parse(items[uid].typeId));
                addExp +=  mo.addStarExp;
            }
        }

        return addExp;
    }

    /// <summary>
    /// 言灵替换
    /// </summary>
    /// <param name="yanlingUid"></param>
    /// <param name="yanlingReplaceUid"></param>
    /// <param name="callback"></param>
    /// <param name="faild"></param>
    public void YanlinReplace(int heroId, int yanlingRank, int heroReplaceId, int yanlingReplaceRank, Action<GameHeroVo> callback)
    {
        Post(CmdCode.cmd_hero_YanLingReplace, new object[] { heroId, yanlingRank, heroReplaceId, yanlingReplaceRank },
         resp =>
         {
              var p = UserProxy.Instance.player;
              p.InitFromStore((JObject)resp.result["store"]);
              JObject jhero = JObject.Parse(resp.result["hero"].ToString());
              foreach (KeyValuePair<string, JToken> kv in jhero)
              {
                   var heroVo = UserProxy.Instance.player.collectHero.UpdateHero(JObject.FromObject(kv.Value));
                
              }

              var vo = UserProxy.Instance.player.collectHero.UpdateHero(JObject.FromObject(resp.result["selfhero"]));
             callback?.Invoke(vo);
         });
    }

    /// <summary>
    /// 6330 召唤言灵
    /// </summary>
    /// <param name="heroId"></param>
    /// <param name="callback"></param>
    public void zhaohuanYanLing(int cardId, Action<ItemVo> callback)
    {
        Post(CmdCode.cmd_hero_zhaohuanYanLing, new object[] { cardId },
         resp =>
         {
             var p = UserProxy.Instance.player;
             p.InitFromStore((JObject)resp.result["store"]);
             p.baseInfo.gold = int.Parse(resp.result["gold"].ToString());
             string yanlingId = resp.result["yanlingId"].ToString();

             ItemVo vo = new ItemVo();
             vo.typeId = yanlingId;
             vo.count = 1;

             callback?.Invoke(vo);
         });
    }

    #region '    英雄评价相关    '



    /// <summary>
    /// 6316 拉取指定英雄的评论信息
    /// </summary> 
    /// <param name="heroModelId">英雄ID</param> 
    /// <param name="callback">成功回调处理,参数:{"ret" => [], 'score' => int}</param>
    public void GetDiscuss(string heroModelId, int index, Action<GetDiscussRetVo> callback)
    {
        Post(CmdCode.cmd_hero_GetDiscuss, new object[] { heroModelId, index }, resp => callback.Invoke(resp.result.ToObject<GetDiscussRetVo>()));
    }

    /// <summary>
    /// 6317 评论指定英雄
    /// </summary> 
    /// <param name="heroId">英雄ID</param> 
    /// <param name="content">评价内容</param>
    /// <param name="callback">成功回调处理,参数:{"ret" => { 'uid' => $uid,'name' => $req->userInfo->game->name,'msg' => $content,'ts' => now(),'praise' => 0 }}</param>
    public void PosttDiscuss(string heroId, string content, Action<PostDiscussRetVo> callback)
    {
        Post(CmdCode.cmd_hero_PostDiscuss, new object[] { heroId, content },
            resp => callback?.Invoke(resp.result.ToObject<PostDiscussRetVo>()));
    }


    /// <summary>
    /// 6319 删除对某个英雄的评价
    /// </summary>
    /// <param name="heroId">英雄ID</param> 
    /// <param name="callback">成功回调处理,参数:{"ret" => { 'uid' => $uid,'name' => $req->userInfo->game->name,'msg' => $content,'ts' => now(),'praise' => 0 }}</param>
    public void DeleteDiscuss(string heroId, Action<DeleteDiscussRetVo> callback)
    {
        Post(CmdCode.cmd_hero_DeleteDiscuss, new object[] { heroId }, resp => callback?.Invoke(resp.result.ToObject<DeleteDiscussRetVo>()));
    }
    /// <summary>
    /// 6318 给指定评价点赞
    /// </summary> 
    /// <param name="heroId">英雄ID</param> 
    /// <param name="discuss_uid">评价以评论者的uid作为索引</param>
    /// <param name="callback">成功回调处理,参数:{"ret" => { 'uid' => $uid,'name' => $req->userInfo->game->name,'msg' => $content,'ts' => now(),'praise' => 0 }}</param>
    public void PraiseDiscuss(string heroId, string discuss_uid, Action<PriaseDiscussRetVo> callback)
    {
        Post(CmdCode.cmd_hero_PraiseDiscuss, new object[] { heroId, discuss_uid }, resp => callback?.Invoke(resp.result.ToObject<PriaseDiscussRetVo>()));
    }

    /// <summary>
    /// 6320 给某个英雄打分
    /// </summary> 
    /// <param name="heroId">英雄ID</param> 
    /// <param name="score">评分(0~5)</param>
    /// <param name="callback">成功回调处理,参数:{"ret" => { 'uid' => $uid,'name' => $req->userInfo->game->name,'msg' => $content,'ts' => now(),'praise' => 0 }}</param>
    public void ScoreIt(string heroId, int score, Action<ScoreItRetVo> callback)
    {
        Post(CmdCode.cmd_hero_scoreit, new object[] { heroId, score }, resp => callback?.Invoke(resp.result.ToObject<ScoreItRetVo>()));
    }

    #endregion

    ///////// <summary>
    /////////  通过消耗英雄碎片 解锁英雄
    ///////// </summary>
    ///////// <param name="uid"></param>
    ///////// <param name="zoneid"></param>
    ///////// <param name="heroModelId"></param>
    ///////// <param name="score"></param>
    ///////// <param name="callback"></param>
    //////public void UnLockHeroByPieces(string uid, int zoneid, string heroModelId, int piecesId, int piecesNum, Action<JObject> callback)
    //////{
    //////    Post(CmdCode.cmd_hero_unlockByPieces, uid, zoneid, new object[] { heroModelId, piecesId, piecesNum },
    //////          resp =>
    //////          {
    //////              if (callback != null)
    //////              {
    //////                  callback.Invoke(resp.result);
    //////              }
    //////          });
    //////}
    ///
    #endregion
}