using LitJson;
using Snxxz.UI;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TableConfig;
using UnityEngine;
namespace Snxxz.UI
{
    public class RealmModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize
    {
        DungeonModel m_DungeonModel;
        DungeonModel dungeonModel
        {
            get
            {
                return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>());
            }
        }

        public void OnBeforePlayerDataInitialize()
        {
            PlayerDatas.Instance.realm.holdDataList.Clear();
            openedRealmUpWin = false;
            serverInited = false;
            leaderId = 0;
            cacheRealmLv = 0;
            beforeRealmPoint = 0;
        }

        public override void Init()
        {
            ParseConfig();
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += RefreshInfo;
            StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
            NewBieCenter.Instance.guideCompletedEvent += GuideCompletedEvent;
            BossShowModel.Instance.bossShowCompletedEvent += BossShowCompletedEvent;
        }

        private int cacheMapId = 0;

        bool serverInited = false;

        public int cacheRealmLv { get; set; }

        public bool openByDungeonStep { get; set; }

        public int leaderId { get; set; }

        public int beforeRealmPoint { get; private set; }

        public int realmGuardianDisplayTime { get; private set; }

        public bool realmDungeonState
        {
            get { return LocalSave.GetBool(StringUtility.Contact(PlayerDatas.Instance.PlayerId, "_RealmDungeon_Show")); }
            set { LocalSave.SetBool(StringUtility.Contact(PlayerDatas.Instance.PlayerId, "_RealmDungeon_Show"), value); }
        }

        private void GuideCompletedEvent(int _id)
        {
            SnxxzGame.Instance.StartCoroutine(Co_GuideComplete());
        }

        IEnumerator Co_GuideComplete()
        {
            yield return null;
            if (StageManager.Instance.CurrentStage is DungeonStage)
            {
                if (PlayerDatas.Instance.realm.holdDataList.Count > 0
                && !WindowCenter.Instance.CheckOpen<RealmUpHoldWin>() && !NewBieCenter.Instance.inGuiding && !BossShowModel.Instance.BossShowing)
                {
                    WindowCenter.Instance.Open<RealmUpHoldWin>();
                }
            }
        }

        private void OnStageLoadFinish()
        {
            if (!(StageManager.Instance.CurrentStage is DungeonStage))
            {
                cacheMapId = 0;
                return;
            }
            if (PlayerDatas.Instance.baseData.MapID == REALM_DUNGEON_ID)
            {
                cacheRealmLv = PlayerDatas.Instance.baseData.realmLevel;
            }
            if (PlayerDatas.Instance.realm.holdDataList.Count > 0
                && !WindowCenter.Instance.CheckOpen<RealmUpHoldWin>() && !NewBieCenter.Instance.inGuiding && !BossShowModel.Instance.BossShowing)
            {
                WindowCenter.Instance.Open<RealmUpHoldWin>();
            }
            if (cacheMapId == REALM_DUNGEON_ID)
            {
                if (dungeonModel.dungeonResult.leaderID == PlayerDatas.Instance.PlayerId)
                {
                    if (!WindowCenter.Instance.CheckOpen<RealmWin>() && !NewBieCenter.Instance.inGuiding)
                    {
                        openByDungeonStep = cacheRealmLv < PlayerDatas.Instance.baseData.realmLevel;
                        WindowCenter.Instance.Open<RealmWin>();
                    }
                }
            }
            cacheMapId = PlayerDatas.Instance.baseData.MapID;
        }

        private void BossShowCompletedEvent()
        {
            if (StageManager.Instance.CurrentStage is DungeonStage)
            {
                if (PlayerDatas.Instance.realm.holdDataList.Count > 0
               && !WindowCenter.Instance.CheckOpen<RealmUpHoldWin>() && !NewBieCenter.Instance.inGuiding && !BossShowModel.Instance.BossShowing)
                {
                    WindowCenter.Instance.Open<RealmUpHoldWin>();
                }
            }
        }

        private void RefreshInfo(PlayerDataRefresh refreshType)
        {
            if (refreshType == PlayerDataRefresh.OfficialRank)
            {
                openedRealmUpWin = false;
            }
            if (refreshType == PlayerDataRefresh.RealmPoint)
            {
                if (!IsRealmHighest && serverInited)
                {
                    var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
                    if (beforeRealmPoint < config.NeedPoint && PlayerDatas.Instance.extersion.realmPoint >= config.NeedPoint)
                    {
                        realmDungeonState = true;
                    }
                }
                beforeRealmPoint = PlayerDatas.Instance.extersion.realmPoint;
            }
            if (refreshType == PlayerDataRefresh.RealmPoint || refreshType == PlayerDataRefresh.OfficialRank)
            {
                UpdateRedpoint();
            }
        }

        private void OnFuncStateChangeEvent(int func)
        {
            if (func == (int)FuncOpenEnum.Realm)
            {
                UpdateRedpoint();
            }
        }

        public override void UnInit()
        {
        }

