using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using UnityEditor;
/// <summary>
/// 任务模块
/// </summary>
public class TaskProxy : ProxyBase<TaskProxy>
{
    public TaskProxy() => this.opeCode = OpeCode.ope_task;

    #region '   过时方法   '

    /// <summary>
    /// 更新任务数据
    /// </summary>
    /// <param name="callback"></param>
    public void GetTaskInfo(Action callback)
    {
        Post(CmdCode.cmd_Task_getTaskInfo, new object[] { }, resp =>
        {
            var p = UserProxy.Instance.player;
            p.task = resp.result["task"].ToObject<Info_UserTask>();
            callback?.Invoke();
        });
    }
    /// <summary>
    /// 领取任务奖励
    /// </summary>
    /// <param name="taskId"></param>
    /// <param name="callback"></param>
    public void GetTaskReward(int taskId, Action callback)
    {
        Post(CmdCode.cmd_Task_getReward, new object[] { taskId }, resp =>
         {
             var p = UserProxy.Instance.player;
             p.baseInfo.gold = Convert.ToInt32(resp.result["gold"].ToString());
             p.baseInfo.cash = Convert.ToInt32(resp.result["cash"].ToString());
             p.baseInfo.tili = Convert.ToInt32(resp.result["tili"].ToString());
             //p.InitFromStore((JObject)resp.result["store"]);
             p.task = resp.result["task"].ToObject<Info_UserTask>();
             callback?.Invoke();
         });

    }
    /// <summary>
    /// 设置关注任务
    /// </summary>
    /// <param name="taskId"></param>
    /// <param name="callback"></param>
    public void SetAttentionTask(int taskId, Action callback)
    {
        Post(CmdCode.cmd_Task_setAttentionTask, new object[] { taskId }, resp =>
         {
             var p = UserProxy.Instance.player;
             p.task.curTaskId = taskId;
             callback?.Invoke();
         });
    }

    /// <summary>
    /// 领取每日任务活跃点数奖励
    /// </summary>
    /// <param name="activeNum"></param>
    /// <param name="callback"></param>
    public void GetActiveReward(int activeNum, Action callback)
    {
        Post(CmdCode.cmd_Task_getActiveReward, new object[] { activeNum }, resp =>
        {
            var p = UserProxy.Instance.player;
            p.baseInfo.gold = Convert.ToInt32(resp.result["gold"].ToString());
            p.baseInfo.cash = Convert.ToInt32(resp.result["cash"].ToString());
            p.baseInfo.tili = Convert.ToInt32(resp.result["tili"].ToString());
            //p.InitFromStore((JObject)resp.result["store"]);
            p.task = resp.result["task"].ToObject<Info_UserTask>();
            callback?.Invoke();
        });
    }

    #endregion

    /// <summary>
    /// [6210] 剧情对话,更新任务步骤的进度
    /// </summary>
    /// <param name="gate_or_npc_id"></param>
    /// <param name="stage"></param>
    /// <param name="order"></param>
    /// <param name="callback">是否有任务卡状态更新</param>
    public void PlotFinish(int gate_or_npc_id, int stage, Action<bool, TaskCardVo> callback)
    {
        Post(CmdCode.cmd_taskCard_PlotFinish, new object[] { gate_or_npc_id, stage }, resp =>
          {
              //var p = UserProxy.Instance.player;
              var bUpdate = true;  // resp.result["taskCardUpdate"].ToObject<bool>();
              if (bUpdate)
              {
                  // 更新任务卡
                  callback?.Invoke(bUpdate, null);
              }
              else
              {
                  callback?.Invoke(bUpdate, null);
              }
          });
    }
    #region '  已废弃方法 2020年12月14日14:33:43'
    /// <summary>
    /// [6211]
    /// </summary> 
    [Obsolete("暂未完成-2020年11月18日16:26:33")]
    public void PlotExchangeTaskCard(Action callback)
    {
        Post(CmdCode.cmd_taskCard_PlotExchangeTaskCard, new object[] { }, resp =>
        {
            callback?.Invoke();
        });
    }
    /// <summary>
    /// [6212]剧情对话奖励任务卡(新手引导完成获得第一个卡)
    /// </summary>
    /// <param name="rwdStr"></param>
    /// <param name="callback"></param>
    [Obsolete("2020.12.12")]
    public void PlotPresentTaskCard(string rwdStr, Action callback)
    {
        Post(CmdCode.cmd_taskCard_PlotPresentTaskCard, new object[] { rwdStr }, resp =>
        {
            //var p = UserProxy.Instance.player;
            //p.InitFromStore((JObject)resp.result["store"]);
            callback?.Invoke();
        });
    }
    /// <summary>
    /// [6213]即时奖励型任务卡-结算(当剧情最后一句播完后,且是最后一个step, 直接调用这个)
    /// </summary>
    /// <param name="taskCardUID"></param>
    /// <param name="callback"></param>
    [Obsolete("2020.12.12")]
    public void ImmetRewardTaskCard(int taskCardUID, Action callback)
    {
        Post(CmdCode.cmd_taskCard_FinishAndReward, new object[] { taskCardUID }, resp =>
        {
            //var p = UserProxy.Instance.player;
            //p.InitFromStore((JObject)resp.result["store"]);
            callback?.Invoke();
        });
    }
    #endregion
    /// <summary>
    /// 6214 上报杀死怪物事件
    /// </summary>
    /// <param name="monsterId"></param>
    /// <param name="num"></param>
    /// <param name="order"></param>
    /// <param name="callback">是否有任务卡状态更新</param>
    public void ReportKillMonsterEvent(int monsterId, int num, Action<bool, TaskCardVo, TaskCardVo> callback)
    {
        Post(CmdCode.cmd_taskCard_killMonsterEvent, new object[] { monsterId, num }, resp =>
        {
            var bUpdate = resp.result["taskCardUpdate"].ToObject<bool>();
            if (bUpdate)
            {
                LogHelper.Log(resp.result);                // 更新任务卡
                callback?.Invoke(bUpdate, null, null);
            }
            else
            {
                callback?.Invoke(false, null, null);
            }

        });
    }

