using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using LitJson;
using TableConfig;
using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.UI
{
    public class FairyLeagueModel : Model, IAfterPlayerDataInitialize, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        public event Action OnRefreshFairyLeagueEvent;
        private FairyLeagueStage m_FairyLeagueStage = FairyLeagueStage.Prepare;
        public FairyLeagueStage fairyLeagueStage
        {
            get
            {
                if (StepRing())
                {
                    return FairyLeagueStage.Over;
                }
                return m_FairyLeagueStage;
            }
        }
        public int fairyLeagueRing
        {
            get
            {
                if (IsNextWeek)
                {
                    return 0;
                }
                var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
                if (_dayOfWeek < groupTimes[1].dayOfWeek || _dayOfWeek > resultTimes[1].dayOfWeek)
                {
                    return 0;
                }
                else if (_dayOfWeek == groupTimes[1].dayOfWeek)
                {
                    if (TimeUtility.ServerNow.Hour < groupTimes[1].startHour)
                    {
                        return 0;
                    }
                    else if (TimeUtility.ServerNow.Hour == groupTimes[1].startHour &&
                        TimeUtility.ServerNow.Minute < groupTimes[1].startMinute)
                    {
                        return 0;
                    }
                }
                return 1;
            }
        }
        public int OpenServerWeek
        {
            get;
            private set;
        }
        public int ringCnt
        {
            get;
            private set;
        }
        public bool IsNextWeek
        {
            get
            {
                if (TimeUtility.OpenWeekCnt >= OpenServerWeek)
                {
                    var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
                    if (_dayOfWeek > resultTimes[1].dayOfWeek && _dayOfWeek <= 7)
                    {
                        return true;
                    }
                    return false;
                }
                else
                {
                    return true;
                }
            }
        }

        public override void Init()
        {
            ParseConfig();
            m_JoinFairyLeagueRedpoint = new Redpoint(10704, 1070401);
            dataRequestDict.Add(FairyLeagueStage.Grouping, false);
            dataRequestDict.Add(FairyLeagueStage.Fight, false);
            dataRequestDict.Add(FairyLeagueStage.Over, false);
            TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
            DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo += OnGetUniversalGameInfo;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
            StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
            fairyLeagueHelp = new FairyLeagueHelp();
        }

        public override void UnInit()
        {
            DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo -= OnGetUniversalGameInfo;
        }
        public void OnBeforePlayerDataInitialize()
        {
            ClearFairyWarHelp();
            fairyLeagueFairyId = 0;
            fairyLeagueFairyName = string.Empty;
        }
        public void OnAfterPlayerDataInitialize()
        {
            for (int i = 0; i < fairyStages.Length; i++)
            {
                dataRequestDict[fairyStages[i]] = false;
            }
            TimeMgr.Instance.OnSyntonyEvent -= OnSyntonyEvent;
            TimeMgr.Instance.OnSyntonyEvent += OnSyntonyEvent;
        }
        public void OnPlayerLoginOk()
        {
            CheckFairyLeagueStage();
            CheckFairyLeagueData();
            UpdateRedpoint();
        }
        private void OnServerOpenDayRefresh()
        {
            CheckFairyLeagueStage();
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh _type)
        {
            if (_type == PlayerDataRefresh.MapID)
            {
                UpdateRedpoint();
            }
        }

        private void OnStageLoadFinish()
        {
            if (StageManager.Instance.CurrentStage is DungeonStage &&
                PlayerDatas.Instance.baseData.MapID == FAIRY_LEAGUE_DUNGEON)
            {
                UpdateRedpoint();
            }
        }

        private void OnSyntonyEvent(TimeMgr.SyntonyType type)
        {
            if (type == TimeMgr.SyntonyType.FairyLeaugeStage)
            {
                CheckFairyLeagueStage();
                CheckFairyLeagueData();
                if (OnRefreshFairyLeagueEvent != null)
                {
                    OnRefreshFairyLeagueEvent();
                }
                UpdateRedpoint();
            }
        }
        #region 配置
        public const int FAIRY_LEAGUE_DUNGEON = 31220;
        public const int FAIRY_LEAGUE_BATTLE = 68;
        public readonly int[] groupRingStates = new int[] { 11, 21 };
        public readonly int[] fightRingStates = new int[] { 12, 22 };
        public readonly int overRingStates = 99;
        public WeekTime[] groupTimes { get; private set; }
        public WeekTime[] fightTimes { get; private set; }
        public WeekTime[] resultTimes { get; private set; }
        public WeekTime overTime { get; private set; }
        public readonly WeekTime skipWeekTime = new WeekTime(1, 0, 0, 0, 0);
        public List<WeekTime> fairyLeagueWeekTimes = new List<WeekTime>();
        private string[] guideImgKeys;
        public string[] GuideImgKeys
        {
            get
            {
                return guideImgKeys;
            }
        }
        private readonly FairyLeagueStage[] fairyStages = new FairyLeagueStage[]
        {
            FairyLeagueStage.Grouping,
            FairyLeagueStage.Fight, FairyLeagueStage.Over
        };
        public int fairyWarResUpperLimit
        {
            get;
            private set;
        }
        public readonly int buffTypeId = 22203;
        public Dictionary<int, List<IntegralRankItem>> integralRankAwardDict = new Dictionary<int, List<IntegralRankItem>>();
        public int[] integralRankAwardPer { get; private set; }
        public int integralAddition { get; private set; }
        public Dictionary<int, int[]> crystalSortDict { get; private set; }
        /// <summary>
        /// key----世界等级
        /// </summary>
        public Dictionary<int, List<AwardItem>> finalWarAwardDict = new Dictionary<int, List<AwardItem>>();
        public Dictionary<int, List<AwardItem>> finalWarChampionAwardDict = new Dictionary<int, List<AwardItem>>();
        private Dictionary<int, float> crystalRateDict = new Dictionary<int, float>();
        private void ParseConfig()
        {
            FuncConfigConfig cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchGuide");
            if (cfg != null)
            {
                guideImgKeys = ConfigParse.GetMultipleStr(cfg.Numerical1);
            }
            ringCnt = groupRingStates.Length;
            groupTimes = new WeekTime[groupRingStates.Length];
            DungeonStateTimeConfig stateCfg = null;
            for (int i = 0; i < groupRingStates.Length; i++)
            {
                stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, groupRingStates[i]);
                if (stateCfg != null)
                {
                    OpenServerWeek = stateCfg.OpenServerWeek;
                    groupTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
                        stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
                    fairyLeagueWeekTimes.Add(groupTimes[i]);
                }
            }
            fightTimes = new WeekTime[fightRingStates.Length];
            resultTimes = new WeekTime[fightRingStates.Length];
            for (int i = 0; i < fightRingStates.Length; i++)
            {
                stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, fightRingStates[i]);
                if (stateCfg != null)
                {
                    fightTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
                        stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
                    fairyLeagueWeekTimes.Add(fightTimes[i]);
                    resultTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.EndHour, stateCfg.EndMinute, 0, 0);
                    fairyLeagueWeekTimes.Add(resultTimes[i]);
                }
            }
            stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, overRingStates);
            overTime = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
                stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
            fairyLeagueWeekTimes.Add(overTime);
            fairyLeagueWeekTimes.Sort(CompareTime);

            cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchResourcePoint");
            if (cfg != null)
            {
                crystalSortDict = new Dictionary<int, int[]>();
                var _sortArray = JsonMapper.ToObject<int[][]>(cfg.Numerical3);
                for (int i = 0; i < _sortArray.Length; i++)
                {
                    crystalSortDict.Add(i + 1, _sortArray[i]);
                }
                fairyLeagueCrystals = JsonMapper.ToObject<int[]>(cfg.Numerical2);
                fairyWarResUpperLimit = int.Parse(cfg.Numerical5);
            }
            cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchRandomBuff");
            if (cfg != null)
            {
                if (RandomBuffPos_Regex.IsMatch(cfg.Numerical1))
                {
                    foreach (Match match in RandomBuffPos_Regex.Matches(cfg.Numerical1))
                    {
                        crystalPosList.Add(new Vector2(float.Parse(match.Groups[1].Value) / 2,
                            float.Parse(match.Groups[2].Value) / 2));
                    }
                }
            }
            Regex _regex = new Regex(@"([0-9]+):\[(.*?\])\]");
            cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchRankReward");
            if (_regex.IsMatch(cfg.Numerical1))
            {
                foreach (Match match in _regex.Matches(cfg.Numerical1))
                {
                    var _rank = int.Parse(match.Groups[1].Value);
                    var _value = StringUtility.Contact('[', match.Groups[2].Value, ']');
                    List<IntegralRankItem> _list = ParseAward(LitJson.JsonMapper.ToObject<int[][]>(_value));
                    integralRankAwardDict.Add(_rank, _list);
                }
                integralRankAwardPer = JsonMapper.ToObject<int[]>(cfg.Numerical2);
            }
            cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchRankOneReward");
            if (_regex.IsMatch(cfg.Numerical1))
            {
                foreach (Match match in _regex.Matches(cfg.Numerical1))
                {
                    var _worldLv = int.Parse(match.Groups[1].Value);
                    List<AwardItem> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
                    finalWarAwardDict.Add(_worldLv, _list);
                }
            }
            cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchSRankOneReward");
            if (_regex.IsMatch(cfg.Numerical1))
            {
                foreach (Match match in _regex.Matches(cfg.Numerical1))
                {
                    var _worldLv = int.Parse(match.Groups[1].Value);
                    List<AwardItem> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
                    finalWarChampionAwardDict.Add(_worldLv, _list);
                }
            }
            cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchPersonalScore");
            integralAddition = int.Parse(cfg.Numerical5);
            cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchResourcePoint1");
            crystalRateDict = ConfigParse.GetDic<int, float>(cfg.Numerical1);
        }
        private List<AwardItem> ParseAward(string _config)
        {
            List<AwardItem> _list = new List<AwardItem>();
            var _array = JsonMapper.ToObject<int[][]>(_config);
            if (_array != null)
            {
                for (int i = 0; i < _array.Length; i++)
                {
                    AwardItem _item = new AwardItem();
                    _item.item.id = _array[i][0];
                    _item.item.count = _array[i][1];
                    _item.isBind = _array[i][2];
                    _list.Add(_item);
                }
            }
            return _list;
        }

        private List<IntegralRankItem> ParseAward(int[][] itemsArray)
        {
            List<IntegralRankItem> _list = new List<IntegralRankItem>();
            if (itemsArray != null)
            {
                for (int i = 0; i < itemsArray.Length; i++)
                {
                    IntegralRankItem _item = new IntegralRankItem();
                    _item.id = itemsArray[i][0];
                    _item.count = itemsArray[i][1];
                    _item.bind = itemsArray[i][2];
                    _item.isPer = itemsArray[i].Length > 3 ? itemsArray[i][3] : 1;
                    _list.Add(_item);
                }
            }
            return _list;
        }
        public SkillConfig GetRandomAttrBuff(int _lv)
        {
            SkillConfig _buffTypeCfg = Config.Instance.Get<SkillConfig>(buffTypeId);
            _lv = Mathf.Min(_lv, _buffTypeCfg.SkillMaxLV);
            return Config.Instance.Get<SkillConfig>(buffTypeId + _lv - 1);
        }

        public bool TryGetCrystalRate(int _npcId, out float _rate)
        {
            return crystalRateDict.TryGetValue(_npcId, out _rate);
        }
        #endregion
        public void CheckFairyLeagueStage()
        {
            var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
            if (IsNextWeek)
            {
                m_FairyLeagueStage = FairyLeagueStage.Prepare;
                return;
            }
            for (int i = 0; i < fairyLeagueWeekTimes.Count; i++)
            {
                var _weekTime = fairyLeagueWeekTimes[i];
                if (_dayOfWeek < _weekTime.dayOfWeek)
                {
                    m_FairyLeagueStage = GetFairyLeagueStage(i);
                    return;
                }
                if (_dayOfWeek == _weekTime.dayOfWeek)
                {
                    if (TimeUtility.Hour < _weekTime.startHour)
                    {
                        m_FairyLeagueStage = GetFairyLeagueStage(i);
                        return;
                    }
                    if (TimeUtility.Hour == _weekTime.startHour &&
                        TimeUtility.Minute < _weekTime.startMinute)
                    {
                        m_FairyLeagueStage = GetFairyLeagueStage(i);
                        return;
                    }
                }
            }
            var _nowTime = new WeekTime(_dayOfWeek, TimeUtility.Hour, TimeUtility.Minute, 0, 0, TimeUtility.Second);
            TimeMgr.Instance.Register(TimeMgr.SyntonyType.FairyLeaugeStage,
                (float)(skipWeekTime - _nowTime).TotalSeconds);
            m_FairyLeagueStage = FairyLeagueStage.Prepare;
        }
        private FairyLeagueStage GetFairyLeagueStage(int _index)
        {
            var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
            var _nowTime = new WeekTime(_dayOfWeek, TimeUtility.Hour, TimeUtility.Minute, 0, 0, TimeUtility.Second);
            TimeMgr.Instance.Register(TimeMgr.SyntonyType.FairyLeaugeStage,
                (float)(fairyLeagueWeekTimes[_index] - _nowTime).TotalSeconds);
            switch (_index)
            {
                case 0:
                    return FairyLeagueStage.Prepare;
                case 1:
                case 4:
                    return FairyLeagueStage.Grouping;
                case 2:
                case 5:
                    return FairyLeagueStage.Fight;
                case 3:
                case 6:
                    return FairyLeagueStage.Over;
            }
            return FairyLeagueStage.Prepare;
        }
        private int CompareTime(WeekTime x, WeekTime y)
        {
            if (x.dayOfWeek.CompareTo(y.dayOfWeek) != 0)
            {
                return x.dayOfWeek.CompareTo(y.dayOfWeek);
            }
            if (x.startHour.CompareTo(y.startHour) != 0)
            {
                return x.startHour.CompareTo(y.startHour);
            }
            return x.startMinute.CompareTo(y.startMinute);
        }
        #region 仙盟联赛副本
        public int[] fairyLeagueCrystals
        {
            get;
            private set;
        }
        public int fairyLeagueWinFaction
        {
            get;
            private set;
        }
        public int fairyLeagueTotalTime
        {
            get;
            private set;
        }
        public int fairyLeagueGroupId
        {
            get;
            private set;
        }

        public uint fairyLeagueFairyId { get; private set; }//仙盟联赛第一轮分配时玩家所在仙盟，默认0代表本仙盟

        public string fairyLeagueFairyName { get; private set; }

        public event Action UpdateWarRankEvent;
        public bool IsAlreadyBattleGuide()
        {
            return QuickSetting.Instance.GetQuickSettingBool(QuickSetting.QuickSettingType.FairyLeagueGuide, 0);
        }
        public void SetBattleGuide()
        {
            QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.FairyLeagueGuide, true);
            QuickSetting.Instance.SendPackage();
        }
        public List<FairyLeagueResultData> fairyLeagueResults = new List<FairyLeagueResultData>();
        public void UpdateFairyResult(HB210_tagMCFamilyWarBillboard _package)
        {
            fairyLeagueResults.Clear();
            fairyLeagueGroupId = _package.GroupID;
            for (int i = 0; i < _package.BillboardCount; i++)
            {
                var _sResult = _package.FBBillboardPlayer[i];
                var _cResult = new FairyLeagueResultData(
                    (int)_sResult.PlayerID, _sResult.PlayerName,
                    (int)_sResult.CrystalCount, (int)_sResult.KillPlayerCount,
                    (int)_sResult.RandBuffCount, (int)_sResult.FightTime,
                    (int)_sResult.Point, _sResult.Faction == _package.WinFaction,
                    _sResult.Faction
                );
                fairyLeagueResults.Add(_cResult);
            }
            if (UpdateWarRankEvent != null)
            {
                UpdateWarRankEvent();
            }
            if (_package.WinFaction != 0 && _package.TotalFightTime > 0)
            {
                fairyLeagueTotalTime = _package.TotalFightTime;
                fairyLeagueWinFaction = _package.WinFaction;
                WindowCenter.Instance.CloseAll(WindowCenter.CloseAllIgnoreType.BaseAndCustom);
                WindowCenter.Instance.Open<MainInterfaceWin>();
                WindowCenter.Instance.Open<FairyLeagueDungeonSettleWin>();
            }
        }

        public void UpdateFairyLeagueFairy(HA40B_tagGCPlayerJoinFamilyWarInfo package)
        {
            fairyLeagueFairyId = package.JoinFamilyID;
            fairyLeagueFairyName = UIHelper.ServerStringTrim(package.JoinFamilyName);
            UpdateRedpoint();
        }
        public int GetCrystalIndex(int _npcId)
        {
            var _array = crystalSortDict[1];
            if (crystalSortDict.ContainsKey((int)PlayerDatas.Instance.baseData.faction))
            {
                _array = crystalSortDict[(int)PlayerDatas.Instance.baseData.faction];
            }
            for (int i = 0; i < _array.Length; i++)
            {
                if (fairyLeagueCrystals[_array[i] - 1] == _npcId)
                {
                    return i;
                }
            }
            return -1;
        }

        public bool BattleChampion()
        {
            var _ring = fairyLeagueRing;
            if (_ring == 0 &&
                fairyLeagueBattleDict.ContainsKey(_ring)
                && fairyLeagueBattleDict[_ring].ContainsKey(5))
            {
                var _list = fairyLeagueBattleDict[_ring][5];
                return _list.Count == 1;
            }
            return false;
        }
        public List<Vector2> crystalPosList = new List<Vector2>();
        private readonly Regex RandomBuffPos_Regex = new Regex(@"\[([0-9]+),([0-9]+)\]");
        #endregion
        #region 协议
        public event Action onFairyLeagueBattleEvent;
        private Dictionary<int, Dictionary<int, List<FairyLeagueBattleData>>> fairyLeagueBattleDict = new Dictionary<int, Dictionary<int, List<FairyLeagueBattleData>>>();
        private void OnGetUniversalGameInfo(HA003_tagUniversalGameRecInfo package)
        {
            if (package.Type == FAIRY_LEAGUE_BATTLE)
            {
                fairyLeagueBattleDict.Clear();
                if (package.Count > 0)
                {
                    for (int i = 0; i < package.Count; i++)
                    {
                        var _pakData = package.UniversalGameRec[i];
                        Dictionary<int, List<FairyLeagueBattleData>> dic = null;
                        fairyLeagueBattleDict.TryGetValue((int)_pakData.Value2 - 1, out dic);
                        if (dic == null)
                        {
                            dic = new Dictionary<int, List<FairyLeagueBattleData>>();
                            fairyLeagueBattleDict.Add((int)_pakData.Value2 - 1, dic);
                        }
                        List<FairyLeagueBattleData> list = null;
                        if (dic.TryGetValue((int)_pakData.Value1, out list) == false)
                        {
                            list = new List<FairyLeagueBattleData>();
                            dic.Add((int)_pakData.Value1, list);
                        }
                        FairyLeagueBattleData battleData = new FairyLeagueBattleData()
                        {
                            grade = (int)_pakData.Value1,
                            ring = (int)_pakData.Value2 - 1,
                            fairyId1 = (int)_pakData.Value3,
                            fairyId2 = (int)_pakData.Value4,
                            winFairyId = (int)_pakData.Value5,
                            fairyName1 = _pakData.StrValue1,
                            fairyName2 = _pakData.StrValue2,
                            dissolveFairys = JsonMapper.ToObject<int[]>(_pakData.StrValue3),
                        };
                        list.Add(battleData);
                    }
                }
                if (onFairyLeagueBattleEvent != null)
                {
                    onFairyLeagueBattleEvent();
                }
                UpdateRedpoint();
                for (int i = 0; i < fairyStages.Length; i++)
                {
                    dataRequestDict[fairyStages[i]] = fairyStages[i] == fairyLeagueStage ? true : false;
                }
            }
        }
        public bool SelfFairyInBattle(out int _error)
        {
            _error = 3;
            var _ring = fairyLeagueRing;
            var _fairyId = PlayerDatas.Instance.fairyData.fairy.FamilyID;
            if (!fairyLeagueBattleDict.ContainsKey(_ring))
            {
                return false;
            }
            var _dict = fairyLeagueBattleDict[_ring];
            foreach (var _grade in _dict.Keys)
            {
                if (_dict[_grade] == null)
                {
                    continue;
                }
                foreach (var _fairyBattle in _dict[_grade])
                {
                    if (_fairyBattle.fairyId1 == _fairyId || _fairyBattle.fairyId2 == _fairyId)
                    {
                        var _battleFairyId = _fairyBattle.fairyId1 == _fairyId ? _fairyBattle.fairyId2 : _fairyBattle.fairyId1;
                        if (_battleFairyId == 0 || _fairyBattle.IsFairyDissolve(_battleFairyId))
                        {
                            _error = 4;
                            return false;
                        }
                        if (_fairyBattle.winFairyId != 0)
                        {
                            _error = 5;
                        }
                        return _fairyBattle.winFairyId == 0;
                    }
                }
            }
            return false;
        }

        public bool SatisfyEnterLeague(out int _error)
        {
            _error = 0;
            if (!PlayerDatas.Instance.fairyData.HasFairy)
            {
                _error = 1;
                return false;
            }
            if (fairyLeagueStage != FairyLeagueStage.Fight)
            {
                return false;
            }
            if (!SelfFairyInBattle(out _error))
            {
                return false;
            }
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.FairyLeague))
            {
                _error = 2;
                return false;
            }
            if (fairyLeagueFairyId != 0 && fairyLeagueFairyId != PlayerDatas.Instance.baseData.Family)
            {
                _error = 6;
                return false;
            }
            return true;
        }

        public void DisplayErrorTip(int _error)
        {
            switch (_error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("LeagueCannotGo5");
                    break;
                case 2:
                    FuncOpen.Instance.ProcessorFuncErrorTip((int)FuncOpenEnum.FairyLeague);
                    break;
                case 3:
                    SysNotifyMgr.Instance.ShowTip("LeagueCannotGo3");
                    break;
                case 4:
                    SysNotifyMgr.Instance.ShowTip("LeagueCannotGo4");
                    break;
                case 5:
                    var _ring = fairyLeagueRing;
                    _ring = fairyLeagueStage == FairyLeagueStage.Fight || fairyLeagueStage == FairyLeagueStage.Over ? 1 - _ring : _ring;
                    if (_ring == 1)
                    {
                        var _param = StringUtility.Contact(Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
                            fightTimes[1].startHour.ToString("D2"), ":", fightTimes[1].startMinute.ToString("D2"));
                        SysNotifyMgr.Instance.ShowTip("LeagueCannotGo1", _param);
                    }
                    else
                    {
                        var _param = StringUtility.Contact(Language.Get("Next"), Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
                            fightTimes[0].startHour.ToString("D2"), ":", fightTimes[0].startMinute.ToString("D2"));
                        SysNotifyMgr.Instance.ShowTip("LeagueCannotGo2", _param);
                    }
                    break;
                case 6:
                    SysNotifyMgr.Instance.ShowTip("PlayerWarFamilyIDIsChange");
                    break;
            }
        }

        private Dictionary<FairyLeagueStage, bool> dataRequestDict = new Dictionary<FairyLeagueStage, bool>();
        public void CheckFairyLeagueData()
        {
            //if (dataRequestDict.ContainsKey(fairyLeagueStage) && !dataRequestDict[fairyLeagueStage])
            //{
            CA001_tagViewUniversalGameRec _pak = new CA001_tagViewUniversalGameRec();
            _pak.ViewType = (byte)FAIRY_LEAGUE_BATTLE;
            GameNetSystem.Instance.SendInfo(_pak);
            //}
        }
        public List<FairyLeagueBattleData> GetFairyLeague(int _ring, int _grade)
        {
            Dictionary<int, List<FairyLeagueBattleData>> dic = null;
            List<FairyLeagueBattleData> list = null;
            fairyLeagueBattleDict.TryGetValue(_ring, out dic);
            if (dic != null)
            {
                dic.TryGetValue(_grade, out list);
            }
            return list;
        }
        public event Action UpdateFairyWarHelpEvent;
        public event Action UpdateWarBuffEvent;
        public event Action UpdateWarCrystalEvent;
        public event Action CrystalBelongChangeEvent;
        public FairyLeagueHelp fairyLeagueHelp
        {
            get;
            private set;
        }
        private const string FairyWarBuffHelpKey = "familyWar_Buff";
        private const string FairyWarCrystalAtkHelpKey = "familyWar_CrystalAtk";
        private const string FairyWarCrystalKey = "familyWar_Crystal";
        private const string FairyWarHelpInfoKey = "familyWar_HelpInfo";
        private const string FairyWarEnterHelpKey = "familyWar_Enter";
        public void UpdateFairyWarHelp(string _mission)
        {
            var _jsonData = JsonMapper.ToObject(_mission);
            foreach (var _key in _jsonData.Keys)
            {
                switch (_key)
                {
                    case FairyWarBuffHelpKey:
                        fairyLeagueHelp.fairyWarBuffs = JsonMapper.ToObject<FairyLeagueHelp.FairyWarBuff[]>(_jsonData[_key].ToJson());
                        if (UpdateWarBuffEvent != null)
                        {
                            UpdateWarBuffEvent();
                        }
                        break;
                    case FairyWarCrystalAtkHelpKey:
                        fairyLeagueHelp.FairyWarCrystalAtks = JsonMapper.ToObject<int[]>(_jsonData[_key].ToJson());
                        if (UpdateWarCrystalEvent != null)
                        {
                            UpdateWarCrystalEvent();
                        }
                        break;
                    case FairyWarCrystalKey:
                        fairyLeagueHelp.fairyWarCrystalDict.Clear();
                        var json = _jsonData[_key];
                        foreach (var _camp in json.Keys)
                        {
                            fairyLeagueHelp.fairyWarCrystalDict.Add(int.Parse(_camp), JsonMapper.ToObject<int[]>(json[_camp].ToJson()));
                        }
                        if (UpdateWarCrystalEvent != null)
                        {
                            UpdateWarCrystalEvent();
                        }
                        if (CrystalBelongChangeEvent != null)
                        {
                            CrystalBelongChangeEvent();
                        }
                        break;
                    case FairyWarHelpInfoKey:
                        fairyLeagueHelp.fairyWarHelpInfos =
                            JsonMapper.ToObject<FairyLeagueHelp.FairyWarHelpInfo[]>(_jsonData[_key].ToJson());
                        break;
                    case FairyWarEnterHelpKey:
                        fairyLeagueHelp.fairyWarEnter = JsonMapper.ToObject<FairyLeagueHelp.FairyWarEnter>(_jsonData[_key].ToJson());
                        break;
                }
            }
            if (UpdateFairyWarHelpEvent != null)
            {
                UpdateFairyWarHelpEvent();
            }
        }
        private void ClearFairyWarHelp()
        {
            fairyLeagueGroupId = 0;
            fairyLeagueTotalTime = 0;
            fairyLeagueWinFaction = 0;
            fairyLeagueHelp.fairyWarBuffs = null;
            fairyLeagueHelp.FairyWarCrystalAtks = null;
            fairyLeagueHelp.fairyWarCrystalDict.Clear();
            fairyLeagueHelp.fairyWarHelpInfos = null;
            fairyLeagueHelp.fairyWarEnter = default(FairyLeagueHelp.FairyWarEnter);
        }

        public FairyLeagueBattleData GetSelfBattleInfo()
        {
            var _ring = fairyLeagueRing;
            var _fairyId = PlayerDatas.Instance.fairyData.fairy.FamilyID;
            if (!fairyLeagueBattleDict.ContainsKey(_ring))
            {
                return null;
            }
            var _dict = fairyLeagueBattleDict[_ring];
            foreach (var _grade in _dict.Keys)
            {
                if (_dict[_grade] == null)
                {
                    continue;
                }
                foreach (var _fairyBattle in _dict[_grade])
                {
                    if (_fairyBattle.fairyId1 == _fairyId || _fairyBattle.fairyId2 == _fairyId)
                    {
                        return _fairyBattle;
                    }
                }
            }
            return null;
        }

        public bool StepRing(int _grade = 5)
        {
            if (fairyLeagueRing == 1)
            {
                if (!fairyLeagueBattleDict.ContainsKey(1))
                {
                    return true;
                }
                if (fairyLeagueBattleDict.ContainsKey(0) &&
                    fairyLeagueBattleDict[0].ContainsKey(_grade) && fairyLeagueBattleDict[0][_grade].Count == 1)
                {
                    return true;
                }
                else if (!fairyLeagueBattleDict[0].ContainsKey(_grade))
                {
                    return true;
                }
            }
            return false;
        }

        public string GetBattleFairyName(int _playerId)
        {
            var _fairy = PlayerDatas.Instance.fairyData.fairy;
            if (PlayerDatas.Instance.PlayerId == _playerId)
            {
                return _fairy == null ? string.Empty : _fairy.FamilyName;
            }
            else if (PlayerDatas.Instance.fairyData.GetMember(_playerId) != null)
            {
                return _fairy == null ? string.Empty : _fairy.FamilyName;
            }
            else
            {
                FairyLeagueBattleData _battle = GetSelfBattleInfo();
                return _battle.fairyId1 == _fairy.FamilyID ? _battle.fairyName2 : _battle.fairyName1;
            }
        }

        public FairyCampType GetBattleCampType(int _playerId)
        {
            if (_playerId == PlayerDatas.Instance.PlayerId ||
                PlayerDatas.Instance.fairyData.GetMember(_playerId) != null)
            {
                return (FairyCampType)PlayerDatas.Instance.baseData.faction;
            }
            return PlayerDatas.Instance.baseData.faction == 1 ? (FairyCampType)2 : (FairyCampType)1;
        }

        public string GetFairyFlagKey(int _playerId)
        {
            var _camp = GetBattleCampType(_playerId);
            return _camp == FairyCampType.Blue ? "FlagBlue" : "FlagRed";
        }

        public int GetBattleFirstPlayer()
        {
            if (fairyLeagueResults.Count == 0)
            {
                return -1;
            }
            for (int i = 0; i < fairyLeagueResults.Count; i++)
            {
                if (fairyLeagueResults[i].IsWin)
                {
                    return i;
                }
            }
            return 0;
        }
        #endregion
        #region 红点
        private Redpoint m_LeagueRedpoint = new Redpoint(107, 10704);
        public Redpoint m_JoinFairyLeagueRedpoint { get; private set; }
        public void UpdateRedpoint()
        {
            m_JoinFairyLeagueRedpoint.state = RedPointState.None;
            int _error = 0;
            if (!SatisfyEnterLeague(out _error))
            {
                return;
            }
            if (PlayerDatas.Instance.baseData.MapID == FAIRY_LEAGUE_DUNGEON)
            {
                return;
            }
            m_JoinFairyLeagueRedpoint.state = RedPointState.Simple;
        }
        #endregion
    }
    public struct WeekTime
    {
        public int dayOfWeek { get; private set; }
        public int startHour { get; private set; }
        public int startMinute { get; private set; }
        public int startSeconds { get; private set; }
        public int endHour { get; private set; }
        public int endMinute { get; private set; }

        public WeekTime(int _weekDay, int _startHour, int _startMinute, int _endHour, int _endMinute, int _startSeconds = 0)
        {
            dayOfWeek = _weekDay;
            startHour = _startHour;
            startMinute = _startMinute;
            startSeconds = _startSeconds;
            endHour = _endHour;
            endMinute = _endMinute;
        }
        public static TimeSpan operator -(WeekTime y, WeekTime x)
        {
            var _totalSeconds = 0;
            int i = x.dayOfWeek;
            for (i = x.dayOfWeek; i != y.dayOfWeek; i = i == 7 ? 1 : i + 1)
            {
                if (i == x.dayOfWeek)
                {
                    _totalSeconds += (23 - x.startHour) * 3600 + (59 - x.startMinute) * 60 + 60 - x.startSeconds;
                }
                else
                {
                    _totalSeconds += 24 * 3600;
                }
            }
            if (i == y.dayOfWeek)
            {
                if (x.dayOfWeek == i)
                {
                    var _timeSpany = new TimeSpan(y.startHour, y.startMinute, y.startSeconds);
                    var _timeSpanx = new TimeSpan(x.startHour, x.startMinute, x.startSeconds);
                    _totalSeconds += (int)(_timeSpany.TotalSeconds - _timeSpanx.TotalSeconds);
                }
                else
                {
                    _totalSeconds += y.startHour * 3600;
                }
            }
            return new TimeSpan(_totalSeconds * TimeSpan.TicksPerSecond);
        }

        private static WeekTime s_Now = new WeekTime();
        public static WeekTime Now
        {
            get
            {
                var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
                s_Now.dayOfWeek = _dayOfWeek;
                s_Now.startHour = TimeUtility.Hour;
                s_Now.startMinute = TimeUtility.Minute;
                s_Now.startSeconds = TimeUtility.Second;
                return s_Now;
            }
        }
    }
    public enum FairyLeagueStage
    {
        Prepare,
        Grouping,
        Fight,
        Over,
    }
    public enum FairyCampType
    {
        None,
        Red = 1,
        Blue = 2
    }
    public class FairyLeagueBattleData
    {
        public int grade;
        public int ring;
        public int fairyId1;
        public int fairyId2;
        public int winFairyId;
        public int[] dissolveFairys;
        public string fairyName1;
        public string fairyName2;

        public bool IsFairyDissolve(int _fairyId)
        {
            if (dissolveFairys == null || dissolveFairys.Length == 0)
            {
                return false;
            }
            for (int i = 0; i < dissolveFairys.Length; i++)
            {
                if (dissolveFairys[i] == _fairyId)
                {
                    return true;
                }
            }
            return false;
        }
        public bool IsFairyWin(int _fairyId)
        {
            return _fairyId == winFairyId;
        }
        public string GetWinFairyName()
        {
            return fairyId1 == winFairyId ? fairyName1 : fairyId2 == winFairyId ? fairyName2 : string.Empty;
        }
        public int GetWinFairyId()
        {
            return fairyId1 == winFairyId ? fairyId1 : fairyId2 == winFairyId ? fairyId2 : 0;
        }
        public string GetLoserFairyName()
        {
            return fairyId1 == winFairyId ? fairyName2 : fairyName1;
        }
        public int GetLoserFairyId()
        {
            return fairyId1 == winFairyId ? fairyId2 : fairyId1;
        }
    }
    public struct FairyLeagueResultData
    {
        public int PlayerId
        {
            get;
            private set;
        }
        public string PlayerName
        {
            get;
            private set;
        }
        public int TakeCrystals
        {
            get;
            private set;
        }
        public int KillNums
        {
            get;
            private set;
        }
        public int TakeBuffs
        {
            get;
            private set;
        }
        public int FightTime
        {
            get;
            private set;
        }
        public int Integral
        {
            get;
            private set;
        }
        public bool IsWin
        {
            get;
            private set;
        }
        public int Faction
        {
            get;
            private set;
        }

        public FairyLeagueResultData(int _playerId, string _playerName, int _crystal, int _killNum,
            int _buffs, int _fightTime, int _integral, bool _isWin, int _faction)
        {
            PlayerId = _playerId;
            PlayerName = _playerName;
            TakeCrystals = _crystal;
            KillNums = _killNum;
            TakeBuffs = _buffs;
            FightTime = _fightTime;
            Integral = _integral;
            IsWin = _isWin;
            Faction = _faction;
        }
    }
    public class FairyLeagueHelp
    {
        public FairyWarBuff[] fairyWarBuffs;
        public int[] FairyWarCrystalAtks;
        public Dictionary<int, int[]> fairyWarCrystalDict = new Dictionary<int, int[]>();
        public FairyWarHelpInfo[] fairyWarHelpInfos;
        public FairyWarEnter fairyWarEnter;

        public int GetCrystalBelongCamp(int _npcId)
        {
            foreach (var _camp in fairyWarCrystalDict.Keys)
            {
                if (fairyWarCrystalDict[_camp] == null)
                {
                    continue;
                }
                for (int i = 0; i < fairyWarCrystalDict[_camp].Length; i++)
                {
                    if (_npcId == fairyWarCrystalDict[_camp][i])
                    {
                        return _camp;
                    }
                }
            }
            return 0;
        }
        public struct FairyWarBuff
        {
            public int PosIndex;
            public int NPCID;
            public int Atk;
        }
        public struct FairyWarHelpInfo
        {
            public double ResPoint;
            public int MemCount;
            public int BuffResPoint;
            public int BuffResPointPer;
            public int BuffAttrLV;
        }
        public struct FairyWarEnter
        {
            public int[] WinCount;
            public int IsFinalMatch;
        }
    }

    public struct IntegralRankItem
    {
        public int id;
        public int count;
        public int bind;
        public int isPer;
    }

    [Serializable]
    public class AwardItemUI
    {
        [SerializeField] Image m_ItemIcon;
        [SerializeField] Image m_BindIcon;
        [SerializeField] Image m_ItemBg;
        [SerializeField] Text m_ItemCnt;

        public Text itemCnt { get { return m_ItemCnt; } }

        public void Init(int _itemId, int _itemCnt, int _isBind = 0)
        {
            ItemConfig _itemCfg = Config.Instance.Get<ItemConfig>(_itemId);
            m_ItemIcon.gameObject.SetActive(_itemCfg != null);
            if (_itemCfg != null)
            {
                m_ItemIcon.SetSprite(_itemCfg.IconKey);
                if (m_ItemBg != null)
                {
                    m_ItemBg.SetItemBackGround(_itemCfg.ItemColor);
                }
            }
            m_ItemCnt.text = _itemCnt <= 1 ? string.Empty : _itemCnt.ToString();
            if (m_BindIcon != null)
            {
                m_BindIcon.gameObject.SetActive(_isBind == 1);
            }
        }
    }
}