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

public enum MiniBattlePassType
{
    None = 0,
    LuckMagic = 1,
    Dive = 2,
    Fishcard = 3,
}

public enum MiniBattleVIPItemType
{
    None = 0,
    LuckMagic = 4,
    Dive = 5,
    Fishcard = 6,
}

public interface IMiniBattlePassDataProvider
{
    MiniBattlePassRecord GetMiniBattlePassRecord(string key);
    void SetMiniBattlePassRecord(string key, MiniBattlePassRecord record);
}



public class MiniBattlePassDataProvider : IMiniBattlePassDataProvider
{
    private Tables _tables;
    PlayerItemData _playerItemData;
    string oldDataKey => "MiniBPKey";
    string newDataKey => "MiniBPKeyNew";
    Dictionary<MiniBattlePassType, MiniBattlePassDataModel> models = new Dictionary<MiniBattlePassType, MiniBattlePassDataModel>();
    Dictionary<string, MiniBattlePassRecord> datas;
    Dictionary<MiniBattleVIPItemType, MiniBattlePassType> itemSubEventToEventSubEvent = new Dictionary<MiniBattleVIPItemType, MiniBattlePassType>() {
        { MiniBattleVIPItemType.LuckMagic, MiniBattlePassType.LuckMagic },
        { MiniBattleVIPItemType.Dive, MiniBattlePassType.Dive },
        { MiniBattleVIPItemType.Fishcard, MiniBattlePassType.Fishcard }
    };
    public MiniBattlePassDataProvider(Tables tables, PlayerItemData playerItemData)
    {
        _tables = tables;
        _playerItemData = playerItemData;
    }
    public void Refresh(FishingEvent t)
    {
        MiniBattlePassType miniBattlePassType = (MiniBattlePassType)t.SubType;
        if (!models.TryGetValue(miniBattlePassType, out MiniBattlePassDataModel model))
        {
            model = NewModel(miniBattlePassType);
        }
        model.Refresh(t);
    }
    MiniBattlePassDataModel NewModel(MiniBattlePassType subType)
    {
        MiniBattlePassDataModel model;

        model = new MiniBattlePassDataModel(_tables, _playerItemData, subType, this);
        models[subType] = model;
        return model;
    }
    public MiniBattlePassDataModel GetModel(MiniBattlePassType subType)
    {
        if (models.TryGetValue(subType, out MiniBattlePassDataModel model))
        {
            return model;
        }
        return NewModel(subType);
    }

    public void SetVipUnlock(int itemSubType)
    {
        MiniBattlePassType subType;
        itemSubEventToEventSubEvent.TryGetValue((MiniBattleVIPItemType)itemSubType, out subType);
        if (subType == 0)
        {
            Debug.LogError($"MiniBattlePassDataProvider.SetVipUnlock: itemSubType {itemSubType} not found in itemSubEventToEventSubEvent mapping.");
            return;
        }
        if (models.TryGetValue(subType, out MiniBattlePassDataModel model))
        {
            model.SetVipUnlock();
        }
    }

    public MiniBattlePassRecord GetMiniBattlePassRecord(string key)
    {
        MiniBattlePassRecord Data;
        if (datas == null)
        {
            string dataStr = PlayFabMgr.Instance.GetLocalData(newDataKey);
            Debug.Log($"GetMiniBattlePassRecord: dataStr = {dataStr}");
            if (string.IsNullOrEmpty(dataStr))
            {
                datas = new Dictionary<string, MiniBattlePassRecord>();
            }
            else
            {
                datas = JsonConvert.DeserializeObject<Dictionary<string, MiniBattlePassRecord>>(dataStr);
            }
        }
        if (datas.TryGetValue(key, out Data))
        {
            return Data;
        }
        else
        {
            Data = GetOldMiniBattlePassRecord();
            datas[key] = Data;
            return Data;
        }
    }

    MiniBattlePassRecord GetOldMiniBattlePassRecord()
    {
        string dataStr = PlayFabMgr.Instance.GetLocalData(oldDataKey);
        if (string.IsNullOrEmpty(dataStr))
        {
            return new MiniBattlePassRecord();
        }
        else
        {
            return JsonConvert.DeserializeObject<MiniBattlePassRecord>(dataStr);
        }
    }

