using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine;
//using Firebase;
//using Firebase.Auth;
//using Firebase.Firestore;
using System;
using System.Linq;
using static BulletHellTemplate.PlayerSave;

namespace BulletHellTemplate
{
    public class FirebaseManager : MonoBehaviour
    {
        //[Header("Component responsible for loading and saving user data")]
        //public FirebaseAuth auth;
        //public FirebaseFirestore firestore;
        //public static FirebaseManager Singleton;

        //[Header("Daily Quest Reset Configuration")]
        //public int resetHour = 0;

        //private void Awake()
        //{
        //    if (Singleton == null)
        //    {
        //        Singleton = this;
        //    }
        //    else
        //    {
        //        Destroy(gameObject);
        //        return;
        //    }
        //    DontDestroyOnLoad(gameObject);

        //}
        //public void Start()
        //{
        //    StartInitializeFirebase();
        //}
        //public void StartInitializeFirebase()
        //{
        //    InitializeFirebase();
        //}

        //private async void InitializeFirebase()
        //{
        //    try
        //    {
        //        var dependencyStatus = await FirebaseApp.CheckAndFixDependenciesAsync();
        //        if (dependencyStatus == DependencyStatus.Available)
        //        {
        //            auth = FirebaseAuth.DefaultInstance;
        //            firestore = FirebaseFirestore.DefaultInstance;

        //            FirebaseAuthManager.Singleton.InitializeAuthBackend(auth, firestore);
        //            FirebaseSave.Singleton.InitializeFirebase(auth.CurrentUser, firestore);

        //            Debug.Log("Firebase initialized successfully.");
        //        }
        //        else
        //        {
        //            Debug.LogError("Could not resolve all Firebase dependencies: " + dependencyStatus);
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to initialize Firebase: " + e.Message);
        //    }
        //}

        ///// <summary>
        ///// Loads and synchronizes all required player data from Firestore in a single method.
        ///// If the player's document does not exist, it will create default data once.
        ///// This approach removes repeated checks and reduces extra snapshot calls.
        ///// </summary>
        ///// <param name="userId">The authenticated user's ID.</param>
        ///// <returns>A result message describing the outcome.</returns>
        //public async Task<string> LoadAndSyncPlayerData(string userId)
        //{
        //    // Single checks at the beginning
        //    if (firestore == null)
        //    {
        //        return "Failed to initialize Firestore.";
        //    }

        //    if (!MonetizationManager.Singleton.IsInitialized())
        //    {
        //        return "MonetizationManager is not initialized.";
        //    }

        //    if (auth == null || auth.CurrentUser == null)
        //    {
        //        return "No user is currently logged in.";
        //    }

        //    PlayerPrefs.DeleteAll();
        //    PlayerPrefs.Save();

        //    try
        //    {
        //        // 1) Check or create the main document
        //        DocumentReference docRef = firestore.Collection("Players").Document(userId);
        //        DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();

        //        if (!snapshot.Exists)
        //        {
        //            await CreateDefaultPlayerData(docRef);
        //            snapshot = await docRef.GetSnapshotAsync();
        //            if (!snapshot.Exists)
        //            {
        //                return "Failed to create default player data.";
        //            }
        //        }

        //        // 2) Parse minimal fields in the main document
        //        Dictionary<string, object> playerData = snapshot.ToDictionary();
        //        if (playerData.TryGetValue("PlayerName", out object pName) && pName != null)
        //        {
        //            PlayerSave.SetPlayerName(pName.ToString());
        //        }
        //        if (playerData.TryGetValue("PlayerIcon", out object pIcon) && pIcon != null)
        //        {
        //            PlayerSave.SetPlayerIcon(pIcon.ToString());
        //        }
        //        if (playerData.TryGetValue("PlayerFrame", out object pFrame) && pFrame != null)
        //        {
        //            PlayerSave.SetPlayerFrame(pFrame.ToString());
        //        }
        //        if (playerData.TryGetValue("AccountLevel", out object aLevelObj) && aLevelObj != null)
        //        {
        //            // Convert the object to int properly, handling Firestore's usual 'long' storage
        //            int levelValue = Convert.ToInt32(aLevelObj);
        //            PlayerSave.SetAccountLevel(levelValue);
        //        }
        //        else
        //        {
        //            // If the field doesn't exist or is null, set a default
        //            PlayerSave.SetAccountLevel(1);
        //        }

        //        if (playerData.TryGetValue("AccountCurrentExp", out object aExpObj) && aExpObj != null)
        //        {
        //            int expValue = Convert.ToInt32(aExpObj);
        //            PlayerSave.SetAccountCurrentExp(expValue);
        //        }
        //        else
        //        {
        //            PlayerSave.SetAccountCurrentExp(0);
        //        }

        //        // 3) Run all other sub-loads in parallel to speed up the process
        //        List<Task> loadTasks = new List<Task>
        //        {
        //            LoadAndSyncCurrencies(userId),
        //            LoadPurchasedItemsAsync(userId),
        //            LoadSelectedCharacter(userId),
        //            LoadPlayerCharacterFavouriteAsync(userId),
        //            LoadAndSyncAllCharacterUpgradesAsync(userId),
        //            LoadUnlockedMapsAsync(userId),
        //            ResetDailyQuestsIfNeeded(userId),
        //            LoadQuestsAsync(userId),
        //            LoadUsedCouponsAsync(userId),
        //            CheckForSeasonEndAsync(userId),
        //            LoadBattlePassProgressAsync(),
        //            LoadClaimedRewardsFromFirebase(userId),
        //            InitializeInventoryAsync(),
        //            LoadAndSyncAllCharacterBasicInfoAsync(),
        //            LoadCharacterSlotsAsync(),
        //            LoadAndSyncAllCharacterUnlockedSkinsAsync(),

        //        };

        //        await Task.WhenAll(loadTasks);
        //        await LoadRewardsDataAsync();
        //        BackendManager.Singleton.SetInitialized();
        //        return "Player data loaded successfully.";
        //    }
        //    catch (Exception ex)
        //    {
        //        Debug.LogError($"Failed to load and synchronize player data: {ex.Message}");
        //        return $"Failed to load player data: {ex.Message}";
        //    }
        //}

        ///// <summary>
        ///// Creates a default player document if none exists.
        ///// </summary>
        //private async Task CreateDefaultPlayerData(DocumentReference docRef)
        //{
        //    try
        //    {
        //        string playerName = "GUEST-" + UnityEngine.Random.Range(100000, 999999);
        //        string defaultIconId = GameInstance.Singleton.iconItems[0].iconId;
        //        string defaultFrameId = GameInstance.Singleton.frameItems[0].frameId;

        //        Dictionary<string, object> defaultData = new Dictionary<string, object>
        //        {
        //            { "PlayerName", playerName },
        //            { "PlayerIcon", defaultIconId },
        //            { "PlayerFrame", defaultFrameId }
        //        };

