using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using UnityEngine;
using Cysharp.Threading.Tasks;

    
    public class ChatCenter : Singleton<ChatCenter>
    {
        public int talkRechargeLimmit;
        public int talkLevelLimmit;

        public void Init()
        {
            ParseConfig();
            //var _uiframe = UIFrameMgr.Inst;
            // ChatSetting.Instance.RefreshChatSetAct += RefreshChatSetAct;
            // TimeMgr.Instance.OnSyntonyEvent += OnSyntonyEvent;
            // VoiceHttpRequest.Instance.samplesDecodecComplete += SamplesDecodecComplete;
            UIManager.Instance.OnOpenWindow += WindowAfterOpenEvent;
            // StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
            // PrepareHandler.Instance.OnPrepareEnd += OnPrepareEnd;

            var time = bandTime;
            banTimeArray[0] = time.Year;
            banTimeArray[1] = time.Month;
            banTimeArray[2] = time.Day;
            banTimeArray[3] = time.Hour;
            banTimeArray[4] = time.Minute;
            banTimeArray[5] = time.Second;
        }

        public void UnInit()
        {

        }

        bool serverInited = false;

        public int chatCharacterLimit { get; private set; }
        public int bugleItem { get; private set; }
        public bool beforeDungeon { get; private set; }
        public List<ChatInfoType> chatChannels { get; private set; }

        public int chatInputLength { get; set; }
        public StringBuilder m_EncodeBuilder = new StringBuilder();
        void ParseConfig()
        {
            chatCharacterLimit = int.Parse(FuncConfigConfig.Get("MessageLength").Numerical1);
            // var _funcCfg = FuncConfigConfig.Get("BugleItem");
            // bugleItem = int.Parse(_funcCfg.Numerical1);
            chatChannels = new List<ChatInfoType>();
            chatChannels.Add(ChatInfoType.System);
            chatChannels.Add(ChatInfoType.World);
            chatChannels.Add(ChatInfoType.CrossServer);
            chatChannels.Add(ChatInfoType.Area);
            chatChannels.Add(ChatInfoType.Team);
            chatChannels.Add(ChatInfoType.Invite);
            chatChannels.Add(ChatInfoType.Trumpet);
            chatChannels.Add(ChatInfoType.Fairy);
            chatChannels.Add(ChatInfoType.Friend);
            chatChannels.Add(ChatInfoType.default1);

            // var config = FuncConfigConfig.Get("ClientChatBan");
            // banCheckSecond = int.Parse(config.Numerical1);
            // repeatCountLimit = int.Parse(config.Numerical2);
            // maliceCheckCount = int.Parse(config.Numerical3);
            // maliceLimitCount = int.Parse(config.Numerical4);
            // var array = ConfigParse.GetMultipleStr<int>(config.Numerical5);
            // singleBanSecond = array[0];
            // maxBanSecond = array[1];

            var config = FuncConfigConfig.Get("LocalChatHistoryCount");
            if (config != null)
            {
                LocalChatHistory.localSaveCount = int.Parse(config.Numerical1);
                if (!string.IsNullOrEmpty(config.Numerical2))
                {
                    LocalChatHistory.localChatKeepHour = int.Parse(config.Numerical2);
                }
            }

            config = FuncConfigConfig.Get("TalkLimit");
            talkRechargeLimmit = int.Parse(config.Numerical1);
            talkLevelLimmit = int.Parse(config.Numerical2);
        }

        public event Action<string, bool, bool> UpdateChatValueEvent;
        public void ChangeChatValue(string _msg, bool _add, bool _force)
        {
            if (UpdateChatValueEvent != null)
            {
                UpdateChatValueEvent(_msg, _add, _force);
            }
        }

        public event Action UpdateChatType;
        public void ChangeChatType()
        {
            if (UpdateChatType != null)
            {
                UpdateChatType();
            }
        }

        public event Action UpdateChatContent;
        public void UpdateChatContentPos()
        {
            if (UpdateChatContent != null)
            {
                UpdateChatContent();
            }
        }

        public ChatData GetChatData(ChatInfoType _type, int _index, int _pteChatId = 0)
        {
            ChatData chat = null;
            if (_type == ChatInfoType.Friend)
            {
                var _list = ChatManager.Instance.GetChatInfo(_pteChatId == 0 ? ChatManager.Instance.PteChatID : _pteChatId);
                if (_list == null || _index >= _list.Count)
                {
                    return null;
                }
                chat = _list[_index];
            }
            else
            {
                List<ChatData> _list = ChatManager.Instance.GetChatInfo(_type);
                if (_list == null || _index >= _list.Count)
                {
                    return null;
                }
                chat = _list[_index];
            }
            return chat;
        }

        public const int RecentlyChatNum = 8;
        public List<RecentlyChat> recentlyChats = new List<RecentlyChat>(RecentlyChatNum);
        public event Action RecentlyChatChangeEvent;
        public RecentlyChat recentlyChat = null;

        public RecentlyChat SaveRecentlyChat(string _chat)
        {
            if (ChatManager.Instance.IsInviteChat(_chat)
                || Regex.IsMatch(_chat, ChatManager.KILL_IDENTIFY))
            {
                return null;
            }
            if (s_VoiceRegex.IsMatch(_chat))
            {
                _chat = s_VoiceRegex.Replace(_chat, string.Empty);
            }
            if (recentlyChats.FindIndex((x) =>
             {
                 return x.display.Equals(_chat);
             }) != -1)
            {
                return null;
            }
            if (recentlyChats.Count >= RecentlyChatNum)
            {
                var _old = recentlyChats[0];
                recentlyChats.RemoveAt(0);
                _old = null;
            }
            var _recentlyChat = new RecentlyChat(_chat);
            recentlyChats.Add(_recentlyChat);
            if (RecentlyChatChangeEvent != null)
            {
                RecentlyChatChangeEvent();
            }
            return _recentlyChat;
        }

        public void OnBeforePlayerDataInitialize()
        {
            recentlyChat = null;
            serverInited = false;
            m_VoiceChatDict.Clear();
        }

        public void OnSwitchAccount()
        {

        }


        public class RecentlyChat
        {
            public string display = string.Empty;
            public List<string> itemInfos = new List<string>();
            public List<int> itemIndexs = new List<int>();
            public List<string> itemNames = new List<string>();

            public RecentlyChat()
            {

            }

            public RecentlyChat(string _chat)
            {
                display = _chat;
            }

            public void Add(string _name, string _itemInfo)
            {
                itemNames.Add(_name);
                itemInfos.Add(_itemInfo);
            }

            public void Reset()
            {
                itemIndexs.Clear();
                for (int i = 0; i < itemInfos.Count; i++)
                {
                    itemIndexs.Add(i);
                }
            }

            public override string ToString()
            {
                return LitJson.JsonMapper.ToJson(this);
            }

            public static bool TryParse(string json, out RecentlyChat chat)
            {
                chat = null;
                try
                {
                    chat = LitJson.JsonMapper.ToObject<RecentlyChat>(json);
                }
                catch (Exception e)
                {
                    Debug.LogError(e.StackTrace + e.Message);
                    return false;
                }
                return chat != null;
            }
        }

        public static readonly Regex s_VoiceRegex = new Regex("<v=([0-9]+)_([0-9]+)>");
        private Dictionary<int, VoiceChat> m_VoiceChatDict = new Dictionary<int, VoiceChat>();

        public class VoiceChat
        {
            public ChatInfoType chatType;
            public int index;
            public int toPlayer;
            public long tick;
            public byte length;
            public bool translate = false;
            public byte[] encode;
            public string result = string.Empty;
        }

        public void SetVoice(int _instance, ChatInfoType _type, float _length, int _toPlayer = 0)
        {
            if (!m_VoiceChatDict.ContainsKey(_instance))
            {
                VoiceChat _chat = new VoiceChat()
                {
                    chatType = _type,
                    index = _instance,
                    toPlayer = _toPlayer,
                    tick = TimeUtility.ServerNow.Ticks,
                    translate = false,
                    encode = null,
                    length = (byte)Mathf.Min((int)(_length * 10), 100),
                };
                m_VoiceChatDict.Add(_instance, _chat);
            }
        }

        public void OnPlayerLoginOk()
        {
            serverInited = true;
        }

        private void WindowAfterOpenEvent(UIBase win)
        {
            CheckChatFloatOpen();
            if (win is MainWin)
            {
                Co_CheckAfterCollect().Forget();
            }
        }

        public bool IsShowChatFloat()
        {
            return !UIManager.Instance.IsOpened<LoadingWin>();
            // if (!UIManager.Instance.IsOpened<LoadingWin>())
            //     return true;
            // return false;
        }

        private void CheckChatFloatOpen()
        {
            if (IsShowChatFloat())
            {
                if (!UIManager.Instance.IsOpened<ChatFloatWin>())
                {
                    UIManager.Instance.OpenWindow<ChatFloatWin>();
                }
            }
        }

        bool openChatAfterCollect = false;
        // private void OnPrepareEnd(int playerId, int type)
        // {
        //     if (playerId == PlayerDatas.Instance.baseData.PlayerID
        //         && type == 0 && PlayerDatas.Instance.baseData.MapID == 31230)
        //     {
        //         openChatAfterCollect = true;
        //     }
        //     CheckOpenChatAfterCollect();
        // }

        async UniTask Co_CheckAfterCollect()
        {
            await UniTask.Yield();
            CheckOpenChatAfterCollect();
        }

        void CheckOpenChatAfterCollect()
        {
            if (!openChatAfterCollect)
            {
                return;
            }
            if (PlayerDatas.Instance.baseData.MapID != 31230)
            {
                return;
            }
            if (!UIManager.Instance.IsOpened<MainWin>()
                /*TODO YYL|| NewBieCenter.Instance.inGuiding*/)
            {
                return;
            }
            openChatAfterCollect = false;

            if (!UIManager.Instance.IsOpened<ChatWin>())
            {
                ChatManager.Instance.presentChatType = ChatInfoType.Fairy;
                UIManager.Instance.OpenWindow<ChatWin>();
            }
        }


        public string SetChatExtra()
        {
            var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
            var job = PlayerDatas.Instance.baseData.Job;
            var bubbleId = PlayerDatas.Instance.baseData.bubbleId;
            var serverGroupId = PlayerDatas.Instance.baseData.ServerGroupId;
            return StringUtility.Contact(vipLevel.ToString().PadLeft(2, '0'), 0, job,
                bubbleId.ToString().PadLeft(2, '0'), serverGroupId.ToString().PadLeft(7, '0'));
        }

        public void HandleChatBanned(ChatInfoType channel, string message, int toPlayer)
        {
            if (IsChatBanned || clientBanned)
            {
                var playerId = PlayerDatas.Instance.baseData.PlayerID;
                var playerName = UIHelper.ServerStringTrim(PlayerDatas.Instance.baseData.PlayerName);
                switch (channel)
                {
                    case ChatInfoType.World:
                        ChatManager.Instance.RevChatInfo(new H0201_tagTalkGong()
                        {
                            Content = message,
                            Extras = SetChatExtra(),
                            PlayerID = playerId,
                            Name = playerName,
                        });
                        break;
                    case ChatInfoType.Area:
                        ChatManager.Instance.RevChatInfo(new H0207_tagTalkArea()
                        {
                            Content = message,
                            Extras = SetChatExtra(),
                            PlayerID = playerId,
                            SrcName = playerName,
                        });
                        break;
                    case ChatInfoType.CrossServer:
                        ChatManager.Instance.RevChatInfo(new H0208_tagTalkCountry()
                        {
                            Content = message,
                            Extras = SetChatExtra(),
                            PlayerID = playerId,
                            Name = playerName,
                        });
                        break;
                    case ChatInfoType.Team:
                        ChatManager.Instance.RevChatInfo(new H0205_tagTalkDui()
                        {
                            PlayerID = playerId,
                            Name = playerName,
                            Content = message,
                            Extras = SetChatExtra(),
                        });
                        break;
                    case ChatInfoType.Fairy:
                        ChatManager.Instance.RevChatInfo(new H0203_tagTalkBang()
                        {
                            PlayerID = playerId,
                            Content = message,
                            Extras = SetChatExtra(),
                            Name = playerName,
                        });
                        break;
                    case ChatInfoType.Friend:
                        ChatManager.Instance.RevChatInfo(new H0206_tagTalkMi()
                        {
                            PlayerID = playerId,
                            SrcName = playerName,
                            Content = message,
                            Extras = SetChatExtra(),
                            ToPlayerID = (uint)toPlayer,
                            ToName = string.Empty,
                            TalkType = 1,
                        });
                        break;
                    case ChatInfoType.default1:
                        ChatManager.Instance.RevChatInfo(new HA707_tagMCPyTalk()
                        {
                            Content = message,
                            Extras = SetChatExtra(),
                            PlayerID = playerId,
                            Name = playerName,
                        });
                        break;
                }
            }
        }

        public void ServerForbidenChat(bool value)
        {
            if (value)
            {
                serverForbidenChat = true;
            }
        }
        private bool m_serverForbidenChat;
        bool serverForbidenChat {
            //get { return LocalSave.GetBool("ServerForbidenChat"); }
            //set { LocalSave.SetBool("ServerForbidenChat", value); }
            get { return m_serverForbidenChat; }
            set { m_serverForbidenChat = value; }
        }

        public bool IsChatBanned {
            get {
                var value = PlayerDatas.Instance.extersion.forbidenTalk;
                //增加判断是否设备禁言
                if (LocalSave.GetBool("ServerForbidenChatDevice1", false) || value > 0)
                    return true;
                return false;
            }
        }

        public bool clientBanned {
            get {
                return false;
                //var time = new DateTime(banTimeArray[0], banTimeArray[1], banTimeArray[2],
                //    banTimeArray[3], banTimeArray[4], banTimeArray[5]);
                //return TimeUtility.ServerNow < time;
            }
        }

        public int banCheckSecond = 60;
        public int repeatCountLimit = 5;
        public int maliceCheckCount = 10;
        public int maliceLimitCount = 5;
        public int singleBanSecond = 1;
        public int maxBanSecond = 1;

    public int banSecond;
        // {
        //     get { return LocalSave.GetInt("ClientChatBanSecond", 0); }
        //     set {
        //         LocalSave.SetInt("ClientChatBanSecond", value);
        //     }
        // }

        private int[] banTimeArray = new int[6];
    private DateTime bandTime;
        // {
        //     get {
        //         var timeArray = LocalSave.GetIntArray("ClientChatBanTime");
        //         if (null == timeArray)
        //         {
        //             return TimeUtility.OriginalTime;
        //         }
        //         else
        //         {
        //             return new DateTime(timeArray[0], timeArray[1], timeArray[2], timeArray[3], timeArray[4], timeArray[5]);
        //         }
        //     }
        //     set {
        //         banTimeArray[0] = value.Year;
        //         banTimeArray[1] = value.Month;
        //         banTimeArray[2] = value.Day;
        //         banTimeArray[3] = value.Hour;
        //         banTimeArray[4] = value.Minute;
        //         banTimeArray[5] = value.Second;
        //         LocalSave.SetIntArray("ClientChatBanTime", banTimeArray);
        //     }
        // }

        public void ChatClientBan()
        {
//            if (!clientBanned)
//            {
//                var time = TimeUtility.ServerNow;
//                var second = Mathf.Min(maxBanSecond, banSecond + singleBanSecond);
//                banSecond = second;
//                bandTime = time.AddTicks(second * TimeSpan.TicksPerSecond);
//#if !UNITY_EDITOR
//                OperationLogCollect.Instance.BugReport(Language.Get("ClientBanTitle"),
//                    Language.Get("ClientBanContent", banSecond));
//#endif
//            }
        }

        public bool IsClientBan(ChatInfoType chatType)
        {
            return false;
            //if (!clientBanned)
            //{
            //    return false;
            //}
            //if (chatType == ChatInfoType.Fairy)
            //{
            //    var model = ModelCenter.Instance.GetModel<DailyQuestModel>();
            //    return model.GetQuestState((int)DailyQuestType.FairyFeast) != DailyQuestModel.DailyQuestState.Normal;
            //}
            //return clientBanned;
        }
    }