    /// <summary>
    ///  [6215] 任务卡 - 激活任务卡
    /// </summary>
    /// <param name="taskCardUID"></param>
    /// <param name="callback"></param>
    public void ActiveTaskCard(int taskCardUID, Action<TaskCardVo> callback)
    {
        Post(CmdCode.cmd_taskCard_active, new object[] { taskCardUID }, resp =>
        {
            var p = UserProxy.Instance.player;                     // 更新任务卡
            p.PrivateState = ((JObject)resp.result["priv"]).ToObject<Info_PrivateState>();
            callback?.Invoke(p.collectTaskCard.collectTaskCardDic[taskCardUID.ToString()]);
        });
    }
    /// <summary>
    ///  [6216] 任务卡 - 领取奖励
    /// </summary>
    /// <param name="taskCardUID"></param>
    /// <param name="callback"></param>
    public void TaskCard_getReward(int taskCardUID, Action callback)
    {
        Post(CmdCode.cmd_taskCard_reward, new object[] { taskCardUID }, resp =>
        {
            var p = UserProxy.Instance.player;
            if (p.collectTaskCard.collectTaskCardDic.ContainsKey(taskCardUID.ToString()))
            {
                var cardMo = p.collectTaskCard.collectTaskCardDic[taskCardUID.ToString()].mo;
                p.baseInfo.getNewXp(cardMo.exp);
            }
            p.baseInfo.gold = Convert.ToInt32(resp.result["gold"].ToString());
            p.baseInfo.cash = Convert.ToInt32(resp.result["cash"].ToString());
            p.baseInfo.level = Convert.ToInt32(resp.result["lvl"].ToString());
            p.PrivateState = ((JObject)resp.result["priv"]).ToObject<Info_PrivateState>();
            p.collegeInfo.Initlize(resp.result["college"]);
            callback?.Invoke();
        });
    }

    /// <summary>
    /// [6217] 更新任务数据
    /// </summary>
    /// <param name="callback"></param>
    public void GetTaskCardInfo(Action callback)
    {
        Post(CmdCode.cmd_taskCard_info, new object[] { }, resp => callback?.Invoke());
    }

    /// <summary>
    /// [6218] 任务卡 - 步骤事件 完成
    /// </summary>
    /// <param name="taskCardUID"></param>
    /// <param name="stepTypeId"></param>
    /// <param name="starOrFinish">1 startAction, 2 finishAction</param>
    /// <param name="callback"></param>
    public void TaskCardStepActionDone(int taskCardUID, int stepTypeId, int starOrFinish, Action callback)
    {
        Post(CmdCode.cmd_taskCard_stepActionDone, new object[] { taskCardUID, stepTypeId, starOrFinish }, resp => callback?.Invoke());
    }


    /// <summary>
    /// [6219] 任务卡 - 设定追踪的任务卡
    /// </summary>
    /// <param name="cardType"></param>
    /// <param name="taskCardUID"></param>
    /// <param name="callback"></param>
    public void TaskCardSetTracingCard(int cardType, int taskCardUID, Action callback)
    {
        Post(CmdCode.cmd_taskCard_SetTracingCard, new object[] { cardType, taskCardUID }, resp =>
        {
            var p = UserProxy.Instance.player;
            p.PrivateState.taskCardTracing = resp.result.ToObject<Dictionary<int, int>>();
            callback?.Invoke();
        });
    }
    /// <summary>
    /// [6220] 任务卡 - 检查是否有任务步骤需要回撤(重新登录/唤灵师死亡/切换场景)
    /// </summary>
    /// <param name="callback"></param>
    public void TaskCardCheckStepFallback(Action callback) => Post(CmdCode.cmd_task_stepFallBack, new object[] { }, resp => callback?.Invoke());