        //        await docRef.SetAsync(defaultData);
        //        Debug.Log($"Created default player data for user document: {docRef.Id}");
        //    }
        //    catch (Exception ex)
        //    {
        //        Debug.LogError($"Failed to create default player data: {ex.Message}");
        //        throw;
        //    }
        //}

        ///// <summary>
        ///// Loads and synchronizes the player's currencies (parallel-ready, no repeated checks).
        ///// </summary>
        //private async Task LoadAndSyncCurrencies(string userId)
        //{
        //    try
        //    {
        //        CollectionReference currenciesCollection = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Currencies");

        //        foreach (Currency currency in MonetizationManager.Singleton.currencies)
        //        {
        //            DocumentReference currencyDoc = currenciesCollection.Document(currency.coinID);
        //            DocumentSnapshot snapshot = await currencyDoc.GetSnapshotAsync();

        //            if (snapshot.Exists)
        //            {
        //                int amount = snapshot.GetValue<int>("amount");
        //                MonetizationManager.SetCurrency(currency.coinID, amount);
        //            }
        //            else
        //            {
        //                Dictionary<string, object> currencyData = new Dictionary<string, object>
        //                {
        //                    { "initialAmount", currency.initialAmount },
        //                    { "amount", currency.initialAmount }
        //                };
        //                await currencyDoc.SetAsync(currencyData);
        //                MonetizationManager.SetCurrency(currency.coinID, currency.initialAmount);
        //            }
        //        }
        //        Debug.Log("Currencies loaded successfully.");
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load currencies: {e.Message}");
        //    }
        //}


        ///// <summary>
        ///// Loads the selected character from the main document, parallel-ready.
        ///// </summary>
        //private async Task LoadSelectedCharacter(string userId)
        //{
        //    try
        //    {
        //        DocumentReference docRef = firestore.Collection("Players").Document(userId);
        //        DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();

        //        if (snapshot.Exists)
        //        {
        //            int selectedCharacter = 0;
        //            if (snapshot.ContainsField("selectedCharacter"))
        //            {
        //                selectedCharacter = snapshot.GetValue<int>("selectedCharacter");
        //            }
        //            else
        //            {
        //                await docRef.UpdateAsync("selectedCharacter", 0);
        //            }
        //            PlayerSave.SetSelectedCharacter(selectedCharacter);
        //        }
        //        else
        //        {
        //            Dictionary<string, object> data = new Dictionary<string, object> { { "selectedCharacter", 0 } };
        //            await docRef.SetAsync(data);
        //            PlayerSave.SetSelectedCharacter(0);
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load selected character: {e.Message}");
        //    }
        //}
        //// <summary>
        ///// Loads purchased items without using 'dynamic'. Each subdocument is handled with a specific typed method.
        ///// </summary>
        //private async Task LoadPurchasedItemsAsync(string userId)
        //{
        //    try
        //    {
        //        CollectionReference docRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("PurchasedItems");

        //        // Default lists
        //        var defaultCharacterList = new PurchasedCharacterList(new List<PurchasedCharacter>());
        //        var defaultIconList = new PurchasedIconList(new List<PurchasedIcon>());
        //        var defaultFrameList = new PurchasedFrameList(new List<PurchasedFrame>());
        //        var defaultShopItemList = new PurchasedShopItemList(new List<PurchasedShopItem>());

        //        // Call each "ensure + load" method separately
        //        Task<PurchasedCharacterList> taskCharacters = EnsureCharactersDocExistsAndLoad(docRef.Document("Characters"), "Characters", defaultCharacterList);
        //        Task<PurchasedIconList> taskIcons = EnsureIconsDocExistsAndLoad(docRef.Document("Icons"), "Icons", defaultIconList);
        //        Task<PurchasedFrameList> taskFrames = EnsureFramesDocExistsAndLoad(docRef.Document("Frames"), "Frames", defaultFrameList);
        //        Task<PurchasedShopItemList> taskShopItems = EnsureShopItemsDocExistsAndLoad(docRef.Document("ShopItems"), "ShopItems", defaultShopItemList);

        //        // Wait for all to complete
        //        await Task.WhenAll(taskCharacters, taskIcons, taskFrames, taskShopItems);

        //        // Retrieve the final typed results
        //        PurchasedCharacterList finalCharacters = taskCharacters.Result;
        //        PurchasedIconList finalIcons = taskIcons.Result;
        //        PurchasedFrameList finalFrames = taskFrames.Result;
        //        PurchasedShopItemList finalShopItems = taskShopItems.Result;
        //        PurchasedInventoryItemList finalItems = new PurchasedInventoryItemList(new List<PurchasedInventoryItem>());

        //        // Merge results into MonetizationManager
        //        MonetizationManager.Singleton.UpdatePurchasedItems(
        //            finalCharacters.purchasedCharacters,
        //            finalIcons.purchasedIcons,
        //            finalFrames.purchasedFrames,
        //            finalShopItems.purchasedShopItems,
        //            finalItems.purchasedInventoryItems
        //        );
        //    }
        //    catch (Exception ex)
        //    {
        //        Debug.LogError("Error loading purchased items: " + ex.Message);
        //    }
        //}

        ///// <summary>
        ///// Ensures the 'Characters' subdocument exists, creates it if not, and returns a PurchasedCharacterList.
        ///// </summary>
        //private async Task<PurchasedCharacterList> EnsureCharactersDocExistsAndLoad(
        //    DocumentReference docRef,
        //    string fieldName,
        //    PurchasedCharacterList defaultValue)
        //{
        //    var snapshot = await docRef.GetSnapshotAsync();
        //    if (!snapshot.Exists)
        //    {
        //        // Create a new document with an empty or default list
        //        await docRef.SetAsync(new Dictionary<string, object>
        //        {
        //            { fieldName, defaultValue.purchasedCharacters } // use the .purchasedCharacters list
        //        });
        //        return defaultValue;
        //    }
        //    else
        //    {
        //        // Load existing data
        //        var listData = snapshot.GetValue<List<object>>(fieldName);
        //        var typed = ConvertToList<PurchasedCharacter>(listData);
        //        return new PurchasedCharacterList(typed);
        //    }
        //}

        ///// <summary>
        ///// Ensures the 'Icons' subdocument exists, creates it if not, and returns a PurchasedIconList.
        ///// </summary>
        //private async Task<PurchasedIconList> EnsureIconsDocExistsAndLoad(
        //    DocumentReference docRef,
        //    string fieldName,
        //    PurchasedIconList defaultValue)
        //{
        //    var snapshot = await docRef.GetSnapshotAsync();
        //    if (!snapshot.Exists)
        //    {
        //        await docRef.SetAsync(new Dictionary<string, object>
        //        {
        //            { fieldName, defaultValue.purchasedIcons }
        //        });
        //        return defaultValue;
        //    }
        //    else
        //    {
        //        var listData = snapshot.GetValue<List<object>>(fieldName);
        //        var typed = ConvertToList<PurchasedIcon>(listData);
        //        return new PurchasedIconList(typed);
        //    }
        //}

