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

public class EventOfferJourneyTableContext
{
    private int _eventId, _redirectId;
    private Tables _tables;
    private EventOfferJourneyMain _tableMain;
    private FishingEvent _tableEvent;
    public int MaxRoundCount => _tableMain.Round;
    public string EntranceIconUrl => _tableMain.Icon;

    private EventOfferJourneyTableContext() { }

    public static EventOfferJourneyTableContext CreateNew(int eventId)
    {
        var ctx = new EventOfferJourneyTableContext();
        ctx._tables = GContext.container.Resolve<Tables>();
        ctx._eventId = eventId;
        var res = GContext.container.Resolve<Tables>().TbFishingEvent.DataMap.TryGetValue(eventId, out ctx._tableEvent);
        if (!res)
        {
            return null;
        }
        ctx._redirectId = ctx._tableEvent.RedirectID;
        ctx._tableMain = GContext.container.Resolve<Tables>().TbEventOfferJourneyMain[ctx._redirectId];
        return ctx;
    }

    public static EventOfferJourneyTableContext GetTestSample()
    {
        var ctx = new EventOfferJourneyTableContext();
        ctx._tables = GContext.container.Resolve<Tables>();
        ctx._eventId = 114514;
        ctx._redirectId = 90502001;
        ctx._tableMain = GContext.container.Resolve<Tables>().TbEventOfferJourneyMain[ctx._redirectId];
        ctx._tableEvent = GContext.container.Resolve<Tables>().TbFishingEvent[ctx._eventId];
        ctx._redirectId = ctx._tableEvent.RedirectID;
        return ctx;
    }

    public List<EventOfferJourneyBlockData> GetRewardList(int vipLvl)
    {
        var packData = _tables.TbEventPackManager.GetOrDefault(_tableMain.PackId);
        var res = new List<EventOfferJourneyBlockData>();
        if (packData == null)
        {
            Debug.Log("[EventOfferJourney] packData not found.");
            return res;
        }
        var baseTicketCostList = _tableMain.ItemRequireBase;
        var packList = packData.VIPPackList[Mathf.Clamp(vipLvl, 0, packData.VIPPackList.Count - 1)].Select(id => _tables.TbPack.GetOrDefault(id)).ToArray();
        UnityEngine.Assertions.Assert.IsTrue(packList.Length == baseTicketCostList.Count,
            $"iap count {packList.Length} and main table count {baseTicketCostList.Count} does not match");
        var vipMultiplier = _tableMain.ItemMultipleVip[Mathf.Clamp(vipLvl, 0, _tableMain.ItemMultipleVip.Count - 1)];
        for (int i = 0; i < packList.Length; i++)
        {
            var iapId = packList[i].IAPID;
            var dropId = packList[i].DropID;
            var ticketCost = GetTicketCost(baseTicketCostList[i], vipMultiplier, _tableMain.Multiple);
            if (iapId != 0)
                res.Add(EventOfferJourneyBlockData.CreateIapData(iapId, dropId));
            else
                res.Add(EventOfferJourneyBlockData.CreateTicketData(ticketCost, dropId));
        }
        return res;
    }

    public int GetDropIdByProgress(int progress, int vipLvl)
    {
        var packData = _tables.TbEventPackManager.GetOrDefault(_tableMain.PackId);
        if (packData == null)
        {
            Debug.Log("[EventOfferJourney] packData not found.");
            return -1;
        }
        // var baseTicketCostList = _tableMain.ItemRequireBase;
        var packList = packData.VIPPackList[Mathf.Clamp(vipLvl, 0, packData.VIPPackList.Count - 1)].Select(id => _tables.TbPack.GetOrDefault(id)).ToArray();
        // UnityEngine.Assertions.Assert.IsTrue(packList.Length == baseTicketCostList.Count,
        //     $"iap count {packList.Length} and main table count {baseTicketCostList.Count} does not match");
        if (progress >= packList.Length)
            return packList[packList.Length - 1].DropID;
        else
            return packList[progress].DropID;
    }

    public Tuple<DateTime, DateTime> GetEventStartTimeAndEndTime()
    {
        try
        {
            var et = DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).EndTime);
            var st = DateTime.Parse((_tableEvent.TimeDefinition as LimitedTime).StartTime);
            return new Tuple<DateTime, DateTime>(st, et);
        }
        catch (Exception e)
        {
            Debug.LogError(e);
            return new Tuple<DateTime, DateTime>(DateTime.MinValue, DateTime.MinValue);
        }
    }

    public int GetTicketCostByProgress(int progress, int vipLvl)
    {
        var baseTicketCostList = _tableMain.ItemRequireBase;
        var vipMultiplier = _tableMain.ItemMultipleVip[Mathf.Clamp(vipLvl, 0, _tableMain.ItemMultipleVip.Count - 1)];
        var modUnit = _tableMain.Multiple;
        var ticketCost = GetTicketCost(baseTicketCostList[progress], vipMultiplier, modUnit);
        return ticketCost;
    }

    public static int GetTicketCost(int baseCost, float multiplier, int modUnit)
    {
        var intCost = (int)(baseCost * multiplier);
        var data = GContext.container.Resolve<IEventOfferJourneyData>();
        if (data != null)
        {
            intCost = GContext.container.Resolve<PlayerItemData>().IntInflation(intCost, data.InflationRate);
        }
        // Debug.Log($"[EventOfferJourney] {intCost} = {baseCost} * {multiplier}");
        var residual = intCost % modUnit;
        if (residual == 0)
        {
            return intCost;
        }
        else if (residual >= modUnit / 2f)
        {
            return intCost + (modUnit - residual);
        }
        else
        {
            return intCost - residual;
        }
    }

    public EventOfferJourneyUiData GetUiData()
    {
        return new EventOfferJourneyUiData()
        {
            PanelUrl = _tableMain.UIPanel,
            InfoPanelUrl = _tableMain.InfoPanel
        };
    }

    public int[] GetTicketRewardArray()
    {
        return _tableMain.PointsGet.ToArray();
    }

    public string GetTicketName()
    {
        var id = _tableMain.Item;
        var item = _tables.TbItem.GetOrDefault(id);
        if (item == null)
            return string.Empty;
        return LocalizationMgr.GetText(item.Name_l10n_key);
    }

    public int GetTicketId()
    {
        return _tableMain.Item;
    }

    public int GetStartPosParam()
    {
        return _tableMain.StartPos;
    }
}

