using asap.core;
using cfg;
using game;
using GameCore;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using UniRx;
using UnityEngine;

public class GetBattlePassRewardEvent
{
    public int NormalLevel;
    public int VipLevel;
}

public struct GetAllBPRewards
{

}

public struct BpGetExp
{

}

public struct BpVipUnlock
{

}

public class BattlePassData
{
    public BattlePassRecord BattlePassRecord;
    public BattleTask BattleTask;

    private Tables _tables;


    public BattlePassData(Tables tables)
    {
        if (BattlePassRecord == null)
            BattlePassRecord = new BattlePassRecord();
        if (BattleTask == null)
            BattleTask = new BattleTask();

        _tables = tables;
    }

    #region Load&Save
    public void InitData(Dictionary<string, string> userDatas = null)
    {
        if (userDatas.TryGetValue("BattlePassRecordTask", out string battlePassRecordTask))
        {

            LoadBattlePassRecordTask(battlePassRecordTask);
        }
        else
        {
            //旧数据兼容
            if (userDatas.TryGetValue("BattlePassRecord", out string data_value))
            {
                LoadBattlePassRecord(data_value);
            }
            if (userDatas.TryGetValue("BattleTask", out data_value))
            {
                LoadBattleTask(data_value);
            }
        }
    }
    public void LoadBattlePassRecordTask(string data)
    {
        string[] values = data.Split('#');
        BattlePassRecord = new BattlePassRecord();
        BattlePassRecord.DeserializeObject(values[0]);

        BattleTask = new BattleTask();
        BattleTask.DeserializeObject(values[1]);
    }
    public void LoadBattlePassRecord(string data)
    {
        BattlePassRecord = JsonConvert.DeserializeObject<BattlePassRecord>(data);
    }
    public void LoadBattleTask(string data)
    {
        BattleTask = JsonConvert.DeserializeObject<BattleTask>(data);
    }
    void SaveBattlePassRecordTask()
    {
        string battlePassRecord = BattlePassRecord.SerializeObject();
        string battleTask = BattleTask.SerializeObject();
        PlayFabMgr.Instance.UpdateUserDataValue("BattlePassRecordTask", battlePassRecord + "#" + battleTask);
    }
    public void SaveBattlePassRecord()
    {
        GContext.container.Resolve<BattlePassDataProvider>().SetRedPoint();
        SaveBattlePassRecordTask();
        //PlayFabMgr.Instance.UpdateUserDataValue("BattlePassRecord", JsonConvert.SerializeObject(BattlePassRecord));
    }

    public void SaveBattleTask()
    {
        GContext.container.Resolve<BattlePassDataProvider>().SetRedPoint();
        SaveBattlePassRecordTask();
        //PlayFabMgr.Instance.UpdateUserDataValue("BattleTask", JsonConvert.SerializeObject(BattleTask));
    }
    #endregion

    #region BattlePass

    public void RefreshBattlePassRecord(FishingEvent t = null)
    {
        //没有开启的战令
        if (t == null)
        {
            GContext.container.Resolve<BattlePassDataProvider>().RecordLastBPUnGetDropIDs();
            BattlePassRecord.ID = 0;
            SaveBattlePassRecord();
            return;
        }
        if (t.ID != BattlePassRecord.ID)
        {
            GContext.container.Resolve<BattlePassDataProvider>().RecordLastBPUnGetDropIDs();
            BattlePassRecord.Init(t.ID);
            RefreshDaiyTask();
            RefreshWeeklyTask();
            SaveBattlePassRecord();
        }
    }

    #endregion

    #region Task

