using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using UnityEngine;
public class MapProxy : ProxyBase<MapProxy>
{
    #region `     constructor  `

    public MapProxy() => this.opeCode = OpeCode.map;

    #endregion

    /// <summary>
    /// 7504 解锁据点
    /// </summary>
    /// <param name="mapId">据点的mapid</param>
    /// <param name="callback">回掉</param>
    public void UnlockMap(int mapId, Action callback)
    {
        Post<Info_NewMap>(CmdCode.map_UnlockMap, new object[] { mapId }, ret =>
         {
             UserProxy.Instance.player.newMap = ret;    // 更新下地图数据
             callback?.Invoke();
         });
    }
    /// <summary>
    /// 7501 进入据点
    /// </summary>
    /// <param name="mapId">据点id</param>
    /// <param name="callback">回调</param>
    public void EntryMap(int mapId, Action callback)
    {
        Post<Ret_EntryMap>(CmdCode.map_EnterFootHold, new object[] { mapId }, ret =>
        {
            var p = UserProxy.Instance.player;
            p.newMap = ret.newMap; 
            p.baseInfo.tili = ret.tili; 
            p.PrivateState.TiliTime = ret.time; 
            p.newMap.curMapId = mapId;
            callback?.Invoke();
        });
    }
    /// <summary>
    /// 7502 开启传送阵
    /// </summary>
    public void FixUpTransmision()
    {
        // todo: 待完善
    }
    /// <summary>
    /// 7503 更新探索度
    /// </summary>
    public void UpdateExplorationProgress()
    {
        // todo: 待完善
    }

    /// <summary>
    /// 【7505】 保存mapid下已经解锁的区域、npc等等
    /// </summary>
    /// <param name="unlockStr"></param>
    /// <param name="callback"></param>
    public void UnlockInfoSva(string unlockStr, Action<int> callback)
    {
        Post<Ret_unlockSav>(CmdCode.map_unlockInfoSva, new object[] { unlockStr }, ret =>
        {
            var p = UserProxy.Instance.player;        // 更新下地图数据;
            p.newMap = ret.newMap;
            p.baseInfo.xp = ret.exp;
            p.baseInfo.level = ret.level;
            callback?.Invoke(ret.num);
        });
    }

    /// <summary>
    ///  获取mapid下已经解锁的列表
    /// </summary>
    /// <param name="mapid"></param>
    /// <returns></returns>
    public List<string> getMapUnlockInfoList(int mapid)
    {
        List<string> list = new List<string>();
        Dictionary<int, List<string>> typeList = UserProxy.Instance.player.newMap.unlockMapTypeList;
        if (typeList.ContainsKey(mapid))
        {
            return typeList[mapid];
        }

        return list;
    }

    /// <summary>
    /// 【7506】领取探索奖励
    /// </summary>
    /// <param name="mapid"></param>
    /// <param name="callback"></param>
    public void reviceExplorerReward(int mapid, Action callback)
    {
        Post<Ret_ExploreRwd>(CmdCode.map_reviceExplorerReward, new object[] { mapid }, ret =>
        {
            var p = UserProxy.Instance.player;              // 更新下地图数据;
            p.newMap = ret.newMap;
            string[] list = ret.cost.Split(',');

            if (int.Parse(list[0]) == (int)EItemSubType.Gold)
            {
                p.baseInfo.gold += int.Parse(list[1]);
            }
            else if (int.Parse(list[0]) == (int)EItemSubType.Gem)
            {
                p.baseInfo.cash += int.Parse(list[1]);
            }

            callback?.Invoke();
        });
    }

    /// <summary>
    /// 7507 回城券使用 
    /// </summary>
    /// <param name="itemId"></param>
    /// <param name="callback"></param>
    public void huichengQuanUse(int mapId, float x, float y, float z, Action callback)
    {
        Post<Ret_NewMap>(CmdCode.map_huichengQuanUse, new object[] { mapId, x, y, z }, ret =>
        {
            UserProxy.Instance.player.newMap = ret.newMap;      // 更新下地图数据;
            callback?.Invoke();
        });
    }

