using System.Collections.Generic;
using System.Linq;
using asap.core;
using cfg;
using GameCore;
using UnityEngine;

public class EventCanTableContext
{
    private Tables _tables;
    private EventCanMain _eventCanMain = null;
    private TbEventCanRange _totalRewardPool = null;
    private FishingEventCycleItem2 _tableCycle = null;
    private FishingEvent _tableEvent = null;

    private EventCanTableContext(Tables tables, EventCanMain eventCanMain,
        FishingEventCycleItem2 tableCycle, FishingEvent tableEvent)
    {
        _tables = tables;
        _eventCanMain = eventCanMain;
        _totalRewardPool = _tables.TbEventCanRange;
        _tableCycle = tableCycle;
        _tableEvent = tableEvent;
    }

    public EventCanTableContext() { }

    public void ReadTables(int eventId)
    {
        int redirectId, cycleId;
        _tables = GContext.container.Resolve<Tables>();
        cycleId = _tables.TbFishingEvent[eventId].RedirectID;
        redirectId = _tables.TbFishingEventCycleItem2[cycleId].RedirectID;
        _tableEvent = _tables.TbFishingEvent[eventId];
        _tableCycle = _tables.TbFishingEventCycleItem2[cycleId];
        _eventCanMain = _tables.TbEventCanMain[redirectId];
        _totalRewardPool = _tables.TbEventCanRange;
        return;
    }

    public List<EventCanRewardInfo> InitRewardPool()
    {
        var rewardIdList = _eventCanMain.CanRange;
        var rewardPool = new List<EventCanRewardInfo>();
        EEventCanRewardType rewardType;
        int weight;
        foreach (var idx in rewardIdList)
        {
            if (!_totalRewardPool.DataMap.TryGetValue(idx, out var eventCanRange))
            {
                Debug.Log($"[EventCan]No table data found for reward id {idx}");
                continue;
            }
            if (eventCanRange.Weight <= 0)
                continue;
            rewardType = GetRewardType(idx);
            weight = eventCanRange.MinMax.Count == 2 ? 0 : eventCanRange.Weight;
            rewardPool.Add(new EventCanRewardInfo()
            {
                RewardId = eventCanRange.RangeID,
                RewardType = rewardType,
                ItemId = eventCanRange.ItemID,
                ItemCount = eventCanRange.ItemNum,
                BaseWeight = weight
            });
        }
        return rewardPool;
    }

    public EEventCanRewardType GetRewardType(int rewardId)
    {
        return (EEventCanRewardType)(rewardId % 10000 / 1000);
    }

    public bool GetWeightChangeThreshold(int rewardId, out (int rewardAppearDraws, int rewardMustDropDraws) res)
    {
        if (!_tables.TbEventCanRange.DataMap.TryGetValue(rewardId, out var eventCanRange) || eventCanRange.MinMax.Count != 2)
        {
            // Debug.Log($"[EventCan]No weigth change data found for reward id {rewardId}");
            res = (0, 0);
            return false;
        }
        res = (eventCanRange.MinMax[0], eventCanRange.MinMax[1]);
        return true;
    }

    public int GetRewardWeight(int rewardId)
    {
        if (!_tables.TbEventCanRange.DataMap.TryGetValue(rewardId, out var eventCanRange))
        {
            Debug.Log($"[EventCan]No table data found for reward id {rewardId}");
            return 0;
        }
        return eventCanRange.Weight;
    }

    public Dictionary<EEventCanRewardType, EventCanGemTaskInfo> InitGemTaskInfo()
    {
        var res = new List<EventCanGemTaskInfo>();
        _eventCanMain.GemReward.ForEach(
            x =>
            {
                var gemTask = _tables.TbEventCanGemReward.Get(x);
                var rewardItemData = new ItemData(gemTask.ItemDrop, gemTask.ItemDropNum);
                GContext.container.Resolve<PlayerItemData>().ItemTransition(rewardItemData);
                res.Add(new EventCanGemTaskInfo()
                {
                    TaskId = x,
                    CurrentGemProgress = 0,
                    TotalGemRequired = gemTask.GemRequired,
                    Reward = rewardItemData
                });
            }
        );
        return res.ToDictionary(x => (EEventCanRewardType)(x.TaskId % 1000 / 100), x => x);
    }

    public EventCanGemTaskInfo GetGemTaskInfo(int taskId, int currentGemProgress = 0)
    {
        // var gemTask = _tables.TbEventCanGemReward.Get(TaskId);
        if (!_tables.TbEventCanGemReward.DataMap.TryGetValue(taskId, out var gemTask))
        {
            Debug.Log($"[EventCan]Gem task id {taskId} not found in gem reward table.");
            return null;
        }
        var rewardItemData = new ItemData(gemTask.ItemDrop, gemTask.ItemDropNum);
        GContext.container.Resolve<PlayerItemData>().ItemTransition(rewardItemData);
        return new EventCanGemTaskInfo()
        {
            TaskId = taskId,
            CurrentGemProgress = currentGemProgress,
            TotalGemRequired = gemTask.GemRequired,
            Reward = rewardItemData
        };
    }