    public void RefreshDaiyTask()
    {
        var bpMain = _tables.TbBattlePassMain.GetOrDefault(_tables.TbFishingEvent.GetOrDefault(BattlePassRecord.ID).RedirectID);
        if (bpMain != null)
        {
            BattleTask.DailyTaskEndTime = ConvertTools.GetDateTimeYMD(ZZTimeHelper.UtcNow().UtcNowOffset()).AddDays(1);
            var dailyTasks = bpMain.DailyTaskList;
            BattleTask.dic_dailyTasks.Clear();
            foreach (var task in dailyTasks)
            {
                BattleTask.dic_dailyTasks.Add(task, 0);
            }
        }
        else
        {
            BattleTask = new BattleTask();
        }
        GContext.Publish(new ConditionTypeEvent { type = ConditionType.LoginDays, count = 1 });
        SaveBattleTask();
    }

    public void RefreshWeeklyTask()
    {

        var bpMain = _tables.TbBattlePassMain.GetOrDefault(_tables.TbFishingEvent.GetOrDefault(BattlePassRecord.ID).RedirectID);
        if (bpMain != null)
        {
            var weeklyTasks = bpMain.WeeklyTaskList;
            BattleTask.dic_weeklyTasks.Clear();
            foreach (var task in weeklyTasks)
            {
                BattleTask.dic_weeklyTasks.Add(task, 0);
            }
            BattleTask.WeeklyTaskEndTime = ConvertTools.GetDateTimeSunDay(ZZTimeHelper.UtcNow().UtcNowOffset()).AddDays(1);
        }
        //当前没有战令了
        else
        {
            BattleTask = new BattleTask();
        }
        BattlePassRecord.InflationRate = GContext.container.Resolve<PlayerData>().InflationRate;

        GContext.Publish(new ConditionTypeEvent { type = ConditionType.LoginDays, count = 1 });
        BattleTask.loginDays.Clear();
        SaveBattleTask();
    }

    #endregion

}

public class BattlePassDataProvider : IDisposable
{
    #region Fields

    public BattlePassData Data;
    private PlayerItemData _itemData;

    public int LockTipID;

    public int DefaultBuyLevel
    {
        get
        {
            return curPassMain.BuyLevel;
        }
    }



    private Tables _tables;
    private Dictionary<int, BattlePassLevel> dic_BPLevel;

    public bool IsActivating => Data.BattlePassRecord.ID != 0;
    public bool UILockVip = false;
    public bool IsUnlockVip => Data.BattlePassRecord.IsUnlockVip == 1;

    CompositeDisposable disposables = new CompositeDisposable();

    public BattlePassMain curPassMain
    {
        get
        {
            var fishingEvent = _tables.TbFishingEvent.GetOrDefault(Data.BattlePassRecord.ID);
            if (fishingEvent == null) { return null; }

            return _tables.TbBattlePassMain.GetOrDefault(fishingEvent.RedirectID);
        }
    }
    public BattlePassLevel curPassLevel
    {
        get
        {
            if (curPassMain != null)
                return dic_BPLevel.GetValueOrDefault(curPassMain.LevelList[Data.BattlePassRecord.Level - 1]);
            return null;
        }
    }


    public BattlePassDataProvider(Tables tables, BattlePassData data, PlayerItemData itemData)
    {
        _tables = tables;
        Data = data;
        dic_BPLevel = tables.TbBattlePassLevel.DataMap;
        _itemData = itemData;
        GContext.OnEvent<ConditionTypeEvent>().Subscribe(UpdateTaskData).AddTo(disposables);
    }

    #endregion

    #region Check Func

    public void CheckIfRefreshBattblePass()
    {
        DateTime endTime = GContext.container.Resolve<FishingEventData>().GetEventEndTime(Data.BattlePassRecord.ID);

        if (ZZTimeHelper.UtcNow().UtcNowOffset() >= endTime && IsActivating)
        {
            RecordLastBPUnGetDropIDs();
            Data.RefreshBattlePassRecord();
            //GContext.container.Resolve<FishingEventData>().GetEventAndInit(3, 7);
        }
    }

