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

using UnityEngine;
namespace Snxxz.UI
{
    [XLua.LuaCallCSharp]
	public class FairyBossModel : Model
    {
        public override void Init()
        {
            ParseConfig();
            TimeMgr.Instance.OnHourEvent += UpdateRedPoint;
            StageLoad.Instance.onStageLoadFinish+= OnStageLoadFinish;
            PlayerDatas.Instance.fairyData.OnRefreshFairyInfo += OnRefreshFairyInfo;
            PlayerDatas.Instance.fairyData.OnRefreshFairyMine += OnRefreshFairyInfo;
        }

        public override void UnInit()
        {
            TimeMgr.Instance.OnHourEvent -= UpdateRedPoint;
            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
            PlayerDatas.Instance.fairyData.OnRefreshFairyInfo -= OnRefreshFairyInfo;
            PlayerDatas.Instance.fairyData.OnRefreshFairyMine -= OnRefreshFairyInfo;
        }

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        FairyModel fairyModel { get { return ModelCenter.Instance.GetModel<FairyModel>(); } }

        public int MapId { get; private set; }
        public int OpenFairyBossNeed { get; private set; }
        public int FairyBossStartHour { get; private set; }
        public int FairyBossEndHour { get; private set; }
        public string fairyBossInfo { get; private set; }
        public int fairyBossNpcId { get; private set; }
        public int fairyBossFood { get; private set; }
        public int fairyBossContinueTime { get; private set; }
        public int fairyBossPrepareTime { get; private set; }
        public int fairyLevelLimit { get; private set; }
        /// <summary>
        /// key---世界等级上限 value---预览物品id
        /// </summary>
        public Dictionary<int, int[]> fairyBossAwardDict { get; private set; }

        public List<int> m_LeagueTableHides { get; private set; }
        public string leagueTableName { get; private set; }
        Dictionary<int, int> fairyBossWeekCntDict = new Dictionary<int, int>();

        private void ParseConfig()
        {
            FuncConfigConfig cfg = FuncConfigConfig.Get("FamilyBossOpen");
            MapId = int.Parse(cfg.Numerical1);
            OpenFairyBossNeed = int.Parse(cfg.Numerical2);
            FairyBossStartHour = ConfigParse.GetMultipleStr<int>(cfg.Numerical3)[0];
            FairyBossEndHour = ConfigParse.GetMultipleStr<int>(cfg.Numerical3)[1];
            cfg = FuncConfigConfig.Get("FamilyBossInfo");
            fairyBossInfo = cfg.Numerical1;
            fairyBossNpcId = int.Parse(cfg.Numerical2);
            fairyBossFood = int.Parse(cfg.Numerical3);
            fairyBossAwardDict = new Dictionary<int, int[]>();
            cfg = FuncConfigConfig.Get("FamilyBossDrop");
            var _json = LitJson.JsonMapper.ToObject(cfg.Numerical1);
            foreach (var _key in _json.Keys)
            {
                var _worldLv = int.Parse(_key);
                fairyBossAwardDict.Add(_worldLv, LitJson.JsonMapper.ToObject<int[]>(_json[_key].ToJson()));
            }
            cfg = FuncConfigConfig.Get("LeagueTable");
            m_LeagueTableHides = new List<int>();
            m_LeagueTableHides.AddRange(ConfigParse.GetMultipleStr<int>(cfg.Numerical1));
            leagueTableName = cfg.Numerical2;

            var configs = FamilyConfig.GetValues();
            for (int i = 0; i < configs.Count; i++)
            {
                fairyBossWeekCntDict.Add(configs[i].familyLV, configs[i].bossFBCnt);
                if (fairyLevelLimit == 0 && configs[i].bossFBCnt > 0)
                {
                    fairyLevelLimit = configs[i].familyLV;
                }
            }

            GetDungeonContinueTime();
        }

        Redpoint redpoint = new Redpoint(10701, 1070102);

        private void OnStageLoadFinish()
        {
            UpdateRedPoint();
            GameObject _go = GameObject.Find(leagueTableName);
            if (_go != null)
            {
                if (m_LeagueTableHides.Contains(PlayerDatas.Instance.baseData.MapID))
                {
                    _go.SetActive(false);
                }
                else
                {
                    _go.SetActive(true);
                }
            }
        }

        public int GetFairyBossWeekCount()
        {
            var lv = 1;
            var fairyData = PlayerDatas.Instance.fairyData;
            if (!fairyData.HasFairy)
            {
                return 0;
            }
            lv = fairyData.fairy.FamilyLV;
            if (fairyBossWeekCntDict.ContainsKey(lv))
            {
                return fairyBossWeekCntDict[lv];
            }
            return 0;
        }

        public bool TryGetWeekCnt(int _fairyLv, out int cnt)
        {
            return fairyBossWeekCntDict.TryGetValue(_fairyLv, out cnt);
        }

        private void OnRefreshFairyInfo()
        {
            UpdateRedPoint();
        }

        public void UpdateRedPoint()
        {
            redpoint.state = RedPointState.None;
            PlayerFairyData fairyData = PlayerDatas.Instance.fairyData;
            if (!fairyModel.fairyBossFuncOpen)
            {
                return;
            }
            if (fairyData.weekBossOpenCnt >= GetFairyBossWeekCount())
            {
                return;
            }
            if (PlayerDatas.Instance.baseData.MapID == MapId)
            {
                return;
            }
            if (TimeUtility.Hour < FairyBossStartHour || TimeUtility.Hour >= FairyBossEndHour)
            {
                return;
            }
            if (fairyData.IsBossOpen == 0)
            {
                if (fairyData.fairy.FamilyHornor < OpenFairyBossNeed)
                {
                    return;
                }
                if (fairyData.IsCanFunc(PlayerFairyData.LimitFunc.CanOpenBoss))
                {
                    redpoint.state = RedPointState.Simple;
                }
            }
            else
            {
                redpoint.state = RedPointState.Simple;
            }
        }

        public bool IsFairyBossOpen()
        {
            PlayerFairyData fairyData = PlayerDatas.Instance.fairyData;
            if (!fairyModel.fairyBossFuncOpen)
            {
                return false;
            }
            if (TimeUtility.Hour < FairyBossStartHour || TimeUtility.Hour >= FairyBossEndHour)
            {
                return false;
            }
            return fairyData.IsBossOpen > 0;
        }

        private void GetDungeonContinueTime()
        {
            var _list = dungeonModel.GetDungeonIds(MapId);
            var _dungeonCfg = DungeonConfig.Get(_list[0]);
            var _stepTime = _dungeonCfg.StepTime;
            _stepTime = _stepTime.Replace("[", string.Empty);
            _stepTime = _stepTime.Replace("]", string.Empty);
            fairyBossContinueTime = int.Parse(_stepTime.Split(',')[1]);
            fairyBossPrepareTime = int.Parse(_stepTime.Split(',')[0]);
        }

        public void HandInFairyFood()
        {
            var singlepack = packModel.GetSinglePack(PackType.Item);
            var count = 0;
            if (singlepack != null)
            {
                count = singlepack.GetCountById(fairyBossFood);
            }
            if (count > 0)
            {
                CA605_tagCMFamilyDonate pak = new CA605_tagCMFamilyDonate();
                GameNetSystem.Instance.SendInfo(pak);
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("FairyFoodHandError");
            }
        }
    }
}