    public void SetMiniBattlePassRecord(string key, MiniBattlePassRecord record)
    {
        datas[key] = record;
        PlayFabMgr.Instance.UpdateUserDataValue(newDataKey, JsonConvert.SerializeObject(datas));
    }
}
public class MiniBattlePassDataModel
{
    string _dataKey = "BP_";
    MiniBattlePassType _type = MiniBattlePassType.LuckMagic;
    private Tables _tables;
    PlayerItemData _playerItemData;
    MiniBattlePass miniBattlePassTable;
    MiniBattlePassLevel miniBattlePassLevel;
    public string PanelName => miniBattlePassTable.Prefab;
    public List<int> ItemCountShow => miniBattlePassLevel.ItemCount;
    public List<int> ItemShow => miniBattlePassLevel.ItemShow;
    public string Icon => miniBattlePassTable.Icon;
    public int Param => miniBattlePassTable.Param;
    public string TaskDesc => miniBattlePassTable.TaskDesc_l10n_key;
    public List<int> ProgressList => miniBattlePassLevel.TaskParamList;
    public List<int> OverFlow => miniBattlePassTable.OverFlow;

    public List<int> FreeRewards => miniBattlePassLevel.FreeRewardList;
    //public int Type => miniBattlePassTable.Type;
    FishingEvent fishingEvent;
    public DateTime endTime { get; private set; } = DateTime.MinValue; //活动结束时间
    public DateTime startTime = DateTime.MaxValue; //活动开始时间
    public MiniBattlePassRecord Data { get; private set; }
    public bool IsVip => Data.IsVIP;
    public int rewardIndex { get; private set; } = -1;//0~
    CompositeDisposable disposables;
    IMiniBattlePassDataProvider _provider;
    public MiniBattlePassDataModel(Tables tables, PlayerItemData playerItemData, MiniBattlePassType type, IMiniBattlePassDataProvider provider)
    {
        _type = type;
        _tables = tables;
        _playerItemData = playerItemData;
        _dataKey = "BP_" + type;
        _provider = provider;
        Data = new MiniBattlePassRecord();
    }

    void UpdateTaskData(ConditionTypeEvent e)
    {
        if (!IsShow() || Data == null)
        {
            disposables?.Dispose();
            disposables = null;
            return;
        }
        int param = miniBattlePassTable.Param;
        if (param > 0)
        {
            e.count *= param;
        }
        Data.Exp += e.count;
        SetLevel();
        SaveBattlePassRecord();
    }

    void SetLevel()
    {
        var tasks = miniBattlePassLevel?.TaskParamList;
        for (int i = rewardIndex + 1; i < tasks?.Count; i++)
        {
            if (Data.Exp < tasks[i])
            {
                break;
            }
            else
            {
                rewardIndex = i;
            }
        }

        SetRedPoint();
    }



    void SetRedPoint()
    {
        bool isRed = false;
        var freeRewards = miniBattlePassLevel?.FreeRewardList;
        int count = 0;
        if (freeRewards?.Count > rewardIndex)
        {
            if (Data.NRIndexs.Count <= rewardIndex)
            {
                isRed = true;
                count = rewardIndex - Data.NRIndexs.Count + 1;
            }
        }
        else
        {
            isRed = rewardIndex > Data.showIndex;
        }

        if (Data.IsVIP)
        {
            if (Data.VRIndexs.Count <= rewardIndex)
            {
                isRed = true;
                count += rewardIndex - Data.VRIndexs.Count + 1;
            }
        }

        RedPointManager.Instance.SetRedPointState(HomeBtnMiniBP.redKey + _type, isRed, count);
    }

    public void Refresh(FishingEvent t)
    {
        //没有数据或者活动ID不一致时，拿数据再判断
        if (t.ID != Data.Id)
        {
            fishingEvent = t;
            endTime = DateTime.Parse((t.TimeDefinition as LimitedTime).EndTime);
            startTime = DateTime.Parse((t.TimeDefinition as LimitedTime).StartTime);
            InitData();
        }
    }