    public void CheckIfRefreshDailyTask()
    {
        if (ZZTimeHelper.UtcNow().UtcNowOffset() >= Data.BattleTask.DailyTaskEndTime && IsActivating)
        {
            Data.RefreshDaiyTask();
        }
    }

    public void CheckIfRefreshWeekTask()
    {

        if (ZZTimeHelper.UtcNow().UtcNowOffset() >= Data.BattleTask.WeeklyTaskEndTime && IsActivating)
        {
            Data.RefreshWeeklyTask();
        }
    }

    public bool CheckIfPopBuyVipPanel()
    {
        if (Data.BattlePassRecord.BuyVipToastIndex >= curPassMain.RemindLevel.Count)
        {
            return false;
        }

        return Data.BattlePassRecord.Level >= curPassMain.RemindLevel[Data.BattlePassRecord.BuyVipToastIndex] && Data.BattlePassRecord.IsUnlockVip == 0;
    }

    public bool CheckIfGetLastBpRewards()
    {
        if (LastBpDropIds.Count != 0)
        {
            var playerData = GContext.container.Resolve<PlayerItemData>();
            ChangeSource changeSource = new ChangeSource(Data.BattlePassRecord.ID, "BattlePass", "BattlePass_Normal28Day", "ExpiredReward");

            var itemDatas = playerData.AddItemByDropListLureInflation(null, LastBpDropIds.GetRange(1, LastBpDropIds.Count - 1), changeSource);
#if AGG
            using (var e = GEvent.GameEvent("bp_level_reward"))
            {
                e.AddContent("bp_level", GetBPCurLevel)
                  .AddContent("drop_id_list", JsonConvert.SerializeObject(LastBpDropIds.GetRange(1, LastBpDropIds.Count - 1)));
                if (itemDatas != null && itemDatas.Count > 0)
                {
                    int reward_hook = 0;
                    int hook_origin = 0;
                    int reward_cash = 0;
                    for (int i = 0; i < itemDatas.Count; i++)
                    {
                        if (itemDatas[i].id == 1001)
                        {
                            reward_hook += itemDatas[i].count;
                            hook_origin += itemDatas[i].origin;
                        }
                        else if (itemDatas[i].id == 1002)
                        {
                            reward_cash += itemDatas[i].count;
                        }
                    }
                    e.AddContent("reward_hook", reward_hook)
                     .AddContent("hook_origin", hook_origin)
                     .AddContent("reward_cash", reward_cash);
                }
            }
#endif
            if (LastBpDropIds[0] > 0)
            {
#if AGG
                using (var e = GEvent.GameEvent("bp_cash_reward"))
                {
                    e.AddContent("bp_level", GetBPCurLevel)
                      .AddContent("cash_num", LastBpDropIds[0]);
                }
#endif

                var cash = new ItemData { id = 1002, count = LastBpDropIds[0] };
                ChangeSource changeSource1 = new ChangeSource(Data.BattlePassRecord.ID, "BattlePass", "BattlePass_Normal28Day", "OverflowReward");

                playerData.AddItem(cash, changeSource1);
                GContext.Publish(new ShowData(cash));
            }
            GContext.Publish(new ShowData(textValue: LocalizationMgr.GetText("UI_BattlePassPanel_25")));
            LastBpDropIds.Clear();
            Data.SaveBattlePassRecord();
            return true;
        }
        return false;
    }
    #endregion

    #region Get Func

    public TimeSpan GetDailyTaskDuration()
    {
        return Data.BattleTask.DailyTaskEndTime - ZZTimeHelper.UtcNow().UtcNowOffset();
    }

    public TimeSpan GetWeeklyTaskDuration()
    {
        return Data.BattleTask.WeeklyTaskEndTime - ZZTimeHelper.UtcNow().UtcNowOffset();
    }

    public int GetBPCurLevel => Data.BattlePassRecord.Level;
    public int GetBPNextLevel => Mathf.Clamp(Data.BattlePassRecord.Level + 1, 1, BPMaxLevel);

