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

namespace Snxxz.UI
{
    public class FuncOpen
    {
        private static FuncOpen _inst = null;
        public static FuncOpen Instance
        {
            get
            {
                if (_inst == null)
                {
                    _inst = new FuncOpen();
                }
                return _inst;
            }
        }
#if UNITY_EDITOR
        public static bool development = true;
        public static Action FuncOpenModeChangeEvent;
#endif

        protected FuncOpen()
        {
#if UNITY_EDITOR
            if (!Application.isPlaying) return;
#endif
            var allKeys = FuncOpenLVConfig.GetKeys();
            funcArray = new int[allKeys.Count];
            int _index = 0;
            foreach (var key in allKeys)
            {
                int func = int.Parse(key);
                funcOpenState[func] = false;
                funcArray[_index] = func;
                _index++;
            }

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

        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;

        public void UpdateFuncState(HA302_tagMCFuncOpenStateList vNetData)
        {
            for (int i = 0; i < vNetData.FuncCount; i++)
            {
                var funcState = vNetData.FuncStateList[i];
                if (!funcOpenState.ContainsKey(funcState.FuncID))
                {
                    funcOpenState.Add(funcState.FuncID, funcState.State == 1);
                }
                else
                {
                    funcOpenState[funcState.FuncID] = funcState.State == 1;
                }
                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.stage < _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;
        }

        public bool IsFuncOpen(int key)
        {
            if (funcOpenState.ContainsKey(key))
            {
                return funcOpenState[key];
            }
            return false;
        }

        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;
                        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);
            return tagFuncOpenLVModel.LimitLV;
        }

        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();
    }
}