//using DG.Tweening;
//using System.Collections;
//using System.Collections.Generic;
//using UnityEngine;
//using UnityEngine.UI;

//public class CardMiniGameSystem : MonoBehaviour
//{
//    public List<GameObject> cardSlots;
//    public List<GameObject> openCardSlots;
//    public List<Transform> cardPositions;
//    public Transform cardStartPos;
//    public Transform cardEndingPos;

//    Vector3 originalFirstCardPos;
//    private void Start()
//    {
//        SetFirstDeck();


//    }

//    void SetFirstDeck()
//    {
//        Debug.Log($"SetFirstDeck");
//        float counter = 0;
//        for (int i = 0; i < cardSlots.Count; i++)
//        {
//            counter += 0.2f;

//            cardSlots[i].transform.position = cardStartPos.position;
//            cardSlots[i].transform.eulerAngles = cardStartPos.eulerAngles;
//            StartCoroutine(SpawnCards(counter, i));

//        }
//    }

//    IEnumerator SpawnCards(float waitTime, int card)
//    {
//        yield return new WaitForSeconds(waitTime);

//        cardSlots[card].transform.DOMove(cardPositions[card].position, 0.5f);
//        cardSlots[card].transform.DORotate(cardPositions[card].eulerAngles, 0.5f);

//    }


//    public void PickCard(int card) // Mi smo odabrali
//    {
//        cardSlots[card].transform.DORotate(new Vector3(0f, -90f, 0f), 0.3f).OnComplete(() =>
//        {
//            cardSlots[card].SetActive(false);
//            openCardSlots[card].transform.eulerAngles = new Vector3(0f, 90f, 0f);
//            openCardSlots[card].SetActive(true);
//            openCardSlots[card].transform.DORotate(new Vector3(0f, 0f, 0f), 0.3f);


//            StartCoroutine(OtherCards(0.75f, card)); // Otkrivamo ostale karte

//        });


//    }

//    IEnumerator OtherCards(float waitTime, int card)
//    {
//        yield return new WaitForSeconds(waitTime);
//        for (int i = 0; i < cardSlots.Count; i++)
//        {
//            Debug.Log($"Iteracija {i}");
//            if (i != card)
//            {
//                Debug.Log($"Flipping card {i}, because it is not the same as {card}");
//                cardSlots[i].transform.DORotate(new Vector3(0f, -90f, 0f), 0.3f);
//                Debug.Log($"Moving card {i}");
//                PickOtherCards(i);
//            }
//        }
//    }


//    public void PickOtherCards(int card) // Pokazuje ostale karte koje nismo odabrali
//    {
//        cardSlots[card].transform.DORotate(new Vector3(0f, -90f, 0f), 0.3f).OnComplete(() =>
//        {
//            cardSlots[card].SetActive(false);
//            openCardSlots[card].transform.eulerAngles = new Vector3(0f, 90f, 0f);
//            openCardSlots[card].GetComponent<Image>().color = new Color(0.6f, 0.6f, 0.6f, 0.8f);
//            openCardSlots[card].SetActive(true);
//            openCardSlots[card].transform.DORotate(new Vector3(0f, 0f, 0f), 0.3f);

//            Invoke(nameof(ReshuffleCards), 0.5f);
//        });


//    }


//    public void ReshuffleCards()
//    {
//        Debug.Log($"ReshuffleCards");
//        float counter = 0;
//        for (int i = 0; i < cardSlots.Count; i++)
//        {
//            counter += 0.05f;
//            StartCoroutine(SendCardsAway(counter, i));


//            if (i == cardSlots.Count - 1) Invoke(nameof(SetFirstDeck), 2f);

//        }



//    }

//    IEnumerator SendCardsAway(float waitTime, int card)
//    {
//        yield return new WaitForSeconds(waitTime);
//        openCardSlots[card].transform.DOMove(cardStartPos.position, 0.5f);
//        openCardSlots[card].transform.DORotate(cardStartPos.eulerAngles, 0.5f).OnComplete(() => 
//        {
//            openCardSlots[card].SetActive(false);
//            openCardSlots[card].GetComponent<Image>().color = Color.white;
//            openCardSlots[card].transform.position = cardPositions[card].position;
//            openCardSlots[card].transform.eulerAngles = cardPositions[card].eulerAngles;



