//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, September 16, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using System;

namespace Snxxz.UI
{

    public class DailyQuestModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize, IMapInitOk
    {

        const int DAILYQUEST_REDPOINTID = 78000;
        const int EVERYDAY_REDPOINTID = 78001;
        const int TIMELIMIT_REDPOINTID = 78002;
        const int ACTIVEVALUE_REDPOINT = 78004;
        const int REALMPOINT_REPOINT = 78005;
        const int DAILYQUEST_REDPOINTIDBASE = 78100;
        const int TRIALEXCHANGE_REDPOINTID = 78006;

        Redpoint dailyQuestRedpoint = new Redpoint(DAILYQUEST_REDPOINTID);
        public Redpoint everyDayRedpoint = new Redpoint(DAILYQUEST_REDPOINTID, EVERYDAY_REDPOINTID);
        public Redpoint timeLimitRedpoint = new Redpoint(DAILYQUEST_REDPOINTID, TIMELIMIT_REDPOINTID);
        Redpoint activeValueRedpoint = new Redpoint(EVERYDAY_REDPOINTID, ACTIVEVALUE_REDPOINT);
        Redpoint realmPointRedpoint = new Redpoint(EVERYDAY_REDPOINTID, REALMPOINT_REPOINT);
        public Redpoint trialExchangeRedpoint = new Redpoint(EVERYDAY_REDPOINTID, TRIALEXCHANGE_REDPOINTID);

        int m_DailyQuestTotalActiveValue = 150;
        public int dailyQuestTotalActiveValue {
            get { return m_DailyQuestTotalActiveValue; }
        }

        int m_CurrentDailyQuest = 0;
        public int currentDailyQuest {
            get { return this.m_CurrentDailyQuest; }
            set { this.m_CurrentDailyQuest = value; }
        }

        int m_CurrentRewardStageIndex = 0;
        public int currentRewardStageIndex {
            get { return m_CurrentRewardStageIndex; }
            private set { m_CurrentRewardStageIndex = value; }
        }

        int m_TotalActiveValue = 0;
        public int totalActiveValue {
            get { return m_TotalActiveValue; }
            private set {
                if (m_TotalActiveValue != value)
                {
                    m_TotalActiveValue = value;

                    if (totalActiveValueUpdateEvent != null)
                    {
                        totalActiveValueUpdateEvent();
                    }
                }
            }
        }

        int m_GotableRealmPoint;
        public int gotableRealmPoint {
            get { return m_GotableRealmPoint; }
            private set {
                if (m_GotableRealmPoint != value)
                {
                    m_GotableRealmPoint = value;
                    realmPointRedpoint.state = FuncOpen.Instance.IsFuncOpen(12) && m_GotableRealmPoint > 0 ? RedPointState.Simple : RedPointState.None;

                    if (realmPointUpdateEvent != null)
                    {
                        realmPointUpdateEvent();
                    }
                }

            }
        }

        Dictionary<int, DailyQuestData> dailyQuests = new Dictionary<int, DailyQuestData>();
        Dictionary<int, int> dungeonToDailyQuestTable = new Dictionary<int, int>();
        Dictionary<int, int> dailyActionToDailyQuestTable = new Dictionary<int, int>();
        List<DailyQuestActiveValueReward> dailyQuestActiveValueRewards = new List<DailyQuestActiveValueReward>();
        Dictionary<int, int> dailyQuestCompletedTimes = new Dictionary<int, int>();//除了副本的其他任务放在这里
        Dictionary<int, DailyQuestOpenTime> dailyQuestOpenTimes = new Dictionary<int, DailyQuestOpenTime>();
        Dictionary<int, Dictionary<int, List<int>>> questCalendar = new Dictionary<int, Dictionary<int, List<int>>>();

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        FairyLeagueModel fairyLeagueModel { get { return ModelCenter.Instance.GetModel<FairyLeagueModel>(); } }

        FairyModel fairyModel { get { return ModelCenter.Instance.GetModel<FairyModel>(); } }
        public event Action<int> activeValueRewardGotEvent;
        public event Action<int> dailyQuestProgressUpdateEvent;
        public event Action totalActiveValueUpdateEvent;
        public event Action realmPointUpdateEvent;

