using Framework;
using System.Collections.Generic;
using System.Linq;
using cfg.LevelCfg;
using UnityEngine;

namespace Gameplay.Level
{
    /// <summary>
    /// 关卡管理器
    /// </summary>
    public partial class LevelManager
    {
        private const string LAST_FIGHT_LEVEL_PREFIX = "last_fight_level_";

        /// <summary>
        /// 关卡信息字典
        /// </summary>
        private Dictionary<int, LevelInfo> dicLevelInfo = new();
        /// <summary>
        /// 章节信息字典
        /// </summary>
        private Dictionary<int, ChapterInfo> dicChapterInfo = new();
        /// <summary>
        /// 关卡组信息字典,key:关卡组id，value:关卡组信息
        /// </summary>
        private Dictionary<int, LevelGroupInfo> dicLevelGroupInfo = new();
        private readonly int[] _levelGroupTypeRedPointIDArray = new[] { 101, 102, 103 };
        /// <summary>
        /// 章节类型字典
        /// </summary>
        private Dictionary<LevelChapterType, List<ChapterInfo>> dicChapterType = new();

        public List<LevelInfo> ListLevelInfo 
        {
            get { return dicLevelInfo.Values.ToList(); }
        }

        private void InitData()
        {
            RegisterEventData();
        }

        private void ReleaseData()
        {
            UnregisterEventData();
            DisposeRedPointTree();
            dicLevelInfo = null;
            dicChapterInfo = null;
            dicLevelGroupInfo = null;
        }

        private void RegisterEventData()
        {
            EventManager.Instance.Register(EventManager.EventName.AllConfigLoad, OnAllConfigLoad);
            EventManager.Instance.Register<int>(EventManager.EventName.NewLevelServerData, OnNewLevelServerData);
        }

        private void UnregisterEventData()
        {
            EventManager.Instance.Unregister(EventManager.EventName.AllConfigLoad, OnAllConfigLoad);
            EventManager.Instance.Unregister<int>(EventManager.EventName.NewLevelServerData, OnNewLevelServerData);
        }

        /// <summary>
        /// 加载配置
        /// </summary>
        private void OnAllConfigLoad()
        {
            LoadAllLevel();
            LoadAllLevelGroup();
            LoadAllChapter();
            ConstructRedPointTree();
        }

        /// <summary>
        /// 加载所有关卡
        /// </summary>
        private void LoadAllLevel()
        {
            dicLevelInfo.Clear();
            List<DataLevel> listAllLevelConfig = TableManager.Instance.Tables.Level.DataList;

            foreach (DataLevel config in listAllLevelConfig)
            {
                dicLevelInfo.Add(config.Id, new LevelInfo(config));
            }
        }

        /// <summary>
        /// 加载所有章节
        /// </summary>
        private void LoadAllChapter()
        {
            dicChapterInfo.Clear();
            foreach (LevelGroupInfo levelGroupInfo in dicLevelGroupInfo.Values)
            {
                int chapterID = levelGroupInfo.ChapterID;
                if (!dicChapterInfo.TryGetValue(chapterID, out ChapterInfo chapterInfo))
                {
                    DataChapter config = TableManager.Instance.Tables.Chapter.Get(chapterID);
                    if (null != config)
                    {
                        chapterInfo = new ChapterInfo(config);
                        dicChapterInfo.Add(chapterID, chapterInfo);
                    }
                    else
                        DebugUtil.LogError($"找不到章节配置,id：{chapterID}");
                }

                chapterInfo?.AddLevelGroup(levelGroupInfo);
            }

            foreach (ChapterInfo chapterInfo in dicChapterInfo.Values)
            {
                LevelChapterType chapterType = chapterInfo.ChapterType;
                if (!dicChapterType.TryGetValue(chapterType, out List<ChapterInfo> list))
                {
                    list = new();
                    dicChapterType.Add(chapterType, list);
                }

                list.Add(chapterInfo);
            }
        }