        ///// <summary>
        ///// Ensures the 'Frames' subdocument exists, creates it if not, and returns a PurchasedFrameList.
        ///// </summary>
        //private async Task<PurchasedFrameList> EnsureFramesDocExistsAndLoad(
        //    DocumentReference docRef,
        //    string fieldName,
        //    PurchasedFrameList defaultValue)
        //{
        //    var snapshot = await docRef.GetSnapshotAsync();
        //    if (!snapshot.Exists)
        //    {
        //        await docRef.SetAsync(new Dictionary<string, object>
        //        {
        //            { fieldName, defaultValue.purchasedFrames }
        //        });
        //        return defaultValue;
        //    }
        //    else
        //    {
        //        var listData = snapshot.GetValue<List<object>>(fieldName);
        //        var typed = ConvertToList<PurchasedFrame>(listData);
        //        return new PurchasedFrameList(typed);
        //    }
        //}

        ///// <summary>
        ///// Ensures the 'ShopItems' subdocument exists, creates it if not, and returns a PurchasedShopItemList.
        ///// </summary>
        //private async Task<PurchasedShopItemList> EnsureShopItemsDocExistsAndLoad(
        //    DocumentReference docRef,
        //    string fieldName,
        //    PurchasedShopItemList defaultValue)
        //{
        //    var snapshot = await docRef.GetSnapshotAsync();
        //    if (!snapshot.Exists)
        //    {
        //        await docRef.SetAsync(new Dictionary<string, object>
        //        {
        //            { fieldName, defaultValue.purchasedShopItems }
        //        });
        //        return defaultValue;
        //    }
        //    else
        //    {
        //        var listData = snapshot.GetValue<List<object>>(fieldName);
        //        var typed = ConvertToList<PurchasedShopItem>(listData);
        //        return new PurchasedShopItemList(typed);
        //    }
        //}

        ///// <summary>
        ///// Loads a single character's upgrades and stores them locally.
        ///// </summary>
        //private async Task LoadCharacterUpgradesAsync(string userId, int characterId)
        //{
        //    try
        //    {
        //        DocumentReference upgradesDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Characters")
        //            .Document(characterId.ToString())
        //            .Collection("Upgrades")
        //            .Document("Stats");

        //        DocumentSnapshot snapshot = await upgradesDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> upgradesData = snapshot.ToDictionary();
        //            foreach (var entry in upgradesData)
        //            {
        //                if (Enum.TryParse(entry.Key, out StatType statType))
        //                {
        //                    int level = Convert.ToInt32(entry.Value);
        //                    PlayerSave.SaveCharacterUpgradeLevel(characterId, statType, level);
        //                }
        //            }
        //        }
        //        else
        //        {
        //            // If no upgrades, save local defaults as 0
        //            foreach (StatType statType in Enum.GetValues(typeof(StatType)))
        //            {
        //                PlayerSave.SaveInitialCharacterUpgradeLevel(characterId, statType);
        //            }
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load character upgrades for {characterId}: {e.Message}");
        //    }
        //}

        ///// <summary>
        ///// Loads and saves all character upgrades in parallel for each unlocked character.
        ///// </summary>
        //private async Task LoadAndSyncAllCharacterUpgradesAsync(string userId)
        //{
        //    try
        //    {
        //        List<Task> upgradeTasks = new List<Task>();
        //        foreach (CharacterData character in GameInstance.Singleton.characterData)
        //        {
        //            if (character.CheckUnlocked || MonetizationManager.Singleton.IsCharacterPurchased(character.characterId.ToString()))
        //            {
        //                upgradeTasks.Add(LoadCharacterUpgradesAsync(userId, character.characterId));
        //            }
        //        }
        //        await Task.WhenAll(upgradeTasks);
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to load all character upgrades: " + e.Message);
        //    }
        //}

        ///// <summary>
        ///// Loads the unlocked skins for a specific character from Firebase Firestore and saves them locally.
        ///// </summary>
        ///// <param name="userId">The user's ID.</param>
        ///// <param name="characterId">The ID of the character.</param>
        //public async Task LoadCharacterUnlockedSkinsAsync(string userId, int characterId)
        //{
        //    try
        //    {
        //        DocumentReference skinsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Characters")
        //            .Document(characterId.ToString())
        //            .Collection("UnlockedSkins")
        //            .Document("Skins");

        //        DocumentSnapshot snapshot = await skinsDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> skinsData = snapshot.ToDictionary();
        //            if (skinsData.ContainsKey("skins"))
        //            {
        //                List<int> unlockedSkins = new List<int>();
        //                // Firestore returns numeric array elements as long.
        //                if (skinsData["skins"] is IList<object> skinsList)
        //                {
        //                    foreach (var skin in skinsList)
        //                    {
        //                        if (skin is long l)
        //                        {
        //                            unlockedSkins.Add((int)l);
        //                        }
        //                        else if (skin is int i)
        //                        {
        //                            unlockedSkins.Add(i);
        //                        }
        //                    }
        //                }
        //                // Save unlocked skins locally using PlayerSave.
        //                PlayerSave.SaveCharacterUnlockedSkins(characterId, unlockedSkins);
        //                Debug.Log($"Unlocked skins for character {characterId} loaded and saved locally.");
        //            }
        //            else
        //            {
        //                Debug.LogWarning($"No 'skins' field found for character {characterId}.");
        //            }
        //        }
        //        else
        //        {
        //            Debug.LogWarning($"No unlocked skins document found for character {characterId}.");
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load unlocked skins for character {characterId}: {e.Message}");
        //    }
        //}

        ///// <summary>
        ///// Loads and synchronizes unlocked skins for all unlocked or purchased characters.
        ///// </summary>
        //public async Task LoadAndSyncAllCharacterUnlockedSkinsAsync()
        //{
        //    if (auth.CurrentUser == null)
        //    {
        //        Debug.LogError("No user is logged in.");
        //        return;
        //    }

        //    try
        //    {
        //        List<Task> tasks = new List<Task>();
        //        foreach (CharacterData character in GameInstance.Singleton.characterData)
        //        {
        //            if (character.CheckUnlocked || MonetizationManager.Singleton.IsCharacterPurchased(character.characterId.ToString()))
        //            {
        //                tasks.Add(LoadCharacterUnlockedSkinsAsync(auth.CurrentUser.UserId, character.characterId));
        //            }
        //        }
        //        await Task.WhenAll(tasks);
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to load all character unlocked skins: " + e.Message);
        //    }
        //}