        public override void Init()
        {
            ParseConfig();
            var values = Config.Instance.GetAllValues<DailyLivenessRewardConfig>();
            for (int i = 0; i < values.Count; i++)
            {
                var config = values[i];
                dailyQuestActiveValueRewards.Add(new DailyQuestActiveValueReward(config.id));
            }

            UpdateRedpoints();

            fairyLeagueModel.onFairyLeagueBattleEvent += OnFairyLeagueBattle;
            dungeonModel.dungeonRecordChangeEvent += OnDungeonRecordChange;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
            PlayerDatas.Instance.PlayerDataRefreshEvent += OnPlayerDataRefresh;
            fairyModel.guardSkyCompleteEvent += GuardSkyCompleteEvent;
            PlayerDatas.Instance.fairyData.OnRefreshFairyInfo += OnRefreshFairyInfo;
            PlayerDatas.Instance.fairyData.OnRefreshFairyMine += OnRefreshFairyInfo;
        }

        public override void UnInit()
        {
            fairyLeagueModel.onFairyLeagueBattleEvent -= OnFairyLeagueBattle;
            dungeonModel.dungeonRecordChangeEvent -= OnDungeonRecordChange;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
            PlayerDatas.Instance.PlayerDataRefreshEvent -= OnPlayerDataRefresh;
            fairyModel.guardSkyCompleteEvent -= GuardSkyCompleteEvent;
            PlayerDatas.Instance.fairyData.OnRefreshFairyInfo -= OnRefreshFairyInfo;
            PlayerDatas.Instance.fairyData.OnRefreshFairyMine -= OnRefreshFairyInfo;
        }

        public void OnPlayerLoginOk()
        {
            DailyQuestActionTimer.Instance.Begin();
        }

        public void OnBeforePlayerDataInitialize()
        {
            totalActiveValue = 0;
            gotableRealmPoint = 0;
        }

        public void OnMapInitOk()
        {
            UpdateRedpoints();
        }

        public List<int> GetDailyQuests(DailyQuestCategory _category)
        {
            var quests = new List<int>();
            foreach (var key in dailyQuestOpenTimes.Keys)
            {
                var openTime = dailyQuestOpenTimes[key];
                switch (_category)
                {
                    case DailyQuestCategory.EveryDay:
                        if (openTime.always && ShouldShowOnDailyQuestWin(key))
                        {
                            quests.Add(key);
                        }
                        break;
                    case DailyQuestCategory.TimeLimit:
                        if (!openTime.always)
                        {
                            quests.Add(key);
                        }
                        break;
                }

            }

            switch (_category)
            {
                case DailyQuestCategory.EveryDay:
                    quests.Sort(EveryDayQuestCompare);
                    break;
                case DailyQuestCategory.TimeLimit:
                    quests.Sort(TimeLimitQuestCompare);
                    break;
            }

            return quests;
        }

        public bool TryGetDailyQuest(int _id, out DailyQuestData _data)
        {
            return dailyQuests.TryGetValue(_id, out _data);
        }

        public bool TryGetActiveValueRewardData(int _id, out DailyQuestActiveValueReward _data)
        {
            for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
            {
                if (dailyQuestActiveValueRewards[i].id == _id)
                {
                    _data = dailyQuestActiveValueRewards[i];
                    return true;
                }
            }

            _data = null;
            return false;
        }

        public bool IsDailyQuestUnLock(int _dailyQuestId)
        {
            var config = Config.Instance.Get<DailyQuestConfig>(_dailyQuestId);
            var unlockFunctionId = config.UnLockFuncID;
            var defaultUnlock = unlockFunctionId == 0 || FuncOpen.Instance.IsFuncOpen(unlockFunctionId);

            switch ((DailyQuestType)_dailyQuestId)
            {
                case DailyQuestType.FairyFeast:
                case DailyQuestType.FairyTask:
                case DailyQuestType.FairyGrabBoss:
                    return defaultUnlock && PlayerDatas.Instance.baseData.Family > 0;
                case DailyQuestType.RuneTowerSweep:
                    return ModelCenter.Instance.GetModel<RuneTowerModel>().yesterdayPassFloor > 0;
                case DailyQuestType.GuardSky:
                    return defaultUnlock && fairyModel.SatisfyGuardSkyFairyLv();
                case DailyQuestType.FairyLeague:
                    return defaultUnlock && fairyModel.SatisfyOpenFairyLeagueLv();
                default:
                    return defaultUnlock;
            }
        }