        #region 玩家是否在打坐状态
        public bool IsInJumpToDaZuo = false;
        public Dictionary<uint, byte> playerSitDic = new Dictionary<uint, byte>();
        public void OnRefreshData(H0411_tagPlayerSit vNetData)
        {
            if (playerSitDic.ContainsKey(vNetData.PlayerID))
            {
                playerSitDic[vNetData.PlayerID] = vNetData.Type;
            }
            else
            {
                playerSitDic.Add(vNetData.PlayerID, vNetData.Type);
            }
            GActorPlayerBase player = GAMgr.Instance.GetBySID(vNetData.PlayerID) as GActorPlayerBase;
            if (player != null)
            {
                if (vNetData.Type == 0)
                {
                    GA_Player _otherPlayer = player as GA_Player;
                    if (_otherPlayer != null)
                    {
                        _otherPlayer.StopMoveToPosition();
                    }
                    player.Dazuo();
                }
                else if (vNetData.Type == 1)
                {
                    player.IdleImmediate();
                }
            }
        }
        #endregion

        #region 配置
        public const int REALM_DUNGEON_ID = 31110;
        public int realmHoleLimit { get; private set; }
        public int realmInspireCoolDownTime { get; private set; }
        public int realmMaxLevel { get; private set; }
        public int realmSuppressHurt { get; private set; }
        private Dictionary<int, List<int>> realmHelperAttrDic = new Dictionary<int, List<int>>();
        private Dictionary<int, Dictionary<int, int>> realmSitTimesDict = new Dictionary<int, Dictionary<int, int>>();
        private Dictionary<int, int> realmStageDict = new Dictionary<int, int>();
        private void ParseConfig()
        {
            var config = Config.Instance.Get<FuncConfigConfig>("RealmFBHelpAttr");
            realmHoleLimit = int.Parse(config.Numerical2);
            realmInspireCoolDownTime = int.Parse(config.Numerical3);
            JsonData _jsonData = JsonMapper.ToObject(config.Numerical1);
            foreach (var typeKey in _jsonData.Keys)
            {
                List<int> list = new List<int>();
                foreach (var attrKey in _jsonData[typeKey].Keys)
                {
                    list.Add(int.Parse(_jsonData[typeKey][attrKey].ToString()));
                }
                realmHelperAttrDic.Add(int.Parse(typeKey), list);
            }

            var configs = Config.Instance.GetAllValues<RealmConfig>();
            var start = 0;
            for (int i = 0; i < configs.Count; i++)
            {
                var _dict = new Dictionary<int, int>();
                var _json = JsonMapper.ToObject(configs[i].SitTime);
                foreach (var _key in _json.Keys)
                {
                    _dict.Add(int.Parse(_key), int.Parse(_json[_key].ToString()));
                }
                realmSitTimesDict.Add(configs[i].Lv, _dict);

                if (configs[i].IsBigRealm == 1)
                {
                    realmStageDict.Add(start, configs[i].Lv);
                    start = configs[i].Lv + 1;
                }

                realmMaxLevel = configs[i].Lv > realmMaxLevel ? configs[i].Lv : realmMaxLevel;
            }

            config = Config.Instance.Get<FuncConfigConfig>("RealmGuardian");
            realmGuardianDisplayTime = int.Parse(config.Numerical1);

            config = Config.Instance.Get<FuncConfigConfig>("RealmSuppressHurt");
            realmSuppressHurt = config != null ? int.Parse(config.Numerical1) : 0;
        }

        public int GetRealmHelperAttr(int type, int index)
        {
            List<int> list = null;
            realmHelperAttrDic.TryGetValue(type, out list);
            if (index < list.Count)
            {
                return list[index];
            }
            return 0;
        }

        public bool IsBigRealm()
        {
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            return config != null && config.IsBigRealm == 1;
        }

        public bool TryGetRealmStage(int _realmLv, out int start, out int end)
        {
            start = 0; end = 0;
            foreach (var _key in realmStageDict.Keys)
            {
                if (_realmLv >= _key && _realmLv <= realmStageDict[_key])
                {
                    start = _key;
                    end = realmStageDict[_key];
                    return true;
                }
            }
            return false;
        }
        #endregion

        public bool IsRealmHighest
        {
            get
            {
                var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel + 1);
                return config == null;
            }
        }

        public bool IsDungeonState
        {
            get
            {
                var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
                if (IsRealmHighest)
                {
                    return false;
                }
                var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
                return _realmPoint >= config.NeedPoint;
            }
        }

        public Redpoint realmRedpoint = new Redpoint(114, 11401);

        public bool openedRealmUpWin = false;

        public void UpdateRedpoint()
        {
            realmRedpoint.state = RedPointState.None;
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Realm))
            {
                return;
            }
            if (IsRealmHighest)
            {
                return;
            }
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            var _realmPoint = PlayerDatas.Instance.extersion.realmPoint;
            if (_realmPoint >= config.NeedPoint && !openedRealmUpWin)
            {
                realmRedpoint.state = RedPointState.Simple;
            }
        }

        public void GotoDungeon()
        {
            var _realmCfg = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            if (_realmCfg == null)
            {
                return;
            }
            if (PlayerDatas.Instance.extersion.realmPoint < _realmCfg.NeedPoint)
            {
                return;
            }
            if (_realmCfg != null && _realmCfg.IsBigRealm == 1)
            {
                dungeonModel.GroupChallenge(REALM_DUNGEON_ID, 1);
            }
            else
            {
                dungeonModel.SingleChallenge(REALM_DUNGEON_ID);
            }
        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
            beforeRealmPoint = PlayerDatas.Instance.extersion.realmPoint;
            serverInited = true;
        }
    }
}