    /// <summary>
    ///  [6231] 任务卡商店 - 开启
    /// </summary>
    /// <param name="callback"></param>
    public void TaskCardShop_open(Action<List<TaskCardShopVo>> callback)
    {
        Post<Ret_OpenTaskShop>(CmdCode.cmd_taskcard_shop_open, new object[] { }, ret =>
        {
            if (null !=ret)
            {
                UserProxy.Instance.player.taskCardShop = ret.taskCardShop;
                callback?.Invoke(ret.taskCardShop.CurCardVos);
            }
        });
    }

    /// <summary>
    ///  [6231] 任务卡商店 - 购买
    /// </summary>
    /// <param name="callback"></param>
    public void TaskCardShop_Buy(int cardTypeId, Action callback)
    {        
        Post<Ret_TaskCardBuy>(CmdCode.cmd_taskcard_shop_buy, new object[] { cardTypeId, 1 }, ret =>
         {
             var p = UserProxy.Instance.player;
             p.baseInfo.gold = ret.gold;              // 同步下花费
             p.baseInfo.cash = ret.cash; 

             callback?.Invoke();
         });
    }

    /// <summary>
    ///  [6231] 任务卡商店 - 刷新
    /// </summary>
    /// <param name="callback"></param>
    public void TaskCardShop_Refresh(Action<List<TaskCardShopVo>> callback)
    {
        Post<Ret_TaskCardShopRefresh>(CmdCode.cmd_taskcard_shop_refresh, new object[] { }, ret =>
        {
            var p = UserProxy.Instance.player;
            p.baseInfo.gold = ret.gold; 
            p.baseInfo.cash = ret.cash; 
            p.taskCardShop = ret.taskCardShop;
            
            callback?.Invoke(p.taskCardShop.CurCardVos);
        });
    }

    public int DailyTaskProgress()
    {
        int index = 0;
        List<TaskCardVo> taskList = UserProxy.Instance.player.collectTaskCard.GetAllCards().GetSubTypes(2);
        string[] sList = GameConfigData.Ins.globalsettings.dailyTask_Common.ToString().Split(',');
        foreach (TaskCardVo vo in taskList)
        {
            if (sList.Contains(vo.typeId) && vo.state == Enum_TaskCardStateType.drawed)
            {
                index += 1;
            }
        }

        return index;
    }

    public List<ItemVo> GetDailyTaskExtraPrize()
    {
        string taskId = GameConfigData.Ins.globalsettings.dailyTask_Common.ToString();
        if (!UserProxy.Instance.player.collectTaskCard.collectTaskCardDic.ContainsKey(taskId))
        {
            return new List<ItemVo>();
        }

        return sm_item_taskcard.GetMoById(int.Parse(taskId)).RealRewards();       
    }
    /// <summary>
    /// 当前追踪的所有任务
    /// </summary>
    /// <returns></returns>
    public List<TaskCardVo> GetTaskTrackInfo()
    {
        List<TaskCardVo> list = new List<TaskCardVo>();
        Dictionary<string, TaskCardVo> collectTaskCardDic = UserProxy.Instance.player.collectTaskCard.collectTaskCardDic;
        Dictionary<int, int> taskCardTracing = UserProxy.Instance.player.PrivateState.taskCardTracing;
        foreach (KeyValuePair<int,int>kv in taskCardTracing)
        {
            if (collectTaskCardDic.ContainsKey(kv.Value.ToString()))
            {
                list.Add(collectTaskCardDic[kv.Value.ToString()]);
            }
        }

        return list;
    }


    #region 内部类
    class Ret_OpenTaskShop {
        public Info_TaskCard_Shop taskCardShop;
    }
    class Ret_TaskCardBuy {
        public int gold;
        public int cash;
    }
    class Ret_TaskCardShopRefresh {
        public int gold;
        public int cash;
        public Info_TaskCard_Shop taskCardShop;
    }
    /// <summary>
    /// 任务主界面
    /// </summary>
    public class UITaskMainVo : Singleton<UITaskMainVo>
    {

        /// <summary>
        /// 剧情任务列表
        /// </summary>
        /// <returns></returns>
        public List<TaskNodeInfo> AllNodeList() =>
            GameConfigData.Ins.task_node.Values.ToList().ConvertAll<TaskNodeInfo>(sm => new TaskNodeInfo() { nodeId = sm.typeId });

        private Player p = UserProxy.Instance.player;

        /// <summary>
        /// 每日任务列表
        /// </summary>
        public List<TaskInfo> dailyTasks => p.task.taskListDaily.Values.ToList();

        /// <summary>
        /// 活跃度奖励列表
        /// </summary>
        public List<TaskActiveRewardInfo> activeRewardInfos => GameConfigData.Ins.task_active_reward.Values
            .Select(mo => new TaskActiveRewardInfo() { num = int.Parse(mo.num) })
            .OrderBy(t => t.num).ToList();
        /// <summary>
        /// 当前活跃点数
        /// </summary>
        public int CurActivePoint => p.task.dailyActivePoint;
        /// <summary>
        /// 最大一档奖励要求的活跃点数
        /// </summary>
        public int MaxActivePoint => activeRewardInfos.Max(ti => ti.num);
    }

    #endregion
}