        /// <summary>
        /// 加载所有关卡组信息
        /// </summary>
        private void LoadAllLevelGroup()
        {
            dicLevelGroupInfo.Clear();
            foreach (LevelInfo levelInfo in dicLevelInfo.Values)
            {
                int levelGroupID = levelInfo.LevelGroupID;
                if (!dicLevelGroupInfo.TryGetValue(levelGroupID, out LevelGroupInfo levelGroupInfo))
                {
                    DataLevelGroup config = TableManager.Instance.Tables.LevelGroupConfig.Get(levelGroupID);
                    if (null != config)
                    {
                        levelGroupInfo = new LevelGroupInfo(config);
                        dicLevelGroupInfo.Add(levelGroupID, levelGroupInfo);
                    }
                    else
                        DebugUtil.LogError($"找不到关卡组配置, id: {levelGroupID}");
                }

                levelGroupInfo?.AddLevel(levelInfo);
            }
        }

        private void ConstructRedPointTree()
        {
            foreach (ChapterInfo chapterInfo in dicChapterInfo.Values)
            {
                int index = (int)chapterInfo.ChapterType;
                if (index < 0 || index > _levelGroupTypeRedPointIDArray.Length)
                {
                    DebugUtil.LogError($"index is out of range!index:{index}");
                    continue;
                }

                int redPointParentID = _levelGroupTypeRedPointIDArray[index];
                chapterInfo.ConstructRedPointTree(redPointParentID);
            }
        }

        private void DisposeRedPointTree()
        {
            foreach (ChapterInfo chapterInfo in dicChapterInfo.Values)
            {
                if (null != chapterInfo.RedPointNode)
                    RedPointManager.Instance.RemoveDynamicNode(chapterInfo.RedPointNode);
            }
        }

        /// <summary>
        /// 新的关卡服务器数据
        /// </summary>
        /// <param name="levelID"></param>
        private void OnNewLevelServerData(int levelID)
        {
            LevelInfo levelInfo = GetLevelInfoByID(levelID);
            levelInfo?.RefreshServerData(false);
        }

        /// <summary>
        /// 保存战斗关卡
        /// </summary>
        /// <param name="levelInfo"></param>
        private void SaveFightLevel(LevelInfo levelInfo)
        {
            if(null == levelInfo)
                return;

            LevelGroupInfo levelGroupInfo = levelInfo.LevelGroupInfo;
            if(null == levelGroupInfo)
                return;

            ChapterInfo chapterInfo = levelGroupInfo.ChapterInfo;
            if(null == chapterInfo)
                return;

            PlayerPrefs.SetInt(GetChapterTypeSaveKey(chapterInfo.ChapterType), levelInfo.ID);
        }

        private string GetChapterTypeSaveKey(LevelChapterType chapterType) => LAST_FIGHT_LEVEL_PREFIX + chapterType;

        #region API
        public void RefreshAllLevelInfo()
        {
            foreach (LevelInfo levelInfo in dicLevelInfo.Values)
            {
                levelInfo?.RefreshServerData(true);
            }
        }

        public LevelInfo GetLevelInfoByID(int id)
        {
            if (!dicLevelInfo.TryGetValue(id, out var levelInfo))
            {
                DebugUtil.LogError($"找不到levelInfo,id:{id}");
            }

            return levelInfo;
        }

        public LevelGroupInfo GetLevelGroupInfoByID(int id)
        {
            if (!dicLevelGroupInfo.TryGetValue(id, out var chapterInfo))
            {
                DebugUtil.LogError($"找不到chapterInfo,id:{id}");
            }

            return chapterInfo;
        }

        public ChapterInfo GetChapterInfoByID(int id)
        {
            if (!dicChapterInfo.TryGetValue(id, out var levelGroupInfo))
            {
                DebugUtil.LogError($"找不到levelGroupInfo,id:{id}");
            }

            return levelGroupInfo;
        }

        public List<ChapterInfo> GetAllChapterInfo()
        {
            return dicChapterInfo.Values.ToList();
        }