        ///// <summary>
        ///// Loads unlocked maps, clearing local data first.
        ///// </summary>
        //private async Task LoadUnlockedMapsAsync(string userId)
        //{
        //    try
        //    {
        //        DocumentReference mapsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("UnlockedMaps");

        //        DocumentSnapshot snapshot = await mapsDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> mapsData = snapshot.ToDictionary();
        //            List<int> unlockedMapIds = new List<int>();
        //            foreach (var entry in mapsData)
        //            {
        //                if (int.TryParse(entry.Key, out int mapId))
        //                {
        //                    unlockedMapIds.Add(mapId);
        //                }
        //            }
        //            PlayerSave.SetUnlockedMaps(unlockedMapIds);
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to load unlocked maps: " + e.Message);
        //    }
        //}

        ///// <summary>
        ///// Loads quests from the "Quests" document and saves them locally.
        ///// </summary>
        //private async Task LoadQuestsAsync(string userId)
        //{
        //    try
        //    {
        //        DocumentReference questsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("Quests");

        //        DocumentSnapshot snapshot = await questsDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> questsData = snapshot.ToDictionary();
        //            foreach (var entry in questsData)
        //            {
        //                if (entry.Key.StartsWith("Complete"))
        //                {
        //                    string[] parts = entry.Key.Split(' ');
        //                    if (parts.Length == 2 && int.TryParse(parts[1], out int questId))
        //                    {
        //                        PlayerSave.SaveQuestCompletion(questId);
        //                    }
        //                }
        //                else if (int.TryParse(entry.Key, out int questId))
        //                {
        //                    int progress = Convert.ToInt32(entry.Value);
        //                    PlayerSave.SaveQuestProgress(questId, progress);
        //                }
        //            }
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to load quests: " + e.Message);
        //    }
        //}

        ///// <summary>
        ///// Checks if daily quests need resetting based on server timestamp.
        ///// </summary>
        //private async Task ResetDailyQuestsIfNeeded(string userId)
        //{
        //    try
        //    {
        //        DocumentReference serverTimeRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("ServerTime")
        //            .Document("CurrentTime");

        //        await serverTimeRef.SetAsync(new Dictionary<string, object> { { "timestamp", FieldValue.ServerTimestamp } });
        //        DocumentSnapshot serverTimeSnapshot = await serverTimeRef.GetSnapshotAsync();
        //        Timestamp serverTimestamp = serverTimeSnapshot.GetValue<Timestamp>("timestamp");

        //        DateTime serverDateTime = serverTimestamp.ToDateTime();
        //        DateTime resetTimeToday = serverDateTime.Date.AddHours(resetHour);

        //        await ResetDailyQuestProgressInFirebase(userId, serverDateTime, resetTimeToday);
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to reset daily quests: " + e.Message);
        //    }
        //}

        //private async Task ResetDailyQuestProgressInFirebase(string userId, DateTime serverDateTime, DateTime resetTimeToday)
        //{
        //    try
        //    {
        //        DocumentReference questsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("Quests");

        //        DocumentSnapshot snapshot = await questsDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> questsData = snapshot.ToDictionary();
        //            foreach (var entry in questsData)
        //            {
        //                if (entry.Key.StartsWith("Complete "))
        //                {
        //                    string[] parts = entry.Key.Split(' ');
        //                    if (parts.Length == 2 && int.TryParse(parts[1], out int questId))
        //                    {
        //                        QuestItem questItem = GameInstance.Singleton.questData.FirstOrDefault(q => q.questId == questId);
        //                        if (questItem != null && questItem.questType == QuestType.Daily)
        //                        {
        //                            string completionTimeKey = $"Complete {questId}_Timestamp";
        //                            if (questsData.TryGetValue(completionTimeKey, out object timestampValue) && timestampValue is Timestamp completionTimestamp)
        //                            {
        //                                DateTime completionTime = completionTimestamp.ToDateTime();
        //                                if (completionTime < resetTimeToday)
        //                                {
        //                                    await questsDocRef.UpdateAsync(new Dictionary<string, object> { { questId.ToString(), 0 } });
        //                                    await questsDocRef.UpdateAsync(new Dictionary<string, object> { { "Complete " + questId, FieldValue.Delete } });
        //                                    await questsDocRef.UpdateAsync(new Dictionary<string, object> { { "Complete " + questId + "_Timestamp", FieldValue.Delete } });

        //                                    PlayerPrefs.DeleteKey(completionTimeKey);
        //                                    Debug.Log($"Quest {questId} has been reset.");
        //                                }
        //                            }
        //                        }
        //                    }
        //                }
        //            }
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to reset daily quest progress: " + e.Message);
        //    }
        //}

        ///// <summary>
        ///// Loads both Daily Rewards and New Player Rewards data from Firebase,
        ///// retrieves the server time, and saves it locally in PlayerSave.
        ///// If the documents do not exist, they are created with default values.
        ///// </summary>
        //public async Task LoadRewardsDataAsync()
        //{
        //    FirebaseUser user = auth.CurrentUser;
        //    if (user == null)
        //    {
        //        Debug.LogError("Cannot load rewards data. No authenticated user found.");
        //        return;
        //    }

        //    DateTime serverDateTime = await FetchServerTimeAsync(user.UserId);
        //    if (serverDateTime == DateTime.MinValue)
        //    {
        //        serverDateTime = DateTime.Now;
        //    }

        //    DailyRewardsData dailyData = await LoadDailyRewardsFromFirebase(user.UserId, serverDateTime);
        //    NewPlayerRewardsData newPlayerData = await LoadNewPlayerRewardsFromFirebase(user.UserId);

        //    PlayerSave.SetDailyRewardsLocal(dailyData);
        //    PlayerSave.SetNewPlayerRewardsLocal(newPlayerData);

        //    DateTime resetTimeToday = serverDateTime.Date.AddHours(resetHour);
        //    DateTime nextReset = (serverDateTime >= resetTimeToday)
        //        ? resetTimeToday.AddDays(1)
        //        : resetTimeToday;

        //    PlayerSave.SetNextDailyReset(nextReset);
        //    Debug.Log($"Daily & New Player rewards loaded. Next reset: {nextReset}");
        //}

        ///// <summary>
        ///// Fetches the current server time from Firestore and returns it as a DateTime.
        ///// </summary>
        //private async Task<DateTime> FetchServerTimeAsync(string userId)
        //{
        //    try
        //    {
        //        DocumentReference serverTimeRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("ServerTime")
        //            .Document("CurrentTime");

        //        await serverTimeRef.SetAsync(new Dictionary<string, object>
        //        {
        //            { "timestamp", FieldValue.ServerTimestamp }
        //        });