        public int GetDailyQuestActiveValue(int _dailyQuestId)
        {
            var times = GetDailyQuestCompletedTimes(_dailyQuestId);
            var config = Config.Instance.Get<DailyQuestConfig>(_dailyQuestId);

            if (config.OnceActivityTime <= 0)
            {
                return 0;
            }
            else
            {
                return times / config.OnceActivityTime * config.OnceActivity;
            }
        }

        public int GetDailyQuestTotalTimes(int _dailyQuestId)
        {
            var config = Config.Instance.Get<DailyQuestConfig>(_dailyQuestId);
            switch (config.RelatedType)
            {
                case 1:
                    var dailyQuestOpenTime = Config.Instance.Get<DailyQuestOpenTimeConfig>(config.RelatedID);
                    if (dailyQuestOpenTime != null)
                    {
                        switch (config.RelatedID)
                        {
                            case 11:
                                return Math.Max(dailyQuestOpenTime.DayTimes, GetDailyQuestCompletedTimes(_dailyQuestId));
                            case 16:
                                return ModelCenter.Instance.GetModel<VipModel>().GetVipPrivilegeCnt(VipPrivilegeType.BossHomeAwardLimit);
                            default:
                                return dailyQuestOpenTime.DayReKind > 0 ? dailyQuestOpenTime.DayTimes : dailyQuestOpenTime.WeekTimes;
                        }
                    }
                    else
                    {
                        return 0;
                    }
                case 2:
                    return dungeonModel.GetTotalTimes(config.RelatedID);
            }

            return 0;
        }

        public int GetDailyQuestCompletedTimes(int _dailyQuestId)
        {
            var config = Config.Instance.Get<DailyQuestConfig>(_dailyQuestId);
            switch (config.RelatedType)
            {
                case 1:
                    if (dailyQuestCompletedTimes.ContainsKey(config.RelatedID))
                    {
                        return dailyQuestCompletedTimes[config.RelatedID];
                    }
                    else
                    {
                        return 0;
                    }
                case 2:
                    DungeonRecord dungeonRecord;
                    if (dungeonModel.TryGetRecord(config.RelatedID, out dungeonRecord))
                    {
                        return dungeonRecord.enterTimes;
                    }
                    else
                    {
                        return 0;
                    }
            }

            return 0;
        }

        public int GetDailyQuestCompletedNums(int relatedID)
        {
            if (dailyQuestCompletedTimes.ContainsKey(relatedID))
            {
                return dailyQuestCompletedTimes[relatedID];
            }
            else
            {
                return 0;
            }
        }

        public int GetDungeonEnterNums(int relatedID)
        {
            DungeonRecord dungeonRecord;
            if (dungeonModel.TryGetRecord(relatedID, out dungeonRecord))
            {
                return dungeonRecord.enterTimes;
            }
            else
            {
                return 0;
            }
        }

        public int GetDailyQuestIdByDataMapId(int _dataMapId)
        {
            if (dungeonToDailyQuestTable.ContainsKey(_dataMapId))
            {
                return dungeonToDailyQuestTable[_dataMapId];
            }
            else
            {
                return 0;
            }
        }

        public void OnDailyQuestCompletedTimesUpdate(HA315_tagMCDailyActionCnt _serverInfo)
        {
            for (int i = 0; i < _serverInfo.Count; i++)
            {
                var dailyAction = _serverInfo.ActionInfo[i];
                if (dailyAction.DayFinishCnt > 0)
                {
                    dailyQuestCompletedTimes[(int)dailyAction.ActionID] = dailyAction.DayFinishCnt;
                }
                else
                {
                    dailyQuestCompletedTimes[(int)dailyAction.ActionID] = (int)dailyAction.WeekFinishCnt;
                }

                if (dailyActionToDailyQuestTable.ContainsKey((int)dailyAction.ActionID))
                {
                    var dailyQuestId = dailyActionToDailyQuestTable[(int)dailyAction.ActionID];
                    UpdateDailyActionRedpoint(dailyQuestId);
                }

                if (dailyQuestProgressUpdateEvent != null)
                {
                    dailyQuestProgressUpdateEvent((int)dailyAction.ActionID);
                }
            }
        }