        /// <summary>
        /// 根据章节类型获取章节信息
        /// </summary>
        /// <param name="levelChapterType"></param>
        /// <returns></returns>
        public void GetChapterInfosByType(LevelChapterType type, ref List<ChapterInfo> listChapterInfo)
        {
            listChapterInfo ??= new();

            listChapterInfo.Clear();

            foreach (ChapterInfo chapterInfo in dicChapterInfo.Values)
            {
                if (chapterInfo.ChapterType == type)
                    listChapterInfo.Add(chapterInfo);
            }
        }

        public List<LevelInfo> GetAllLevelInfo()
        {
            return dicLevelInfo.Values.ToList();
        }

        public List<LevelGroupInfo> GetAllLevelGroupInfo()
        {
            return dicLevelGroupInfo.Values.ToList();
        }

        /// <summary>
        /// 获取某种关卡类型的最新进度
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public LevelInfo GetLatestLevelInfo(LevelChapterType type)
        {
            if (dicChapterType.TryGetValue(type, out var list))
            {
                ChapterInfo latestChapterInfo = list.Where(chapterInfo => !chapterInfo.IsLock).ToList()[^1];
                if (null == latestChapterInfo)
                    return null;

                List<LevelInfo> allUnlockLevels = latestChapterInfo.AllLevelInfo.Where(level => !level.IsLock).ToList();
                allUnlockLevels.Sort((a, b) => a.ID.CompareTo(b.ID));

                return allUnlockLevels[^1];
            }

            return null;
        }

        //获取某种关卡类型上一次战斗的关卡
        public LevelInfo GetLastFightLevelInfo(LevelChapterType type)
        {
            var key = GetChapterTypeSaveKey(type);
            if (!PlayerPrefs.HasKey(key))
            {
                return null;
            }

            var levelID = PlayerPrefs.GetInt(key);
            var levelInfo = GetLevelInfoByID(levelID);
            return levelInfo;
        }

        /// <summary>
        /// 根据关卡ID获取关卡所属章节类型
        /// </summary>
        /// <param name="levelID"></param>
        /// <returns></returns>
        public LevelChapterType GetLevelChapterType(int levelID)
        {
            if (!dicLevelInfo.ContainsKey(levelID))
            {
                DebugUtil.LogError("error level ID! ");
                return LevelChapterType.Main;
            }
            var levelInfo = GetLevelInfoByID(levelID);
            int levelGroupID = levelInfo.LevelGroupID;
            DataLevelGroup config = TableManager.Instance.Tables.LevelGroupConfig.Get(levelGroupID);

            DataChapter chapterCfg = TableManager.Instance.Tables.Chapter.Get(config.ChapterID);
            var chapterInfo = new ChapterInfo(chapterCfg);
            return chapterInfo.ChapterType;
        }

        /// <summary>
        /// 判断关卡是否解锁
        /// </summary>
        /// <param name="levelID"></param>
        /// <returns></returns>
        public bool CheckLevelUnlock(int levelID)
        {
            var levelInfo = GetLevelInfoByID(levelID);
            if(levelInfo == null)
            {
                DebugUtil.LogError($"cant find levelInfo,id:{levelID}");
                return false;
            }
            return !levelInfo.IsLock;
        }

        public string LevelIDToNum(int levelID)
        {
            var levelInfo = GetLevelInfoByID(levelID);
            if(levelInfo == null)
            {
                DebugUtil.LogError($"cant find levelInfo,id:{levelID}");
                return string.Empty;
            }
            return levelInfo.ChapterIndex + "-" + levelInfo.LevelIndex;
        }

        public string LevelIDToName(int levelID)
        {
            var levelInfo = GetLevelInfoByID(levelID);
            if (levelInfo == null)
            {
                DebugUtil.LogError($"cant find levelInfo,id:{levelID}");
                return string.Empty;
            }
            return levelInfo.Name;
        }

        public string GetLevelNum(LevelInfo info)
        {
            if (info == null)
            {
                DebugUtil.LogError("info is null");
                return string.Empty;
            }
            return info.ChapterIndex + "-" + info.LevelIndex;
        }

        public string GetLevelName(LevelInfo info)
        {
            if (info == null)
            {
                DebugUtil.LogError("info is null");
                return string.Empty;
            }
            return info.Name;
        }

        #endregion
    }
}