//        });
//        cardSlots[card].transform.position = cardStartPos.position;
//        cardSlots[card].transform.eulerAngles = cardStartPos.eulerAngles;
//        cardSlots[card].SetActive(true);

//    }





//}
using DG.Tweening;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
using Newtonsoft.Json;
using UnityEditor.PackageManager.Requests;

public class CardMiniGameSystem : MonoBehaviour
{
    [Header("Animacije")]
    public List<GameObject> cardSlots;
    public List<GameObject> openCardSlots;
    public List<Transform> cardPositions;
    public Transform cardStartPos;
    public Transform cardEndingPos;

    [Header("Config")]
    public string configUrl = "https://imperium1.imperiummultimedia.com/pfl/cards.json";
    public int maxLevel = 25;

    [Header("UI Dugmići")]
    public GameObject TakeLootBtn;
    public GameObject ContinueBtn;
    public GameObject ContinuePrice;
    public Text continuePriceValue;
    [SerializeField]
    private CardMiniGameData config;
    private int currentLevel = 1;
    private bool gameActive = false;
    private List<Reward> allCollectedRewards = new();
    private List<Reward> currentCardSet = new();

    private bool isFailContinueState = false;
    private int failedCardIndex = -1;
    private bool[] cardRevealedStates;
    [Space(10)]
    public Image levelFillbar;
    public Text levelText;
    [Space(10)]
    public GameObject collectedItemSlot;
    public GridLayoutGroup collectedItemsGrid;
    public List<GameObject> collectSlots;

    private void Start()
    {
        StartCoroutine(LoadConfig());
    }