    /// <summary>
    /// 7508
    /// </summary>
    /// <param name="unlockStr"></param>
    /// <param name="callback"></param>
    public void huichengQuanEnd(Action callback)
    {
        Post<Ret_NewMap>(CmdCode.map_huichengQuanEnd, new object[] { }, ret =>
        {
            UserProxy.Instance.player.newMap = ret.newMap;    // 更新下地图数据;
            callback?.Invoke();
        });
    }

    #region ret vo

    class Ret_NewMap
    {
        public Info_NewMap newMap;
    }
    class Ret_ExploreRwd : Ret_NewMap
    {
        public string cost;
    }
    class Ret_EntryMap : Ret_NewMap {
        public int tili;
        public long time;
    }
    class Ret_unlockSav : Ret_NewMap
    {
        public int num;
        public int exp;
        public int level;
    }
    #endregion

    #region UI VO

    /// <summary>
    /// 大地图UI所需数据接口
    /// </summary>
    public class UI_BigMap
    {

        /// <summary>
        /// 快速访问 玩家数据 
        /// </summary>
        private Player player;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="user">需要传入玩家数据</param>
        public UI_BigMap(Player user) => this.player = user;


        /// <summary>
        /// 当前所在据点mapId
        /// </summary>
        int CurMapId => player.newMap.curMapId;

        /// <summary>
        /// 当前所在据点数据
        /// </summary>
        public Ins_FootHold CurMap => player.newMap.unlockedFootholds[CurMapId];

        /// <summary>
        /// 当前据点所属的区域数据(区域相关内容待细化)
        /// </summary>
        public int ZoneId
        {
            get
            {
                int zoneid = 501007;
                Dictionary<int, sm_gate_zone> gate_zone = GameConfigData.Ins.gate_zone;
                foreach (KeyValuePair<int, sm_gate_zone> kv in gate_zone)
                {
                    string[] slist = kv.Value.contains.Split(',');
                    if (slist.Contains(this.CurMapId.ToString()))
                    {
                        zoneid = this.CurMapId;
                        break;
                    }
                }

                return zoneid;
            }
        }
        /// <summary>
        /// 当前大地图所有据点数据信息(含有常量数据和实例数据)
        /// </summary>
        //public Dictionary<int, UIVO_FootHoldInfo> FootHoldList => GameConfigData.Ins.map_scene.Where(kv => kv.Value.zoneId == ZoneId)
        //    .ToList().ConvertAll(kv => new KeyValuePair<int, UIVO_FootHoldInfo>(kv.Key, new UIVO_FootHoldInfo(player, kv.Value))).ToDictionary(kv => kv.Key, kv => kv.Value);

        public Dictionary<int, UIVO_FootHoldInfo> FootHoldList
        {
            get
            {
                Dictionary<int, UIVO_FootHoldInfo> FootHoldList = new Dictionary<int, UIVO_FootHoldInfo>();
                int zoneid = 501007;
                Dictionary<int, sm_gate_zone> gate_zone = GameConfigData.Ins.gate_zone;
                foreach (KeyValuePair<int, sm_gate_zone> kv in gate_zone)
                {
                    string[] slist = kv.Value.contains.Split(',');
                    if (slist.Contains(this.CurMapId.ToString()))
                    {
                        zoneid = kv.Key;
                        break;
                    }
                }

                string[] list = GameConfigData.Ins.Getgate_zoneMo(zoneid).contains.Split(',');
                foreach (string id in list)
                {
                    sm_gate mo = sm_gate.GetMoById(int.Parse(id));
                    UIVO_FootHoldInfo vo = new UIVO_FootHoldInfo(this.player, mo);
                    FootHoldList[int.Parse(id)] = vo;
                }


                return FootHoldList;
            }
        }

        /// <summary>
        /// map所有的区id集合
        /// </summary>
        public List<int> mapZoneList
        {
            get
            {
                List<int> mapZoneList = new List<int>();
                mapZoneList.Add(501007);
                mapZoneList.Add(501008);

                return mapZoneList;
            }
        }

