using System;
using System.Collections.Generic;
using ProtoCSStruct;
using Sog;

namespace Game
{

    public static class TaskEXEvent
    {
        //忽略的类型
        public static List<QuestType> FilterType = new List<QuestType>()
                        {
                           QuestType.HandBook,
                           QuestType.AdventurePass,
                        };

        // 这里只管任务进度更新

        // 直接检查进度集合
        private static Action<PlayerOnGame>[] m_mthType_mth_list = new Action<PlayerOnGame>[((int)QuestMethod.Size)];

        // 此处只注册需要刚开启就能刷新进度的任务 顺序严格按照TaskEXCompleteMethod来
        public static void RegisterAllInitAbleTaskHandle()
        {
            m_mthType_mth_list[(int)QuestMethod.None] = TriggerNoCondition;
            m_mthType_mth_list[(int)QuestMethod.PassChapterN] = null;
            m_mthType_mth_list[(int)QuestMethod.Over_adventure] = PassChapterBattle;
            m_mthType_mth_list[(int)QuestMethod.Knight_upgrade] = ToLevelUp;
            
            m_mthType_mth_list[(int)QuestMethod.Pay] = TriggerPay;
            m_mthType_mth_list[(int)QuestMethod.Login] = null;
            m_mthType_mth_list[(int)QuestMethod.LoginY] = TriggerProcessLoginDay;
            m_mthType_mth_list[(int)QuestMethod.WearQualityGemN] = TriggerProcessWearQualityGem;
            m_mthType_mth_list[(int)QuestMethod.CostPowerY] = TriggerCostPowerY;
            
            
        }

        public static void InitAndUpdateAllCondition(PlayerOnGame player)
        {
            for (int i = 0; i < m_mthType_mth_list.Length; i++)
            {
                if (null != m_mthType_mth_list[i])
                {
                    m_mthType_mth_list[i](player);
                }
            }
        }

        public static void InitSingleCondition(int mth, PlayerOnGame player, int index)
        {
            if (mth < (int)QuestMethod.None)
            {
                return;
            }
            if (null != m_mthType_mth_list[mth])
            {
                m_mthType_mth_list[mth](player);
            }
            // 登录需要特殊处理
            if (mth == (int)QuestMethod.Login)
            {
                ref var task = ref TaskEXSvc.GetTaskByIndex(player, index);
                task.Condition[0].CurrVal += 1;
                task.Condition[1].CurrVal = (int)GameServerUtils.GetTimeSecond();
                var taskDesc = QuestEXDescMgr.Instance.GetConfig(task.TaskId);
                if (task.Condition[0].CurrVal >= taskDesc.fulfill[0].Condition[0])
                {
                    task.Condition[0].Done = true;
                    task.Status = (int)TaskEXCfg.TaskStatusComplete;
                }
                player.MakeDirty();
            }
        }

        public static void TiggerPlayerBornEvent(PlayerOnGame player)
        {
            player.Trace("TaskEXEvent.TiggerPlayerBornEvent player {0} dataSeq {1}"
                , player.UserID, player.DataSeq);

            // init finish task

            int nVal = 0;
            for (int i = player.RoleData.TaskEXData.FinishTaskList.Count; i < player.RoleData.TaskEXData.FinishTaskList.GetMaxCount(); i++)
            {
                player.RoleData.TaskEXData.FinishTaskList.Add(ref nVal);
            }
            SortedList<int, QuestEXDesc> list = QuestEXDescMgr.Instance.ItemTable;
            for (int i = 0; i < list.Values.Count; i++)
            {
                //新生玩家领取任务对部分任务进行过滤
                if (FilterType.IndexOf(list.Values[i].questType) != -1) continue;
                TaskEXSvc.ProcessAcceptTask(player, list.Values[i].questId, false, out int index);
            }
        }