    IEnumerator LoadConfig()
    {
        UnityWebRequest request = UnityWebRequest.Get(configUrl);
        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            config = JsonConvert.DeserializeObject<CardMiniGameData>(request.downloadHandler.text);
            Debug.Log("MiniGame - Config loaded.");
            StartMiniGame();
        }
        else
        {
            Debug.LogError("Failed to load config: " + request.error);
        }
    }

    void StartMiniGame()
    {
        currentLevel = 1;
        gameActive = true;
        allCollectedRewards.Clear();
        Debug.Log($"MiniGame - Game started. Entry cost: {config.cardGameConfig.entryCost}");
        cardRevealedStates = new bool[cardSlots.Count];
        levelFillbar.fillAmount = (float)currentLevel / maxLevel;
        levelText.text = $"Level {currentLevel}";
        SetFirstDeck();
    }

    #region Animacije
    void SetFirstDeck()
    {
        if (!gameActive)
        {
            Debug.Log($"SetFirstDeck OVER!");
         
        }
        else
        {
            GenerateNextCardSet();
            SetCardsInteractable(true);
            Debug.Log($"SetFirstDeck");
            float counter = 0;
            for (int i = 0; i < cardSlots.Count; i++)
            {
                counter += 0.2f;
                cardSlots[i].transform.position = cardStartPos.position;
                cardSlots[i].transform.eulerAngles = cardStartPos.eulerAngles;
                StartCoroutine(SpawnCards(counter, i));
            }
        }
        
    }

    IEnumerator SpawnCards(float waitTime, int card)
    {
        yield return new WaitForSeconds(waitTime);
        cardSlots[card].transform.DOMove(cardPositions[card].position, 0.5f);
        cardSlots[card].transform.DORotate(cardPositions[card].eulerAngles, 0.5f);
    }

    public void PickCard(int card) // Klik na kartu
    {
        if (!gameActive || card < 0 || card >= currentCardSet.Count)
            return;

        if (cardRevealedStates[card])
            return;
        SetCardsInteractable(false);
        var chosen = currentCardSet[card];
        cardRevealedStates[card] = true;

        // Animacija flip
        cardSlots[card].transform.DORotate(new Vector3(0f, -90f, 0f), 0.3f).OnComplete(() =>
        {
            cardSlots[card].SetActive(false);
            openCardSlots[card].transform.eulerAngles = new Vector3(0f, 90f, 0f);
            openCardSlots[card].SetActive(true);
            openCardSlots[card].transform.DORotate(new Vector3(0f, 0f, 0f), 0.3f);

            // === LOGIKA IZ CardGameManager ===
            HandleCardChoice(chosen, card);
        });
        once = false;
        StartCoroutine(OtherCards(0.75f, card)); // Otkrivamo ostale karte
    }

    IEnumerator OtherCards(float waitTime, int card)
    {
        yield return new WaitForSeconds(waitTime);

        //ovde stopiram dalja deljenja i treba da se nastavi, ali ne znam jos da li je dobro mesto za to

        if (gameActive)
        {
            
            for (int i = 0; i < cardSlots.Count; i++)
            {
                if (i != card)
                {
                    PickOtherCards(i);
                }
            }
        }
        else
        {
            if (currentLevel < 25)
            {
                Debug.Log($"MiniGame - Gotova igra Prompt Continue");
            }
           
        }

    }

    //public void PickOtherCards(int card)
    //{
    //    cardSlots[card].transform.DORotate(new Vector3(0f, -90f, 0f), 0.3f).OnComplete(() =>
    //    {
    //        cardSlots[card].SetActive(false);
    //        openCardSlots[card].transform.eulerAngles = new Vector3(0f, 90f, 0f);
    //        openCardSlots[card].SetActive(true);
    //        openCardSlots[card].transform.DORotate(new Vector3(0f, 0f, 0f), 0.3f);
    //    });
    //}
    public void PickOtherCards(int card) // Pokazuje ostale karte koje nismo odabrali
    {
        cardSlots[card].transform.DORotate(new Vector3(0f, -90f, 0f), 0.3f).OnComplete(() =>
        {
            cardSlots[card].SetActive(false);
            openCardSlots[card].transform.eulerAngles = new Vector3(0f, 90f, 0f);
            openCardSlots[card].GetComponent<Image>().color = new Color(0.6f, 0.6f, 0.6f, 0.8f);
            openCardSlots[card].SetActive(true);
            openCardSlots[card].transform.DORotate(new Vector3(0f, 0f, 0f), 0.3f);

            Invoke(nameof(ReshuffleCards), 0.5f);
        });
    }
    public bool once;
    public void ReshuffleCards()
    {
        if (!once)
        {
            Debug.Log($"ReshuffleCards");
            float counter = 0;

            for (int i = 0; i < cardSlots.Count; i++)
            {
                counter += 0.05f;
                StartCoroutine(SendCardsAway(counter, i));


                if (i == cardSlots.Count - 1) Invoke(nameof(SetFirstDeck), 2f);

            }
            once = true;
        }
       

    }

    IEnumerator SendCardsAway(float waitTime, int card)
    {
        yield return new WaitForSeconds(waitTime);
        openCardSlots[card].transform.DOMove(cardStartPos.position, 0.5f);
        openCardSlots[card].transform.DORotate(cardStartPos.eulerAngles, 0.5f).OnComplete(() =>
        {
            openCardSlots[card].SetActive(false);
            openCardSlots[card].GetComponent<Image>().color = Color.white;
            openCardSlots[card].transform.position = cardPositions[card].position;
            openCardSlots[card].transform.eulerAngles = cardPositions[card].eulerAngles;



        });
        cardSlots[card].transform.position = cardStartPos.position;
        cardSlots[card].transform.eulerAngles = cardStartPos.eulerAngles;
        cardSlots[card].SetActive(true);

    }
        #endregion

        #region Logika igre
    void GenerateNextCardSet()
    {
        currentCardSet.Clear();
        cardRevealedStates = new bool[cardSlots.Count];
        isFailContinueState = false;
        failedCardIndex = -1;

        int totalCards = 4;
        bool guaranteed = config.cardGameConfig.levelsWithGuaranteedWin.Contains(currentLevel);
        int loseCardsCount = 0;

        if (!guaranteed && config.loseCardCountByLevel != null)
        {
            foreach (var kvp in config.loseCardCountByLevel)
            {
                var range = kvp.Key.Split('-');
                int min = int.Parse(range[0]);
                int max = int.Parse(range[1]);
                if (currentLevel >= min && currentLevel <= max)
                {
                    loseCardsCount = Mathf.Clamp(kvp.Value, 0, totalCards - 1);
                    break;
                }
            }
        }

        int rewardCardsCount = totalCards - loseCardsCount;

        for (int i = 0; i < loseCardsCount; i++)
        {
            currentCardSet.Add(new Reward { type = "LOSE" });
        }

        for (int i = 0; i < rewardCardsCount; i++)
        {
            string rarity;
            if (guaranteed && currentLevel == 25)
                rarity = "legendary";
            else
            {
                var chanceData = GetChancesForLevel(currentLevel);
                rarity = SelectRarity(chanceData);
            }

            Reward reward = GetRandomReward(config.rewardPools, rarity, currentLevel);
            reward.rarity = rarity;
            currentCardSet.Add(reward);
        }

        currentCardSet = currentCardSet.OrderBy(_ => Random.value).ToList();

        Debug.Log($"MiniGame - Level {currentLevel}: Cards generated. Lose cards: {loseCardsCount}");
        for (int i = 0; i < currentCardSet.Count; i++)
        {
            var c = currentCardSet[i];
            PopulateCards(i, currentCardSet[i].type, currentCardSet[i].amount);
            Debug.Log($"MiniGame - Card {i}: {(c.type == "LOSE" ? "LOSE" : $"{c.rarity.ToUpper()} {c.type} x{c.amount}")}");
        }



    }

    void PopulateCards(int cardInt, string reward, int amount)
    {

        switch (reward)
        {
            case "CASH":
                openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.cashIcon;
                openCardSlots[cardInt].transform.FindDeepChild("RewardAmount").GetComponent<Text>().text = amount.ToString();
                break;
            case "SPORTY_COIN":
                openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.sportyCoinIcon;
                openCardSlots[cardInt].transform.FindDeepChild("RewardAmount").GetComponent<Text>().text = amount.ToString();
                break;
            case "BOOSTER":
                openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.boostersIcon;
                openCardSlots[cardInt].transform.FindDeepChild("RewardAmount").GetComponent<Text>().text = amount.ToString();
                break;
            case "HEAL_ITEM":
                openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.healItemsIcon;
                openCardSlots[cardInt].transform.FindDeepChild("RewardAmount").GetComponent<Text>().text = amount.ToString();
                break;
            case "ATTRIBUTE":

                List<string> attributes = new() { "HEALTH", "STANDUP", "GROUND", "DEFENCE", "STAMINA" };

                string selectedAttribute = attributes[Random.Range(0, attributes.Count)];

                switch (selectedAttribute)
                {
                    case "HEALTH":
                        openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeHealthIcon;
                        break;
                    case "STANDUP":
                        openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeStandUpIcon;
                        break;
                    case "GROUND":
                        openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeGroundIcon;
                        break;
                    case "DEFENCE":
                        openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeDefenceIcon;

                        break;
                    case "STAMINA":
                        openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeStaminaIcon;

                        break;
                }

                
                openCardSlots[cardInt].transform.FindDeepChild("RewardAmount").GetComponent<Text>().text = amount.ToString();
                break;
            case "LOSE":
                openCardSlots[cardInt].transform.FindDeepChild("RewardIcon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.loseIcon;
                openCardSlots[cardInt].transform.FindDeepChild("RewardAmount").GetComponent<Text>().text = "";
                break;

        }

    }

    private void SetCardsInteractable(bool state)
    {
        for (int i = 0; i < cardSlots.Count; i++)
        {
            cardSlots[i].GetComponent<Button>().interactable = state;
        }
    }

    void HandleCardChoice(Reward chosen, int index)
    {
        

        if (chosen.type == "LOSE")
        {
            Debug.Log("MiniGame - You hit LOSE!");
            gameActive = false;

            if (TakeLootBtn != null)
            {
                TakeLootBtn.SetActive(false);
            }
            if (ContinueBtn != null)
            {
                ContinueBtn.SetActive(true);
                ContinuePrice.SetActive(true);
            }

            PromptContinue();
            //ovde da se ubaci pitanje za nastavak
            //EndGame();
        }
        else
        {
            allCollectedRewards.Add(chosen);
            Debug.Log($"MiniGame - You got: {chosen.rarity} {chosen.type} x{chosen.amount}");
            AddToCollectedGrid(chosen);

            if (currentLevel <= maxLevel)
            {
                levelFillbar.fillAmount = (float)currentLevel / maxLevel;
                levelText.text = $"Level {currentLevel}";
            }


            currentLevel++;
            if (TakeLootBtn != null)
            {
                TakeLootBtn.SetActive(true);
            }
            if (ContinueBtn != null)
            {
                ContinuePrice.SetActive(false);
                ContinueBtn.SetActive(false);
            }

            if (currentLevel > maxLevel)
                EndGame();
            
                
        }
    }

    void AddToCollectedGrid(Reward reward)
    {
        GameObject slot = Instantiate(collectedItemSlot, collectedItemsGrid.transform);
        switch (reward.type)
        {
            case "CASH":
                slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.cashIcon;
                slot.transform.FindDeepChild("Amount").GetComponent<Text>().text = $"x{reward.amount}";
                break;
            case "SPORTY_COIN":
                slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.sportyCoinIcon;
                slot.transform.FindDeepChild("Amount").GetComponent<Text>().text = $"x{reward.amount}";
                break;
            case "BOOSTER":
                slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.boostersIcon;
                slot.transform.FindDeepChild("Amount").GetComponent<Text>().text = $"x{reward.amount}";
                break;
            case "HEAL_ITEM":
                slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.healItemsIcon;
                slot.transform.FindDeepChild("Amount").GetComponent<Text>().text = $"x{reward.amount}";
                break;
            case "ATTRIBUTE":
                List<string> attributes = new() { "HEALTH", "STANDUP", "GROUND", "DEFENCE", "STAMINA" };
                string selectedAttribute = attributes[Random.Range(0, attributes.Count)];
                switch (selectedAttribute)
                {
                    case "HEALTH":
                        slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeHealthIcon;
                        break;
                    case "STANDUP":
                        slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeStandUpIcon;
                        break;
                    case "GROUND":
                        slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeGroundIcon;
                        break;
                    case "DEFENCE":
                        slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeDefenceIcon;
                        break;
                    case "STAMINA":
                        slot.transform.FindDeepChild("Icon").GetComponent<Image>().sprite = GetComponent<CampaignRewardSystem>().rewardIcons.attributeStaminaIcon;
                        break;
                }
                slot.transform.FindDeepChild("Amount").GetComponent<Text>().text = $"x{reward.amount}";
                break;
        }
        slot.SetActive(true);
        collectSlots.Add(slot);
        AdjustContentPanelSizeVertical(collectedItemsGrid, collectedItemsGrid.GetComponent<RectTransform>(), collectSlots);

    }


    public void EndGame()
    {
        foreach (var r in allCollectedRewards)
            Debug.Log($"MiniGame - EndGame - Game done, rewards: {r.rarity} {r.type} x{r.amount}");

        gameActive = false;
    }
    #endregion

    #region Helper metode
    LevelRewardChance GetChancesForLevel(int level)
    {
        foreach (var kvp in config.levelRewardChances)
        {
            string[] range = kvp.Key.Split('-');
            int min, max;

            if (range.Length == 1)
            {
                if (!int.TryParse(range[0], out min))
                    continue;
                max = min;
            }
            else if (range.Length == 2)
            {
                if (!int.TryParse(range[0], out min) || !int.TryParse(range[1], out max))
                    continue;
            }
            else continue;

            if (level >= min && level <= max)
                return kvp.Value;
        }

        return new LevelRewardChance { common = 100, rare = 0, epic = 0, legendary = 0 };
    }
    public void PromptContinue()
    {
        int cost = GetContinueCost();
        Debug.Log($"MiniGame - Continue cost: {cost}");
        continuePriceValue.text = $"{cost}";
        //continuePriceText.text = $"Cena za nastavak: {cost}";
        // Ako igrač prihvati, pozovi ConfirmContinue()
    }
    public int GetContinueCost()
    {
        float baseCost = config.cardGameConfig.entryCost;
        float multiplier = config.cardGameConfig.continueMultiplier;
        return Mathf.RoundToInt(baseCost * Mathf.Pow(multiplier, currentLevel - 1));
    }

    public void QuitEarly()
    {
        Debug.Log("MiniGame - You quit and collected:");
        foreach (var r in allCollectedRewards)
            Debug.Log($"MiniGame - {r.rarity} {r.type} x{r.amount}");

        // Dodaj nagrade igraču
        gameActive = false;
    }

    public void ConfirmContinue()
    {
        Debug.Log("MiniGame - Player paid continue cost.");
        SetCardsInteractable(true);
        if (failedCardIndex >= 0)
        {
            isFailContinueState = true;
            gameActive = true;

            // Ostavimo lose kartu otkrivenu i onemogućenu
            cardRevealedStates[failedCardIndex] = true;

            // Sve ostale koje nisu otkrivene vraćamo da budu klikabilne
            for (int i = 0; i < cardSlots.Count; i++)
            {
                if (i != failedCardIndex && !cardRevealedStates[i])
                {
                    // Vrati ih da budu aktivne i da se mogu birati
                    cardSlots[i].SetActive(true);
                    openCardSlots[i].SetActive(false);
                }
            }

            Debug.Log("MiniGame - Continue confirmed, player can pick remaining cards.");
        }
        else
        {
            // Ako nije bilo fail-a (fallback scenario), samo nastavi dalje
            gameActive = true;
            //GenerateNextCardSet();
        }
    }

    string SelectRarity(LevelRewardChance chance)
    {
        int roll = Random.Range(1, 101);
        int cumulative = 0;

        cumulative += chance.common;
        if (roll <= cumulative) return "common";

        cumulative += chance.rare;
        if (roll <= cumulative) return "rare";

        cumulative += chance.epic;
        if (roll <= cumulative) return "epic";

        if (chance.legendary > 0) return "legendary";

        return "common";
    }

    Reward GetRandomReward(RewardPool pool, string rarity, int level)
    {
        List<Reward> poolList = rarity switch
        {
            "common" => pool.common,
            "rare" => pool.rare,
            "epic" => pool.epic,
            "legendary" => pool.legendary,
            _ => pool.common
        };

        Reward template = poolList[Random.Range(0, poolList.Count)];
        Reward reward = new()
        {
            type = template.type,
            id = template.id,
            amount = template.amount
        };

        if (template.amountByLevel != null)
        {
            foreach (var range in template.amountByLevel)
            {
                if (level >= range.minLevel && level <= range.maxLevel)
                {
                    reward.amount = Random.Range(range.min, range.max + 1);
                    break;
                }
            }
        }
        return reward;
    }
    #endregion

    public void AdjustContentPanelSizeVertical(GridLayoutGroup gridLayoutGroup, RectTransform contentPanel, List<GameObject> slots)
    {
        // Get cell size and spacing from the Grid Layout Group
        Vector2 cellSize = gridLayoutGroup.cellSize;
        Vector2 spacing = gridLayoutGroup.spacing;

        // Calculate the total width of the content panel
        float totalWidth = contentPanel.rect.width;

        // Calculate the number of columns that can fit in the available width
        int columns = Mathf.FloorToInt(totalWidth / (cellSize.x + spacing.x));
        columns = Mathf.Max(columns, 1); // Ensure at least one column

        // Calculate the number of rows needed to fit all items vertically
        int rows = Mathf.CeilToInt((float)slots.Count / columns);

        // Calculate the new height for the content panel
        float newHeight = (cellSize.y + spacing.y) * rows - spacing.y;
        float newWidth = totalWidth; // Optionally keep the width the same

        // Set the new size of the content panel
        contentPanel.sizeDelta = new Vector2(newWidth, newHeight);
    }

}