    public bool IsShow()
    {
        return /*false &&*/ fishingEvent != null
            && miniBattlePassTable != null
            && endTime > ZZTimeHelper.UtcNow()
            && startTime < ZZTimeHelper.UtcNow();
    }


    public bool IsDone()
    {
        return Data.VRIndexs.Count >= miniBattlePassLevel.PrimeRewardList.Count;
    }

    void InitData()
    {
        Data = _provider.GetMiniBattlePassRecord(_dataKey);
        //拿到数据判断刷新活动
        miniBattlePassTable = _tables.TbMiniBattlePass.GetOrDefault(fishingEvent.RedirectID);
        if (Data.Id != fishingEvent.ID)
        {
            int oldRedirectID = Data.RedirectID;
            int oldExp = 0;
            List<int> lastDropIDs = new List<int>();
            if (oldRedirectID > 0)
            {
                var miniTabel = _tables.TbMiniBattlePass.GetOrDefault(oldRedirectID);
                if (miniTabel != null)
                {
                    int Level = Data.PriceLv;
                    int levelId = miniTabel.VipList.Count > Level ? miniTabel.VipList[Level] : miniTabel.VipList[^1];
                    MiniBattlePassLevel passLevel = _tables.TbMiniBattlePassLevel.GetOrDefault(levelId);
                    int lv = GetLevel(Data.Exp, passLevel.TaskParamList);
                    if (lv >= 0)
                    {
                        lastDropIDs = SetLastDropIDs(passLevel, lv, Data.NRIndexs, Data.VRIndexs, Data.IsVIP);
                        oldExp = Data.Exp;
                    }
                }
            }
            Data = new MiniBattlePassRecord();
            Data.Id = fishingEvent.ID;
            Data.PriceLv = GContext.container.Resolve<PlayerData>().PriceLv;
            Data.LastDropIDs = lastDropIDs;
            Data.oldExp = oldExp;
            Data.oldRedirectID = oldRedirectID;
            rewardIndex = -1;
            SaveBattlePassRecord();
        }
        int id = miniBattlePassTable.VipList.Count > Data.PriceLv ? miniBattlePassTable.VipList[Data.PriceLv] : miniBattlePassTable.VipList[^1];
        miniBattlePassLevel = _tables.TbMiniBattlePassLevel.GetOrDefault(id);
        Data.RedirectID = fishingEvent.RedirectID;
        SetLevel();
        disposables?.Dispose();
        disposables = new CompositeDisposable();
        GContext.OnEvent<ConditionTypeEvent>().Where(x => x.type == miniBattlePassTable?.TaskType).Subscribe(UpdateTaskData).AddTo(disposables);
        //string panelName = PanelName;
        //UIType uIType = UITypes.GetOrNew(panelName);
        //GContext.container.Resolve<IFaceUIService>().AddFaceCustomUIData(uIType);
    }