        void OnDungeonRecordChange(int _dungeonId)
        {
            if (dungeonToDailyQuestTable.ContainsKey(_dungeonId))
            {
                var dailyQuestId = dungeonToDailyQuestTable[_dungeonId];
                UpdateDailyActionRedpoint(dailyQuestId);
            }
        }

        public void OnDailyQuestActiveValueInfoUpdate(HA333_tagMCDailyActivityInfoList _activeValueInfo)
        {
            totalActiveValue = (int)_activeValueInfo.CurValue;
            gotableRealmPoint = (int)_activeValueInfo.RealmPoint;

            currentRewardStageIndex = (int)_activeValueInfo.StageIndex;

            for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
            {
                var reward = dailyQuestActiveValueRewards[i];
                var oldGot = reward.got;
                dailyQuestActiveValueRewards[i].got = MathUtility.GetBitValue(_activeValueInfo.AwardRecord, (ushort)i);

                if (oldGot != reward.got)
                {
                    if (activeValueRewardGotEvent != null)
                    {
                        activeValueRewardGotEvent(reward.id);
                    }
                }
            }

            UpdateActiveValueRedpoint();
        }

        public void RequestGetActiveValueReward(int _id)
        {
            var index = 0;
            for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
            {
                if (dailyQuestActiveValueRewards[i].id == _id)
                {
                    index = i;
                    break;
                }
            }

            var sendInfo = new CA504_tagCMPlayerGetReward();
            sendInfo.RewardType = (int)GotServerRewardType.Def_RewardType_Activity;
            sendInfo.DataEx = (uint)index;
            sendInfo.DataExStrLen = 0;
            sendInfo.DataExStr = string.Empty;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public void RequestGetRealmPoint()
        {
            var sendInfo = new CA504_tagCMPlayerGetReward();
            sendInfo.RewardType = (int)GotServerRewardType.Def_RewardType_DayRealmPoint;
            sendInfo.DataExStrLen = 0;
            sendInfo.DataExStr = string.Empty;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public bool TryGetOpenTime(int _id, out DailyQuestOpenTime _openTime)
        {
            return dailyQuestOpenTimes.TryGetValue(_id, out _openTime);
        }

        public List<int> GetQuestByWeekTimeNode(int _week, int _timeNode)
        {
            var quests = new List<int>();
            foreach (var item in dailyQuestOpenTimes.Values)
            {
                if (item.ContainTimeNode(_week, _timeNode))
                {
                    quests.Add(item.id);
                }
            }

            return quests;
        }

        /// <summary>
        /// 时间 活动id列表
        /// </summary>
        /// <param name="_week"></param>
        /// <returns></returns>
        public Dictionary<int, List<int>> GetQuestByWeekTime(int _week)
        {
            var timeNodes = new Dictionary<int, List<int>>();
            foreach (var item in GeneralConfig.Instance.dailyQuestOpenTime)
            {
                timeNodes[item] = GetQuestByWeekTimeNode(_week, item);
            }

            return timeNodes;
        }

        private void OnFunctionStateChange(int _functionId)
        {
            if (_functionId == 78)
            {
                UpdateRedpoints();

                DailyQuestActionTimer.Instance.Begin();
            }
        }

        private void GuardSkyCompleteEvent()
        {
            UpdateDailyActionRedpoint((int)DailyQuestType.GuardSky);
        }

        private void OnRefreshFairyInfo()
        {
            UpdateDailyActionRedpoint((int)DailyQuestType.GuardSky);
            UpdateDailyActionRedpoint((int)DailyQuestType.FairyLeague);
        }

        private void OnPlayerDataRefresh(PlayerDataRefresh _refreshType, int _value)
        {
            switch (_refreshType)
            {
                case PlayerDataRefresh.LV:
                    if (_value == GeneralConfig.Instance.dailyQuestRedpointLevelLimit)
                    {
                        UpdateRedpoints();
                    }
                    break;
            }
        }

        private void OnFairyLeagueBattle()
        {
            UpdateDailyActionRedpoint((int)DailyQuestType.FairyLeague);
        }

        public Dictionary<int, DailyQuestData> GetDailyQuestlist()
        {
            return dailyQuests;
        }

        public void UpdateRedpoints()
        {
            foreach (var dailyQuest in dailyQuests.Values)
            {
                UpdateDailyActionRedpoint(dailyQuest.id);
            }
        }

        private void UpdateDailyActionRedpoint(int _questId)
        {
            if (!FuncOpen.Instance.IsFuncOpen(78))
            {
                return;
            }

            var dailyQuestState = GetQuestState(_questId);
            var dailyQuest = dailyQuests[_questId];

            if (dailyQuest.redpoint != null)
            {
                DailyQuestOpenTime openTime;
                if (TryGetOpenTime(_questId, out openTime))
                {
                    if (openTime.always)
                    {
                        switch ((DailyQuestType)_questId)
                        {
                            case DailyQuestType.FairyTask:
                            case DailyQuestType.BlastStove:
                            case DailyQuestType.Prayer:
                            case DailyQuestType.PersonalBoss:
                            case DailyQuestType.ElderGodArea:
                            case DailyQuestType.DungeonAssist:
                            case DailyQuestType.RuneTower:
                            case DailyQuestType.TreasureCollectSoul:
                                dailyQuest.redpoint.state = RedPointState.None;
                                break;
                            default:
                                if (PlayerDatas.Instance.baseData.LV <= GeneralConfig.Instance.dailyQuestRedpointLevelLimit
                                    && (dailyQuestState == DailyQuestState.CanBuyTimes || dailyQuestState == DailyQuestState.Normal))
                                {
                                    dailyQuest.redpoint.state = RedPointState.Simple;
                                }
                                else
                                {
                                    dailyQuest.redpoint.state = RedPointState.None;
                                }
                                break;
                        }
                    }
                    else
                    {
                        var dailyQuestConfig = Config.Instance.Get<DailyQuestConfig>(_questId);
                        var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
                        if (dailyQuestConfig.RelatedType == 2 && dataMapId == dailyQuestConfig.RelatedID)
                        {
                            dailyQuest.redpoint.state = RedPointState.None;
                        }
                        else
                        {
                            var completedTimes = GetDailyQuestCompletedTimes(dailyQuest.id);
                            var totalTimes = GetDailyQuestTotalTimes(dailyQuest.id);
                            switch ((DailyQuestType)_questId)
                            {
                                case DailyQuestType.HeavenBattle:
                                case DailyQuestType.FairyFeast:
                                    if (dailyQuestState == DailyQuestState.CanBuyTimes || (dailyQuestState == DailyQuestState.Normal && completedTimes < totalTimes))
                                    {
                                        dailyQuest.redpoint.state = RedPointState.Simple;
                                    }
                                    else
                                    {
                                        dailyQuest.redpoint.state = RedPointState.None;
                                    }
                                    break;
                                case DailyQuestType.FairyLeague:
                                    if (dailyQuestState == DailyQuestState.Normal)
                                    {
                                        var error = 0;
                                        dailyQuest.redpoint.state = fairyLeagueModel.SatisfyEnterLeague(out error) ? RedPointState.Simple : RedPointState.None;
                                    }
                                    else
                                    {
                                        dailyQuest.redpoint.state = RedPointState.None;
                                    }
                                    break;
                                case DailyQuestType.FairyGrabBoss:
                                    if (dailyQuestState == DailyQuestState.Normal)
                                    {
                                        dailyQuest.redpoint.state = completedTimes >= totalTimes ? RedPointState.None : RedPointState.Simple;
                                    }
                                    else
                                    {
                                        dailyQuest.redpoint.state = RedPointState.None;
                                    }
                                    break;
                                default:
                                    if (dailyQuestState == DailyQuestState.CanBuyTimes || dailyQuestState == DailyQuestState.Normal)
                                    {
                                        dailyQuest.redpoint.state = RedPointState.Simple;
                                    }
                                    else
                                    {
                                        dailyQuest.redpoint.state = RedPointState.None;
                                    }
                                    break;
                            }
                        }
                    }
                }
            }
        }

        private void UpdateActiveValueRedpoint()
        {
            var count = dailyQuestActiveValueRewards.Count;
            var anyAwardable = false;
            for (int i = 0; i < count; i++)
            {
                var reward = dailyQuestActiveValueRewards[i];
                if (!reward.got)
                {
                    var config = Config.Instance.Get<DailyLivenessRewardConfig>(reward.id);
                    if (totalActiveValue >= config.Liveness)
                    {
                        anyAwardable = true;
                        break;
                    }
                }
            }

            activeValueRedpoint.state = anyAwardable ? RedPointState.Simple : RedPointState.None;
        }

        private int EveryDayQuestCompare(int _lhs, int _rhs)
        {
            var state1 = GetQuestState(_lhs);
            var state2 = GetQuestState(_rhs);

            var config1 = Config.Instance.Get<DailyQuestConfig>(_lhs);
            var config2 = Config.Instance.Get<DailyQuestConfig>(_rhs);

            if (state1 == state2)
            {
                return config1.order < config2.order ? -1 : 1;
            }
            else
            {
                if (state1 == DailyQuestState.Completed)
                {
                    return 1;
                }
                else if (state2 == DailyQuestState.Completed)
                {
                    return -1;
                }
                else if (state1 == DailyQuestState.Locked)
                {
                    return 1;
                }
                else if (state2 == DailyQuestState.Locked)
                {
                    return -1;
                }
                else if (state1 == DailyQuestState.CanBuyTimes)
                {
                    return 1;
                }
                else if (state2 == DailyQuestState.CanBuyTimes)
                {
                    return -1;
                }
                else
                {
                    return config1.order < config2.order ? -1 : 1;
                }
            }

        }

        private int TimeLimitQuestCompare(int _lhs, int _rhs)
        {
            var unLock1 = IsDailyQuestUnLock(_lhs);
            var unLock2 = IsDailyQuestUnLock(_rhs);

            if (unLock1 && !unLock2)
            {
                return -1;
            }
            else if (!unLock1 && unLock2)
            {
                return 1;
            }
            else
            {
                DailyQuestOpenTime openTime1;
                TryGetOpenTime(_lhs, out openTime1);

                DailyQuestOpenTime openTime2;
                TryGetOpenTime(_rhs, out openTime2);

                var dayOfWeek = (int)TimeUtility.ServerNow.DayOfWeek;
                var isActiveDay1 = openTime1.always || openTime1.GetHourMinuteByWeek(dayOfWeek) != null;
                var isActiveDay2 = openTime2.always || openTime2.GetHourMinuteByWeek(dayOfWeek) != null;

                if (isActiveDay1 && !isActiveDay2)
                {
                    return -1;
                }
                else if (!isActiveDay1 && isActiveDay2)
                {
                    return 1;
                }
                else
                {
                    var inOpenTime1 = openTime1.InOpenTime();
                    var inOpenTime2 = openTime2.InOpenTime();

                    if (inOpenTime1 && !inOpenTime2)
                    {
                        return -1;
                    }
                    else if (!inOpenTime1 && inOpenTime2)
                    {
                        return 1;
                    }
                    else if (!inOpenTime1 && !inOpenTime2)
                    {
                        HourMinute hourMinute1;
                        var beforeOpenTime1 = openTime1.TryGetTodayNearestOpenTime(out hourMinute1);

                        HourMinute hourMinute2;
                        var beforeOpenTime2 = openTime2.TryGetTodayNearestOpenTime(out hourMinute2);

                        if (beforeOpenTime1 && !beforeOpenTime2)
                        {
                            return -1;
                        }
                        else if (!beforeOpenTime1 && beforeOpenTime2)
                        {
                            return 1;
                        }
                        else
                        {
                            return HourMinute.Compare(hourMinute1, hourMinute2);
                        }
                    }
                    else
                    {
                        return _lhs < _rhs ? -1 : 1;
                    }
                }
            }

        }

        private bool ShouldShowOnDailyQuestWin(int _dailyQuestId)
        {
            switch ((DailyQuestType)_dailyQuestId)
            {
                case DailyQuestType.BossHome:
                    return ModelCenter.Instance.GetModel<VipModel>().GetVipPrivilegeCnt(VipPrivilegeType.BossHomeAwardLimit) > 0;
                case DailyQuestType.PersonalBoss:
                    return ModelCenter.Instance.GetModel<DungeonModel>().GetTotalTimes(PersonalBossModel.PERSONALBOSS_MAPID) > 0;
                default:
                    return true;
            }
        }

        public DailyQuestState GetQuestState(int _dailyQuestId)
        {
            var isUnLocked = IsDailyQuestUnLock(_dailyQuestId);
            if (!isUnLocked)
            {
                return DailyQuestState.Locked;
            }

            DailyQuestOpenTime openTime;
            if (TryGetOpenTime(_dailyQuestId, out openTime))
            {
                var inOpenTime = openTime.InOpenTime();
                if (!inOpenTime)
                {
                    return DailyQuestState.OutTime;
                }
            }

            switch ((DailyQuestType)_dailyQuestId)
            {
                case DailyQuestType.HeavenBattle:
                case DailyQuestType.FairyFeast:
                case DailyQuestType.FairyLeague:
                case DailyQuestType.FairyGrabBoss:
                    return DailyQuestState.Normal;
                case DailyQuestType.GuardSky:
                    if (!fairyModel.completeGuardSky)
                    {
                        return DailyQuestState.Normal;
                    }
                    break;
            }

            var completedTimes = GetDailyQuestCompletedTimes(_dailyQuestId);
            var totalTimes = GetDailyQuestTotalTimes(_dailyQuestId);

            var config = Config.Instance.Get<DailyQuestConfig>(_dailyQuestId);
            if (completedTimes >= totalTimes)
            {
                switch (config.RelatedType)
                {
                    case 1:
                        switch (config.RelatedID)
                        {
                            case 11:
                                var dailyQuestOpenTime = Config.Instance.Get<DailyQuestOpenTimeConfig>(config.RelatedID);
                                if (completedTimes >= dailyQuestOpenTime.DayTimes + GeneralConfig.Instance.runeTowerSweepBuyTimes)
                                {
                                    return DailyQuestState.Completed;
                                }
                                else
                                {
                                    return DailyQuestState.CanBuyTimes;
                                }
                            default:
                                return DailyQuestState.Completed;
                        }
                    case 2:
                        DungeonRecord record;
                        dungeonModel.TryGetRecord(config.RelatedID, out record);
                        var buyTimes = record != null ? record.buyTimes : 0;
                        var buyTimesLimit = dungeonModel.GetBuyTimesLimit(config.RelatedID);
                        return buyTimes >= buyTimesLimit ? DailyQuestState.Completed : DailyQuestState.CanBuyTimes;
                }
            }

            return DailyQuestState.Normal;
        }

        public static string GetDailyQuestUnLockDescription(int _dailyQuestId)
        {
            var type = (DailyQuestType)_dailyQuestId;
            var dailyConfig = Config.Instance.Get<DailyQuestConfig>(_dailyQuestId);
            if (type == DailyQuestType.FairyFeast || type == DailyQuestType.FairyTask || type == DailyQuestType.FairyGrabBoss)
            {
                if (PlayerDatas.Instance.fairyData.HasFairy)
                {
                    return StringUtility.Contact(FuncOpen.Instance.GetLimitLv(dailyConfig.UnLockFuncID), Language.Get("Z1041"));
                }
                else
                {
                    return Language.Get("DailyQuestWin_Participate");
                }
            }

            var _fairyModel = ModelCenter.Instance.GetModel<FairyModel>();
            switch (type)
            {
                case DailyQuestType.GuardSky:
                    if (!PlayerDatas.Instance.fairyData.HasFairy)
                    {
                        return Language.Get("DailyQuestWin_Participate");
                    }
                    if (!_fairyModel.SatisfyGuardSkyFairyLv())
                    {
                        return Language.Get("DailyquestXMLevel", _fairyModel.guardSkyOpenFairyLv);
                    }
                    break;
                case DailyQuestType.FairyLeague:
                    if (!PlayerDatas.Instance.fairyData.HasFairy)
                    {
                        return Language.Get("DailyQuestWin_Participate");
                    }
                    if (!_fairyModel.SatisfyOpenFairyLeagueLv())
                    {
                        return Language.Get("DailyquestXMLevel", _fairyModel.fairyLeagueLimit);
                    }
                    break;
            }

            var description = string.Empty;
            var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
            var functionConfig = Config.Instance.Get<FuncOpenLVConfig>(dailyConfig.UnLockFuncID);

            if (functionConfig == null)
            {
                description = Language.Get("DailyQuest_NoLevelLimit");
            }
            else if (functionConfig.LimitMagicWeapon > 0)
            {
                Treasure treasure = null;
                if (treasureModel.TryGetTreasure(functionConfig.LimitMagicWeapon / 100, out treasure))
                {
                    var treasureConfig = Config.Instance.Get<TreasureConfig>(functionConfig.LimitMagicWeapon / 100);
                    description = Language.Get("DailyQuestwin1", treasureConfig.Name);
                }
            }
            else if (functionConfig.LimitLV > 0 && functionConfig.LimitMissionID > 0)
            {
                var config = Config.Instance.Get<PyTaskConfig>(functionConfig.LimitMissionID);
                var taskInfoConfig = Config.Instance.Get<TASKINFOConfig>(config.name);
                description = Language.Get("DailyQuestwin2", functionConfig.LimitLV);
            }
            else if (functionConfig.LimitMissionID > 0)
            {
                var config = Config.Instance.Get<PyTaskConfig>(functionConfig.LimitMissionID);
                var taskInfoConfig = Config.Instance.Get<TASKINFOConfig>(config.name);
                description = Language.Get("DailyQuestwin8");
            }
            else
            {
                description = StringUtility.Contact(functionConfig.LimitLV, Language.Get("Z1041"));
            }

            if (type == DailyQuestType.RuneTowerSweep && FuncOpen.Instance.IsFuncOpen(80))
            {
                var runeTowerModel = ModelCenter.Instance.GetModel<RuneTowerModel>();
                if (runeTowerModel.yesterdayPassFloor <= 0)
                {
                    var runeModel = ModelCenter.Instance.GetModel<RuneModel>();
                    if (runeModel.RuneTowerOpenLV > 0)
                    {
                        description = Language.Get("DailyQuestwin4");
                    }
                    else
                    {
                        description = Language.Get("DailyQuestwin3");
                    }
                }
            }

            return description;
        }

        private void ParseConfig()
        {
            var allConfigs = Config.Instance.GetAllValues<DailyQuestConfig>();

            var redpointIndex = 1;
            foreach (var config in allConfigs)
            {
                if (VersionConfig.Get().isBanShu && config.ID == 12)
                {
                    continue;
                }

                var openTime = default(DailyQuestOpenTime);
                var redpointParent = 0;
                switch (config.RelatedType)
                {
                    case 1:
                        var activityOpenTime = Config.Instance.Get<DailyQuestOpenTimeConfig>(config.RelatedID);
                        openTime = dailyQuestOpenTimes[config.ID] = new DailyQuestOpenTime(config.ID);
                        openTime.ParseQuestNormalOpenTime(activityOpenTime.OpenTime, activityOpenTime.Duration);
                        openTime.ParseQuestSpecificOpenTimes(DailyQuestSpecialOpenTimeConfig.GetDailyQuestTimes(config.RelatedID));
                        dailyActionToDailyQuestTable[config.RelatedID] = config.ID;
                        break;
                    case 2:
                        var dungeonOpenTimes = DungeonStateTimeConfig.DungeonStateCanEnterFB(config.RelatedID);
                        openTime = dailyQuestOpenTimes[config.ID] = new DailyQuestOpenTime(config.ID);
                        openTime.ParseDungeonNormalOpenTimes(dungeonOpenTimes);
                        openTime.ParseDungeonSpecificOpenTimes(DungeonSpecialStateTimeConfig.GetDungeonTimes(config.RelatedID));
                        dungeonToDailyQuestTable[config.RelatedID] = config.ID;
                        break;
                }

                redpointParent = openTime.always ? EVERYDAY_REDPOINTID : TIMELIMIT_REDPOINTID;
                dailyQuests[config.ID] = new DailyQuestData(config.ID, DAILYQUEST_REDPOINTIDBASE + redpointIndex++, redpointParent);
            }

        }

        public enum DailyQuestCategory
        {
            EveryDay = 1,
            TimeLimit = 2,
        }

        public enum DailyQuestState
        {
            Locked = 0,
            OutTime = 2,
            Normal = 3,
            CanBuyTimes = 5,
            Completed = 6,
        }
    }

}