    public bool GetNextProgressTaskInfo(EventCanProgressTaskInfo currentTaskInfo)
    {
        var rewardList = _eventCanMain.CanReward;
        var idx = (currentTaskInfo.TaskIdx + 1) % rewardList.Count;
        var rewardId = rewardList[idx];
        if (!_tables.TbEventCanReward.DataMap.TryGetValue(rewardId, out var eventCanReward))
        {
            Debug.Log($"[EventCan]No table data found for reward id {rewardId}");
            return false;
        }
        var itemData = new ItemData(eventCanReward.ItemID, eventCanReward.Num);
        GContext.container.Resolve<PlayerItemData>().ItemTransition(itemData);
        currentTaskInfo.TaskIdx = idx;
        currentTaskInfo.CurrentProgress -= currentTaskInfo.TotalProgressRequired;
        currentTaskInfo.TotalProgressRequired = eventCanReward.Consume;
        currentTaskInfo.Reward = itemData;
        return true;
    }

    public EventCanProgressTaskInfo InitProgressTaskInfo()
    {
        var eventCanReward = _tables.TbEventCanReward.DataList[0];
        var itemData = new ItemData(eventCanReward.ItemID, eventCanReward.Num);
        GContext.container.Resolve<PlayerItemData>().ItemTransition(itemData);
        return new EventCanProgressTaskInfo()
        {
            TaskIdx = 0,
            CurrentProgress = 0,
            TotalProgressRequired = eventCanReward.Consume,
            Reward = itemData,
        };
    }

    public bool GetProgressInfoByIdx(int idx, out int ProgressRequired, out ItemData Reward)
    {
        var taskIdList = _eventCanMain.CanReward;
        ProgressRequired = 0;
        Reward = null;
        if (idx >= taskIdList.Count || idx < 0)
        {
            Debug.Log($"[EventCan]Idx {idx} out of range {taskIdList.Count}.");
            return false;
        }
        var task = _tables.TbEventCanReward[taskIdList[idx]];
        Reward = new ItemData(task.ItemID, task.Num);
        GContext.container.Resolve<PlayerItemData>().ItemTransition(Reward);
        ProgressRequired = task.Consume;
        return true;
    }

    public bool GetNextGemTaskInfo(EventCanGemTaskInfo currentTaskInfo)
    {
        var id = currentTaskInfo.TaskId;
        if (!_tables.TbEventCanGemReward.DataMap.TryGetValue(id, out var eventCanGemRewardData))
        {
            Debug.Log($"[EventCan]No table data found for gem reward id {id}");
            return false;
        }
        if (!_tables.TbEventCanGemReward.DataMap.TryGetValue(eventCanGemRewardData.NextTarget, out var newGemRewardData))
        {
            Debug.Log($"[EventCan]No table data found for gem reward id {eventCanGemRewardData.NextTarget}");
            return false;
        }
        var itemData = new ItemData(newGemRewardData.ItemDrop, newGemRewardData.ItemDropNum);
        GContext.container.Resolve<PlayerItemData>().ItemTransition(itemData);
        currentTaskInfo.TaskId = newGemRewardData.TaskID;
        currentTaskInfo.CurrentGemProgress -= currentTaskInfo.TotalGemRequired;
        currentTaskInfo.TotalGemRequired = newGemRewardData.GemRequired;
        currentTaskInfo.Reward = itemData;
        return true;
    }

    public int GetMaxCanCount()
    {
        return _eventCanMain.CanMax;
    }


    public int GetWelcomeGift()
    {
        return _tableCycle.WelcomeGift;
    }

    public Dictionary<int, int> GetInitialDrawsSinceLastRewards()
    {
        return _eventCanMain.CanRange.Select(id => _tables.TbEventCanRange[id])
            .Where(reward => reward.MinMax.Count == 2)
            .ToDictionary(reward => reward.RangeID, _ => 0);
    }

    public EventCanEntranceBtnData GetEntranceBtnData()
    {
        var res = new EventCanEntranceBtnData();
        res.BtnIconUrl = _eventCanMain.Icon;
        res.RedPointTicketThreshold = _tableCycle.RedDot;
        System.DateTime et = new System.DateTime(), st = new System.DateTime();
        try
        {
            et = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).EndTime);
            st = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).StartTime);
        }
        catch (System.Exception e)
        {
            Debug.Log($"[EventCan] {e.Message}\n{e.StackTrace}");
            return null;
        }
        finally
        {
            res.ExpiryTime = et;
            res.StartTime = st;
        }
        return res;
    }

    public EventChainPackInfo GetPackData()
    {
        var chainList = _tables.TbEventPackManager[_eventCanMain.PackId].VIPPackList[0];
        var expireTime = new System.DateTime();
        try
        {
            expireTime = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).EndTime);
        }
        catch (System.Exception e)
        {
            Debug.Log($"[EventBreak] {e.Message}\n{e.StackTrace}");
            return null;
        }
        var chainListIdSet = chainList.ToHashSet();
        var packs = _tables.TbPack.DataList.Where(p => chainListIdSet.Contains(p.ID)).ToArray();//?
        return new EventChainPackInfo()
        {
            ChainList = chainList,
            ExpireTime = expireTime,
            Packs = packs,
            RedPointKey = "eventcan.pack"
        };
    }

    public GeneralEventNormalPackInfo GetNormalPackInfo()
    {
        var expireTime = new System.DateTime();
        try
        {
            expireTime = System.DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).EndTime);
        }
        catch (System.Exception e)
        {
            Debug.Log($"[EventBreak] {e.Message}\n{e.StackTrace}");
            return null;
        }
        var packList = _tables.TbEventPackManager[_eventCanMain.PackId2].VIPPackList[0];
        return new GeneralEventNormalPackInfo
        {
            EventId = _tableEvent.ID,
            PackLeft = _tables.TbPack[packList[0]],
            PackRight = _tables.TbPack[packList[1]],
            ExpireTime = expireTime,
        };
    }
}