    public int BPMaxLevel => curPassMain.LevelList.Count;
    public List<int> LastBpDropIds => Data.BattlePassRecord.LastDropIDs;

    public BattlePassLevel GetBPLevel(int level) => dic_BPLevel[curPassMain.LevelList[level - 1]];

    public int GetBPCurExp() => Data.BattlePassRecord.Exp;

    public int GetNeedExpToLevelUp(int upLevel)
    {
        var curLevel = Data.BattlePassRecord.Level;
        return GetTotalExpFromLevelRange(curLevel, curLevel + upLevel) - Data.BattlePassRecord.Exp;
    }

    public int GetCashBoxCount()
    {
        var count = 0;
        if (GetBPCurLevel == BPMaxLevel)
            count = GetBPCurExp() / 100 * curPassMain.ExpToCash;
        return count;
    }

    /// <summary>
    /// Level Up From StartLevel To EndLevel
    /// </summary>
    /// <param name="startLevel"></param>
    /// <param name="endLevel"></param>
    /// <returns></returns>
    public int GetTotalExpFromLevelRange(int startLevel, int endLevel)
    {
        var expNeed = 0;
        endLevel = endLevel > BPMaxLevel ? BPMaxLevel : endLevel;
        for (int i = startLevel; i < endLevel; i++)
        {
            expNeed += dic_BPLevel[curPassMain.LevelList[i - 1]].Exp;
        }
        return expNeed;
    }

    public BPRewardSlot.ESlotState GetSlotState(int level, bool isNormalReward)
    {
        //        if ( !IsUnlockVip&&!isNormalReward )
        //            return BPRewardSlot.ESlotState.VipLock;
        if (Data.BattlePassRecord.Level < level || (!isNormalReward && !IsUnlockVip))
        {
            return BPRewardSlot.ESlotState.LevelLock;
        }
        if (isNormalReward)
        {
            if (Data.BattlePassRecord.NormalRewardGet.Contains(level))
                return BPRewardSlot.ESlotState.HasGotReward;
        }
        else if (Data.BattlePassRecord.VipRewardGet.Contains(level))
            return BPRewardSlot.ESlotState.HasGotReward;
        return BPRewardSlot.ESlotState.CanGetReward;
    }

    public void GetAllBpRewards()
    {
        var playItemData = GContext.container.Resolve<PlayerItemData>();
        var dropIds = new List<int>();
        var dropIds1 = new List<int>();
        var dropIds2 = new List<int>();
        List<ItemData> itemDatas = new List<ItemData>();
        List<ItemData> itemDatas1 = new List<ItemData>();
        List<ItemData> itemDatas2 = new List<ItemData>();
        for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
        {
            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
            {
                dropIds1.Add(GetSlotDropID(i, true));
                SetLevelRewardGet(i, true);
            }
        }
        if (dropIds1.Count > 0)
        {
            dropIds.AddRange(dropIds1);
            ChangeSource changeSource = new ChangeSource(Data.BattlePassRecord.ID, "BattlePass", "BattlePass_Normal28Day", "FreeLevelReward");
            itemDatas1 = playItemData.GetItemByDropListLureInflation(null, dropIds1);
            for (int i = 0; i < itemDatas1.Count; i++)
            {
                itemDatas1[i].changeSource = changeSource;
            }
            itemDatas.AddRange(itemDatas1);
        }
        if (IsUnlockVip)
        {
            for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
            {
                if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
                {
                    dropIds2.Add(GetSlotDropID(i, false));
                    SetLevelRewardGet(i, false);
                }
            }
            if (dropIds2.Count > 0)
            {
                dropIds.AddRange(dropIds2);
                ChangeSource changeSource = new ChangeSource(Data.BattlePassRecord.ID, "BattlePass", "BattlePass_Normal28Day", "PrimeLevelReward");
                itemDatas2 = playItemData.GetItemByDropListLureInflation(null, dropIds2);
                for (int i = 0; i < itemDatas2.Count; i++)
                {
                    itemDatas2[i].changeSource = changeSource;
                }
                itemDatas.AddRange(itemDatas2);
            }
        }
        Data.SaveBattlePassRecord();
        GContext.Publish(new ShowData(itemDatas));
        playItemData.AddItem(itemDatas, null);
#if AGG
        using (var e = GEvent.GameEvent("bp_level_reward"))
        {
            e.AddContent("bp_level", GContext.container.Resolve<BattlePassDataProvider>().GetBPCurLevel)
              .AddContent("drop_id_list", JsonConvert.SerializeObject(dropIds));
            if (itemDatas != null && itemDatas.Count > 0)
            {
                int reward_hook = 0;
                int hook_origin = 0;
                int reward_cash = 0;
                for (int i = 0; i < itemDatas.Count; i++)
                {
                    if (itemDatas[i].id == 1001)
                    {
                        reward_hook += itemDatas[i].count;
                        hook_origin += itemDatas[i].origin;
                    }
                    else if (itemDatas[i].id == 1002)
                    {
                        reward_cash += itemDatas[i].count;
                    }
                }
                e.AddContent("reward_hook", reward_hook)
                 .AddContent("hook_origin", hook_origin)
                 .AddContent("reward_cash", reward_cash);
            }
        }
#endif
    }