public class EventOfferJourneyLvlTriggerTableContext
{
    public static int ThePackId = 90501001;
    private readonly Tables _tables = GContext.container.Resolve<Tables>();
    private EventOfferJourneyMain TableMain => _tables.TbEventOfferJourneyMain[ThePackId];
    public int TriggerPackId => TableMain.PackId;
    public int MaxRoundCount => TableMain.Round;
    private TriggerPackBuyData PackTriggerData => GContext.container.Resolve<TriggerPackData>().GetTriggerPackBuyDataById(TriggerPackId);
    public bool IsEventActive => PackTriggerData != null;
    public int VipLvlOnTrigger => PackTriggerData.vipLevel;
    public string EntranceIconUrl => TableMain.Icon;

    public List<EventOfferJourneyBlockData> GetRewardList()
    {
        var packData = _tables.TbTriggerPackManager.GetOrDefault(TableMain.PackId);
        var res = new List<EventOfferJourneyBlockData>();
        if (packData == null)
        {
            Debug.Log($"[EventOfferJourney] packData not found for {TableMain.PackId}");
            return res;
        }
        var baseTicketCostList = TableMain.ItemRequireBase;
        var packList = packData.VIPPackList[Mathf.Clamp(VipLvlOnTrigger, 0, packData.VIPPackList.Count - 1)]
            .Select(id => _tables.TbPack.GetOrDefault(id)).ToArray();
        UnityEngine.Assertions.Assert.IsTrue(packList.Length == baseTicketCostList.Count,
            $"iap count {packList.Length} and main table count {baseTicketCostList.Count} does not match");
        var vipMultiplier = TableMain.ItemMultipleVip[PackTriggerData.vipLevel];
        for (int i = 0; i < packList.Length; i++)
        {
            var iapId = packList[i].IAPID;
            var dropId = packList[i].DropID;
            var ticketCost = EventOfferJourneyTableContext.GetTicketCost(baseTicketCostList[i], vipMultiplier, TableMain.Multiple);
            if (iapId != 0)
                res.Add(EventOfferJourneyBlockData.CreateIapData(iapId, dropId));
            else
                res.Add(EventOfferJourneyBlockData.CreateTicketData(ticketCost, dropId));
        }
        return res;
    }

    public int GetTicketCostByProgress(int progress)
    {
        var baseTicketCostList = TableMain.ItemRequireBase;
        float vipMultiplier;
        if (IsEventActive)
            vipMultiplier = TableMain.ItemMultipleVip[Mathf.Clamp(VipLvlOnTrigger, 0, TableMain.ItemMultipleVip.Count - 1)];
        else
        {
            Debug.LogWarning("[EventOfferJourney] No trigger pack data. This is a problem.");
            vipMultiplier = 1;
        }
        var ticketCost = EventOfferJourneyTableContext.GetTicketCost(baseTicketCostList[progress], vipMultiplier, TableMain.Multiple);
        return ticketCost;
    }

    public EventOfferJourneyUiData GetUiData()
    {
        return new EventOfferJourneyUiData
        {
            PanelUrl = TableMain.UIPanel,
            InfoPanelUrl = TableMain.InfoPanel
        };
    }

    public Tuple<DateTime, DateTime> GetEventStartTimeAndEndTime()
    {
        try
        {
            var cur = ZZTimeHelper.UtcNow();
            var et = GlobalUtils.TryParseDateTime(PackTriggerData.time, cur);
            var st = et - TimeSpan.FromDays(7);
            return new Tuple<DateTime, DateTime>(st, et);
        }
        catch (Exception e)
        {
            Debug.LogError(e);
            return new Tuple<DateTime, DateTime>(DateTime.MinValue, DateTime.MinValue);
        }
    }

    public int[] GetTicketRewardArray()
    {
        return TableMain.PointsGet.ToArray();
    }

    public string GetTicketName()
    {
        var id = TableMain.Item;
        var item = _tables.TbItem.GetOrDefault(id);
        if (item == null)
            return string.Empty;
        return LocalizationMgr.GetText(item.Name_l10n_key);
    }

    public int GetTicketId()
    {
        return TableMain.Item;
    }

    public int GetStartPosParam()
    {
        return TableMain.StartPos;
    }
}