        /// <summary>
        /// 新手村和言灵学院的所有小地图信息
        /// </summary>
        public Dictionary<int,Dictionary<int,UIVO_FootHoldInfo>> AllFootHoldList
        {
            get
            {
                Dictionary<int, Dictionary<int, UIVO_FootHoldInfo>> allFootHoldList = new Dictionary<int, Dictionary<int, UIVO_FootHoldInfo>>();
                List<int> mapZoneList = this.mapZoneList;
                foreach (int zid in mapZoneList)
                {
                    sm_gate_zone zoneMo = sm_gate_zone.GetMoById(zid);
                    string[] sList = zoneMo.contains.Split(',');
                    Dictionary<int, UIVO_FootHoldInfo> dic = new Dictionary<int, UIVO_FootHoldInfo>();
                    foreach (string mapid in sList)
                    {
                        sm_gate mo = sm_gate.GetMoById(int.Parse(mapid));
                        UIVO_FootHoldInfo vo = new UIVO_FootHoldInfo(this.player, mo);
                        dic[int.Parse(mapid)] = vo;
                    }

                    allFootHoldList.Add(zid,dic);
                }


                return allFootHoldList;
            }
        }


        /// <summary>
        /// 据点信息
        /// </summary>
        public class UIVO_FootHoldInfo
        {
            private Player player { get; }
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="user">玩家信息</param>
            /// <param name="mo">常量</param>
            public UIVO_FootHoldInfo(Player user, sm_gate mo)
            {
                player = user;
                Mo = mo;
            }

            /// <summary>
            /// 配置数据
            /// </summary>
            public sm_gate Mo { get; }

            /// <summary>
            /// 此据点是否已经解锁
            /// </summary>
            public bool IsUnLocked => player.newMap.unlockedFootholds.ContainsKey(Mo.gateId);

            /// <summary>
            /// 显示有主线任务图标
            /// </summary>
            public bool HasMainTaskIcon
            {
                get
                {
                    var flag = false;
                    player.collectTaskCard.GetActivingCards().ForEach(tk =>
                    {
                        if ((int)Enum_TaskCardType.Main == tk.mo.type              // 是主线任务
                        && Enum_TaskCardStateType.finish == tk.state               // 且, 可领奖
                        && tk.FinialSteps().Exists(stp => stp.IsInMap(Mo.gateId))   // 且, 最终步骤处于当前地图
                        )
                        {
                            flag = true;
                        }
                    });
                    return flag;
                }
            }
            /// <summary>
            /// 显示可能接取到主线任务图标
            /// </summary>
            public bool MayGetMainTask
            {
                get
                {
                    var flag = false;
                    player.collectTaskCard.GetAllCards().ForEach(tk =>     // 遍历背包看有没有能开展的任务卡
                    {
                        if ((int)Enum_TaskCardType.Main == tk.mo.type                // 是主线任务
                        && tk.mo.tasksteps.Split(',').ToList().ConvertAll(s => sm_task_step.GetMoByID(int.Parse(s))).Exists(mo => mo.IsInMap(Mo.gateId)))       // 且, 初始步骤处于当前据点
                        {
                            flag = true;
                        }
                    });
                    return flag;
                }
            }
            /// <summary>
            /// 显示支线任务图标
            /// </summary>
            public bool HasBranchTaskIcon
            {
                get
                {
#warning 支线任务类型还未细化细节(以前的分类有主线、日常、学院、悬赏). 2022.3.15
                    return false;
                }
            }
            /// <summary>
            /// 显示可能接取到支线任务图标
            /// </summary>
            public bool MayGetBranchTaskIcon
            {
                get
                {
#warning 支线任务类型还未细化细节(以前的分类有主线、日常、学院、悬赏). 2022.3.15
                    return false;
                }
            }
            /// <summary>
            /// 显示我的位置指示图标
            /// </summary>
            public bool HasMyLocationIcon => player.newMap.curMapId == Mo.gateId;
            /// <summary>
            /// 显示其他队员位置指示图标
            /// </summary>
            public bool HasOthersLocationIcon
            {
                get
                {
#warning 这里其他队员位置设定尚未细化,2022.3.15 
                    return false;
                }
            }


            /// <summary>
            /// 运行时实例数据, 任何编码均需注意防范 null 值, 可在逻辑前先判断IsUnlocked值
            /// </summary>
            public Ins_FootHold Ins => IsUnLocked ? player.newMap.unlockedFootholds[Mo.gateId] : null;

        }
    }

    #endregion
}