        public static void TiggerNewDayStart(PlayerOnGame player, bool bNotifyClient)
        {
            player.Trace("TaskEXEvent.TiggerNewDayStart player {0}", player.UserID);
            TaskEXSvc.RefreshTaskStatus(player);
            TriggerLoginTimes(player);
            TriggerProcessLoginDay(player);
            TriggerPay(player);
            
            TriggerPlayerLogin(player);
            TriggerProcessLoginDay(player);
        }

        public static void TriggerPlayerLogin(PlayerOnGame player)
        {
            TaskEXSvc.TryAcceptNewNoPreTask(player);
            InitAndUpdateAllCondition(player);
            TriggerLoginTimes(player);
            TriggerProcessLoginDay(player);
        }

        // 这种处理方式可以把方法内部的desc 拿到调用方法的地方使用 
        public static void Process(QuestMethod mth, PlayerOnGame player, Func<DBTaskEXOne, QuestEXDesc, bool> commonJudge = null, Func<QuestEXDesc, int, int, bool> update = null)
        {
            CSTaskEXChangeNotify chgNotify = new CSTaskEXChangeNotify();
            ref var playerTask = ref player.RoleData.TaskEXData.TaskList;
            for (int i = playerTask.Count - 1; i >= 0; i--)
            {
                var taskDesc = QuestEXDescMgr.Instance.GetConfig(playerTask[i].TaskId);
                if (taskDesc == null)
                    continue;
                if (commonJudge != null && !commonJudge(playerTask[i], taskDesc))
                    continue;
                bool bMakeDirty = false;
                for (int k = 0; k < taskDesc.fulfill.Length; k++)
                {
                    // 只处理类型对应的
                    if (taskDesc.fulfill[k].Method == mth)
                    {
                        if (playerTask[i].Condition[k].CurrVal >= taskDesc.fulfill[k].Condition[^1] || playerTask[i].Condition[k].Done)
                        {
                            continue;
                        }

                        if (update != null)
                        {
                            bMakeDirty = update(taskDesc, i, k);
                        }
                    }

                }
                if (bMakeDirty)
                    chgNotify.ChgTaskList.Add(ref playerTask[i]);

            }
            if (chgNotify.ChgTaskList.GetCount() > 0)
            {
                player.SendToClient((int)CSGameMsgID.TaskexChangeNotify, ref chgNotify);

            }
        }