    public int GetAllToGetRewardCount()
    {
        var count = 0;
        for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
        {
            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
            {
                count++;
            }
        }
        if (IsUnlockVip)
        {
            for (int i = 1; i <= Data.BattlePassRecord.Level; i++)
            {
                if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
                {
                    count++;
                }
            }
        }
        return count;
    }

    public int GetSlotDropID(int level, bool isNormalReward)
    {
        if (isNormalReward)
        {
            return curPassMain.FreeRewardList[level - 1];
        }
        return curPassMain.PrimeRewardList[level - 1];
    }
    public ItemData GetSlotDropItem(int level, bool isNormalReward)
    {
        if (isNormalReward)
        {
            return _itemData.GetItemDataOneLureInflation(null, curPassMain.FreeRewardList[level - 1]);
        }
        return _itemData.GetItemDataOneLureInflation(null, curPassMain.PrimeRewardList[level - 1]);
    }

    public int GetDiamondCostByUpLevel(int upLevel)
    {
        var needExp = GetNeedExpToLevelUp(upLevel);
        if (needExp % 100 > 0)
        {
            needExp = (needExp / 100 + 1) * 100;
        }
        return needExp / 100 * curPassMain.ExpPrice;
    }

    public List<ItemData> GetRewardsByUpLevel(int upLevel, bool isNormal)
    {
        return GetRewardsByLevelRange(GetBPCurLevel + 1, GetBPCurLevel + upLevel, isNormal);
    }

    public List<ItemData> GetRewardsByLevelRange(int startLevel, int endLevel, bool isNormal)
    {

        var curLevel = startLevel;
        var maxLevel = BPMaxLevel;
        var curPass = curPassMain;

        Dictionary<int, int> dic_allRewards = new();

        var dic_items = GContext.container.Resolve<Tables>().TbItem.DataMap;
        var playerItemData = GContext.container.Resolve<PlayerItemData>();
        var rewardList = isNormal ? curPass.FreeRewardList : curPass.PrimeRewardList;

        for (int i = curLevel - 1; i < endLevel && i < maxLevel; i++)
        {
            var curItemData = playerItemData.GetItemDataOneLureInflation(null, rewardList[i]);
            if (dic_allRewards.ContainsKey(curItemData.id))
            {
                dic_allRewards[curItemData.id] += curItemData.count;
            }
            else
                dic_allRewards.Add(curItemData.id, curItemData.count);
        }

        var rewards = dic_allRewards.OrderByDescending(x => dic_items[x.Key].Quality).Select(x => new ItemData { id = x.Key, count = x.Value }).ToList();
        return rewards;
    }

