using LitJson;
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace vnxbqy.UI
{
    public enum PhantasmPavilionTab
    {
        Avatar,                 // 0 - Í·Ïñ
        AvatarFrame,            // 1 - Í·Ïñ¿ò
        ChatExpression,         // 2 - ÁÄÌì±íÇé
        ChatBubble              // 3 - ÁÄÌìÆøÅÝ
    }

    public class PhantasmPavilionModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        public readonly int MaxItemRowCount = 2;    // Ò»ÐÐչʾx¸öÎïÆ·
        public readonly int MaxEmojiCount = 10;
        public readonly int FuncId = 236;
        private PhantasmPavilionTab m_SelectTab;
        //µ±Ç°Ñ¡ÖеıêÇ©Ò³
        public PhantasmPavilionTab selectTab
        {
            get { return m_SelectTab; }
            set
            {
                m_SelectTab = value;
                TabChangeEvent?.Invoke();
            }
        }

        private int m_selectItemId;
        public int selectItemId
        {
            get { return m_selectItemId; }
            set
            {
                m_selectItemId = value;
                ItemIdChangeEvent?.Invoke();
            }
        }

        //µ±Ç°Ñ¡ÖеıíÇé°ü×é

        private int m_SelectEmojiPackID;
        public int selectEmojiPackID
        {
            get { return m_SelectEmojiPackID; }
            set
            {
                m_SelectEmojiPackID = value;
                EmojiPackIDChangeEvent?.Invoke();
            }
        }

        private Dictionary<PhantasmPavilionTab, IPhantasmPavilionTabHandler> handlers = new Dictionary<PhantasmPavilionTab, IPhantasmPavilionTabHandler>();
        public Dictionary<PhantasmPavilionTab, Dictionary<int, PhantasmPavilionInfo>> infoDict = new Dictionary<PhantasmPavilionTab, Dictionary<int, PhantasmPavilionInfo>>();
        public Dictionary<PhantasmPavilionTab, Dictionary<int, int>> defaultIDDict = new Dictionary<PhantasmPavilionTab, Dictionary<int, int>>();
        public Dictionary<PhantasmPavilionTab, int> nowIDDict = new Dictionary<PhantasmPavilionTab, int>();

        // »Ã¾³¸óÈë¿Úºìµã 459
        Redpoint mainRedPoint = new Redpoint(10101, MainRedDot.PhantasmPavilionRepoint);

        //±êÇ©Ò³ºìµã 4591 - 4594
        public Dictionary<PhantasmPavilionTab, Redpoint> tabRedPointDict = new Dictionary<PhantasmPavilionTab, Redpoint>();

        public Dictionary<PhantasmPavilionTab, Dictionary<int, Redpoint>> itemRedPointDict = new Dictionary<PhantasmPavilionTab, Dictionary<int, Redpoint>>();

        public event Action TabChangeEvent;         //Çл»±êÇ©Ò³
        public event Action ItemIdChangeEvent;      //Çл»Ñ¡ÖÐÏî
        public event Action EmojiPackIDChangeEvent;      //Çл»Ñ¡ÖÐÏî
        public event Action UpdateFaceInfoEvent;
        public event Action UpdateFacePicInfoEvent;
        public event Action UpdateEmojiPackInfoEvent;
        public event Action UpdateChatBubbleBoxInfoEvent;
        public Action<string> SendChatAction;

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        public override void Init()
        {
            PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataRefreshEvent;
            packModel.refreshItemCountEvent += OnRefreshItemCountEvent;
            InitHandler();
            InitTable();
            InitRedPoint();
        }

        public override void UnInit()
        {
            PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataRefreshEvent;
            packModel.refreshItemCountEvent -= OnRefreshItemCountEvent;
        }

        private void OnRefreshItemCountEvent(PackType type, int arg2, int arg3)
        {
            UpdateRedPoint();
        }

        public void OnBeforePlayerDataInitialize()
        {
            infoDict.Clear();
        }

        public void OnPlayerLoginOk()
        {
            selectTab = PhantasmPavilionTab.Avatar;
            var list = ShowItemList(selectTab, out int fristIndex);
            if (!list.IsNullOrEmpty())
                selectItemId = fristIndex;

            nowIDDict[PhantasmPavilionTab.Avatar] = PlayerDatas.Instance.baseData.face;
            nowIDDict[PhantasmPavilionTab.AvatarFrame] = PlayerDatas.Instance.baseData.facePic;
            nowIDDict[PhantasmPavilionTab.ChatBubble] = (int)PlayerDatas.Instance.baseData.bubbleId;
        }

        private void OnPlayerDataRefreshEvent(PlayerDataType type)
        {
            if (type == PlayerDataType.Face)
            {
                nowIDDict[PhantasmPavilionTab.Avatar] = (int)PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.Face);
            }
            else if (type == PlayerDataType.HairColor)
            {
                nowIDDict[PhantasmPavilionTab.AvatarFrame] = (int)PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.HairColor);
            }
            else if (type == PlayerDataType.ExAttr10)
            {
                nowIDDict[PhantasmPavilionTab.ChatBubble] = (int)PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.ExAttr10);
            }
        }

        private void InitHandler()
        {
            handlers = new Dictionary<PhantasmPavilionTab, IPhantasmPavilionTabHandler>();
            handlers[PhantasmPavilionTab.Avatar] = new PhantasmPavilionAvatarHandler();
            handlers[PhantasmPavilionTab.AvatarFrame] = new PhantasmPavilionAvatarFrameHandler();
            handlers[PhantasmPavilionTab.ChatExpression] = new PhantasmPavilionChatExpressionHandler();
            handlers[PhantasmPavilionTab.ChatBubble] = new PhantasmPavilionChatBubbleHandler();
        }

        private void InitTable()
        {
            InitDefault();
        }

        private void InitRedPoint()
        {
            InitTabRedPoint();
            InitItemRedPoint(PhantasmPavilionTab.Avatar, PlayerFaceConfig.GetKeys());
            InitItemRedPoint(PhantasmPavilionTab.AvatarFrame, PlayerFacePicConfig.GetKeys());
            InitItemRedPoint(PhantasmPavilionTab.ChatExpression, EmojiPackConfig.GetKeys());
            InitItemRedPoint(PhantasmPavilionTab.ChatBubble, ChatBubbleBoxConfig.GetKeys());
        }

        private void InitDefault()
        {
            var tabValues = Enum.GetValues(typeof(PhantasmPavilionTab));
            for (int i = 0; i < tabValues.Length; i++)
            {
                PhantasmPavilionTab tab = (PhantasmPavilionTab)tabValues.GetValue(i);
                if (!defaultIDDict.ContainsKey(tab))
                {
                    defaultIDDict[tab] = new Dictionary<int, int>();
                }
            }

            var config = FuncConfigConfig.Get("PhantasmPavilion");
            var jsonData = JsonMapper.ToObject(config.Numerical1);
            List<string> keyList = jsonData.Keys.ToList();
            for (int i = 0; i < keyList.Count; i++)
            {
                int key = int.Parse(keyList[i]);
                int value = int.Parse(jsonData[keyList[i]].ToString());
                defaultIDDict[PhantasmPavilionTab.Avatar][key] = value;
            }

            jsonData = JsonMapper.ToObject(config.Numerical2);
            keyList = jsonData.Keys.ToList();
            for (int i = 0; i < keyList.Count; i++)
            {
                int key = int.Parse(keyList[i]);
                int value = int.Parse(jsonData[keyList[i]].ToString());
                defaultIDDict[PhantasmPavilionTab.AvatarFrame][key] = value;
            }
            //defaultIDDict[PhantasmPavilionTab.ChatExpression][0] = int.Parse(config.Numerical3);
            defaultIDDict[PhantasmPavilionTab.ChatBubble][0] = int.Parse(config.Numerical3);
        }

        private void InitTabRedPoint()
        {
            var values = Enum.GetValues(typeof(PhantasmPavilionTab));
            for (int i = 0; i < values.Length; i++)
            {
                PhantasmPavilionTab tab = (PhantasmPavilionTab)values.GetValue(i);
                int id = MainRedDot.PhantasmPavilionRepoint * 10 + (int)tab + 1;
                tabRedPointDict[tab] = new Redpoint(MainRedDot.PhantasmPavilionRepoint, id);
            }
        }

        private void InitItemRedPoint(PhantasmPavilionTab tab, List<string> keys)
        {
            if (!infoDict.ContainsKey(tab))
                itemRedPointDict[tab] = new Dictionary<int, Redpoint>();

            List<int> idList = StringListToIntList(keys);
            for (int i = 0; i < idList.Count; i++)
            {
                int id = idList[i];
                int baseValue = MainRedDot.PhantasmPavilionRepoint * 10 + (int)tab + 1;
                itemRedPointDict[tab][id] = new Redpoint(baseValue, baseValue * 1000 + id);
            }
        }

        public void UpdateRedPoint()
        {
            var values = Enum.GetValues(typeof(PhantasmPavilionTab));
            for (int i = 0; i < values.Length; i++)
            {
                PhantasmPavilionTab key = (PhantasmPavilionTab)values.GetValue(i);
                tabRedPointDict[key].state = RedPointState.None;
                var keyList = itemRedPointDict[key].Keys.ToList();
                for (int j = 0; j < keyList.Count; j++)
                {
                    int id = keyList[j];
                    itemRedPointDict[key][id].state = RedPointState.None;
                    //¿É¼¤»î
                    if (GetUnLockState(key, id) == 1)
                    {
                        itemRedPointDict[key][id].state = RedPointState.Simple;

                        if (selectTab != key)
                        {
                            tabRedPointDict[key].state = RedPointState.Simple;
                        }
                    }
                    //¿ÉÉýÐÇ

                    if (IsUpStar(key, id))
                    {
                        itemRedPointDict[key][id].state = RedPointState.Simple;
                        if (selectTab != key)
                        {
                            tabRedPointDict[key].state = RedPointState.Simple;
                        }
                    }
                }
            }
        }


        public bool IsCustom(int faceID,out int customPlayerID)
        {
            customPlayerID = 0;
            if (!PlayerFaceConfig.Has(faceID))
                return false;
            customPlayerID = PlayerFaceConfig.Get(faceID).CustomPlayerID;
            if (customPlayerID <= 0)
                return false;
            return true;
        }

        public void SetStarColor(int nowStar, List<ImageEx> starShowList)
        {
            for (int i = 0; i < starShowList.Count; i++)
            {
                // ¸ù¾ÝÐǼ¶ÉèÖò»Í¬ÑÕÉ«µÄÐÇÐÇ
                if (nowStar <= 10)
                {
                    starShowList[i].SetSprite("TreasureStar1"); // »ÆÉ«ÐÇÐÇ
                }
                else if (nowStar <= 20)
                {
                    int blueStars = nowStar - 10;
                    if (i < blueStars)
                    {
                        starShowList[i].SetSprite("TreasureStar2"); // À¶É«ÐÇÐÇ
                    }
                    else
                    {
                        starShowList[i].SetSprite("TreasureStar1"); // »ÆÉ«ÐÇÐÇ
                    }
                }
                else
                {
                    int purpleStars = nowStar - 20;
                    if (i < purpleStars)
                    {
                        starShowList[i].SetSprite("TreasureStar3"); // ×ÏÉ«ÐÇÐÇ
                    }
                    else
                    {
                        starShowList[i].SetSprite("TreasureStar2"); // À¶É«ÐÇÐÇ
                    }
                }
            }
        }

        //»ñÈ¡²»Í¬Ö°Òµ¶ÔÓ¦µÄĬÈÏÖµ
        public bool TryGetDefaultID(PhantasmPavilionTab key, int job, out int defaultID)
        {
            defaultID = 0;
            if (defaultIDDict == null || !defaultIDDict.TryGetValue(key, out var dict) || dict == null)
                return false;
            // ³¢ÊÔ»ñÈ¡ job ¶ÔÓ¦µÄÖµ£¬Èç¹ûûÓÐÔò»ñÈ¡ key Ϊ 0 µÄÖµ
            return dict.TryGetValue(job, out defaultID) || dict.TryGetValue(0, out defaultID);
        }

        public bool TryGetNowShowID(PhantasmPavilionTab key, out int result)
        {
            result = 0;
            int job = PlayerDatas.Instance.baseData.Job;
            // Èç¹û nowIDDict Ϊ¿Õ»òûÓе±Ç° ID£¬Ö±½Ó³¢ÊÔ»ñȡĬÈÏ ID
            if (nowIDDict == null || !TryGetDefaultID(key, job, out int defaultID))
                return false;

            // »ñÈ¡µ±Ç° ID£¬Èç¹û´æÔÚÔò¸³Öµ¸ø result
            if (nowIDDict.TryGetValue(key, out int nowID) && IsUnlock(key, nowID))
            {
                result = nowID;
            }
            else
            {
                result = defaultID;
            }

            return true;
        }

        public bool TryGetInfo(PhantasmPavilionTab tab, int id, out PhantasmPavilionInfo info)
        {
            info = new PhantasmPavilionInfo();
            if (!Has(tab, id))
                return false;
            if (infoDict == null || !infoDict.TryGetValue(tab, out var tempInfoDict))
                return false;
            if (tempInfoDict == null || !tempInfoDict.TryGetValue(id, out info))
                return false;
            return true;
        }

        public List<int> StringListToIntList(List<string> stringList)
        {
            List<int> resultList = new List<int>();
            for (int i = 0; i < stringList.Count; i++)
            {
                string str = stringList[i];
                resultList.Add(int.Parse(str));
            }
            return resultList;
        }

        public List<int> ShowItemList(PhantasmPavilionTab tab, out int fristIndex)
        {
            fristIndex = 0;
            if (!handlers.TryGetValue(tab, out var handler))
                return new List<int>();

            var resList = handler.GetTableKeys();
            resList.Sort((int a, int b) => Cmp(a, b, tab));

            if (tab == PhantasmPavilionTab.Avatar)
            {
                for (int i = resList.Count - 1; i >= 0; i--)
                {
                    int id = resList[i];
                    int[] JobShowList = PlayerFaceConfig.Get(id).JobShowList;
                    if (JobShowList != null && !JobShowList.Contains(PlayerDatas.Instance.baseData.Job) && resList.Contains(id))
                    {
                        resList.Remove(id);
                    }
                }
            }

            fristIndex = resList.First();
            return resList;
        }

        public int Cmp(int a, int b, PhantasmPavilionTab tab)
        {
            // »ñÈ¡ a ºÍ b µÄ½âËø״̬
            int stateA = GetUnLockState(tab, a);
            int stateB = GetUnLockState(tab, b);

            // ½«×´Ì¬ÖØж¨ÒåΪÓÅÏȼ¶ÅÅÐòÊýÖµ£º¿É¼¤»î > ÒѼ¤»î > δ¼¤»î×îºó
            int priorityA = stateA == 1 ? 0 : (stateA == 2 ? 1 : 2);
            int priorityB = stateB == 1 ? 0 : (stateB == 2 ? 1 : 2);

            if (priorityA != priorityB)
            {
                return priorityA.CompareTo(priorityB);
            }

            // Èç¹û¼¤»î״̬Ïàͬ£¬±È½Ï SortNum
            int sortNumA = GetSortNum(tab, a);
            int sortNumB = GetSortNum(tab, b);

            if (sortNumA != sortNumB)
            {
                if (tab == PhantasmPavilionTab.Avatar)
                {
                    return sortNumB.CompareTo(sortNumA);
                }
                else
                {
                    return sortNumA.CompareTo(sortNumB);
                }
            }

            return a.CompareTo(b);
        }

        ////»ñµÃµ±Ç°×´Ì¬ 0 - δ¼¤»î 1 - ¿É¼¤»î 2 - ÒѼ¤»î
        public int GetUnLockState(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return 0;
            //û¼¤»î
            if (!IsUnlock(tab, id))
            {
                //ûÓÐÌ»îÎïÆ·
                if (!TryGetUnLockNeedItem(tab, id, out int itemId, out int count))
                    return 0;
                //¼¤»îÎïÆ·ÊýÁ¿²»×ã
                int hasCnt = packModel.GetItemCountByID(PackType.Item, itemId);
                if (hasCnt < count)
                    return 0;
                return 1;
            }
            return 2;
        }

        //»ñµÃÊôÐÔչʾÑùʽÀàÐÍ  0 ¼ÓºÅ 1 ¼ýÍ· false²»Õ¹Ê¾
        public bool TryGetAttrShowType(PhantasmPavilionTab tab, int faceId, out int type)
        {
            type = 0;
            int unLockState = GetUnLockState(tab, faceId);// 0 - δ¼¤»î 1 - ¿É¼¤»î 2 - ÒѼ¤»î
            bool isNoMaxStar = TryGetUpStar(tab, faceId, out int nowUpStar);
            bool isHaveUnLockAttr = TryGetUnLockAttr(tab, selectItemId, out int[] lightAttrTypeArr, out int[] lightAttrValueArr);
            bool isHaveAddStarAttr = TryGetMaxStarLV(tab, faceId, out int starCount);

            if (!isHaveUnLockAttr)
                return false;

            if (unLockState == 2)
            {
                if (!isHaveAddStarAttr)
                {
                    type = 0;
                }
                else
                {
                    type = isNoMaxStar ? 1 : 0;
                }
            }
            else
            {
                type = 0;
            }
            return true;
        }

        //»ñÈ¡¼¤»îºóÏÂÒ»ÐǼ¶ºÍµ±Ç°ÐǼ¶µÄ¶Ô±ÈÊý¾Ý 0ÐÇÊǸռ¤»îµÄ״̬
        public bool TryGetAttrProp(PhantasmPavilionTab tab, int id, int faceStar, out List<int> attrTypeList, out List<int> oldAttrValueList, out List<int> newAttrValueList)
        {
            attrTypeList = new List<int>();
            oldAttrValueList = new List<int>();
            newAttrValueList = new List<int>();
            if (!Has(tab, id))
                return false;
            bool isHaveUnLockAttr = TryGetUnLockAttr(tab, id, out int[] lightAttrTypeArr, out int[] lightAttrValueArr);
            bool isHaveAddStarAttr = TryGetMaxStarLV(tab, id, out int maxStarLV);
            if (!isHaveUnLockAttr || faceStar > maxStarLV)
                return false;

            int nextStar = faceStar + 1;
            bool isHaveNowStarAttr = TryGetAddStarAttr(tab, id, faceStar, out int[] nowAddStarAttrTypeArr, out int[] nowAddStarAttrValueArr);
            bool isHaveNextStarAttr = TryGetAddStarAttr(tab, id, nextStar, out int[] nextAddStarAttrTypeArr, out int[] nextAddStarAttrValueArr);
            Dictionary<int, int> oldDict = new Dictionary<int, int>();
            Dictionary<int, int> newDict = new Dictionary<int, int>();

            if (!isHaveAddStarAttr)
            {
                attrTypeList = lightAttrTypeArr.ToList();
                newAttrValueList = lightAttrValueArr.ToList();
                for (int i = 0; i < attrTypeList.Count; i++)
                {
                    oldAttrValueList.Add(0);
                }
            }
            else
            {
                for (int i = 0; i < lightAttrTypeArr.Length; i++)
                {
                    int attrType = lightAttrTypeArr[i];
                    oldDict[attrType] = lightAttrValueArr[i];
                    newDict[attrType] = lightAttrValueArr[i];
                }

                if (faceStar == 0)
                {
                    if (!isHaveNextStarAttr)
                        return false;
                    attrTypeList = nextAddStarAttrTypeArr.ToList();
                    for (int i = 0; i < nextAddStarAttrTypeArr.Length; i++)
                    {
                        int attrType = nextAddStarAttrTypeArr[i];
                        int nextAttrValue = nextAddStarAttrValueArr[i];
                        if (!oldDict.ContainsKey(attrType))
                        {
                            oldDict[attrType] = 0;
                        }

                        if (!newDict.ContainsKey(attrType))
                        {
                            newDict[attrType] = nextAttrValue;
                        }
                        else
                        {
                            newDict[attrType] += nextAttrValue;
                        }
                    }

                    for (int i = 0; i < attrTypeList.Count; i++)
                    {
                        int attrType = attrTypeList[i];
                        oldAttrValueList.Add(oldDict[attrType]);
                        newAttrValueList.Add(newDict[attrType]);
                    }
                }
                else if (nextStar > maxStarLV)
                {
                    attrTypeList = nowAddStarAttrTypeArr.ToList();
                    for (int i = 0; i < nowAddStarAttrTypeArr.Length; i++)
                    {
                        int attrType = nowAddStarAttrTypeArr[i];
                        int nextAttrValue = nowAddStarAttrValueArr[i];
                        if (!oldDict.ContainsKey(attrType))
                        {
                            oldDict[attrType] = nextAttrValue;
                        }
                        else
                        {
                            oldDict[attrType] += nextAttrValue;
                        }
                        newDict[attrType] = 0;
                    }

                    for (int i = 0; i < attrTypeList.Count; i++)
                    {
                        int attrType = attrTypeList[i];
                        newAttrValueList.Add(oldDict[attrType]);
                        oldAttrValueList.Add(0);
                    }
                }
                else
                {
                    attrTypeList = nextAddStarAttrTypeArr.ToList();
                    for (int i = 0; i < nextAddStarAttrTypeArr.Length; i++)
                    {
                        int attrType = nextAddStarAttrTypeArr[i];
                        int attrValue = nextAddStarAttrValueArr[i];

                        if (!oldDict.ContainsKey(attrType))
                        {
                            oldDict[attrType] = 0;
                        }
                        if (!newDict.ContainsKey(attrType))
                        {
                            newDict[attrType] = 0;
                        }
                        newDict[attrType] += attrValue;
                    }
                    for (int i = 0; i < nowAddStarAttrTypeArr.Length; i++)
                    {
                        int attrType = nowAddStarAttrTypeArr[i];
                        int attrValue = nowAddStarAttrValueArr[i];

                        oldDict[attrType] += attrValue;
                    }

                    for (int i = 0; i < attrTypeList.Count; i++)
                    {
                        int attrType = attrTypeList[i];
                        oldAttrValueList.Add(oldDict[attrType]);
                        newAttrValueList.Add(newDict[attrType]);
                    }
                }
            }

            if (attrTypeList == null || oldAttrValueList == null || newAttrValueList == null)
                return false;
            if (attrTypeList.Count != oldAttrValueList.Count || oldAttrValueList.Count != newAttrValueList.Count)
                return false;

            return true;
        }

        #region ±íÇé°ü½ÓÈëÏà¹Ø

        public List<int> GetUnlockIDList()
        {
            List<int> allList = StringListToIntList(EmojiPackConfig.GetKeys());
            List<int> result = new List<int>();
            for (int i = 0; i < allList.Count; i++)
            {
                int id = allList[i];
                if (IsUnlock(PhantasmPavilionTab.ChatExpression, id))
                {
                    result.Add(id);
                }
            }
            return result;
        }

        public List<string> GetEmojiList(int id)
        {
            var info = FaceConfig.GetEmojiPackList();
            if (info == null || !info.TryGetValue(id, out var list) || list == null)
                return new List<string>();
            return list;
        }

        public int GetShowEmojiInfo(float itemWidth, int id, out int rowCount, out int emojiCount, out int space)
        {
            emojiCount = 0;
            rowCount = 0;
            space = 0; // ĬÈÏÖµ

            int minSpace = 5; // ×îС¼ä¸ô
            int maxSpace = 50; // ×î´ó¼ä¸ô
            int width = Mathf.CeilToInt(itemWidth);

            GetEmojiShowSize(id, out int emojiWidth, out int emojiHeight);
            List<string> emojiList = GetEmojiList(id);
            if (emojiList == null || emojiList.Count == 0 || emojiWidth == 0)
                return 0;

            int listCount = emojiList.Count;
            emojiCount = Mathf.Min(MaxEmojiCount, Mathf.Min(width / emojiWidth, listCount));

            if (emojiCount > 1)
            {
                int availableWidthForSpaces = width - (emojiCount * emojiWidth);
                space = availableWidthForSpaces / (emojiCount - 1);
                space = Mathf.Clamp(space, minSpace, maxSpace);
            }
            else
            {
                space = 0; // ûÓпռä¿É·ÖÅä¼ä¸ô»òÕß¼ä¸ôÖ®¼äÖ»ÓÐÒ»¸ö±íÇé
            }

            rowCount = Mathf.CeilToInt((float)listCount / emojiCount);
            return 0;
        }

        // »ñµÃ±íÇé°üÖбíÇé×î´óµÄ³ß´ç
        public void GetEmojiShowSize(int id, out int width, out int height)
        {
            width = 0;
            height = 0;

            List<string> emojiList = GetEmojiList(id);
            if (emojiList.IsNullOrEmpty())
                return;

            for (int i = 0; i < emojiList.Count; i++)
            {
                string imgSrc = emojiList[i];

                if (UIFrameMgr.Inst.ContainsDynamicImage(imgSrc))
                {
                    List<UnityEngine.Sprite> spriteList = UIFrameMgr.Inst.GetDynamicImage(imgSrc);
                    if (!spriteList.IsNullOrEmpty())
                    {
                        for (int j = 0; j < spriteList.Count; j++)
                        {
                            UpdateMaxSize(spriteList[j], ref width, ref height);
                        }
                    }
                }
                else if (IconConfig.Has(imgSrc))
                {
                    UnityEngine.Sprite sprite = UILoader.LoadSprite(imgSrc);
                    UpdateMaxSize(sprite, ref width, ref height);
                }
            }
        }

        // ¸üÐÂ×î´ó³ß´çµÄ·½·¨
        private void UpdateMaxSize(UnityEngine.Sprite sprite, ref int width, ref int height)
        {
            float nowWidth = sprite.rect.width;
            float nowHeight = sprite.rect.height;
            if (width < nowWidth)
                width = Mathf.CeilToInt(nowWidth);
            if (height < nowHeight)
                height = Mathf.CeilToInt(nowHeight);
        }

        #endregion

        //»ñµÃ×Ô¼ºµÄÁÄÌìÆøÅÝID
        public int GetNowChatBubbleID()
        {
            PhantasmPavilionTab key = PhantasmPavilionTab.ChatBubble;
            int job = 0;
            // ³¢ÊÔ»ñÈ¡µ±Ç° ID
            if (nowIDDict.TryGetValue(key, out int nowID) && ChatBubbleBoxConfig.Has(nowID) && IsUnlock(key, nowID))
                return nowID;
            // Èç¹ûµ±Ç° ID ²»´æÔÚ»òδ½âËø£¬³¢ÊÔ»ñȡĬÈÏ ID
            return TryGetDefaultID(key, job, out int defaultID) ? defaultID : -1;
        }

        //»ñµÃÆäËûÍæ¼ÒµÄÁÄÌìÆøÅÝID
        public int GetNowOtherChatBubbleID(int nowID)
        {
            PhantasmPavilionTab key = PhantasmPavilionTab.AvatarFrame;
            // ³¢ÊÔ»ñÈ¡µ±Ç° ID
            if (ChatBubbleBoxConfig.Has(nowID))
                return nowID;
            // Èç¹ûµ±Ç° ID ²»´æÔÚ»òδ½âËø£¬³¢ÊÔ»ñȡĬÈÏ ID
            return TryGetDefaultID(key, 0, out int defaultID) ? defaultID : -1;
        }

        public bool IsUnlock(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return false;
            int unlockDefault = GetUnlockDefault(tab, id);
            //ÅäĬÈϼ¤»îµÄ ²»×öÆäËûÅж¨Ö±½Ó¼¤»î
            if (unlockDefault == 1)
                return true;
            // ·â°üÖÐûÓÐ
            if (!TryGetInfo(tab, id, out var info))
                return false;
            // ״̬ÊÇδ¼¤»î
            if (!info.State)
                return false;
            // ʱЧ²»ÎªÓÀ¾Ã ÇÒʱЧÓÃÍê
            if (info.EndTime > 0 && info.EndTime < TimeUtility.AllSeconds)
                return false;
            return true;
        }

        //ÊÇ·ñÓÐʱЧ true ÓÐʱ¼äÏÞÖÆ false ÓÀ¾Ã£¨ÎÞʱ¼äÏÞÖÆ£©
        public bool IsLimitTime(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return false;
            int unlockDefault = GetUnlockDefault(tab, id);
            int expireMinutes = GetExpireMinutes(tab, id);
            //ûÕÒµ½
            if (unlockDefault == -1 || expireMinutes == -1)
                return false;
            //ĬÈϼ¤»îµÄ¶¼ÊÇÓÀ¾ÃµÄ,ûÓÐʱЧÏÞÖÆ
            if (unlockDefault == 1)
                return false;
            //ʱЧ·ÖÖÓÅä0µÄ¶¼ÊÇÓÀ¾ÃµÄ,ûÓÐʱЧÏÞÖÆ
            if (expireMinutes <= 0)
                return false;
            return true;
        }

        //¿ÉÉýÐÇ£¿
        public bool IsUpStar(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return false;
            //δ¼¤»îµÄ²»¿ÉÉýÐÇ
            if (!IsUnlock(tab, id))
                return false;
            //ûÓÐÓÐÏÂÒ»ÐÇ¿ÉÒÔÉý¼¶
            if (!TryGetUpStar(tab, id, out int nowUpStar))
                return false;
            //±í¸ñûÓÐÌîдÉýÐÇÎïÆ·
            if (!TryGetStarUpNeedItem(tab, id, nowUpStar, out int itemId, out int count))
                return false;
            //ÏÞʱµÄ²»ÄÜÉýÐÇ
            if (IsLimitTime(tab, id))
                return false;
            //¼¤»îÎïÆ·ÊýÁ¿²»×ã
            int hasCnt = packModel.GetItemCountByID(PackType.Item, itemId);
            if (hasCnt < count)
                return false;
            return true;
        }

        public void ShowImage(PhantasmPavilionTab tab, int id, ImageEx imgTitle)
        {
            if (!Has(tab, id))
                return;
            string image = GetImage(tab, id);
            UIFrame frame = imgTitle.GetComponent<UIFrame>();
            if (UIFrameMgr.Inst.ContainsDynamicImage(image))
            {
                if (frame == null)
                    frame = imgTitle.gameObject.AddComponent<UIFrame>();

                List<UnityEngine.Sprite> spriteList = UIFrameMgr.Inst.GetDynamicImage(image);
                if (!spriteList.IsNullOrEmpty())
                {
                    imgTitle.rectTransform.sizeDelta = new Vector2(spriteList[0].rect.width, spriteList[0].rect.height);
                }

                imgTitle.raycastTarget = false;
                frame.ResetFrame(image);
                frame.enabled = true;
            }
            else
            {
                if (frame != null)
                    frame.enabled = false;
                imgTitle.SetSprite(image);
                imgTitle.SetNativeSize();
            }
        }

        public bool TryGetUpStar(PhantasmPavilionTab tab, int id, out int nowUpStar)
        {
            nowUpStar = 0;
            if (!Has(tab, id))
                return false;
            if (!TryGetMaxStarLV(tab, id, out int maxStarCount))
                return false;
            if (!TryGetInfo(tab, id, out var info))
                return false;
            nowUpStar = info.Star + 1;
            if (nowUpStar > maxStarCount)
                return false;
            return true;
        }

        #region handlerÏà¹Ø

        public bool Has(PhantasmPavilionTab tab, int id)
        {
            if (!handlers.TryGetValue(tab, out var handler))
                return false;
            return handler.Has(id);
        }
        public string GetDescriptive(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return string.Empty;
            if (!handlers.TryGetValue(tab, out var handler))
                return string.Empty;
            return handler.GetDescriptive(id);
        }

        public int GetSortNum(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return 0;
            if (!handlers.TryGetValue(tab, out var handler))
                return 0;
            return handler.GetSortNum(id);
        }

        public string GetName(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return string.Empty;
            if (!handlers.TryGetValue(tab, out var handler))
                return string.Empty;
            return handler.GetName(id);
        }

        public string GetImage(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return string.Empty;
            if (!handlers.TryGetValue(tab, out var handler))
                return string.Empty;
            return handler.GetImage(id);
        }

        public int GetUnlockDefault(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return 0;
            if (!handlers.TryGetValue(tab, out var handler))
                return 0;
            return handler.GetUnlockDefault(id);
        }

        public int GetExpireMinutes(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return 0;
            if (!handlers.TryGetValue(tab, out var handler))
                return 0;
            return handler.GetExpireMinutes(id);
        }

        public bool IsUsing(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return false;
            if (!TryGetNowShowID(tab, out int result))
                return false;
            return result == id;
        }

        public bool TryGetUnLockAttr(PhantasmPavilionTab tab, int id, out int[] lightAttrTypeArr, out int[] lightAttrValueArr)
        {
            lightAttrTypeArr = null;
            lightAttrValueArr = null;
            if (!Has(tab, id))
                return false;
            if (!handlers.TryGetValue(tab, out var handler))
                return false;
            return handler.TryGetUnLockAttr(id, out lightAttrTypeArr, out lightAttrValueArr);
        }

        public bool TryGetUnLockNeedItem(PhantasmPavilionTab tab, int id, out int itemId, out int count)
        {
            itemId = 0;
            count = 0;
            if (!Has(tab, id))
                return false;
            if (!handlers.TryGetValue(tab, out var handler))
                return false;
            return handler.TryGetUnLockNeedItem(id, out itemId, out count);
        }

        public bool TryGetStarUpNeedItem(PhantasmPavilionTab tab, int id, int faceStar, out int itemId, out int count)
        {
            itemId = 0;
            count = 0;
            if (!Has(tab, id))
                return false;
            if (!handlers.TryGetValue(tab, out var handler))
                return false;
            return handler.TryGetStarUpNeedItem(id, faceStar, out itemId, out count);
        }

        public bool TryGetEffectID(PhantasmPavilionTab tab, int id, out int effectID)
        {
            effectID = 0;
            if (!Has(tab, id))
                return false;
            if (!handlers.TryGetValue(tab, out var handler))
                return false;
            return handler.TryGetEffectID(id, out effectID);
        }

        public bool TryGetMaxStarLV(PhantasmPavilionTab tab, int id, out int maxStarLV)
        {
            maxStarLV = 0;
            if (!Has(tab, id))
                return false;
            if (!handlers.TryGetValue(tab, out var handler))
                return false;
            return handler.TryGetMaxStarLV(id, out maxStarLV);
        }

        public bool TryGetAddStarAttr(PhantasmPavilionTab tab, int id, int faceStar, out int[] nowAddStarAttrTypeArr, out int[] nowAddStarAttrValueArr)
        {
            nowAddStarAttrTypeArr = new int[1];
            nowAddStarAttrValueArr = new int[1];
            if (!Has(tab, id))
                return false;
            if (!handlers.TryGetValue(tab, out var handler))
                return false;
            return handler.TryGetAddStarAttr(id, faceStar, out nowAddStarAttrTypeArr, out nowAddStarAttrValueArr);
        }

        public void SendStarUPPack(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return;
            if (!handlers.TryGetValue(tab, out var handler))
                return;
            handler.SendStarUPPack(id);
        }

        public void SendUsePack(PhantasmPavilionTab tab, int id)
        {
            if (!Has(tab, id))
                return;
            if (!handlers.TryGetValue(tab, out var handler))
                return;
            handler.SendUsePack(id);
        }

        #endregion

        #region ·¢·â°ü

        public void SendCA323UnLockPack(int itemIndex, int count)
        {
            var pack = new CA323_tagCMUseItems();
            pack.ItemIndex = (byte)itemIndex;
            pack.UseCnt = (ushort)count;
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB226FaceChange(int faceId)
        {
            var pack = new CB226_tagCMFaceChange();
            pack.FaceID = (uint)faceId;
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB227FaceStarUP(int faceId)
        {
            var pack = new CB227_tagCMFaceStarUP();
            pack.FaceID = (uint)faceId;
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB228FacePicChange(int facePicId)
        {
            var pack = new CB228_tagCMFacePicChange();
            pack.FacePicID = (uint)facePicId;
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB229FacePicStarUP(int facePicId)
        {
            var pack = new CB229_tagCMFacePicStarUP();
            pack.FacePicID = (uint)facePicId;
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCA230SetChatBubbleBox(int id)
        {
            CA230_tagCMSetChatBubbleBox pak = new CA230_tagCMSetChatBubbleBox();
            pak.BubbleBoxType = (byte)id;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void SendCA236ChatBubbleBoxStarUP(int id)
        {
            var pack = new CA236_tagCMChatBubbleBoxStarUP();
            pack.BoxID = (byte)id;
            GameNetSystem.Instance.SendInfo(pack);
        }

        #endregion

        #region ÊÕ·â°ü

        public void UpdateFaceInfo(HB117_tagMCFaceInfo vNetData)
        {
            if (!infoDict.ContainsKey(PhantasmPavilionTab.Avatar))
                infoDict[PhantasmPavilionTab.Avatar] = new Dictionary<int, PhantasmPavilionInfo>();
            for (int i = 0; i < vNetData.FaceList.Length; i++)
            {
                HB117_tagMCFaceInfo.tagMCFace tagMCFaces = vNetData.FaceList[i];
                if (!infoDict[PhantasmPavilionTab.Avatar].ContainsKey((int)tagMCFaces.FaceID))
                    infoDict[PhantasmPavilionTab.Avatar][(int)tagMCFaces.FaceID] = new PhantasmPavilionInfo();
                infoDict[PhantasmPavilionTab.Avatar][(int)tagMCFaces.FaceID].ID = (int)tagMCFaces.FaceID;
                infoDict[PhantasmPavilionTab.Avatar][(int)tagMCFaces.FaceID].State = tagMCFaces.State == 1;
                infoDict[PhantasmPavilionTab.Avatar][(int)tagMCFaces.FaceID].EndTime = tagMCFaces.EndTime;
                infoDict[PhantasmPavilionTab.Avatar][(int)tagMCFaces.FaceID].Star = tagMCFaces.Star;
            }
            UpdateRedPoint();
            UpdateFaceInfoEvent?.Invoke();
        }

        public void UpdateFacePicInfo(HB118_tagMCFacePicInfo vNetData)
        {
            if (!infoDict.ContainsKey(PhantasmPavilionTab.AvatarFrame))
                infoDict[PhantasmPavilionTab.AvatarFrame] = new Dictionary<int, PhantasmPavilionInfo>();

            for (int i = 0; i < vNetData.FacePicList.Length; i++)
            {
                HB118_tagMCFacePicInfo.tagMCFacePic tagMCFacePics = vNetData.FacePicList[i];
                if (!infoDict[PhantasmPavilionTab.AvatarFrame].ContainsKey((int)tagMCFacePics.FacePicID))
                    infoDict[PhantasmPavilionTab.AvatarFrame][(int)tagMCFacePics.FacePicID] = new PhantasmPavilionInfo();
                infoDict[PhantasmPavilionTab.AvatarFrame][(int)tagMCFacePics.FacePicID].ID = (int)tagMCFacePics.FacePicID;
                infoDict[PhantasmPavilionTab.AvatarFrame][(int)tagMCFacePics.FacePicID].State = tagMCFacePics.State == 1;
                infoDict[PhantasmPavilionTab.AvatarFrame][(int)tagMCFacePics.FacePicID].EndTime = tagMCFacePics.EndTime;
                infoDict[PhantasmPavilionTab.AvatarFrame][(int)tagMCFacePics.FacePicID].Star = tagMCFacePics.Star;
            }
            UpdateRedPoint();
            UpdateFacePicInfoEvent?.Invoke();
        }

        public void UpdateEmojiPackInfo(HA721_tagMCEmojiPackInfo vNetData)
        {
            if (!infoDict.ContainsKey(PhantasmPavilionTab.ChatExpression))
                infoDict[PhantasmPavilionTab.ChatExpression] = new Dictionary<int, PhantasmPavilionInfo>();

            for (int i = 0; i < vNetData.EmojiPackList.Length; i++)
            {
                HA721_tagMCEmojiPackInfo.tagMCEmojiPack emojiPack = vNetData.EmojiPackList[i];
                if (!infoDict[PhantasmPavilionTab.ChatExpression].ContainsKey((int)emojiPack.PackID))
                    infoDict[PhantasmPavilionTab.ChatExpression][(int)emojiPack.PackID] = new PhantasmPavilionInfo();
                infoDict[PhantasmPavilionTab.ChatExpression][(int)emojiPack.PackID].ID = (int)emojiPack.PackID;
                infoDict[PhantasmPavilionTab.ChatExpression][(int)emojiPack.PackID].State = emojiPack.State == 1;
                infoDict[PhantasmPavilionTab.ChatExpression][(int)emojiPack.PackID].EndTime = emojiPack.EndTime;
            }
            UpdateRedPoint();
            UpdateEmojiPackInfoEvent?.Invoke();
        }

        public void UpdateChatBubbleBoxInfo(HA717_tagMCChatBubbleBoxState vNetData)
        {
            if (!infoDict.ContainsKey(PhantasmPavilionTab.ChatBubble))
                infoDict[PhantasmPavilionTab.ChatBubble] = new Dictionary<int, PhantasmPavilionInfo>();

            for (int i = 0; i < vNetData.BoxList.Length; i++)
            {
                HA717_tagMCChatBubbleBoxState.tagMCChatBubbleBox chatBubbleBox = vNetData.BoxList[i];
                if (!infoDict[PhantasmPavilionTab.ChatBubble].ContainsKey((int)chatBubbleBox.BoxID))
                    infoDict[PhantasmPavilionTab.ChatBubble][(int)chatBubbleBox.BoxID] = new PhantasmPavilionInfo();
                infoDict[PhantasmPavilionTab.ChatBubble][(int)chatBubbleBox.BoxID].ID = (int)chatBubbleBox.BoxID;
                infoDict[PhantasmPavilionTab.ChatBubble][(int)chatBubbleBox.BoxID].State = chatBubbleBox.State == 1;
                infoDict[PhantasmPavilionTab.ChatBubble][(int)chatBubbleBox.BoxID].EndTime = chatBubbleBox.EndTime;
                infoDict[PhantasmPavilionTab.ChatBubble][(int)chatBubbleBox.BoxID].Star = chatBubbleBox.Star;
            }
            UpdateRedPoint();
            UpdateChatBubbleBoxInfoEvent?.Invoke();
        }

        #endregion
    }

    public class PhantasmPavilionInfo
    {
        public int ID;                  //ID
        public bool State;              //ÊÇ·ñÒѼ¤»î
        public uint EndTime;            //µ½ÆÚʱ¼ä´Á£¬0ΪÓÀ¾Ã
        public int Star;               //ÐǼ¶
    }
}