    public bool CheckIfGetLastBpRewards()
    {
        MiniBattlePass miniBattlePass = _tables.TbMiniBattlePass.GetOrDefault(Data.oldRedirectID);
        if (miniBattlePass == null)
        {
            return false;
        }
        int Level = Data.PriceLv;
        int id = miniBattlePass.VipList.Count > Level ? miniBattlePass.VipList[Level] : 0;
        var passLevel = _tables.TbMiniBattlePassLevel.GetOrDefault(id);
        if (Data.LastDropIDs.Count != 0 || (miniBattlePass.OverFlow.Count >= 3 && Data.oldExp > passLevel.TaskParamList[^1]))
        {
            var playerData = GContext.container.Resolve<PlayerItemData>();
            var newList = new List<int>(Data.LastDropIDs);
            var itemDatas = playerData.GetItemDataByDropList(newList);
            int lv = GetLevel(Data.oldExp, passLevel.TaskParamList);
            if (miniBattlePass.OverFlow.Count >= 3)
            {
                int exp = Data.oldExp - passLevel.TaskParamList[^1];
                if (exp >= miniBattlePass.OverFlow[0])
                {
                    ItemData itemData = new ItemData
                    {
                        id = miniBattlePass.OverFlow[2], // 钩子
                        count = exp * miniBattlePass.OverFlow[1] / miniBattlePass.OverFlow[0]
                    };
                    itemDatas.Add(itemData);
                }
            }
            Data.oldExp = 0;
            if (itemDatas.Count == 0)
            {
                return false;
            }
            GContext.Publish(new ShowData(itemDatas));
            playerData.AddItem(itemDatas);
#if AGG
            using (var e = GEvent.GameEvent("minibp_level_reward"))
            {
                e.AddContent("bp_id", miniBattlePass.Id)
                    .AddContent("drop_id_list", JsonConvert.SerializeObject(newList));
                if (itemDatas != null && itemDatas.Count > 0)
                {
                    for (int i = 0; i < itemDatas.Count; i++)
                    {
                        if (itemDatas[i].id == 1001)
                        {
                            e.AddContent("reward_hook", itemDatas[i].count);
                        }
                        else if (itemDatas[i].id == 1002)
                        {
                            e.AddContent("reward_cash", itemDatas[i].count);
                        }
                    }
                }
            }
#endif
            string eventName = "";
            if (miniBattlePass != null)
            {
                eventName = LocalizationMgr.GetText(miniBattlePass.TitleDesc_l10n_key);
            }

            string textValue = LocalizationMgr.GetFormatTextValue("UI_MiniBattlePass_DivePopupPanel_7", eventName);
            GContext.Publish(new ShowData(textValue: textValue));
            Data.LastDropIDs.Clear();
            SaveBattlePassRecord();
            return true;
        }
        return false;
    }

    /// <summary>
    /// 能领奖的等级 从0开始
    /// </summary>
    /// <param name="exp"></param>
    /// <param name="tasks"></param>
    /// <returns></returns>
    int GetLevel(int exp, List<int> tasks)
    {
        int index = -1;
        for (int i = 0; i < tasks.Count; i++)
        {
            if (exp < tasks[i])
            {
                break;
            }
            else
            {
                index = i;
            }
        }
        return index;
    }
    /// <summary>
    /// 获得未获得奖励
    /// </summary>
    /// <param name="miniTabel"></param>
    /// <param name="reward"></param>
    /// <param name="nrIndexs"></param>
    /// <param name="vrIndexs"></param>
    /// <param name="vip"></param>
    /// <returns></returns>
    List<int> SetLastDropIDs(MiniBattlePassLevel passLevel, int reward, List<int> nrIndexs, List<int> vrIndexs, bool vip)
    {
        var freeRewards = passLevel.FreeRewardList;
        var primeRewards = passLevel.PrimeRewardList;
        List<int> rewardList = new List<int>();
        if (freeRewards.Count > reward)
        {
            for (int i = 0; i <= reward; i++)
            {
                if (!nrIndexs.Contains(i))
                {
                    rewardList.Add(freeRewards[i]);
                }
            }
        }
        if (vip)
        {
            for (int i = 0; i <= reward; i++)
            {
                if (!vrIndexs.Contains(i))
                {
                    rewardList.Add(primeRewards[i]);
                }
            }
        }
        return rewardList;
    }

    /// <summary>
    /// 展示后
    /// </summary>
    public void SetOldLevel()
    {
        if (Data != null)
        {
            Data.showIndex = rewardIndex;
            SaveBattlePassRecord();
        }
    }

    void CheckDone()
    {
        if (IsDone())
        {
            GContext.Publish(new TargetEvent(fishingEvent.ID, fishingEvent.Type, fishingEvent.SubType));
        }
    }