        //新获得多少个宝石
        public static void TriggerGetGem(PlayerOnGame player, int gemNum = 1)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.GetGemN, player, gemNum);
        }

        //累计消耗体力
        public static void TriggerPowerCost(PlayerOnGame player, int cost)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.CostPowerN, player, cost);
        }
        
        //签到
        public static void TriggerGetSignRwdN(PlayerOnGame player)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.GetSignRwdN, player);
        }

        //兑换商店兑换次数
        public static void TriggerMarkShopEquip(PlayerOnGame player)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.ShopChangeBuyN, player);
        }

        //速通奖励领取次数
        public static void TriggerGetStageRwdN(PlayerOnGame player)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.GetStageRwdN, player);
        }

        public static void GetQualityEquipN(PlayerOnGame player,CommonQuality quality)
        {
            
            Process(QuestMethod.GetQualityEquipN, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                if ((int)quality == desc.fulfill[idx].Condition[0] && (!AppTime.IsSameDay(task.PickupTime, GameServerUtils.GetTimeSecond()) || task.Condition[idx].CurrVal == 0))
                {
                    task.Condition[idx].CurrVal += 1;
                    task.PickupTime = (int)GameServerUtils.GetTimeSecond();
                }
                else if ((int)quality == desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal += 1;
                }
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[1];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1];
                player.MakeDirty();
                return true;
            });
        }

        public static void TriggerCostPowerY(PlayerOnGame player)
        {
            Process(QuestMethod.CostPowerY, player, null, (desc, index, idx) =>
            {
                var value = player.RoleData.PowerPointData.CostPower;
                ref var task = ref player.RoleData.TaskEXData.TaskList[index];
                if ((!AppTime.IsSameDay(task.PickupTime, GameServerUtils.GetTimeSecond()) ||
                     task.Condition[idx].CurrVal == 0))
                {
                    task.Condition[idx].CurrVal = value;
                    task.PickupTime = (int)GameServerUtils.GetTimeSecond();
                }
                else
                {
                    task.Condition[idx].CurrVal = value;
                }

                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[0];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }

                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0];
                player.MakeDirty();
                return true;
            });
        }

        public static void TriggerContBttlTimesN(PlayerOnGame player)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.ContBttlTimesN, player, 1);
        }

        public static void TriggerBreakEquipN(PlayerOnGame player,int num)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.BreakEquipN, player, num);
        }
        
        public static void TriggerGemDrawN(PlayerOnGame player,int num)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.GemDrawN, player, num);
        }
        
        public static void TriggerWatchAdsN(PlayerOnGame player,int num)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.WatchAdsN, player, num);
        }
        
        public static void TriggerCostDiamondN(PlayerOnGame player,int num)
        {
            ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.CostDiamondN, player, num);
        }
        
        
        
        public static void TriggerBuyShopGoodsN(PlayerOnGame player,int shopId,int num)
        {
            Process(QuestMethod.BuyShopGoodsN, player, null, (desc, index, idx) =>
            {
                if(desc.fulfill[idx].Condition[0] != shopId)
                {
                    return false;
                }
                ref var task = ref player.RoleData.TaskEXData.TaskList[index];
                if ((!AppTime.IsSameDay(task.PickupTime, GameServerUtils.GetTimeSecond()) ||
                     task.Condition[idx].CurrVal == 0))
                {
                    task.Condition[idx].CurrVal = num;
                    task.PickupTime = (int)GameServerUtils.GetTimeSecond();
                }
                else
                {
                    task.Condition[idx].CurrVal += num;
                }

                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[1];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }

                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1];
                player.MakeDirty();
                return true;
            });
        }
        

        // 触发进度加一
        public static void ProcessTriggerPlayerEventCurrentValAdd(QuestMethod mth, PlayerOnGame player, int num = 1)
        {
            Process(mth, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                task.Condition[idx].CurrVal += num;
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[0];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0];
                player.MakeDirty();
                return true;
            });
        }

        // 直接完成的任务类型 这里condition_type检查放松 
        public static void ProcessTriggerPlayerEventDirectFinish(QuestMethod mth, PlayerOnGame player)
        {
            Process(mth, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[0];
                task.Condition[idx].Done = true;
                if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                {
                    task.Status = (int)TaskEXCfg.TaskStatusComplete;
                }
                player.MakeDirty();
                return true;
            });
        }

        // 直接检查玩家当前状态值 
        public static void ProcessCheckPlayerCurrentValue(QuestMethod mth, PlayerOnGame player, long moduleValue = 0)
        {
            Process(mth, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                if (moduleValue >= desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[0];
                    task.Condition[idx].Done = true;
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                else
                {
                    task.Condition[idx].CurrVal = (int)moduleValue;
                    task.Condition[idx].Done = false;
                }
                player.MakeDirty();
                return true;
            });
        }

        public static void ProcessCheckNotifyClient(int taskId, PlayerOnGame player)
        {
            ref var tasks = ref player.RoleData.TaskEXData.TaskList;
            var local = -1;
            for (var i = 0; i < tasks.Count; i++)
            {
                if (tasks[i].TaskId == taskId)
                {
                    local = i;
                    break;
                }
            }
            if (local == -1)
            {
                TraceLog.Error("TaskEXEvent.ProcessCheckNotifyClient player:{0} taskid:{1}!", player.UserID, taskId);
                return;
            }
            CSTaskEXChangeNotify chgNotify = new CSTaskEXChangeNotify();
            chgNotify.ChgTaskList.Add(ref player.RoleData.TaskEXData.TaskList[local]);
            player.SendToClient((int)CSGameMsgID.TaskexChangeNotify, ref chgNotify);
        }
        
        public static void NotifyClientNoneDoth(int taskId, PlayerOnGame player)
        {
            ref var tasks = ref player.RoleData.TaskEXData.TaskList;
            var local = -1;
            for (var i = 0; i < tasks.Count; i++)
            {
                if (tasks[i].TaskId == taskId)
                {
                    local = i;
                    break;
                }
            }
            if (local == -1)
            {
                TraceLog.Error("TaskEXEvent.ProcessCheckNotifyClient player:{0} taskid:{1}!", player.UserID, taskId);
                return;
            }

            var desc = QuestEXDescMgr.Instance.GetConfig(taskId);
            
            if (null != m_mthType_mth_list[(int)desc.fulfill[0].Method])
            {
                return;
            }
            var chgNotify = new CSTaskEXChangeNotify();
            chgNotify.ChgTaskList.Add(ref player.RoleData.TaskEXData.TaskList[local]);
            player.SendToClient((int)CSGameMsgID.TaskexChangeNotify, ref chgNotify);
        }



        public static void TriggerNoCondition(PlayerOnGame player)
        {
            ProcessTriggerPlayerEventDirectFinish(QuestMethod.None, player);
        }
      
      
        public static void TriggerPay(PlayerOnGame player)
        {
            var value = player.RoleData.PayData.TodayPayDiamond;
            Process(QuestMethod.Pay, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                if (!AppTime.IsSameDay(task.PickupTime, GameServerUtils.GetTimeSecond()) ||
                    task.Condition[idx].CurrVal == 0)
                {
                    task.Condition[idx].CurrVal = (int)value;
                    task.PickupTime = (int)GameServerUtils.GetTimeSecond();
                }
                else
                {
                    task.Condition[idx].CurrVal += (int)value;
                }
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[0];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0];
                player.MakeDirty();
                return true;
            });
        }

        public static void PassChapterBattle(PlayerOnGame player)
        {
            var value = player.RoleData.ChapterData.BattleId;
            Process(QuestMethod.Over_adventure, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                if (value >= desc.fulfill[idx].Condition[0] && (!AppTime.IsSameDay(task.PickupTime, GameServerUtils.GetTimeSecond()) || task.Condition[idx].CurrVal == 0))
                {
                    task.Condition[idx].CurrVal += 1;
                    task.PickupTime = (int)GameServerUtils.GetTimeSecond();
                }
                if (value >= desc.fulfill[idx].Condition[0])
                {
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = value >= desc.fulfill[idx].Condition[0];
                player.MakeDirty();
                return true;
            });
        }

        public static void ToLevelUp(PlayerOnGame player)
        {
            var level = player.RoleData.Knight.DbHero.Level;
            Process(QuestMethod.Knight_upgrade, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                task.Condition[idx].CurrVal = level;
                task.Condition[idx].CurrVal = (int)Math.Min(task.Condition[idx].CurrVal, desc.fulfill[idx].Condition[0]);
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0])
                {
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = level >= desc.fulfill[idx].Condition[0];
                
                player.MakeDirty();
                return true;
            });
        }


        public static void TriggerChapterBattle(PlayerOnGame player,int battleId)
        {

            Process(QuestMethod.PassChapterN, player, null, (desc, index, idx) =>
            {
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                if (battleId == desc.fulfill[idx].Condition[0] &&
                    (!AppTime.IsSameDay(task.PickupTime, GameServerUtils.GetTimeSecond()) ||
                     task.Condition[idx].CurrVal == 0))
                {
                    task.Condition[idx].CurrVal += 1;
                    task.PickupTime = (int)GameServerUtils.GetTimeSecond();
                }
                else if (battleId == desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal += 1;
                }
                
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[1];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1];
                player.MakeDirty();
                return true;
            });
        }

        public static void TriggerPaySuccess(PlayerOnGame player, int itemId, uint payDiamond, uint addDiamond, uint money, bool isPlayerFirstPay, long payTime3rd, ref CSPayGoogleSuccessRes csRes)
        {
            TriggerPay(player);
            TriggerProcessPayMoney(player, itemId);
        }

        public static void TriggerLoginTimes(PlayerOnGame player)
        {
            //ProcessTriggerPlayerEventCurrentValAdd(TaskEXCompleteMethod.Login, player);
            Process(QuestMethod.Login, player, null, (desc, index, idx) =>
            { 
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                if (task.Condition[idx + 1].CurrVal == 0)
                {
                    task.Condition[idx + 1].CurrVal = (int)GameServerUtils.GetTimeSecond();
                }
                if (!AppTime.IsSameDay(task.Condition[idx + 1].CurrVal, GameServerUtils.GetTimeSecond()))
                {
                    task.Condition[idx].CurrVal += 1;
                    task.Condition[idx + 1].CurrVal = (int)GameServerUtils.GetTimeSecond();
                }
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[0];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0];
                player.MakeDirty();
                return true;
            });
        }


 



        public static void TriggerProcessPayMoney(PlayerOnGame player, int itemId)
        {
            var desc = PayDiamondDescMgr.Instance.GetConfig(itemId);
            var num = 0;
            if (desc != null)
            {
                num = (int)desc.currencyRes;
            } 
           // ProcessTriggerPlayerEventCurrentValAdd(QuestMethod.PayNum, player, num);
        }
        
        public static void TriggerProcessLoginDay(PlayerOnGame player)
        {
            Process(QuestMethod.LoginY, player, null, (desc, index, idx) =>
            { 
                ref DBTaskEXOne task = ref player.RoleData.TaskEXData.TaskList[index];
                if (task.Condition[idx + 1].CurrVal == 0)
                {
                    task.Condition[idx + 1].CurrVal = (int)GameServerUtils.GetTimeSecond();
                    var value = (int)StatisticsOp.GetIDTotal(player, (int)CSRoleStatisticsID.LoginDay);
                    if (value == 0)
                    {
                        value = 1;
                    }
                    task.Condition[idx].CurrVal += value;
                }
                if (!AppTime.IsSameDay(task.Condition[idx + 1].CurrVal, GameServerUtils.GetTimeSecond()))
                {
                    task.Condition[idx].CurrVal += 1;
                    task.Condition[idx + 1].CurrVal = (int)GameServerUtils.GetTimeSecond();
                }
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[0];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[0];
                player.MakeDirty();
                return true;
            });
        }


        public static void TriggerProcessWearQualityGem(PlayerOnGame player)
        {
            Process(QuestMethod.WearQualityGemN, player, null, (desc, index, idx) =>
            {
                var gem = player.RoleData.Knight.DbHero.WearGem;
                var quality = desc.fulfill[idx].Condition[0];
                var qn = 0;
                for (var i = 0; i < gem.Count; i++)
                {
                    if (gem[i].Quality >= quality)
                    {
                        qn++;
                    }
                }
                ref var task = ref player.RoleData.TaskEXData.TaskList[index];
                if (qn >= desc.fulfill[idx].Condition[1] &&
                    (!AppTime.IsSameDay(task.PickupTime, GameServerUtils.GetTimeSecond()) ||
                     task.Condition[idx].CurrVal == 0))
                {
                    task.Condition[idx].CurrVal = qn;
                    task.PickupTime = (int)GameServerUtils.GetTimeSecond();
                }
                else 
                {
                    task.Condition[idx].CurrVal = Math.Max(qn, task.Condition[idx].CurrVal);
                }
                if (task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1])
                {
                    task.Condition[idx].CurrVal = (int)desc.fulfill[idx].Condition[1];
                    if (task.Status == (int)TaskEXCfg.TaskStatusProcessing)
                    {
                        task.Status = (int)TaskEXCfg.TaskStatusComplete;
                    }
                }
                task.Condition[idx].Done = task.Condition[idx].CurrVal >= desc.fulfill[idx].Condition[1];
                player.MakeDirty();
                return true;
            });
        }




        public static void OnReloadConfig(string excelConfigFile)
        {
            TaskEXSvc.TaskUpdateDict.Clear();
            TaskEXSvc.NoPreviewTaskId.Clear();

            var questList = QuestEXDescMgr.Instance.ItemTable;
        }
    }
}