        //        DocumentSnapshot snapshot = await serverTimeRef.GetSnapshotAsync();
        //        Timestamp serverTimestamp = snapshot.GetValue<Timestamp>("timestamp");
        //        return serverTimestamp.ToDateTime();
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to fetch server time: {e.Message}");
        //        return DateTime.MinValue;
        //    }
        //}

        ///// <summary>
        ///// Loads the daily reward data from Firebase and returns a structured object.
        ///// If the document does not exist, creates a new one with the current server date.
        ///// </summary>
        //private async Task<DailyRewardsData> LoadDailyRewardsFromFirebase(string userId, DateTime serverDateTime)
        //{
        //    DailyRewardsData result = new DailyRewardsData();

        //    try
        //    {
        //        CollectionReference dailyRewardsCollection = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("DailyRewards");

        //        DocumentReference docRef = dailyRewardsCollection.Document("RewardData");
        //        DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();

        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> data = snapshot.ToDictionary();

        //            if (data.ContainsKey("firstClaimDate"))
        //            {
        //                Timestamp ts = (Timestamp)data["firstClaimDate"];
        //                result.firstClaimDate = ts.ToDateTime();
        //            }
        //            else
        //            {
        //                result.firstClaimDate = serverDateTime.Date;
        //            }

        //            if (data.ContainsKey("claimedRewards"))
        //            {
        //                result.claimedRewards = new List<int>();
        //                foreach (var obj in (List<object>)data["claimedRewards"])
        //                {
        //                    result.claimedRewards.Add(Convert.ToInt32(obj));
        //                }
        //            }
        //            else
        //            {
        //                result.claimedRewards = new List<int>();
        //            }
        //        }
        //        else
        //        {
        //            result.firstClaimDate = serverDateTime.Date;
        //            result.claimedRewards = new List<int>();

        //            Dictionary<string, object> defaultData = new Dictionary<string, object>
        //            {
        //                { "firstClaimDate", Timestamp.FromDateTime(serverDateTime.Date.ToUniversalTime()) },
        //                { "claimedRewards", new List<int>() }
        //            };

        //            await docRef.SetAsync(defaultData);
        //            Debug.Log("Created new DailyRewards document with default data.");
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Error loading daily rewards: {e.Message}");
        //    }

        //    return result;
        //}

        ///// <summary>
        ///// Loads the new player reward data from Firebase and returns a structured object.
        ///// </summary>
        //private async Task<NewPlayerRewardsData> LoadNewPlayerRewardsFromFirebase(string userId)
        //{
        //    NewPlayerRewardsData result = new NewPlayerRewardsData();

        //    try
        //    {
        //        DocumentReference docRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("NewPlayerRewards")
        //            .Document("RewardData");

        //        DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> data = snapshot.ToDictionary();

        //            if (data.ContainsKey("accountCreationDate"))
        //            {
        //                Timestamp ts = (Timestamp)data["accountCreationDate"];
        //                result.accountCreationDate = ts.ToDateTime();
        //            }
        //            else
        //            {
        //                result.accountCreationDate = DateTime.Now.Date;
        //            }

        //            if (data.ContainsKey("claimedRewards"))
        //            {
        //                result.claimedRewards = new List<int>();
        //                foreach (var obj in (List<object>)data["claimedRewards"])
        //                {
        //                    result.claimedRewards.Add(Convert.ToInt32(obj));
        //                }
        //            }
        //            else
        //            {
        //                result.claimedRewards = new List<int>();
        //            }
        //        }
        //        else
        //        {
        //            result.accountCreationDate = DateTime.Now.Date;
        //            result.claimedRewards = new List<int>();
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Error loading new player rewards: {e.Message}");
        //    }

        //    return result;
        //}


        ///// <summary>
        ///// Loads the player's used coupons.
        ///// </summary>
        //private async Task LoadUsedCouponsAsync(string userId)
        //{
        //    try
        //    {
        //        DocumentReference couponsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("UsedCoupons");

        //        DocumentSnapshot snapshot = await couponsDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> couponsData = snapshot.ToDictionary();
        //            List<string> usedCoupons = new List<string>();

        //            foreach (var entry in couponsData)
        //            {
        //                usedCoupons.Add(entry.Key);
        //            }
        //            PlayerSave.SaveUsedCoupons(usedCoupons);
        //        }
        //        else
        //        {
        //            PlayerSave.SaveUsedCoupons(new List<string>());
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load used coupons: {e.Message}");
        //    }
        //}

        ///// <summary>
        ///// Retrieves the top 30 players with the highest scores.
        ///// </summary>
        ///// <returns>A list of dictionaries containing player data.</returns>
        //public async Task<List<Dictionary<string, object>>> GetTopPlayersAsync()
        //{
        //    List<Dictionary<string, object>> topPlayers = new List<Dictionary<string, object>>();

        //    try
        //    {

        //        CollectionReference playersRef = firestore.Collection("Players");

        //        Query query = playersRef.OrderByDescending("score").Limit(30);
        //        QuerySnapshot querySnapshot = await query.GetSnapshotAsync();

        //        foreach (DocumentSnapshot document in querySnapshot.Documents)
        //        {
        //            topPlayers.Add(document.ToDictionary());
        //        }

        //        Debug.Log("Top players retrieved successfully.");
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError("Error retrieving top players: " + e.Message);
        //    }

        //    return topPlayers;
        //}

        ///// <summary>
        ///// Loads the player's favorite character from the main document, parallel-ready.
        ///// </summary>
        //private async Task LoadPlayerCharacterFavouriteAsync(string userId)
        //{
        //    try
        //    {
        //        DocumentReference docRef = firestore.Collection("Players").Document(userId);
        //        DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();

        //        if (snapshot.Exists && snapshot.ContainsField("PlayerCharacterFavourite"))
        //        {
        //            int favouriteCharacter = snapshot.GetValue<int>("PlayerCharacterFavourite");
        //            PlayerSave.SetFavouriteCharacter(favouriteCharacter);
        //        }
        //        else
        //        {
        //            await docRef.UpdateAsync("PlayerCharacterFavourite", 0);
        //            PlayerSave.SetFavouriteCharacter(0);
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load favourite character: {e.Message}");
        //    }
        //}

        ///// <summary>
        ///// Retrieves the player's current rank based on their score.
        ///// </summary>
        ///// <returns>The player's rank as an integer.</returns>
        //public async Task<int> GetPlayerRankAsync()
        //{
        //    FirebaseUser user = auth.CurrentUser;
        //    if (user == null)
        //    {
        //        Debug.LogError("No user is logged in.");
        //        return -1; // Return an invalid rank if no user is logged in
        //    }

        //    try
        //    {
        //        // Retrieve all players ordered by score
        //        QuerySnapshot allPlayersSnapshot = await firestore.Collection("Players")
        //            .OrderByDescending("score")
        //            .GetSnapshotAsync();

        //        int rank = 1;