    public void ReceiveReward(int index, bool isFree)
    {
        if (Data != null)
        {
            var freeRewards = miniBattlePassLevel.FreeRewardList;
            var primeRewards = miniBattlePassLevel.PrimeRewardList;
            int dropid = 0;
            if (isFree)
            {
                if (!Data.NRIndexs.Contains(index))
                {
                    Data.NRIndexs.Add(index);
                    dropid = freeRewards[index];
                    miniBPItemDatas[index].isFreeClaimed = true;
                }
            }
            else if (Data.IsVIP)
            {

                if (!Data.VRIndexs.Contains(index))
                {
                    Data.VRIndexs.Add(index);
                    dropid = primeRewards[index];
                    miniBPItemDatas[index].isGrandClaimed = true;
                }
            }
            if (dropid == 0)
            {
                return;
            }
            List<ItemData> itemDatas = _playerItemData.AddItemByDrop(dropid);
            GContext.Publish(new ShowData());
            CheckDone();
            SaveBattlePassRecord();
#if AGG
            using (var e = GEvent.GameEvent("minibp_reward"))
            {
                e.AddContent("bp_level", index + 1)
                    .AddContent("bp_id", Data.RedirectID)
                    .AddContent("event_id", Data.Id)
                    .AddContent("is_activate", Data.IsVIP)
                  .AddContent("drop_id_list", dropid);
                if (itemDatas != null && itemDatas.Count > 0)
                {
                    for (int i = 0; i < itemDatas.Count; i++)
                    {
                        if (itemDatas[i].id == 1001)
                        {
                            e.AddContent("reward_hook", itemDatas[i].count);
                        }
                        else if (itemDatas[i].id == 1002)
                        {
                            e.AddContent("reward_cash", itemDatas[i].count);
                        }
                    }
                }
            }
#endif
        }
    }

    public void ReceiveAllReward()
    {
        if (Data != null)
        {
            var freeRewards = miniBattlePassLevel.FreeRewardList;
            var primeRewards = miniBattlePassLevel.PrimeRewardList;
            List<int> rewardList = new List<int>();
            if (freeRewards.Count > rewardIndex)
            {
                for (int i = 0; i <= rewardIndex; i++)
                {
                    if (!Data.NRIndexs.Contains(i))
                    {
                        Data.NRIndexs.Add(i);
                        rewardList.Add(freeRewards[i]);
                    }
                }
            }
            if (Data.IsVIP)
            {
                for (int i = 0; i <= rewardIndex; i++)
                {
                    if (!Data.VRIndexs.Contains(i))
                    {
                        Data.VRIndexs.Add(i);
                        rewardList.Add(primeRewards[i]);
                    }
                }
            }
            if (rewardList.Count == 0)
            {
                return;
            }
            List<ItemData> itemDatas = _playerItemData.AddItemByDropList(rewardList);
            GContext.Publish(new ShowData());
            RefreshDataReward();
            CheckDone();

            SaveBattlePassRecord();
#if AGG
            using (var e = GEvent.GameEvent("minibp_reward"))
            {
                e.AddContent("bp_level", rewardIndex + 1)
                    .AddContent("bp_id", Data.RedirectID)
                    .AddContent("event_id", Data.Id)
                    .AddContent("is_activate", Data.IsVIP)
                  .AddContent("drop_id_list", JsonConvert.SerializeObject(rewardList));
                if (itemDatas != null && itemDatas.Count > 0)
                {
                    for (int i = 0; i < itemDatas.Count; i++)
                    {
                        if (itemDatas[i].id == 1001)
                        {
                            e.AddContent("reward_hook", itemDatas[i].count);
                        }
                        else if (itemDatas[i].id == 1002)
                        {
                            e.AddContent("reward_cash", itemDatas[i].count);
                        }
                    }
                }
            }
#endif
        }
    }

    public void SaveBattlePassRecord()
    {
        SetRedPoint();
        _provider.SetMiniBattlePassRecord(_dataKey, Data);
    }

    public IAPItemList GetIAPItem()
    {
        return _tables.TbIAPItemList.GetOrDefault(miniBattlePassLevel.IapId);
    }

