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

using System;

namespace vnxbqy.UI
{
    
    public class DailyQuestModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize, IMapInitOk, IAfterPlayerDataInitialize
    {
        const int DAILYQUEST_REDPOINTID = 78000;
        const int EVERYDAY_REDPOINTID = 78001;
        const int TIMELIMIT_REDPOINTID = 78002;
        const int ACTIVEVALUE_REDPOINT = 78004;
        const int DAILYQUEST_REDPOINTIDBASE = 78100;
        const int TRIALEXCHANGE_REDPOINTID = 78006;
        const int LIVENESSREWARD_REDPOINTID = 78007;

        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);
        public Redpoint LivenessRewardRedPoint = new Redpoint(EVERYDAY_REDPOINTID, LIVENESSREWARD_REDPOINTID);

        PrayerModel modelPray { get { return ModelCenter.Instance.GetModel<PrayerModel>(); } }
        WorldBossModel worldBossModel { get { return ModelCenter.Instance.GetModel<WorldBossModel>(); } }
        private PackModel m_PackModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        VipModel vipModel { get { return ModelCenter.Instance.GetModel<VipModel>(); } }
        BuffModel buffModel { get { return ModelCenter.Instance.GetModel<BuffModel>(); } }

        CommonDungeonSelectModel commonDungeonSelectModel { get { return ModelCenter.Instance.GetModel<CommonDungeonSelectModel>(); } }

        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_WannaLookDailyQuest = 0;
        public int wannaLookDailyQuest {
            get { return this.m_WannaLookDailyQuest; }
            set { this.m_WannaLookDailyQuest = value; }
        }

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

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

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

        int useActivity = 0; //单次探索的活跃消耗

        // 可使用的活跃点
        int m_UsableActivePoint = 0;
        public int usableActivePoint {
            get { return m_UsableActivePoint; }
            private set {
                if (m_UsableActivePoint != value)
                {
                    m_UsableActivePoint = value;

                    if (usableActivePointUpdateEvent != null)
                    {
                        usableActivePointUpdateEvent();
                    }
                    if (useActivity > 0)
                        UpdateDailyActionRedpoint((int)DailyQuestType.ActivityPlace);
                }
            }
        }


        DailyQuestCategory m_Category;
        public DailyQuestCategory category {
            get {
                return m_Category;
            }
            set {
                if (m_Category != value)
                {
                    m_Category = value;
                    if (categoryChangeEvent != null)
                    {
                        categoryChangeEvent();
                    }
                }
            }
        }

        private List<int> m_HasShowDailyQuestList = new List<int>();

        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, DailyQuestTimes> dailyQuestTimes = new Dictionary<int, DailyQuestTimes>();//除了副本的其他任务放在这里
        Dictionary<int, DailyQuestOpenTime> dailyQuestOpenTimes = new Dictionary<int, DailyQuestOpenTime>();
        Dictionary<int, Dictionary<int, List<int>>> questCalendar = new Dictionary<int, Dictionary<int, List<int>>>();
        List<int> DailyQuestLVList = new List<int>();

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        FairyLeagueModel fairyLeagueModel { get { return ModelCenter.Instance.GetModel<FairyLeagueModel>(); } }
        FairyModel fairyModel { get { return ModelCenter.Instance.GetModel<FairyModel>(); } }
        AllianceBossModel allianceBossModel { get { return ModelCenter.Instance.GetModel<AllianceBossModel>(); } }
        TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
        MapModel mapModel { get { return ModelCenter.Instance.GetModel<MapModel>(); } }
        SkyTowerModel skyTowerModel { get { return ModelCenter.Instance.GetModel<SkyTowerModel>(); } }
        HazyRegionModel hazyRegionModel { get { return ModelCenter.Instance.GetModel<HazyRegionModel>(); } }
        PrayerModel prayerModel { get { return ModelCenter.Instance.GetModel<PrayerModel>(); } }
        FairyNewModel fairyNewModel { get { return ModelCenter.Instance.GetModel<FairyNewModel>(); } }
        FairyFeastModel fairyFeastModel { get { return ModelCenter.Instance.GetModel<FairyFeastModel>(); } }

        public event Action<int> activeValueRewardGotEvent;
        public event Action<int> dailyQuestProgressUpdateEvent;
        public event Action currentActiveValueUpdateEvent;
        public event Action usableActivePointUpdateEvent;
        public event Action categoryChangeEvent;
        public event Action newDailyQuestOpenEvent;

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