        //        // Iterate through the players and find the rank of the current player
        //        foreach (DocumentSnapshot document in allPlayersSnapshot.Documents)
        //        {
        //            if (document.Id == user.UserId)
        //            {
        //                return rank;
        //            }
        //            rank++;
        //        }

        //        // If the player's ID was not found
        //        return -1;
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to get player rank: " + e.Message);
        //        return -1;
        //    }
        //}

        ///// <summary>
        ///// Loads the Battle Pass progress from Firebase and checks if the player's season is up-to-date.
        ///// If the player's season data is missing, it will save the current season from the global settings.
        ///// </summary>
        //public async Task LoadBattlePassProgressAsync()
        //{
        //    FirebaseUser user = auth.CurrentUser;
        //    if (user == null)
        //    {
        //        Debug.LogError("No user is logged in.");
        //        return;
        //    }

        //    try
        //    {
        //        // Reference to the Battle Pass progress and season documents
        //        DocumentReference battlePassDocRef = firestore
        //            .Collection("Players")
        //            .Document(user.UserId)
        //            .Collection("Progress")
        //            .Document("BattlePass");

        //        DocumentReference seasonDocRef = firestore
        //            .Collection("Players")
        //            .Document(user.UserId)
        //            .Collection("Progress")
        //            .Document("Season");

        //        // Get snapshots of the Battle Pass progress and season data
        //        DocumentSnapshot battlePassSnapshot = await battlePassDocRef.GetSnapshotAsync();
        //        DocumentSnapshot seasonSnapshot = await seasonDocRef.GetSnapshotAsync();

        //        if (battlePassSnapshot.Exists)
        //        {
        //            // Load Battle Pass XP, Level, and Unlock Status
        //            int currentXP = battlePassSnapshot.ContainsField("CurrentXP") ? battlePassSnapshot.GetValue<int>("CurrentXP") : 0;
        //            int currentLevel = battlePassSnapshot.ContainsField("CurrentLevel") ? battlePassSnapshot.GetValue<int>("CurrentLevel") : 1;
        //            bool isUnlocked = battlePassSnapshot.ContainsField("IsUnlocked") && battlePassSnapshot.GetValue<bool>("IsUnlocked");

        //            // Set the Battle Pass manager values
        //            BattlePassManager.Singleton.currentXP = currentXP;
        //            BattlePassManager.Singleton.currentLevel = currentLevel;
        //            BattlePassManager.Singleton.xpForNextLevel = BattlePassManager.Singleton.CalculateXPForNextLevel(currentLevel);

        //            // Season management
        //            int currentSeason;
        //            if (!seasonSnapshot.Exists || !seasonSnapshot.ContainsField("CurrentSeason"))
        //            {
        //                currentSeason = await GetCurrentSeasonAsync();
        //                await seasonDocRef.SetAsync(new Dictionary<string, object> { { "CurrentSeason", currentSeason } });
        //                Debug.Log($"Player's current season saved: {currentSeason}");
        //            }
        //            else
        //            {
        //                currentSeason = seasonSnapshot.GetValue<int>("CurrentSeason");
        //            }

        //            // If the Battle Pass is unlocked, store that information locally
        //            if (isUnlocked)
        //            {
        //                PlayerPrefs.SetInt(BattlePassManager.Singleton.playerPrefsPassUnlockedKey, 1);
        //            }

        //            // Save XP and Level to PlayerPrefs
        //            PlayerPrefs.SetInt(BattlePassManager.Singleton.playerPrefsXPKey, currentXP);
        //            PlayerPrefs.SetInt(BattlePassManager.Singleton.playerPrefsLevelKey, currentLevel);

        //            // Set the current season in the BattlePassManager
        //            BattlePassManager.SetPlayerBattlePassSeason(currentSeason);

        //            // Save PlayerPrefs changes
        //            PlayerPrefs.Save();

        //            Debug.Log("Battle Pass progress loaded from Firebase successfully.");
        //        }

        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to load Battle Pass progress: " + e.Message);
        //    }
        //}
        ///// <summary>
        ///// Loads claimed rewards for the player's Battle Pass.
        ///// </summary>
        //private async Task LoadClaimedRewardsFromFirebase(string userId)
        //{
        //    try
        //    {
        //        DocumentReference rewardsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("BattlePassRewards");

        //        DocumentSnapshot snapshot = await rewardsDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists)
        //        {
        //            Dictionary<string, object> rewardData = snapshot.ToDictionary();
        //            foreach (KeyValuePair<string, object> entry in rewardData)
        //            {
        //                string rewardId = entry.Key;
        //                bool isClaimed = (bool)entry.Value;
        //                if (isClaimed)
        //                {
        //                    BattlePassManager.Singleton.MarkRewardAsClaimed(rewardId);
        //                }
        //            }
        //            PlayerPrefs.Save();
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load claimed rewards: {e.Message}");
        //    }
        //}
        ///// <summary>
        ///// Resets Battle Pass progress in Firebase if you want to call it automatically.
        ///// </summary>
        //public async Task ResetBattlePassProgressAsync()
        //{
        //    string userId = auth.CurrentUser.UserId;
        //    try
        //    {
        //        DocumentReference battlePassDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("BattlePass");

        //        await battlePassDocRef.DeleteAsync();

        //        DocumentReference battlePassRewardsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("BattlePassRewards");

        //        await battlePassRewardsDocRef.DeleteAsync();

        //        int currentSeason = await GetCurrentSeasonAsync();
        //        DocumentReference seasonDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Progress")
        //            .Document("Season");

        //        await seasonDocRef.SetAsync(new Dictionary<string, object> { { "CurrentSeason", currentSeason } });
        //        BattlePassManager.SetPlayerBattlePassSeason(currentSeason);
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to reset Battle Pass: {e.Message}");
        //    }
        //}


        ///// <summary>
        ///// Retrieves the current Battle Pass season from the Firestore database.
        ///// If the season document or field is missing, it returns a default value of 1.
        ///// </summary>
        ///// <returns>The current Battle Pass season as an integer.</returns>
        //public async Task<int> GetCurrentSeasonAsync()
        //{
        //    try
        //    {
        //        // Reference to the document that contains the current season information
        //        DocumentReference seasonDocRef = firestore.Collection("BattlePass").Document("SeasonInfo");
        //        DocumentSnapshot snapshot = await seasonDocRef.GetSnapshotAsync();