    public async Task<bool> BuyBattlePass()
    {
        var iAPItemList = _tables.TbIAPItemList.GetOrDefault(miniBattlePassLevel.IapId);
        int dropID = miniBattlePassLevel.ActivateId;
        var itemDatas = GContext.container.Resolve<PlayerItemData>().GetItemDataByDropId(dropID);

        ShopBuyTypeData shopBuyTypeData = new ShopBuyTypeData();
        shopBuyTypeData.type = ShopBuyType.None;
        shopBuyTypeData.IsHide = true;
        bool Result = await GContext.container.Resolve<PlayerShopData>().OnBuy(dropID, shopBuyTypeData, iAPItemList, itemDatas);
        if (Result)
        {
            RefreshDataVIP();
        }
        return Result;

    }

    void RefreshDataVIP()
    {
        if (miniBPItemDatas != null && miniBPItemDatas.Count > 0)
        {
            for (int i = 0; i < miniBPItemDatas.Count; i++)
            {
                miniBPItemDatas[i].isGrandReward = true;
            }
        }
    }

    void RefreshDataReward()
    {
        if (miniBPItemDatas != null && miniBPItemDatas.Count > 0)
        {
            for (int i = 0; i < miniBPItemDatas.Count; i++)
            {
                var item = miniBPItemDatas[i];
                item.isGrandClaimed = Data.VRIndexs.Contains(i);
                item.isFreeClaimed = Data.NRIndexs.Contains(i);
            }
        }
    }

    public void SetVipUnlock()
    {
        if (Data != null)
        {
            Data.IsVIP = true;
            SaveBattlePassRecord();
        }
    }

    public void SetPanelData()
    {
        if (miniBattlePassTable == null)
        {
            miniBattlePassTable = _tables.TbMiniBattlePass.GetOrDefault(fishingEvent.RedirectID);
        }
        if (miniBattlePassTable == null)
        {
            return;
        }
        int Level = Data.PriceLv;
        int id = miniBattlePassTable.VipList.Count > Level ? miniBattlePassTable.VipList[Level] : miniBattlePassTable.VipList[^1];
        miniBattlePassLevel = _tables.TbMiniBattlePassLevel.GetOrDefault(id);
        SetData();
    }

    public List<MiniBPItemData> miniBPItemDatas;

    void SetData()
    {
        miniBPItemDatas = new List<MiniBPItemData>();
        var tasks = miniBattlePassLevel.TaskParamList;
        var FreeRewardList = miniBattlePassLevel.FreeRewardList;
        var PrimeRewardList = miniBattlePassLevel.PrimeRewardList;
        string format = LocalizationMgr.GetText(miniBattlePassTable.TaskDesc_l10n_key);
        for (int i = 0; i < tasks.Count; i++)
        {
            MiniBPItemData item = new MiniBPItemData();
            item.index = i;
            item.progress = Data.Exp;
            item.maxProgress = tasks[i];
            item.taskName = format.SafeFormat(tasks[i]);
            if (FreeRewardList.Count > i)
            {
                item.freeReward = _playerItemData.GetItemDataOne(FreeRewardList[i]);
            }
            item.grandReward = _playerItemData.GetItemDataOne(PrimeRewardList[i]);
            item.isGrandReward = Data.IsVIP;
            item.isGrandClaimed = Data.VRIndexs.Contains(i);
            item.isFreeClaimed = Data.NRIndexs.Contains(i);
            miniBPItemDatas.Add(item);
        }
    }


    ~MiniBattlePassDataModel()
    {
        Dispose();
    }

    void Dispose()
    {
        disposables?.Dispose();
        disposables = null;
    }
}


public class MiniBattlePassRecord
{
    /// <summary>
    /// 活动ID
    /// </summary>
    public int Id;
    public int RedirectID;
    public int PriceLv;
    /// <summary>
    /// 普通领奖进度
    /// </summary>
    public List<int> NRIndexs = new List<int>();
    /// <summary>
    /// 是否付费
    /// </summary>
    public bool IsVIP;
    /// <summary>
    /// 付费领奖进度
    /// </summary>
    public List<int> VRIndexs = new List<int>();
    public int oldRedirectID;
    public int oldExp;
    public List<int> LastDropIDs = new List<int>();
    /// <summary>
    /// 展示过的等级，和新等级之间表现用
    /// </summary>
    public int showIndex;
    /// <summary>
    /// 累计经验
    /// </summary>
    public int Exp;
}