            dailyQuestActiveValueRewards.Sort((x, y) => { return x.id.CompareTo(y.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;
            allianceBossModel.allianceBossStateRefresh += AllianceBossStateRefresh;
            RedpointCenter.Instance.redpointValueChangeEvent += RedpointValueChangeEvent;
            TaskModel.Event_FairyAuTask += OnFairyTaskRefresh;

            //ActivityPlaceInfoEvent usableActivePointUpdateEvent
        }

        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;
            allianceBossModel.allianceBossStateRefresh -= AllianceBossStateRefresh;
            RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
            TaskModel.Event_FairyAuTask -= OnFairyTaskRefresh;
            m_HasShowDailyQuestList.Clear();
        }

        public void OnBeforePlayerDataInitialize()
        {
            currentActiveValue = 0;
            usableActivePoint = 0;
        }

        public void OnAfterPlayerDataInitialize()
        {
            m_HasShowDailyQuestList.Clear();
            var playerId = PlayerDatas.Instance.baseData.PlayerID;
            var localSavedArray = LocalSave.GetIntArray(StringUtility.Contact("DailyQuestNewFunctionShowList_", playerId));
            if (!localSavedArray.IsNullOrEmpty())
            {
                m_HasShowDailyQuestList.AddRange(localSavedArray);
            }
        }

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

        public void OnMapInitOk()
        {
            UpdateRedpoints();
        }

        public bool IsNewDailyQuest(int id)
        {
            if (category != DailyQuestCategory.EveryDay)
            {
                return false;
            }

            if (PlayerDatas.Instance.baseData.LV >= 90)
            {
                return false;
            }
            switch ((DailyQuestType) id)
            {
                case DailyQuestType.Prayer:
                case DailyQuestType.Auction:
                case DailyQuestType.KillMonster:
                case DailyQuestType.SkyTower:
                case DailyQuestType.ActivityPlace:
                case DailyQuestType.PersonalBoss:
                case DailyQuestType.WorldBoss:
                case DailyQuestType.BossHome:
                    return false;

            }
            if (!IsDailyQuestUnLock(id))
            {
                return false;
            }

            if (m_HasShowDailyQuestList.Contains(id))
            {
                return false;
            }

            return true;
        }

        public void AddHasShowNewDailyQuest(int id)
        {
            if (IsDailyQuestUnLock(id) && !m_HasShowDailyQuestList.Contains(id))
            {
                m_HasShowDailyQuestList.Add(id);
                var playerId = PlayerDatas.Instance.baseData.PlayerID;
                LocalSave.SetIntArray(StringUtility.Contact("DailyQuestNewFunctionShowList_", playerId), m_HasShowDailyQuestList.ToArray());
            }
        }

        private void RedpointValueChangeEvent(int id)
        {
            if (id == prayerModel.redpoint.id)
            {
                UpdateDailyActionRedpoint((int)DailyQuestType.Prayer);
            }

            if (id == hazyRegionModel.redpoint.id)
            {
                UpdateDailyActionRedpoint((int)DailyQuestType.HazyRegion);
            }

            if (id == skyTowerModel.redpoint03.id)
            {
                UpdateDailyActionRedpoint((int)DailyQuestType.SkyTower);
            }
            if (id == skyTowerModel.redpoint04.id)
            {
                UpdateDailyActionRedpoint((int)DailyQuestType.SkyTower);
            }
            if (id == fairyNewModel.sitRedpoint.id)
            {
                UpdateDailyActionRedpoint((int)DailyQuestType.default3);
            }
        }

        private void OnFairyTaskRefresh()
        {
            UpdateDailyActionRedpoint((int)DailyQuestType.FairyTask);
        }

        public List<int> GetDailyQuests()
        {
            var quests = new List<int>(dailyQuests.Keys);
            if (quests.Contains((int)DailyQuestType.SkyTower) && skyTowerModel.allPassed)
            {
                quests.Remove((int)DailyQuestType.SkyTower);
            }

            return quests;
        }

        public List<LivenessRewardData> GetLivenessRewardDatas()
        {
            List<LivenessRewardData> DataList = new List<LivenessRewardData>();
            List<LivenessRewardData>[] DataListAry = new List<LivenessRewardData>[3]
            {
                new List<LivenessRewardData>(),//可领取
                new List<LivenessRewardData>(),//未达成条件
                new List<LivenessRewardData>() //已领取
            };
            for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
            {
                var Reward = dailyQuestActiveValueRewards[i];
                LivenessRewardData Data = new LivenessRewardData();
                Data.config = DailyLivenessRewardConfig.Get(Reward.id);
                if (Data.config.Liveness > currentActiveValue)
                {
                    Data.state = 0;
                    DataListAry[1].Add(Data);
                }
                else
                {
                    if (Reward.got)
                    {
                        Data.state = 2;
                        DataListAry[2].Add(Data);
                    }
                    else
                    {
                        Data.state = 1;
                        DataListAry[0].Add(Data);
                    }

                }
            }
            foreach (var TempDataList in DataListAry)
            {
                foreach (var TempData in TempDataList)
                {
                    DataList.Add(TempData);
                }
            }
            return DataList;
        }

        public List<int> GetDailyQuests(DailyQuestCategory category, bool LimitLv = false)
        {
            var quests = new List<int>();
            var PlayerLV = PlayerDatas.Instance.baseData.LV;
            var NextLV = 0;
            if (PlayerLV >= DailyQuestLVList[DailyQuestLVList.Count - 1])
            {
                NextLV = PlayerLV;
            }
            else
            {
                for (int i = 0; i < DailyQuestLVList.Count; i++)
                {
                    if (DailyQuestLVList[i] > PlayerLV)
                    {
                        NextLV = DailyQuestLVList[i];
                        break;
                    }
                }
            }
            foreach (var key in dailyQuestOpenTimes.Keys)
            {
                //if (key == (int)DailyQuestType.SkyTower && skyTowerModel.allPassed)
                //{
                //    continue;
                //}
                if (key == (int)DailyQuestType.FairyChuanGong && TimeUtility.OpenDay >= fairyFeastModel.activeOpenday)
                {
                    continue;
                }

                if (key == (int)DailyQuestType.CrossServerBoss && !FuncOpen.Instance.IsFuncOpen(162))
                {
                    continue;
                }

                if (key == (int)DailyQuestType.CrossServerPk
                    && (TimeUtility.OpenDay < GeneralDefine.crossServerOneVsOneOpenDay
                    || !CrossServerOneVsOnePKSeason.Instance.InPkSeason(TimeUtility.ServerNow)))
                {
                    continue;
                }

                if (key == (int)DailyQuestType.default4
                    && (TimeUtility.OpenDay < GeneralDefine.crossServerBattleFieldOpenDay))
                {
                    continue;
                }

                var openTime = dailyQuestOpenTimes[key];
                switch (category)
                {
                    case DailyQuestCategory.EveryDay:
                        if (openTime.always && ShouldShowOnDailyQuestWin(key))
                        {
                            if (LimitLv)
                            {
                                if (GetDailyQuestLV(key) <= NextLV)
                                {
                                    quests.Add(key);
                                }
                            }
                            else
                            {
                                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 TryGetDailyQuestTimes(int _id, out DailyQuestTimes _dailyQuestTime)
        {
            _dailyQuestTime = default(DailyQuestTimes);
            var config = DailyQuestConfig.Get(_id);
            if (config != null && config.RelatedType == 1)
            {
                return dailyQuestTimes.TryGetValue(config.RelatedID, out _dailyQuestTime);
            }
            else
            {
                return false;
            }
        }

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

            switch ((DailyQuestType)_dailyQuestId)
            {
                case DailyQuestType.FairyFeast:
                case DailyQuestType.FairyGrabBoss:
                case DailyQuestType.AllianceBoss:
                    return defaultUnlock && PlayerDatas.Instance.baseData.FamilyId > 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 = DailyQuestConfig.Get(_dailyQuestId);

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

        /// <param name="includeVip">true包含当前VIP可增加次数，false则返回含购买的次数</param>
        public int GetDailyQuestTotalTimes(int _dailyQuestId, bool includeVip = true)
        {
            var config = DailyQuestConfig.Get(_dailyQuestId);
            switch (config.RelatedType)
            {
                case 1:
                    var dailyQuestOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
                    if (dailyQuestOpenTime != null)
                    {
                        switch (config.RelatedID)
                        {
                            case 11:
                                return Math.Max(dailyQuestOpenTime.DayTimes, GetDailyQuestCompletedTimes(_dailyQuestId));
                            case 9:
                                return worldBossModel.WorldBossMaxCount
                                    + m_PackModel.GetItemUsedTimesToday(1129) 
                                    + m_PackModel.GetItemUsedTimesToday(1128)
                                    + m_PackModel.GetItemUsedTimesToday(4680)*3;
                            default:
                                if (dailyQuestOpenTime.DayReKind > 0)
                                {
                                    if (dailyQuestTimes.ContainsKey(config.RelatedID))
                                        return dailyQuestOpenTime.DayTimes + dailyQuestTimes[config.RelatedID].dayBuyTimes + dailyQuestTimes[config.RelatedID].dayUseItemTimes;
                                    else
                                        return dailyQuestOpenTime.DayTimes;
                                }
                                else
                                {
                                    return dailyQuestOpenTime.WeekTimes;
                                }
                                return dailyQuestOpenTime.DayReKind > 0 ? dailyQuestOpenTime.DayTimes : dailyQuestOpenTime.WeekTimes;
                        }
                    }
                    else
                    {
                        return 0;
                    }
                case 2:
                    return dungeonModel.GetTotalTimes(config.RelatedID, includeVip);
            }

            return 0;
        }


        public int GetDailyQuestCompletedTimes(int _dailyQuestId)
        {
            var config = DailyQuestConfig.Get(_dailyQuestId);
            switch (config.RelatedType)
            {
                case 1:
                    if (dailyQuestTimes.ContainsKey(config.RelatedID))
                    {
                        return dailyQuestTimes[config.RelatedID].completeTimes;
                    }
                    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 (dailyQuestTimes.ContainsKey(relatedID))
            {
                return dailyQuestTimes[relatedID].completeTimes;
            }
            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)
                {
                    dailyQuestTimes[(int)dailyAction.ActionID] = new DailyQuestTimes()
                    {
                        completeTimes = dailyAction.DayFinishCnt,
                        dayBuyTimes = dailyAction.DayBuyTimes,
                        dayUseItemTimes = dailyAction.DayItemTimes,
                    };
                }
                else
                {
                    dailyQuestTimes[(int)dailyAction.ActionID] = new DailyQuestTimes()
                    {
                        completeTimes = (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);
            }
        }

        private bool IsGetNewLivenessReward(int OldValue, int NewValue)
        {
            foreach (var reward in dailyQuestActiveValueRewards)
            {
                if (reward.got)
                {
                    continue;
                }
                var RewardConfig = DailyLivenessRewardConfig.Get(reward.id);
                if (OldValue < RewardConfig.Liveness && NewValue >= RewardConfig.Liveness)
                {
                    return true;
                }
            }
            return false;
        }

        public void OnDailyQuestActiveValueInfoUpdate(HA333_tagMCDailyActivityInfoList _activeValueInfo)
        {
            int OldCurrentActiveValue = currentActiveValue;
            currentActiveValue = (int)_activeValueInfo.CurValue;
            currentRewardStageIndex = (int)_activeValueInfo.StageIndex;

            usableActivePoint = (int)_activeValueInfo.UsableActivePoint;

            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);
                    }
                }
            }
            if (IsGetNewLivenessReward(OldCurrentActiveValue, currentActiveValue))
            {
                LivenessRewardRedPoint.state = RedPointState.Simple;
            }
            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 GeneralDefine.dailyQuestOpenTime)
            {
                timeNodes[item] = GetQuestByWeekTimeNode(_week, item);
            }

            return timeNodes;
        }

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

                DailyQuestActionTimer.Instance.Begin();
            }
            else if (_functionId == 16)
            {
                UpdateDailyActionRedpoint((int)DailyQuestType.FairyTask);
            }
        }
        public void UpdateArenaRedPoint()
        {
            UpdateDailyActionRedpoint((int)DailyQuestType.ArenaPK);
        }
        private void GuardSkyCompleteEvent()
        {
            UpdateDailyActionRedpoint((int)DailyQuestType.GuardSky);
        }

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

        private void AllianceBossStateRefresh()
        {
            UpdateDailyActionRedpoint((int)DailyQuestType.AllianceBoss);
        }

        private void OnPlayerDataRefresh(PlayerDataType _refreshType)
        {
            switch (_refreshType)
            {
                case PlayerDataType.LV:
                    if (PlayerDatas.Instance.baseData.LV == GeneralDefine.dailyQuestRedpointLevelLimit)
                    {
                        UpdateRedpoints();
                    }
                    else if (PlayerDatas.Instance.baseData.LV > 50)
                        UpdateDailyActionRedpoint((int)DailyQuestType.SkyTower);
                    break;
                case PlayerDataType.Family:
                    UpdateDailyActionRedpoint((int)DailyQuestType.FairyTask);
                    break;
            }
        }

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

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

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

            var dailyQuest = dailyQuests[_questId];
            if (dailyQuest.redpoint == null)
            {
                return;
            }

            DailyQuestOpenTime openTime;
            if (!TryGetOpenTime(_questId, out openTime))
            {
                return;
            }

            var dailyQuestState = GetQuestState(_questId);
            if (openTime.always)
            {
                switch ((DailyQuestType)_questId)
                {
                    case DailyQuestType.FairyTask:
                        if (PlayerDatas.Instance.baseData.LV <= GeneralDefine.dailyQuestRedpointLevelLimit)
                        {
                            if (FuncOpen.Instance.IsFuncOpen(16)
                                && TaskAllocation.Instance.FairyAuAllNumber() < taskModel.FairyAuTaskCount_Day)
                            {
                                dailyQuest.redpoint.state = RedPointState.Simple;
                            }
                            else
                            {
                                dailyQuest.redpoint.state = RedPointState.None;
                            }
                        }
                        else
                        {
                            dailyQuest.redpoint.state = RedPointState.None;
                        }
                        break;
                    case DailyQuestType.Prayer:
                        if (PlayerDatas.Instance.baseData.LV <= GeneralDefine.dailyQuestRedpointLevelLimit)
                        {
                            var completedTimes = GetDailyQuestCompletedTimes(_questId);
                            var totalTimes = GetDailyQuestTotalTimes(_questId);
                            dailyQuest.redpoint.state = prayerModel.redpoint.state != RedPointState.None
                                && completedTimes < totalTimes ?
                                  RedPointState.Simple : RedPointState.None;
                        }
                        else
                        {
                            dailyQuest.redpoint.state = RedPointState.None;
                        }
                        break;
                    case DailyQuestType.BlastStove:
                    case DailyQuestType.PersonalBoss:
                    case DailyQuestType.ElderGodArea:
                    case DailyQuestType.RuneTower:
                    case DailyQuestType.TreasureCollectSoul:
                    case DailyQuestType.Auction:
                        dailyQuest.redpoint.state = RedPointState.None;
                        break;
                    case DailyQuestType.HazyRegion:
                        dailyQuest.redpoint.state = hazyRegionModel.redpoint.state;
                        break;
                    case DailyQuestType.ActivityPlace:
                        dailyQuest.redpoint.state = RedPointState.None;
                        if (FuncOpen.Instance.IsFuncOpen(186))
                        {
                            if (usableActivePoint > useActivity || ActivityPlaceInfo.RewardCount > 2
                                || (ActivityPlaceInfo.RewardCount > 0 && ActivityPlaceInfo.PlaceCount == 0))
                                dailyQuest.redpoint.state = RedPointState.Simple;
                            else
                                dailyQuest.redpoint.state = RedPointState.None;
                        }
                        break;
                    case DailyQuestType.SkyTower:
                        var state = RedPointState.None;
                        if (skyTowerModel.redpoint04.state != RedPointState.None)
                            state = skyTowerModel.redpoint04.state;
                        else if (skyTowerModel.redpoint03.state != RedPointState.None)
                            state = skyTowerModel.redpoint03.state;
                        else if (skyTowerModel.IsRecommendNextLevel())
                            state = RedPointState.Simple;

                        dailyQuest.redpoint.state = state;
                        break;
                    case DailyQuestType.DungeonAssist:
                        break;
                    case DailyQuestType.ArenaPK:
                        dailyQuest.redpoint.state = RedPointState.None;
                        var _funcOpenLv = FuncOpenLVConfig.Get((int)FuncOpenEnum.default6);
                        if (PlayerDatas.Instance.baseData.LV >= _funcOpenLv.LimitLV &&  !ArenaManager.isArenaOver)
                        {
                            dailyQuest.redpoint.state = RedPointState.Simple;
                        }
                        else
                        {
                            dailyQuest.redpoint.state = RedPointState.None;
                        }
                        break;
                    default:
                        if (PlayerDatas.Instance.baseData.LV <= GeneralDefine.dailyQuestRedpointLevelLimit
                            && dailyQuestState == DailyQuestState.Normal)
                        {
                            dailyQuest.redpoint.state = RedPointState.Simple;
                        }
                        else
                        {
                            dailyQuest.redpoint.state = RedPointState.None;
                        }
                        break;
                }
            }
            else
            {
                var dailyQuestConfig = DailyQuestConfig.Get(_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.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:
                        case DailyQuestType.AllianceBoss:
                        case DailyQuestType.RidingPetActivity:
                            if (dailyQuestState == DailyQuestState.Normal && !allianceBossModel.isActivityOver)
                            {
                                dailyQuest.redpoint.state = completedTimes >= totalTimes ? RedPointState.None : RedPointState.Simple;
                            }
                            else
                            {
                                dailyQuest.redpoint.state = RedPointState.None;
                            }
                            break;
                        case DailyQuestType.CrossServerPk:
                            if (CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch && FuncOpen.Instance.IsFuncOpen(157))
                            {
                                dailyQuest.redpoint.state = completedTimes >= totalTimes ? RedPointState.None : RedPointState.Simple;
                            }
                            else
                            {
                                dailyQuest.redpoint.state = RedPointState.None;
                            }
                            break;
                        case DailyQuestType.default4:
                            if(ILCrossServerModel.Instance.IsOpen())
                            {
                                dailyQuest.redpoint.state = completedTimes >= totalTimes ? RedPointState.None : RedPointState.Simple;
                            }
                            else
                            {
                                dailyQuest.redpoint.state = RedPointState.None;
                            }
                            break;
                        case DailyQuestType.FairyChuanGong:
                            if (dailyQuestState == DailyQuestState.Normal)
                            {
                                dailyQuest.redpoint.state = completedTimes >= totalTimes ? RedPointState.None : RedPointState.Simple;
                            }
                            else
                            {
                                dailyQuest.redpoint.state = RedPointState.None;
                            }
                            break;
                        case DailyQuestType.default3:
                            if (dailyQuestState == DailyQuestState.Normal)
                            {
                                dailyQuest.redpoint.state = fairyNewModel.sitRedpoint.state;
                            }
                            else
                            {
                                dailyQuest.redpoint.state = RedPointState.None;
                            }

                            break;
                        default:
                            if (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 = DailyLivenessRewardConfig.Get(reward.id);
                    if (currentActiveValue >= 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 = DailyQuestConfig.Get(_lhs);
            var config2 = DailyQuestConfig.Get(_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)
                    {
                        var serverHour = TimeUtility.ServerNow.Hour;
                        var serverMinute = TimeUtility.ServerNow.Minute;

                        HourMinute hourMinute1;
                        var miss1 = openTime1.TryGetTodayNearestOpenTime(out hourMinute1) && hourMinute1.AfterOpenTime(serverHour, serverMinute);
                        HourMinute hourMinute2;
                        var miss2 = openTime2.TryGetTodayNearestOpenTime(out hourMinute2) && hourMinute2.AfterOpenTime(serverHour, serverMinute);

                        if (!miss1 && miss2)
                        {
                            return -1;
                        }
                        else if (miss1 && !miss2)
                        {
                            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:
                    var bossHomeModel = ModelCenter.Instance.GetModel<BossHomeModel>();
                    var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
                    return vipLevel >= bossHomeModel.GetFloorVipRequirement(1);
                case DailyQuestType.PersonalBoss:
                    return ModelCenter.Instance.GetModel<DungeonModel>().GetTotalTimes(PersonalBossModel.PERSONALBOSS_MAPID) > 0;
                case DailyQuestType.FairyChuanGong:
                    if (TimeUtility.OpenDay > 6)
                        return false;
                    return true;
                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:
                case DailyQuestType.AncientBattleGround:
                case DailyQuestType.RidingPetActivity:
                    return DailyQuestState.Normal;
                case DailyQuestType.GuardSky:
                    if (!fairyModel.completeGuardSky)
                    {
                        return DailyQuestState.Normal;
                    }
                    break;
                case DailyQuestType.AllianceBoss:
                    return DailyQuestState.Normal;

                case DailyQuestType.Prayer:
                    if (modelPray.GetAllCoinPrayCnt() == modelPray.coinPrayerCnt && modelPray.GetAllExpPrayCnt() == modelPray.expPrayerCnt)
                    {
                        return DailyQuestState.Completed;
                    }
                    break;
                case DailyQuestType.default3:
                    if (fairyNewModel.sitRound == fairyNewModel.sitMaxRound)
                    {
                        return DailyQuestState.Completed;
                    }
                    break;
                }

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

            var config = DailyQuestConfig.Get(_dailyQuestId);
            if (completedTimes >= totalTimes)
            {
                switch (config.RelatedType)
                {
                    case 1:
                        var dailyQuestOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
                        switch (config.RelatedID)
                        {
                            case 11:
                                {
                                    if (completedTimes >= dailyQuestOpenTime.DayTimes + GeneralDefine.runeTowerSweepBuyTimes)
                                    {
                                        return DailyQuestState.Completed;
                                    }
                                    else
                                    {
                                        return DailyQuestState.CanBuyTimes;
                                    }
                                }
                            case 25:
                                {
                                    if (!hazyRegionModel.IsAllIncidentComplete())
                                    {
                                        //还有未寻访的小事件
                                        return DailyQuestState.Normal;
                                    }
                                    else
                                    {
                                        return DailyQuestState.CanBuyTimes;
                                    }
                                }
                            case 19:
                            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 = DailyQuestConfig.Get(_dailyQuestId);
            if (type == DailyQuestType.FairyFeast || type == DailyQuestType.FairyGrabBoss)
            {
                if (PlayerDatas.Instance.fairyData.HasFairy)
                {
                    var config = FuncOpenLVConfig.Get(dailyConfig.UnLockFuncID);
                    if (config.LimitMissionID > 0)
                    {
                        var taskConfig = PyTaskConfig.Get(config.LimitMissionID);
                        return Language.Get("DailyQuestwin2", taskConfig.lv);
                    }
                    else
                    {
                        return Language.Get("LoadIconLV", FuncOpen.Instance.GetLimitLv(dailyConfig.UnLockFuncID));
                    }
                }
                else
                {
                    return Language.Get("DailyQuestWin_Participate");
                }
            }

            var _fairyModel = ModelCenter.Instance.GetModel<FairyModel>();
            switch (type)
            {
                case DailyQuestType.AllianceBoss:
                    if (!PlayerDatas.Instance.fairyData.HasFairy)
                    {
                        return Language.Get("DailyQuestWin_Participate");
                    }
                    break;
                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 = FuncOpenLVConfig.Get(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 = TreasureConfig.Get(functionConfig.LimitMagicWeapon / 100);
                    description = Language.Get("DailyQuestwin1", treasureConfig.Name);
                }
            }
            else if (functionConfig.LimitMissionID > 0)
            {
                var config = PyTaskConfig.Get(functionConfig.LimitMissionID);
                description = Language.Get("DailyQuestwin2", config.lv);
            }
            else
            {
                description = Language.Get("LoadIconLV", functionConfig.LimitLV);
            }

            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.passRuneTowerFloor > 0)
                    {
                        description = Language.Get("DailyQuestwin4");
                    }
                    else
                    {
                        description = Language.Get("DailyQuestwin3");
                    }
                }
            }

            return description;
        }
        //通过日常任务表->日常活动表-》界面索引表
        void SetURLJump(int id)
        {
            var currentMapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
            if (currentMapConfig.MapFBType != 0)
            {
                SysNotifyMgr.Instance.ShowTip("DungeonNoGO");
                return;
            }
            var config = DailyQuestConfig.Get(id);
            var TimeConfig = DailyQuestOpenTimeConfig.Get(config.RelatedID);
            WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)TimeConfig.OpenUI);
        }

        
        public void GotoDailyQuest(int _id)
        {
            switch ((DailyQuestType)_id)
            {
                case DailyQuestType.default2:
                    //情缘副本
                    WindowCenter.Instance.Open("WeddingWin", false, 2);
                    break;
                case DailyQuestType.ArenaPK:
                    //WindowCenter.Instance.Open("ArenaWin");
                    SetURLJump(_id);
                    break;
                case DailyQuestType.FairyLand:
                    GotoNormalDungeon(_id);
                    break;
                case DailyQuestType.IceCrystal:
                    WindowCenter.Instance.Open<IceCrystalVeinWin>();
                    break;
                case DailyQuestType.GuardSky:
                    var _fairyModel = ModelCenter.Instance.GetModel<FairyModel>();
                    if (!_fairyModel.SatisfyGuardSkyFairyLv())
                    {
                        SysNotifyMgr.Instance.ShowTip("GuardSkyOpenLvError", _fairyModel.guardSkyOpenFairyLv);
                        break;
                    }
                    if (_fairyModel.completeGuardSky)
                    {
                        SysNotifyMgr.Instance.ShowTip("TheEmperor1");
                        break;
                    }
                    GotoNormalDungeon(_id);
                    break;
                case DailyQuestType.Kirin:
                    GotoMultipleDifficultyDungeon(_id);
                    break;
                case DailyQuestType.BountyMission:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.BountyInterface);
                    break;
                case DailyQuestType.Demon:
                    GotoChaosDemon(_id);
                    break;
                case DailyQuestType.Trial:
                    GotoTrial();
                    break;
                case DailyQuestType.default5:
                case DailyQuestType.default6:
                case DailyQuestType.default7:
                case DailyQuestType.default8:
                case DailyQuestType.default9:
                    GotoCommonTrial(_id);
                    break;
                case DailyQuestType.BlastStove:
                    GotoBlastStove();
                    break;
                case DailyQuestType.AncientBattleGround:
                    GotoNormalDungeon(_id, dungeonModel.GetBelongToLine(_id));
                    break;
                case DailyQuestType.EmperorRelic:
                    GotoNuwa();
                    break;
                case DailyQuestType.WyTaiChi:
                    GotoTaiChiDungeon(_id);
                    break;
                case DailyQuestType.HeavenBattle:
                    GotoHeavenBattleDungeon(_id);
                    break;
                case DailyQuestType.Prayer:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<WelfareWin>(false, 1);
                    WindowCenter.Instance.Close<MainInterfaceWin>();
                    break;
                case DailyQuestType.WorldBoss:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 1);
                    break;
                case DailyQuestType.DemonJar:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 0);
                    break;
                case DailyQuestType.FairyTask:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.UnionTask);
                    break;
                case DailyQuestType.FairyLeague:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<UnionPanel>(false, 4);
                    break;
                case DailyQuestType.FairyFeast:
                    dungeonModel.SingleChallenge(31230);
                    break;
                case DailyQuestType.RuneTowerSweep:
                    RuneTowerWin.guideSweep = true;
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<TowerWin>(false, 1);
                    break;
                case DailyQuestType.BossHome:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 2);
                    break;
                case DailyQuestType.PersonalBoss:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 3);
                    break;
                case DailyQuestType.ElderGodArea:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 4);
                    break;
                case DailyQuestType.RuneTower:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<TowerWin>(false, 1);
                    break;
                case DailyQuestType.TreasureCollectSoul:
                    GotoTreasureCollectSoul();
                    break;
                case DailyQuestType.DungeonAssist:
                    WindowCenter.Instance.Open<DungeonAssistWin>();
                    break;
                case DailyQuestType.FairyGrabBoss:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 1);
                    break;
                case DailyQuestType.KillMonster:
                    var point = mapModel.GetRecommendHangPoint();
                    var mapEventConfig = MapEventPointConfig.Get(point);
                    mapModel.wannaLookLocalMap = mapEventConfig.DataMapID;
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<LocalMapWin>();
                    break;
                case DailyQuestType.GatherSoulDungeon:
                    GotoNormalDungeon(_id, 0);
                    break;
                case DailyQuestType.CrossServerPk:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<CrossServerWin>(false, 0);
                    break;
                case DailyQuestType.default4:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<CrossServerWin>(false, 3);
                    break;
                case DailyQuestType.AllianceBoss:
                    GotoAllianceBoss(_id, 0);
                    break;
                case DailyQuestType.RidingPetActivity:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 1);
                    break;
                case DailyQuestType.HazyRegion:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<HazyRegionFrameWin>();
                    break;
                case DailyQuestType.ActivityPlace:
                    WindowCenter.Instance.Open<ActivityPlaceWin>();
                    break;
                case DailyQuestType.SkyTower:
                    GotoSkyTower();
                    break;
                case DailyQuestType.Auction:
                    GotoAuction();
                    break;
                case DailyQuestType.JadeDynastyBoss:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 5);
                    break;
                case DailyQuestType.CrossServerBoss:
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    WindowCenter.Instance.Open<CrossServerWin>(false, 1);
                    break;
                default:
                    SetURLJump(_id);
                    break;
            }

            WindowJumpMgr.Instance.ClearJumpData();
        }

        private void GotoTaiChiDungeon(int _dailyQuestId, int _lineId = 0)
        {
            if (VersionConfig.Get().isBanShu)
            {
                return;
            }

            var config = DailyQuestConfig.Get(_dailyQuestId);
            currentDailyQuest = config.ID;
            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, _lineId);
            WindowCenter.Instance.Open<TaiChilDungeonEntranceWin>();
        }

        private void GotoHeavenBattleDungeon(int _dailyQuestId, int _lineId = 0)
        {
            var config = DailyQuestConfig.Get(_dailyQuestId);
            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, _lineId);
            WindowCenter.Instance.Open<HeavenBattleWin>();
        }

        private void GotoNormalDungeon(int _dailyQuestId, int _lineId = 0)
        {
            var config = DailyQuestConfig.Get(_dailyQuestId);
            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, _lineId);
            WindowCenter.Instance.Open<NormalDungeonEntranceWin>();
        }

        private void GotoMultipleDifficultyDungeon(int _dailyQuestId)
        {
            var config = DailyQuestConfig.Get(_dailyQuestId);
            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
            dungeonModel.selectedKylinDungeon = default(Dungeon);
            WindowCenter.Instance.Open<MultipleDifficultyDungeonWin>();
        }

        private void GotoChaosDemon(int _dailyQuestId)
        {
            var completedTimes = GetDailyQuestCompletedTimes(_dailyQuestId);
            var totalTimes = GetDailyQuestTotalTimes(_dailyQuestId);
            if (completedTimes >= totalTimes)
            {
                if (DayRemind.Instance.GetDayRemind(DayRemind.DUNGEON_DEMON_TIP))
                {
                    GotoNormalDungeon(_dailyQuestId);
                }
                else
                {
                    ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("TodayDungeonComplete"), Language.Get("TodayNoNotify"), (bool isOk, bool isToggle) =>
                    {
                        if (isOk)
                        {
                            GotoNormalDungeon(_dailyQuestId);
                        }
                        if (isToggle)
                        {
                            DayRemind.Instance.SetDayRemind(DayRemind.DUNGEON_DEMON_TIP, true);
                        }
                    });
                }
                return;
            }

            GotoNormalDungeon(_dailyQuestId);
        }

        private void GotoNuwa()
        {
            var id = (int)DailyQuestType.EmperorRelic;
            var completedTimes = GetDailyQuestCompletedTimes(id);
            var totalTimes = GetDailyQuestTotalTimes(id);
            if (completedTimes >= totalTimes)
            {
                if (DayRemind.Instance.GetDayRemind(DayRemind.DUNGEON_RELIC_TIP))
                {
                    GotoNormalDungeon(id);
                }
                else
                {
                    ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("TodayDungeonComplete"), Language.Get("TodayNoNotify"), (bool isOk, bool isToggle) =>
                    {
                        if (isOk)
                        {
                            GotoNormalDungeon(id);
                        }
                        if (isToggle)
                        {
                            DayRemind.Instance.SetDayRemind(DayRemind.DUNGEON_RELIC_TIP, true);
                        }
                    });
                }
                return;
            }
            GotoNormalDungeon(id);
        }

        private void GotoTrial()
        {
            var id = (int)DailyQuestType.Trial;
            var config = DailyQuestConfig.Get(id);

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

            if (completedTimes >= totalTimes)
            {
                if (DayRemind.Instance.GetDayRemind(DayRemind.DUNGEON_TRIAL_TIP))
                {
                    WindowCenter.Instance.Close<DailyQuestWin>();
                    dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
                    WindowCenter.Instance.Open<TrialDungeonSelectWin>();
                }
                else
                {
                    ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("TodayTrialComplete"), Language.Get("TodayNoNotify"), (bool isOk, bool isToggle) =>
                    {
                        if (isOk)
                        {
                            WindowCenter.Instance.Close<DailyQuestWin>();
                            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
                            WindowCenter.Instance.Open<TrialDungeonSelectWin>();
                        }
                        if (isToggle)
                        {
                            DayRemind.Instance.SetDayRemind(DayRemind.DUNGEON_TRIAL_TIP, true);
                        }
                    });
                }
                return;
            }

            WindowCenter.Instance.Close<DailyQuestWin>();
            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
            WindowCenter.Instance.Open<TrialDungeonSelectWin>();
        }

        //通用的材料副本
        private void GotoCommonTrial(int id)
        {
            var config = DailyQuestConfig.Get(id);

            commonDungeonSelectModel.selectDailyQuestType = id;
            WindowCenter.Instance.Close<DailyQuestWin>();
            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
            WindowCenter.Instance.Open<CommonDungeonSelectWin>();
        }

        private void GotoBlastStove()
        {
            WindowCenter.Instance.Close<DailyQuestWin>();
            WindowCenter.Instance.Open<AlchemyBaseWin>();
        }

        private void GotoBountyMission()
        {
            var inDungeon = MapUtility.IsDungeon(PlayerDatas.Instance.baseData.MapID);
            if (inDungeon)
            {
                SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
            }
            else
            {
                taskModel.DailyBountyMove();
                WindowCenter.Instance.Close<DailyQuestWin>();
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
        }

        private void GotoAllianceBoss(int id, int lineId)
        {
            WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 3);
        }

        private void GotoTreasureCollectSoul()
        {
            var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
            var treasures = treasureModel.GetTreasureCategory(TreasureCategory.Human);
            var gotoTreasureId = 0;
            for (int i = treasures.Count - 1; i >= 0; i--)
            {
                if (IsTreasureCollectSoul(treasures[i]))
                {
                    gotoTreasureId = treasures[i];
                    break;
                }
            }

            if (gotoTreasureId == 0)
            {
                for (int i = 0; i < treasures.Count; i++)
                {
                    Treasure treasure;
                    if (treasureModel.TryGetTreasure(treasures[i], out treasure))
                    {
                        if (treasure != null
                            && (treasure.state == TreasureState.Locked || treasure.state == TreasureState.Collecting))
                        {
                            gotoTreasureId = treasure.id;
                            break;
                        }
                    }
                }
            }

            WindowCenter.Instance.Close<DailyQuestWin>();

            if (gotoTreasureId == 0)
            {
                treasureModel.currentCategory = TreasureCategory.Human;
                WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.TreasureFunc1);
            }
        }

        private void GotoSkyTower()
        {
            WindowCenter.Instance.Close<DailyQuestWin>();
            WindowCenter.Instance.Open<TowerWin>(false, 0);
        }

        private void GotoAuction()
        {
            WindowCenter.Instance.Close<DailyQuestWin>();
            WindowCenter.Instance.Open<AuctionHouseWin>(false, 0);
        }

        private bool IsTreasureCollectSoul(int _treasureId)
        {
            return false;
        }

        public int GetDailyQuestLV(int id)
        {
            var QuestConfig = DailyQuestConfig.Get(id);
            var LVConfig = FuncOpenLVConfig.Get(QuestConfig.UnLockFuncID);
            int NeedLV = 0;
            if (LVConfig.LimitLV != 0)
            {
                NeedLV = LVConfig.LimitLV;
            }
            else
            {
                if (LVConfig.LimitMissionID != 0)
                {
                    var TaskConfig = PyTaskConfig.Get(LVConfig.LimitMissionID);
                    NeedLV = TaskConfig == null ? NeedLV : TaskConfig.lv;
                }
            }
            return NeedLV;
        }

        private void ParseConfig()
        {
            var allConfigs = DailyQuestConfig.GetValues();
            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 NeedLV = GetDailyQuestLV(config.ID);
                        if (!DailyQuestLVList.Contains(NeedLV))
                        {
                            bool bIsAdd = false;
                            for (int i = 0; i < DailyQuestLVList.Count; i++)
                            {
                                if (NeedLV < DailyQuestLVList[i])
                                {
                                    DailyQuestLVList.Insert(i, NeedLV);
                                    bIsAdd = true;
                                    break;
                                }
                            }
                            if (!bIsAdd)
                            {
                                DailyQuestLVList.Add(NeedLV);
                            }

                        }

                        var activityOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
                        openTime = dailyQuestOpenTimes[config.ID] = new DailyQuestOpenTime(config.ID);
                        openTime.ParseQuestNormalOpenTime(activityOpenTime);
                        openTime.ParseQuestSpecialOpenTimes(DailyQuestSpecialOpenTimeConfig.GetDailyQuestTimes(config.RelatedID));
                        openTime.ParseQuestMixServerOpenTime(DailyQuestMixServerStateTimeConfig.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.ParseDungeonSpecialOpenTimes(DungeonSpecialStateTimeConfig.GetDungeonTimes(config.RelatedID));
                        openTime.ParseDungeonMixServerOpenTimes(DungeonMixServerStateTimeConfig.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);
            }

            var allRewardKeys = DailyLivenessRewardConfig.GetKeys();
            m_DailyQuestTotalActiveValue = DailyLivenessRewardConfig.Get(allRewardKeys[allRewardKeys.Count - 1]).Liveness;

            useActivity = int.Parse(FuncConfigConfig.Get("ActivityPlace").Numerical2); //单次消耗活跃点
        }

        public enum DailyQuestCategory
        {
            EveryDay = 1,
            TimeLimit = 2,
            //后续IL开发添加预设
            default1,
            default2,
            default3,
            default4,
            default5,

        }

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

        BuffModel m_BuffModel;
        BuffModel BuffModel
        {
            get
            {
                return m_BuffModel ?? (m_BuffModel = ModelCenter.Instance.GetModel<BuffModel>());
            }
        }

        public HB027_tagMCActivityPlaceInfo ActivityPlaceInfo = new HB027_tagMCActivityPlaceInfo();
        public event Action ActivityPlaceInfoEvent;
        public void OnActivityPlaceInfo(HB027_tagMCActivityPlaceInfo pack)
        {
            ActivityPlaceInfo = pack;
            UpdateDailyActionRedpoint((int)DailyQuestType.ActivityPlace);
            if (ActivityPlaceInfoEvent != null)
                ActivityPlaceInfoEvent();

            if (pack.PlaceCount != 0)
            {
                H0605_tagObjAddBuff _h0605 = new H0605_tagObjAddBuff()
                {
                    ObjType = (byte)GameObjType.gotPlayer,
                    ObjID = PlayerDatas.Instance.PlayerId,
                    BuffType = (int)E_BuffType.bfBuff,
                    SkillID = 22218,
                    LastTime = 0,

                };

                if (!buffModel._BuffDic.ContainsKey(_h0605.SkillID))
                {
                    StatusMgr.Instance.Request(_h0605);
                    BuffModel.ObjAddBuff(_h0605);
                }
            }
            else
            {
                H0606_tagObjDelBuff vNetData = new H0606_tagObjDelBuff()
                {
                    ObjType = (byte)GameObjType.gotPlayer,
                    ObjID = PlayerDatas.Instance.PlayerId,
                    BuffType = (int)E_BuffType.bfBuff,
                    SkillID = 22218,
                };
                StatusMgr.Instance.Release(vNetData);
                BuffModel.ObjDelBuff((int)vNetData.ObjID, (int)vNetData.SkillID);
            }
        }

    }

}