        //        if (snapshot.Exists)
        //        {
        //            // Try to retrieve the value of the 'Season' field
        //            if (snapshot.TryGetValue<int>("Season", out int currentSeason))
        //            {
        //                Debug.Log($"Current Season from Firestore: {currentSeason}");
        //                return currentSeason;
        //            }
        //            else
        //            {
        //                Debug.LogWarning("Season field is missing in Firestore document.");
        //                return 1; // Default value if the 'Season' field is missing
        //            }
        //        }
        //        else
        //        {
        //            Debug.LogWarning("Season document does not exist in Firestore.");
        //            return 1; // Default value if the document does not exist
        //        }
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError($"Failed to get current season: {e.Message}");
        //        return 1; // Default value in case of an error
        //    }
        //}
        ///// <summary>
        ///// Checks if the season has ended (parallel call if you want). 
        ///// </summary>
        //private async Task<bool> CheckForSeasonEndAsync(string userId)
        //{
        //    // You can remove user checks, as we did them in the main method
        //    try
        //    {
        //        DocumentReference seasonDocRef = firestore
        //            .Collection("BattlePass")
        //            .Document("SeasonInfo");

        //        DocumentSnapshot snapshot = await seasonDocRef.GetSnapshotAsync();
        //        if (snapshot.Exists && snapshot.ContainsField("StartSeason"))
        //        {
        //            Timestamp startSeasonTimestamp = snapshot.GetValue<Timestamp>("StartSeason");
        //            DateTime startSeasonDate = startSeasonTimestamp.ToDateTime();
        //            int seasonLengthInDays = BattlePassManager.Singleton.SeasonLengthInDays;
        //            DateTime seasonEndDate = startSeasonDate.AddDays(seasonLengthInDays);

        //            BattlePassManager.Singleton.SaveRemainingSeasonTimeLocally(startSeasonDate);

        //            if (DateTime.UtcNow >= seasonEndDate)
        //            {
        //                Debug.Log("The current season has ended.");
        //                BattlePassManager.SetPlayerBattlePassSeasonEnded();
        //                return true;
        //            }
        //        }
        //        return false;
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to check for season end: {e.Message}");
        //        return false;
        //    }
        //}

        ///// <summary>
        ///// Loads basic character info (skin, level, experience, mastery) from Firestore
        ///// and applies to local PlayerSave.
        ///// </summary>
        ///// <param name="characterId">ID of the character.</param>
        //public async Task LoadCharacterBasicInfoAsync(int characterId)
        //{
        //    if (auth.CurrentUser == null)
        //    {
        //        Debug.LogError("No user is logged in.");
        //        return;
        //    }

        //    try
        //    {
        //        string userId = auth.CurrentUser.UserId;
        //        DocumentReference charDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("Characters")
        //            .Document(characterId.ToString());

        //        DocumentSnapshot snapshot = await charDocRef.GetSnapshotAsync();
        //        if (!snapshot.Exists)
        //        {
        //            Debug.LogWarning($"No character info found in Firestore for CharacterId {characterId}.");
        //            return;
        //        }

        //        // Apply to local PlayerSave if fields exist
        //        if (snapshot.ContainsField("CharacterSelectedSkin"))
        //        {
        //            int skinIndex = snapshot.GetValue<int>("CharacterSelectedSkin");
        //            PlayerSave.SetCharacterSkin(characterId, skinIndex);
        //        }
        //        if (snapshot.ContainsField("CharacterLevel"))
        //        {
        //            int level = snapshot.GetValue<int>("CharacterLevel");
        //            PlayerSave.SetCharacterLevel(characterId, level);
        //        }
        //        if (snapshot.ContainsField("CharacterCurrentExp"))
        //        {
        //            int currentExp = snapshot.GetValue<int>("CharacterCurrentExp");
        //            PlayerSave.SetCharacterCurrentExp(characterId, currentExp);
        //        }
        //        if (snapshot.ContainsField("CharacterMasteryLevel"))
        //        {
        //            int masteryLevel = snapshot.GetValue<int>("CharacterMasteryLevel");
        //            PlayerSave.SetCharacterMasteryLevel(characterId, masteryLevel);
        //        }
        //        if (snapshot.ContainsField("CharacterCurrentMasteryExp"))
        //        {
        //            int masteryExp = snapshot.GetValue<int>("CharacterCurrentMasteryExp");
        //            PlayerSave.SetCharacterCurrentMasteryExp(characterId, masteryExp);
        //        }

        //        Debug.Log($"Character basic info loaded for CharacterId {characterId}.");
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load character basic info for {characterId}: {e.Message}");
        //    }
        //}

        //public async Task LoadAndSyncAllCharacterBasicInfoAsync()
        //{
        //    if (auth.CurrentUser == null)
        //    {
        //        Debug.LogError("No user is logged in.");
        //        return;
        //    }

        //    try
        //    {
        //        List<Task> tasks = new List<Task>();
        //        foreach (CharacterData character in GameInstance.Singleton.characterData)
        //        {
        //            if (character.CheckUnlocked || MonetizationManager.Singleton.IsCharacterPurchased(character.characterId.ToString()))
        //            {
        //                tasks.Add(LoadCharacterBasicInfoAsync(character.characterId));
        //            }
        //        }
        //        await Task.WhenAll(tasks);
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError("Failed to load all character info: " + e.Message);
        //    }
        //}

        ///// <summary>
        ///// Loads the item documents for each known slot of each character in GameInstance.Singleton.characterData.
        ///// For each 'slotName' in charData.itemSlots and charData.runeSlots,
        ///// fetches the subcollection path: /Players/{userId}/Characters/{charId}/{slotName}.
        ///// Then loads all docs found (usually only 1 doc, if you equip 1 item por slot).
        ///// </summary>
        //public async Task LoadCharacterSlotsAsync()
        //{
        //    if (auth.CurrentUser == null)
        //    {
        //        Debug.LogError("No user is logged in.");
        //        return;
        //    }
        //    if (GameInstance.Singleton == null || GameInstance.Singleton.characterData == null)
        //    {
        //        Debug.LogError("GameInstance or characterData is null. Cannot load character slots.");
        //        return;
        //    }

        //    string userId = auth.CurrentUser.UserId;

        //    try
        //    {
        //        foreach (var charData in GameInstance.Singleton.characterData)
        //        {
        //            int charId = charData.characterId;
        //            if (charData.itemSlots != null)
        //            {
        //                foreach (string slotName in charData.itemSlots)
        //                {
        //                    await LoadSlotDocsForCharacter(userId, charId, slotName);
        //                }
        //            }
        //            if (charData.runeSlots != null)
        //            {
        //                foreach (string slotName in charData.runeSlots)
        //                {
        //                    await LoadSlotDocsForCharacter(userId, charId, slotName);
        //                }
        //            }

        //            Debug.Log($"[LoadCharacterSlotsAsync] Finished loading slots for Character {charId}.");
        //        }

        //        Debug.Log("[LoadCharacterSlotsAsync] Finished loading slots for ALL characters.");
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"[LoadCharacterSlotsAsync] Failed: {e.Message}");
        //    }
        //}