    public int GetBarsDefaultPos()
    {
        for (int i = 1; i <= GetBPCurLevel; i++)
        {
            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
                return Mathf.Clamp(i - 1, 1, BPMaxLevel - 3);

            if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
                return Mathf.Clamp(i - 1, 1, BPMaxLevel - 3);
        }
        return Mathf.Clamp(GetBPCurLevel - 1, 1, BPMaxLevel - 3);
    }


    #endregion

    #region Set Func
    public void RecordLastBPUnGetDropIDs()
    {
        if (curPassMain == null)
            return;
        var drops = Data.BattlePassRecord.LastDropIDs;
        if (Data.BattlePassRecord.ID == 0 || drops.Count > 0)
            return;
        drops.Add(GContext.container.Resolve<PlayerItemData>().GetExtraCoinMag(GetCashBoxCount()));
        for (int i = 1; i <= GetBPCurLevel; i++)
        {
            if (GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
                drops.Add(curPassMain.FreeRewardList[i - 1]);

            if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward)
                drops.Add(curPassMain.PrimeRewardList[i - 1]);
        }

    }
    public void SetRedPoint()
    {
        var flag = 0;
        for (int i = 1; i <= GetBPCurLevel; i++)
        {
            if (GetSlotState(i, false) == BPRewardSlot.ESlotState.CanGetReward || GetSlotState(i, true) == BPRewardSlot.ESlotState.CanGetReward)
            {
                RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Reward, true);
                flag = 1;
                break;
            }
        }
        if (flag == 0)
            RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Reward, false);

        foreach (var taskInfo in Data.BattleTask.dic_dailyTasks)
        {
            var task = _tables.TbBattlePassTask.Get(taskInfo.Key);
            int requiredCount = int.Parse(task.Param[0]);
            if (task.Type == ConditionType.ConsumeEnergy)
            {
                requiredCount = GContext.container.Resolve<PlayerItemData>().IntInflation(requiredCount, Data.BattlePassRecord.InflationRate);
            }
            if (taskInfo.Value >= requiredCount)
            {
                RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Task, true);
                return;
            }
        }
        foreach (var taskInfo in Data.BattleTask.dic_weeklyTasks)
        {
            var task = _tables.TbBattlePassTask.Get(taskInfo.Key);
            int requiredCount = int.Parse(task.Param[0]);
            if (task.Type == ConditionType.ConsumeEnergy)
            {
                requiredCount = GContext.container.Resolve<PlayerItemData>().IntInflation(requiredCount, Data.BattlePassRecord.InflationRate);
            }
            if (taskInfo.Value >= requiredCount)
            {
                RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Task, true);
                return;
            }
        }
        RedPointManager.Instance.SetRedPointState(RedPointName.Home_BattlePass_Task, false);
    }

    public void SetVipUnlock()
    {
        Data.BattlePassRecord.IsUnlockVip = 1;
        Data.SaveBattlePassRecord();
    }

    public void SetLevelRewardGet(int level, bool isNormal)
    {
        if (isNormal)
        {
            if (Data.BattlePassRecord.NormalRewardGet.Contains(level))
            {
                Debug.LogError("Has Get Reward" + level);
                return;
            }
            Data.BattlePassRecord.NormalRewardGet.Add(level);
        }
        else
        {
            if (Data.BattlePassRecord.VipRewardGet.Contains(level))
            {
                Debug.LogError("Has Get Reward" + level);
                return;
            }
            Data.BattlePassRecord.VipRewardGet.Add(level);
        }
    }

    public void SetBPExp(int exp)
    {
        var curExp = Data.BattlePassRecord.Exp + exp;
        //Debug.Log("StartExp:" + Data.BattlePassRecord.Exp);
        var upLevel = 0;
        var curLevel = GetBPCurLevel;
        while (curExp - GetTotalExpFromLevelRange(curLevel, curLevel + upLevel + 1) >= 0 && curLevel + upLevel < BPMaxLevel)
        {
            upLevel++;
        }

        Data.BattlePassRecord.Exp = curExp - GetTotalExpFromLevelRange(curLevel, curLevel + upLevel);
        Data.BattlePassRecord.Level = curLevel + upLevel;
        //Debug.Log("EndExp:" + Data.BattlePassRecord.Exp + "Get:" + exp + "  Level" + Data.BattlePassRecord.Level);
        Data.SaveBattlePassRecord();
        SetRedPoint();
    }

    public void UpdateVipToastLevel()
    {
        Data.BattlePassRecord.BuyVipToastIndex++;
        Data.SaveBattlePassRecord();
    }

    void UpdateTaskData(ConditionTypeEvent conditionTypeEvent)
    {
        if (!IsActivating)
            return;
        bool isUpdata = false;
        var tasks = _tables.TbBattlePassTask;
        var curTasks = Data.BattleTask.dic_dailyTasks;
        var curTasksId = Data.BattleTask.dic_dailyTasks.Keys.ToList();
        //每日任务
        foreach (var taskId in curTasksId)
        {
            var task = tasks.GetOrDefault(taskId);
            if (task == null)
                continue;
            if (task.Type == conditionTypeEvent.type)
            {
                int requiredCount = int.Parse(task.Param[0]);
                if (task.Type == ConditionType.ConsumeEnergy)
                {
                    requiredCount = GContext.container.Resolve<PlayerItemData>().IntInflation(requiredCount, Data.BattlePassRecord.InflationRate);
                }
                if (curTasks[taskId] == requiredCount || curTasks[taskId] == -1)
                {
                    continue;
                }
                if (task.Type == ConditionType.LoginDays && Data.BattleTask.loginDays.Contains((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek))
                {
                    continue;
                }

                curTasks[taskId] += conditionTypeEvent.count;
                if (curTasks[taskId] >= requiredCount)
                {
                    curTasks[taskId] = requiredCount;
                }

                isUpdata = true;
            }
        }
        curTasks = Data.BattleTask.dic_weeklyTasks;
        curTasksId = Data.BattleTask.dic_weeklyTasks.Keys.ToList();
        //每周任务
        foreach (var taskId in curTasksId)
        {
            var task = tasks.GetOrDefault(taskId);
            if (task == null)
                continue;
            if (task.Type == conditionTypeEvent.type)
            {
                int requiredCount = int.Parse(task.Param[0]);
                if (task.Type == ConditionType.ConsumeEnergy)
                {
                    requiredCount = GContext.container.Resolve<PlayerItemData>().IntInflation(requiredCount, Data.BattlePassRecord.InflationRate);
                }
                if (curTasks[taskId] == requiredCount || curTasks[taskId] == -1)
                {
                    continue;
                }

                if (task.Type == ConditionType.LoginDays && Data.BattleTask.loginDays.Contains((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek))
                {
                    continue;
                }

                curTasks[taskId] += conditionTypeEvent.count;
                if (curTasks[taskId] >= requiredCount)
                {
                    curTasks[taskId] = requiredCount;
                }

                isUpdata = true;
            }
        }
        if (isUpdata)
        {
            if (conditionTypeEvent.type == ConditionType.LoginDays && Data.BattleTask.loginDays.Contains((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek))
            {
                Data.BattleTask.loginDays.Add((int)ZZTimeHelper.UtcNow().UtcNowOffset().DayOfWeek);
            }
            Data.SaveBattleTask();
        }


    }

    public void SetTaskDone(int taskID, bool isDailyTask)
    {
        var tasks = isDailyTask ? Data.BattleTask.dic_dailyTasks : Data.BattleTask.dic_weeklyTasks;
        tasks[taskID] = -1;
        Data.SaveBattleTask();
    }
    #endregion
    public void Dispose()
    {
        disposables?.Dispose();
        disposables = null;
    }

}

public class BattlePassRecord
{
    public int ID;
    public int Level;
    public int Exp;
    //0:Lock,1:Unlock
    public int IsUnlockVip;
    public int BuyVipToastIndex;
    public List<int> NormalRewardGet;
    public List<int> VipRewardGet;
    public List<int> LastDropIDs;
    public float InflationRate;

    public BattlePassRecord()
    {
        ID = 0;
        BuyVipToastIndex = 0;
        Level = 1;
        NormalRewardGet = new List<int>();
        VipRewardGet = new List<int>();
        LastDropIDs = new();
    }
    public void Init(int id)
    {
        ID = id;
        Level = 1;
        Exp = 0;
        BuyVipToastIndex = 0;
        IsUnlockVip = 0;
        NormalRewardGet.Clear();
        VipRewardGet.Clear();
    }
    public string SerializeObject()
    {
        return $"{ID}|{Level}|{Exp}|{BuyVipToastIndex}|{IsUnlockVip}|{string.Join(',', NormalRewardGet)}|{string.Join(',', VipRewardGet)}";
    }
    public void DeserializeObject(string data)
    {
        var arr = data.Split('|');
        ID = int.Parse(arr[0]);
        Level = int.Parse(arr[1]);
        Exp = int.Parse(arr[2]);
        BuyVipToastIndex = int.Parse(arr[3]);
        IsUnlockVip = int.Parse(arr[4]);
        NormalRewardGet = arr[5].Split(',').Where(x => !string.IsNullOrEmpty(x)).Select(x => int.Parse(x)).ToList();
        VipRewardGet = arr[6].Split(',').Where(x => !string.IsNullOrEmpty(x)).Select(x => int.Parse(x)).ToList();
    }
}
public class BattleTask
{
    public Dictionary<int, int> dic_dailyTasks;
    public Dictionary<int, int> dic_weeklyTasks;
    public List<int> loginDays;
    public DateTime DailyTaskEndTime;
    public DateTime WeeklyTaskEndTime;
    public BattleTask()
    {
        dic_dailyTasks = new Dictionary<int, int>();
        dic_weeklyTasks = new Dictionary<int, int>();
        loginDays = new List<int>();
    }
    public string SerializeObject()
    {
        string dailyTasksStr = string.Join(',', dic_dailyTasks.Select(x => $"{x.Key}:{x.Value}"));
        string weeklyTasksStr = string.Join(',', dic_weeklyTasks.Select(x => $"{x.Key}:{x.Value}"));
        string loginDaysStr = string.Join(',', loginDays);
        return $"{dailyTasksStr}|{weeklyTasksStr}|{loginDaysStr}|{DailyTaskEndTime.Ticks}|{WeeklyTaskEndTime.Ticks}";
    }
    public void DeserializeObject(string data)
    {
        var arr = data.Split('|');
        dic_dailyTasks = arr[0].Split(',').Where(x => !string.IsNullOrEmpty(x)).Select(x =>
        {
            var kv = x.Split(':');
            return new KeyValuePair<int, int>(int.Parse(kv[0]), int.Parse(kv[1]));
        }).ToDictionary(x => x.Key, x => x.Value);
        dic_weeklyTasks = arr[1].Split(',').Where(x => !string.IsNullOrEmpty(x)).Select(x =>
        {
            var kv = x.Split(':');
            return new KeyValuePair<int, int>(int.Parse(kv[0]), int.Parse(kv[1]));
        }).ToDictionary(x => x.Key, x => x.Value);
        loginDays = arr[2].Split(',').Where(x => !string.IsNullOrEmpty(x)).Select(x => int.Parse(x)).ToList();
        DailyTaskEndTime = new DateTime(long.Parse(arr[3]));
        WeeklyTaskEndTime = new DateTime(long.Parse(arr[4]));
    }
}