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

    public class FuncOpen
    {
        private static FuncOpen _inst = null;
        public static FuncOpen Instance {
            get {
                if (_inst == null)
                {
                    _inst = new FuncOpen();
                }
                return _inst;
            }
        }

        protected FuncOpen()
        {
            if (Application.isEditor)
            {
                if (!Application.isPlaying) return;
            }

            var allKeys = new List<int>(FuncOpenLVConfig.dic.Keys);//GetKeys();
            funcArray = new int[allKeys.Count];
            int _index = 0;
            foreach (var key in allKeys)
            {
                int func = key;
                funcOpenState[func] = false;
                funcArray[_index] = func;
                _index++;
            }

            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += BeforePlayerDataInitializeEvent;
            DTC0102_tagCDBPlayer.switchAccountEvent += SwitchAccountEvent;

            funcClientLVLimitDict.Clear();
            var jsonConfig = JsonMapper.ToObject(FuncConfigConfig.Get("FuncLevelLimitClient").Numerical1);
            foreach (var key in jsonConfig.Keys)
            {
                funcClientLVLimitDict[int.Parse(key)] = int.Parse(jsonConfig[key].ToString());
            }
        }

        private void BeforePlayerDataInitializeEvent()
        {
            for (int i = 0; i < funcArray.Length; i++)
            {
                funcOpenState[funcArray[i]] = false;
            }
        }

        private void SwitchAccountEvent()
        {
            for (int i = 0; i < funcArray.Length; i++)
            {
                funcOpenState[funcArray[i]] = false;
                if (OnFuncStateChangeEvent != null)
                {
                    OnFuncStateChangeEvent(funcArray[i]);
                }
            }
        }

        // TaskModel m_TaskModel;
        // TaskModel taskmodel { get { return m_TaskModel ?? (m_TaskModel = ModelCenter.Instance.GetModel<TaskModel>()); } }
        private static Dictionary<int, bool> funcOpenState = new Dictionary<int, bool>();
        private int[] funcArray;

        public event Action<int> OnFuncStateChangeEvent;

        //纯客户端的功能等级限制, key 以功能配置表的FuncLevelLimitClient为准
        //1. 精彩活动-全服红包显示等级
        public Dictionary<int, int> funcClientLVLimitDict = new Dictionary<int, int>();
        public bool IsClientLVLimit(int key)
        {
            if (!funcClientLVLimitDict.ContainsKey(key))
                return true;

            if (PlayerDatas.Instance.baseData.LV >= funcClientLVLimitDict[key])
                return true;

            return false;
        }


        public void UpdateFuncState(HA302_tagMCFuncOpenStateList vNetData)
        {
            for (int i = 0; i < vNetData.FuncCount; i++)
            {
                
                var funcState = vNetData.FuncStateList[i];

                bool bPerFuncIsOpen = false;
                bool bAfterFuncIsOpen = false;

                if (!funcOpenState.ContainsKey(funcState.FuncID))
                {
                    funcOpenState.Add(funcState.FuncID, funcState.State == 1);
                    bAfterFuncIsOpen = true;
                }
                else
                {
                    bPerFuncIsOpen = funcOpenState[funcState.FuncID];
                    funcOpenState[funcState.FuncID] = funcState.State == 1;
                    bAfterFuncIsOpen = funcOpenState[funcState.FuncID];
                }
                if (OnFuncStateChangeEvent != null)
                {
                    OnFuncStateChangeEvent(funcState.FuncID);
                }
            }
        }

        private bool IsFuncOpen(int key, out int errorCode)
        {
            
            errorCode = 0;
            var config = FuncOpenLVConfig.Get(key);
            if (config == null)
            {
                return false;
            }
            // if (config.LimitMagicWeapon > 0)
            // {
            //     Treasure treasure = null;
            //     var _stage = config.LimitMagicWeapon % 100;
            //     ModelCenter.Instance.GetModel<TreasureModel>().TryGetTreasure(config.LimitMagicWeapon / 100, out treasure);
            //     if (treasure == null || treasure.state != TreasureState.Collected || treasure.level < _stage)
            //     {
            //         errorCode = 2;
            //         return false;
            //     }
            // }
            // if (config.LimitMissionID > 0)
            // {
                // MissionDetailDates missionDetailDates = null;
                // taskmodel.allMissionDict.TryGetValue(config.LimitMissionID, out missionDetailDates);
                // if (missionDetailDates == null || missionDetailDates.MissionState != 3)
                // {
                    // errorCode = 4;
                    // return false;
                // }
            // }
            // if (config.LimiRealmLV > 0 && PlayerDatas.Instance.baseData.realmLevel < config.LimiRealmLV)
            // {
            //     errorCode = 3;
            //     return false;
            // }
            if (config.LimitLV > 0 && PlayerDatas.Instance.baseData.LV < config.LimitLV)
            {
                errorCode = 1;
                return false;
            }
            return true;
            // return false;
        }

        public bool IsFuncOpen(int key, bool tip = false)
        {
            bool isOpen = false;
            if (funcOpenState.ContainsKey(key))
                isOpen = funcOpenState[key];
            if (!isOpen && tip)
                ProcessorFuncErrorTip(key);
            return isOpen;
        }

        public void ProcessorFuncErrorTip(int key)
        {
            var config = FuncOpenLVConfig.Get(key);
            if (config != null)
            {
                SoundPlayer.Instance.PlayUIAudio(SoundPlayer.defaultClickNegativeAudio);
                if (config.Tip.Equals("FuncLimit_Level"))
                {
                    SysNotifyMgr.Instance.ShowTip(config.Tip);
                    return;
                }
                var errorCode = 0;
                if (!IsFuncOpen(key, out errorCode))
                {
                    switch (errorCode)
                    {
                        case 1:
                            SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc4", config.LimitLV));
                            break;
                        //  TODO YYL
                        // case 2:
                        //     var treasureConfig = TreasureConfig.Get(config.LimitMagicWeapon / 100);
                        //     SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc1", treasureConfig != null ? treasureConfig.Name : string.Empty));
                        //     break;
                        // case 3:
                        //     SysNotifyMgr.Instance.ShowTip(config.Tip, UIHelper.GetRealmName(config.LimiRealmLV, true));
                        //     break;
                        case 4:
                            if (config.LimitLV > 0)
                            {
                                SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc2", config.LimitLV));
                            }
                            else
                            {
                                SysNotifyMgr.Instance.ShowTip(config.Tip, Language.Get("OpenFunc3"));
                            }
                            break;
                    }
                }
            }
        }

        public int GetLimitLv(int key)
        {
            // FuncOpenLVConfig tagFuncOpenLVModel = FuncOpenLVConfig.Get(key);
            // if (tagFuncOpenLVModel.LimitLV != 0)
            // {
            //     return tagFuncOpenLVModel.LimitLV;
            // }
            // if (tagFuncOpenLVModel.LimitMissionID != 0)
            // {
            //     var TaskConfig = PyTaskConfig.Get(tagFuncOpenLVModel.LimitMissionID);
            //     return TaskConfig.lv;
            // }

            return 1;
        }

        Dictionary<int, ICheckFuncOpen> m_CheckFuncDict = new Dictionary<int, ICheckFuncOpen>();
        public void Register(int _key, ICheckFuncOpen _check)
        {
            if (!m_CheckFuncDict.ContainsKey(_key))
            {
                m_CheckFuncDict.Add(_key, _check);
            }
        }

        public bool CheckFuncOpen(int _key)
        {
            if (m_CheckFuncDict.ContainsKey(_key))
            {
                return m_CheckFuncDict[_key].CheckFunc();
            }
            return true;
        }
    }

    public interface ICheckFuncOpen
    {
        bool CheckFunc();
    }