        ///// <summary>
        ///// Loads *all* documents in the slot subcollection of a single character.
        ///// Path: /Players/{userId}/Characters/{charId}/{slotName}
        ///// Each doc is typically a single item (uniqueItemGuid).
        ///// </summary>
        //private async Task LoadSlotDocsForCharacter(string userId, int charId, string slotName)
        //{
        //    CollectionReference slotCol = firestore
        //        .Collection("Players")
        //        .Document(userId)
        //        .Collection("Characters")
        //        .Document(charId.ToString())
        //        .Collection(slotName);

        //    QuerySnapshot snapshot = await slotCol.GetSnapshotAsync();
        //    foreach (DocumentSnapshot doc in snapshot.Documents)
        //    {
        //        if (!doc.Exists)
        //            continue;

        //        string uniqueGuid = doc.Id;
        //        string itemId = doc.ContainsField("ItemId") ? doc.GetValue<string>("ItemId") : "";
        //        int itemLevel = doc.ContainsField("ItemLevel") ? doc.GetValue<int>("ItemLevel") : 1;

        //        PlayerSave.SetCharacterSlotItem(charId, slotName, uniqueGuid);

        //        PlayerPrefs.SetInt($"{charId}_{slotName}_level", itemLevel);

        //        Debug.Log($"[LoadSlotDocsForCharacter] Loaded item '{itemId}' (GUID={uniqueGuid}) at slot '{slotName}', level={itemLevel}, for Char {charId}.");
        //    }
        //}

        ///// <summary>
        ///// Loads all purchased items from Firestore into local MonetizationManager,
        ///// then checks each InventoryItem in GameInstance. If 'isUnlocked' is true and
        ///// no item with the same itemId exists, purchases it to create a new GUID.
        ///// </summary>
        //public async Task InitializeInventoryAsync()
        //{
        //    if (auth.CurrentUser == null)
        //    {
        //        Debug.LogError("No user is logged in.");
        //        return;
        //    }
        //    List<PurchasedInventoryItem> remotePurchasedItems = await LoadAllPurchasedInventoryItemsAsync();
        //    var existingCharacters = MonetizationManager.Singleton.GetPurchasedCharacters();
        //    var existingIcons = MonetizationManager.Singleton.GetPurchasedIcons();
        //    var existingFrames = MonetizationManager.Singleton.GetPurchasedFrames();
        //    var existingShopItems = MonetizationManager.Singleton.GetPurchasedShopItems();

        //    MonetizationManager.Singleton.UpdatePurchasedItems(
        //        existingCharacters,
        //        existingIcons,
        //        existingFrames,
        //        existingShopItems,
        //        remotePurchasedItems
        //    );
        //    bool needSaveItem = false;
        //    foreach (var soItem in GameInstance.Singleton.inventoryItems)
        //    {
        //        if (soItem.isUnlocked)
        //        {
        //            bool alreadyOwned = MonetizationManager.Singleton
        //                .GetPurchasedInventoryItems()
        //                .Exists(pi => pi.itemId == soItem.itemId);

        //            if (!alreadyOwned)
        //            {
        //                MonetizationManager.Singleton.PurchaseInventoryItemNoImmediateSave(soItem.itemId);
        //                Debug.Log($"Created new purchased item for {soItem.itemId} (isUnlocked).");
        //                needSaveItem = true;
        //            }
        //        }
        //    }
        //    MonetizationManager.Singleton.SavePurchasedItems(needSaveItem);
        //}


        ///// <summary>
        ///// Loads all purchased inventory items from Firestore into a List, ensuring that the parent document exists.
        ///// </summary>
        //public async Task<List<PurchasedInventoryItem>> LoadAllPurchasedInventoryItemsAsync()
        //{
        //    List<PurchasedInventoryItem> result = new List<PurchasedInventoryItem>();

        //    try
        //    {
        //        string userId = auth.CurrentUser.UserId;
        //        // Reference to the "Items" document under PurchasedItems
        //        DocumentReference itemsDocRef = firestore
        //            .Collection("Players")
        //            .Document(userId)
        //            .Collection("PurchasedItems")
        //            .Document("Items");

        //        // Check if the "Items" document exists; if not, create it.
        //        DocumentSnapshot itemsDocSnapshot = await itemsDocRef.GetSnapshotAsync();
        //        if (!itemsDocSnapshot.Exists)
        //        {
        //            await itemsDocRef.SetAsync(new Dictionary<string, object>());
        //            Debug.Log("Created the 'Items' document as it did not exist.");
        //        }

        //        // Get the collection reference for the "List" subcollection
        //        CollectionReference itemsColRef = itemsDocRef.Collection("List");

        //        QuerySnapshot snapshot = await itemsColRef.GetSnapshotAsync();
        //        foreach (DocumentSnapshot doc in snapshot.Documents)
        //        {
        //            if (!doc.Exists)
        //                continue;

        //            string uniqueGuid = doc.Id;
        //            string itemId = doc.ContainsField("itemId") ? doc.GetValue<string>("itemId") : "";
        //            int itemLevel = doc.ContainsField("itemLevel") ? doc.GetValue<int>("itemLevel") : 0;

        //            Dictionary<int, int> upgrades = new Dictionary<int, int>();
        //            if (doc.ContainsField("itemUpgrades"))
        //            {
        //                Dictionary<string, object> upgradesData = doc.GetValue<Dictionary<string, object>>("itemUpgrades");
        //                foreach (var kvp in upgradesData)
        //                {
        //                    if (int.TryParse(kvp.Key, out int upgradeIndex))
        //                    {
        //                        int upgradeValue = Convert.ToInt32(kvp.Value);
        //                        upgrades[upgradeIndex] = upgradeValue;
        //                    }
        //                }
        //            }

        //            PurchasedInventoryItem pi = new PurchasedInventoryItem
        //            {
        //                uniqueItemGuid = uniqueGuid,
        //                itemId = itemId,
        //                itemLevel = itemLevel,
        //                upgrades = upgrades
        //            };
        //            result.Add(pi);
        //        }

        //        Debug.Log($"Loaded {result.Count} purchased inventory items from Firestore.");
        //    }
        //    catch (Exception e)
        //    {
        //        Debug.LogError($"Failed to load purchased inventory items: {e.Message}");
        //    }

        //    return result;
        //}


        ///// <summary>
        ///// Converts a list of generic objects to a list of a specific type using JsonUtility.
        ///// </summary>
        //private List<T> ConvertToList<T>(List<object> data)
        //{
        //    var list = new List<T>();
        //    if (data == null) return list;

        //    foreach (var item in data)
        //    {
        //        try
        //        {
        //            list.Add(JsonUtility.FromJson<T>(item.ToString()));
        //        }
        //        catch (Exception ex)
        //        {
        //            Debug.LogError($"Error converting item: {ex.Message}");
        //        }
        //    }
        //    return list;
        //}
    }
}