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

namespace BulletHellTemplate
{
    public class FirebaseSave : MonoBehaviour
    {
        public static FirebaseSave Singleton;
        public FirebaseUser user;
        public FirebaseFirestore firestore;

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

        public void InitializeFirebase(FirebaseUser _user, FirebaseFirestore _firestore)
        {
            user = _user;
            firestore = _firestore;
        }

        /// <summary>
        /// Updates the player's icon in Firestore.
        /// </summary>
        /// <param name="newIconId">The new icon ID to set.</param>
        public async Task UpdatePlayerIcon(string newIconId)
        {
            if (user != null)
            {
                try
                {
                    DocumentReference docRef = firestore.Collection("Players").Document(user.UserId);
                    await docRef.UpdateAsync("PlayerIcon", newIconId);
                    Debug.Log("Player icon updated successfully.");
                }
                catch (Exception e)
                {
                    Debug.LogError("Failed to update player icon: " + e.Message);
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        /// <summary>
        /// Updates the player's frame in Firestore.
        /// </summary>
        /// <param name="newFrameId">The new frame ID to set.</param>
        public async Task UpdatePlayerFrame(string newFrameId)
        {
            if (user != null)
            {
                try
                {
                    DocumentReference docRef = firestore.Collection("Players").Document(user.UserId);
                    await docRef.UpdateAsync("PlayerFrame", newFrameId);
                    Debug.Log("Player frame updated successfully.");
                }
                catch (Exception e)
                {
                    Debug.LogError("Failed to update player frame: " + e.Message);
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        /// <summary>
        /// Updates the player's account level and current experience in Firestore.
        /// </summary>
        /// <param name="level">The new account level to set.</param>
        /// <param name="currentExp">The new current experience to set.</param>
        public async Task UpdatePlayerAccountLevel(int level, int currentExp)
        {
            if (user != null)
            {
                try
                {
                    DocumentReference docRef = firestore.Collection("Players").Document(user.UserId);
                    var data = new Dictionary<string, object>
                {
                    { "AccountLevel", level },
                    { "AccountCurrentExp", currentExp }
                };
                    await docRef.SetAsync(data, SetOptions.MergeAll);
                    Debug.Log("Account info updated successfully.");
                }
                catch (Exception e)
                {
                    Debug.LogError("Failed to update account info: " + e.Message);
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        /// <summary>
        /// Updates the player's name in Firestore.
        /// </summary>
        /// <param name="newName">The new player name to set.</param>
        public async Task UpdatePlayerName(string newName)
        {
            if (user != null)
            {
                try
                {
                    // Validate the new player name
                    if (string.IsNullOrWhiteSpace(newName) || newName.Length < 3 || newName.Length > 14)
                    {
                        Debug.LogError("Player name must be between 3 and 14 characters.");
                        return;
                    }

                    // Check if the new player name already exists in the database
                    bool nameExists = await CheckIfNameExists(newName);
                    if (nameExists)
                    {
                        Debug.LogError("The player name already exists.");
                        return;
                    }

                    // Update the player's name in Firestore
                    DocumentReference docRef = firestore.Collection("Players").Document(user.UserId);
                    await docRef.UpdateAsync("PlayerName", newName);

                    // Update the player's name locally
                    PlayerSave.SetPlayerName(newName);
                    Debug.Log("Player name updated successfully.");


                }
                catch (Exception e)
                {
                    Debug.LogError("Failed to update player name: " + e.Message);
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        /// <summary>
        /// Checks if a player name already exists in the Firestore database.
        /// </summary>
        /// <param name="playerName">The name to check.</param>
        /// <returns>True if the name exists; otherwise, false.</returns>
        public async Task<bool> CheckIfNameExists(string playerName)
        {
            try
            {
                // Reference to the "Players" collection
                CollectionReference playersCollection = firestore.Collection("Players");

                // Create a query to find documents where "PlayerName" equals the provided name
                Query query = playersCollection.WhereEqualTo("PlayerName", playerName);

                // Execute the query and get a snapshot of the results
                QuerySnapshot querySnapshot = await query.GetSnapshotAsync();

                // Check if any document exists in the result
                return querySnapshot.Count > 0;
            }
            catch (Exception e)
            {
                Debug.LogError("Failed to check if name exists: " + e.Message);
                return false;
            }
        }

        /// <summary>
        /// Updates the amount of a specific currency in Firestore.
        /// </summary>
        /// <param name="currencyId">The ID of the currency to update.</param>
        /// <param name="newAmount">The new amount to set for the currency.</param>
        public async Task UpdateCurrencies(string currencyId, int newAmount)
        {
            if (user != null)
            {
                try
                {
                    DocumentReference currencyDocRef = firestore
                        .Collection("Players")
                        .Document(user.UserId)
                        .Collection("Currencies")
                        .Document(currencyId);
                    await currencyDocRef.UpdateAsync("amount", newAmount);

                    Debug.Log($"Currency {currencyId} updated successfully to {newAmount}.");
                }
                catch (Exception e)
                {
                    Debug.LogError($"Failed to update currency {currencyId}: " + e.Message);
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }    

        /// <summary>
        /// Updates the selected character for the logged-in user in Firestore.
        /// If the field doesn't exist, it creates it.
        /// </summary>
        /// <param name="characterId">The ID of the selected character to save.</param>
        public async Task UpdateSelectedCharacter(int characterId)
        {
            if (user != null)
            {
                try
                {
                    DocumentReference docRef = firestore.Collection("Players").Document(user.UserId);

                    await docRef.UpdateAsync("selectedCharacter", characterId);
                    Debug.Log($"Selected character updated successfully: {characterId}");
                }
                catch (Exception e)
                {

                    if (e.Message.Contains("No document to update"))
                    {
                        Debug.LogWarning("Document does not exist, creating field instead.");

                        Dictionary<string, object> data = new Dictionary<string, object>
                {
                    { "selectedCharacter", characterId }
                };
                        await firestore.Collection("Players").Document(user.UserId).SetAsync(data, SetOptions.MergeAll);
                        Debug.Log($"Selected character created successfully: {characterId}");
                    }
                    else
                    {
                        Debug.LogError($"Failed to update or create selected character: {e.Message}");
                    }
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        /// <summary>
        /// Updates the list of purchased items for the currently logged-in user in Firestore.
        /// </summary>
        /// <returns>A task representing the asynchronous operation.</returns>
        public async Task SavePurchasedItemsAsync()
        {
            try
            {
                if (user == null)
                {
                    Debug.LogError("No user is currently logged in.");
                    return;
                }
                string userId = user.UserId;
                var characters = MonetizationManager.Singleton.GetPurchasedCharacters();
                var icons = MonetizationManager.Singleton.GetPurchasedIcons();
                var frames = MonetizationManager.Singleton.GetPurchasedFrames();
                var shopItems = MonetizationManager.Singleton.GetPurchasedShopItems();

                // Convert lists to the format suitable for Firestore
                var characterData = characters.Select(c => JsonUtility.ToJson(c)).ToList();
                var iconData = icons.Select(i => JsonUtility.ToJson(i)).ToList();
                var frameData = frames.Select(f => JsonUtility.ToJson(f)).ToList();
                var shopItemData = shopItems.Select(s => JsonUtility.ToJson(s)).ToList();

                var db = FirebaseFirestore.DefaultInstance;
                var batch = db.StartBatch();

                // Save purchased characters
                var characterDocRef = db.Collection("Players").Document(userId).Collection("PurchasedItems").Document("Characters");
                batch.Set(characterDocRef, new { Characters = characterData });

                // Save purchased icons
                var iconDocRef = db.Collection("Players").Document(userId).Collection("PurchasedItems").Document("Icons");
                batch.Set(iconDocRef, new { Icons = iconData });

                // Save purchased frames
                var frameDocRef = db.Collection("Players").Document(userId).Collection("PurchasedItems").Document("Frames");
                batch.Set(frameDocRef, new { Frames = frameData });

                // Save purchased shop items
                var shopItemDocRef = db.Collection("Players").Document(userId).Collection("PurchasedItems").Document("ShopItems");
                batch.Set(shopItemDocRef, new { ShopItems = shopItemData });

                // Commit the batch operation
                await batch.CommitAsync();
                Debug.Log("Purchased items saved successfully.");
            }
            catch (Exception ex)
            {
                Debug.LogError("Error saving purchased items: " + ex.Message);
            }
        }

        /// <summary>
        /// Saves the upgrades of a specific character to Firebase Firestore.
        /// </summary>
        /// <param name="characterId">The ID of the character.</param>
        /// <param name="upgrades">The dictionary containing upgrade data.</param>
        public async Task SaveCharacterUpgradesAsync(string characterId, Dictionary<StatType, int> upgrades)
        {
            if (user != null)
            {
                try
                {
                    DocumentReference upgradesDocRef = firestore
                        .Collection("Players")
                        .Document(user.UserId)
                        .Collection("Characters")
                        .Document(characterId)
                        .Collection("Upgrades")
                        .Document("Stats");

                    Dictionary<string, object> upgradesData = new Dictionary<string, object>();
                    foreach (var upgrade in upgrades)
                    {
                        upgradesData[upgrade.Key.ToString()] = upgrade.Value;
                    }

                    await upgradesDocRef.SetAsync(upgradesData);
                    Debug.Log($"Character upgrades for {characterId} saved successfully.");
                }
                catch (Exception e)
                {
                    Debug.LogError($"Failed to save character upgrades for {characterId}: " + e.Message);
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        /// <summary>
        /// Saves the unlocked skins for a specific character to Firebase Firestore.
        /// </summary>
        /// <param name="characterId">The ID of the character as a string.</param>
        /// <param name="unlockedSkins">List of unlocked skin indices.</param>
        public async Task SaveCharacterUnlockedSkinsAsync(string characterId, List<int> unlockedSkins)
        {
            if (user!= null)
            {
                try
                {
                    DocumentReference skinsDocRef = firestore
                        .Collection("Players")
                        .Document(user.UserId)
                        .Collection("Characters")
                        .Document(characterId)
                        .Collection("UnlockedSkins")
                        .Document("Skins");

                    Dictionary<string, object> skinsData = new Dictionary<string, object>
                    {
                        { "skins", unlockedSkins }
                    };

                    await skinsDocRef.SetAsync(skinsData);
                    Debug.Log($"Character unlocked skins for {characterId} saved successfully.");
                }
                catch (Exception e)
                {
                    Debug.LogError($"Failed to save unlocked skins for {characterId}: {e.Message}");
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        /// <summary>
        /// Saves the unlocked maps for the player to Firebase Firestore.
        /// </summary>
        /// <returns>A task representing the asynchronous operation.</returns>
        public async Task SaveUnlockedMapsAsync()
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }

            try
            {
                List<int> unlockedMapIds = PlayerSave.GetUnlockedMaps();
                Dictionary<string, object> mapsData = new Dictionary<string, object>();

                foreach (int mapId in unlockedMapIds)
                {
                    mapsData[mapId.ToString()] = true;
                }

                DocumentReference mapsDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Progress")
                    .Document("UnlockedMaps");

                await mapsDocRef.SetAsync(mapsData);
                Debug.Log("Unlocked maps saved to Firebase successfully.");
            }
            catch (Exception e)
            {
                Debug.LogError("Failed to save unlocked maps: " + e.Message);
            }
        }

        /// <summary>
        /// Saves a used coupon to Firebase Firestore.
        /// </summary>
        /// <param name="couponId">The unique ID of the coupon.</param>
        /// <returns>A task representing the asynchronous operation.</returns>
        public async Task SaveUsedCouponAsync(string couponId)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }

            try
            {
                DocumentReference couponsDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Progress")
                    .Document("UsedCoupons");
                DocumentSnapshot snapshot = await couponsDocRef.GetSnapshotAsync();

                if (!snapshot.Exists)
                {
                    // If the document does not exist, create it with the initial coupon
                    await couponsDocRef.SetAsync(new Dictionary<string, object>
            {
                { couponId, true }
            });
                    Debug.Log($"Coupon {couponId} created and saved to Firebase successfully.");
                }
                else
                {
                    await couponsDocRef.UpdateAsync(new Dictionary<string, object>
            {
                { couponId, true }
            });
                    Debug.Log($"Coupon {couponId} saved to Firebase successfully.");
                }
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save used coupon {couponId} to Firebase: " + e.Message);
            }
        }

        /// <summary>
        /// Saves the progress of a quest to Firebase Firestore.
        /// </summary>
        /// <param name="questId">The ID of the quest.</param>
        /// <param name="progress">The progress value to save.</param>
        /// <returns>A task representing the asynchronous operation.</returns>
        public async Task SaveQuestProgressAsync(int questId, int progress)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }
            try
            {
                DocumentReference questsDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Progress")
                    .Document("Quests");

                DocumentSnapshot snapshot = await questsDocRef.GetSnapshotAsync();

                if (!snapshot.Exists)
                {
                    // If the document does not exist, create it with the initial quest progress
                    await questsDocRef.SetAsync(new Dictionary<string, object>
            {
                { questId.ToString(), progress }
            });
                    Debug.Log($"Quest progress for {questId} created and saved successfully in Firebase.");
                }
                else
                {
                    // If the document exists, update the quest progress
                    await questsDocRef.UpdateAsync(new Dictionary<string, object>
            {
                { questId.ToString(), progress }
            });
                    Debug.Log($"Quest progress for {questId} updated successfully in Firebase.");
                }
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save quest progress for {questId}: {e.Message}");
            }
        }

        /// <summary>
        /// Saves the completion status of a quest to Firebase Firestore, including the completion timestamp.
        /// </summary>
        /// <param name="questId">The ID of the quest.</param>
        /// <returns>A task representing the asynchronous operation.</returns>
        public async Task SaveQuestCompletionAsync(int questId)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }

            try
            {
                DocumentReference questsDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Progress")
                    .Document("Quests");

                string questKey = "Complete " + questId.ToString(); // Format key as "Complete X"

                // Get the current timestamp
                Timestamp completionTimestamp = Timestamp.GetCurrentTimestamp();

                // Check if the document exists
                DocumentSnapshot snapshot = await questsDocRef.GetSnapshotAsync();

                if (snapshot.Exists)
                {
                    await questsDocRef.UpdateAsync(new Dictionary<string, object>
            {
                { questKey, 1 }, // Assuming 1 represents completion
                { questKey + "_Timestamp", completionTimestamp } // Save completion timestamp
            });
                }
                else
                {
                    // If the document doesn't exist, create it with the quest completion status and timestamp
                    await questsDocRef.SetAsync(new Dictionary<string, object>
            {
                { questKey, 1 }, // Assuming 1 represents completion
                { questKey + "_Timestamp", completionTimestamp } // Save completion timestamp
            });
                }

                Debug.Log($"Quest completion for {questId} saved successfully in Firebase with timestamp.");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save quest completion for {questId}: {e.Message}");
            }
        }

        /// <summary>
        /// Saves the number of monsters killed by the player to their Firestore document.
        /// The total number of kills is incremented by the amount achieved in the current game session.
        /// </summary>
        /// <param name="monstersKilled">The number of monsters killed in the current session.</param>
        public async Task SaveMonstersKilledAsync(int monstersKilled)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }
            DocumentReference playerDocRef = firestore
                .Collection("Players")
                .Document(user.UserId);

            try
            {
                DocumentSnapshot snapshot = await playerDocRef.GetSnapshotAsync();
                double currentScore = 0;
                // If the document exists and the "score" field is present, retrieve the current score.
                if (snapshot.Exists && snapshot.ContainsField("score"))
                {
                    currentScore = Convert.ToDouble(snapshot.GetValue<string>("score"));
                }
                else
                {
                    Debug.Log("No score found for the player, starting from 0.");
                }
                // Add the new kills to the current score
                currentScore += monstersKilled;
                // Update the Firestore document with the new score
                await playerDocRef.UpdateAsync("score", currentScore.ToString());

                Debug.Log($"Monsters killed ({monstersKilled}) added to player's score. New score: {currentScore}");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save monsters killed to Firestore: {e.Message}");
            }
        }

        /// <summary>
        /// Saves the PlayerCharacterFavourite to Firestore.
        /// </summary>
        /// <param name="characterId">The ID of the character to save as favourite.</param>
        public async Task SavePlayerCharacterFavouriteAsync(int characterId)
        {
            if (user != null)
            {
                try
                {
                    DocumentReference docRef = firestore.Collection("Players").Document(user.UserId);
                    DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();

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

                        if (playerData.ContainsKey("PlayerCharacterFavourite"))
                        {
                            // Update the existing field
                            await docRef.UpdateAsync("PlayerCharacterFavourite", characterId);
                        }
                        else
                        {
                            // Create the field if it doesn't exist
                            await docRef.SetAsync(new Dictionary<string, object> { { "PlayerCharacterFavourite", characterId } }, SetOptions.MergeFields("PlayerCharacterFavourite"));
                        }

                        Debug.Log("PlayerCharacterFavourite saved successfully.");
                    }
                    else
                    {
                        Debug.LogWarning("Player document does not exist.");
                    }
                }
                catch (Exception e)
                {
                    Debug.LogError("Failed to save PlayerCharacterFavourite: " + e.Message);
                }
            }
            else
            {
                Debug.LogError("No user is logged in.");
            }
        }

        public async Task SaveClaimedRewardAsync(string passItemId)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }

            try
            {
                DocumentReference rewardsDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Progress")
                    .Document("BattlePassRewards");

                DocumentSnapshot snapshot = await rewardsDocRef.GetSnapshotAsync();

                if (snapshot.Exists)
                {
                    await rewardsDocRef.UpdateAsync(new Dictionary<string, object>
            {
                { passItemId, true }
            });
                }
                else
                {
                    await rewardsDocRef.SetAsync(new Dictionary<string, object>
            {
                { passItemId, true }
            });
                }

                Debug.Log($"Claimed reward {passItemId} saved to Firebase.");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save claimed reward {passItemId} to Firebase: {e.Message}");
            }
        }
        public async Task SaveBattlePassProgressAsync(int currentXP, int currentLevel, bool isUnlocked)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }

            try
            {
                DocumentReference battlePassDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Progress")
                    .Document("BattlePass");

                Dictionary<string, object> battlePassData = new Dictionary<string, object>
        {
            { "CurrentXP", currentXP },
            { "CurrentLevel", currentLevel },
            { "IsUnlocked", isUnlocked }
        };

                await battlePassDocRef.SetAsync(battlePassData);
                Debug.Log("Battle Pass progress saved to Firebase successfully.");
            }
            catch (Exception e)
            {
                Debug.LogError("Failed to save Battle Pass progress: " + e.Message);
            }
        }

        /// <summary>
        /// Saves basic character info (skin, level, experience, mastery) to Firestore and updates local PlayerSave.
        /// </summary>
        /// <param name="characterId">ID of the character.</param>
        /// <param name="skinIndex">Index of the selected skin. Use -1 if no skin is selected.</param>
        /// <param name="level">Character level.</param>
        /// <param name="currentExp">Current experience points.</param>
        /// <param name="masteryLevel">Current mastery level.</param>
        /// <param name="masteryExp">Current mastery experience points.</param>
        public async Task SaveCharacterBasicInfoAsync(int characterId, int skinIndex, int level, int currentExp, int masteryLevel, int masteryExp)
        {
            try
            {
                DocumentReference charDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Characters")
                    .Document(characterId.ToString());

                Dictionary<string, object> data = new Dictionary<string, object>
                {
                    { "CharacterSelectedSkin", skinIndex },
                    { "CharacterLevel", level },
                    { "CharacterCurrentExp", currentExp },
                    { "CharacterMasteryLevel", masteryLevel },
                    { "CharacterCurrentMasteryExp", masteryExp }
                };

                // Update Firestore
                await charDocRef.SetAsync(data, SetOptions.MergeAll);
                Debug.Log($"Character basic info saved for CharacterId {characterId}.");
              ;
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save character basic info for {characterId}: {e.Message}");
            }
        }

        /// <summary>
        /// Saves an item to the sub-collection named by 'slotName' under the character document.
        /// Each item is stored in its own document, named by the unique item identifier.
        /// Path: Players/{userId}/Characters/{characterId}/{slotName}/{uniqueItemGuid}
        /// </summary>
        /// <param name="characterId">ID of the character.</param>
        /// <param name="slotName">Slot name (e.g. "WeaponSlot" or "RuneSlot").</param>
        /// <param name="uniqueItemGuid">Unique ID for this item doc.</param>
        /// <param name="itemId">ID of the item (scriptable or otherwise).</param>
        /// <param name="itemLevel">Level of the item.</param>
        public async Task SaveCharacterItemAsync(int characterId, string slotName, string uniqueItemGuid, string itemId, int itemLevel)
        {
            try
            {
                // Example: /Players/{userId}/Characters/{characterId}/{slotName}/{uniqueItemGuid}
                DocumentReference itemDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Characters")
                    .Document(characterId.ToString())
                    .Collection(slotName)  // <-- The "slotName" subcollection
                    .Document(uniqueItemGuid);

                Dictionary<string, object> data = new Dictionary<string, object>
        {
            { "ItemId", itemId },
            { "ItemLevel", itemLevel }
        };

                await itemDocRef.SetAsync(data, SetOptions.MergeAll);
                Debug.Log($"[SaveCharacterItemAsync] Item saved: Char {characterId}, Slot {slotName}, Doc {uniqueItemGuid}.");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save item for CharId {characterId}, slot {slotName}: {e.Message}");
            }
        }

        /// <summary>
        /// Removes (unequips) an item document from the specified slot of the character.
        /// Path: Players/{userId}/Characters/{characterId}/{slotName}/{uniqueItemGuid}
        /// </summary>
        public async Task RemoveCharacterItemAsync(int characterId, string slotName, string uniqueItemGuid)
        {
            try
            {
                DocumentReference docRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("Characters")
                    .Document(characterId.ToString())
                    .Collection(slotName)
                    .Document(uniqueItemGuid);

                await docRef.DeleteAsync();
                Debug.Log($"[RemoveCharacterItemAsync] Removed item {uniqueItemGuid} from slot {slotName} of Char {characterId}.");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to remove item {uniqueItemGuid} from char {characterId}, slot {slotName}: {e.Message}");
            }
        }

        /// <summary>
        /// Saves a purchased inventory item into Firestore (Players/{userId}/PurchasedItems/Items/{uniqueItemGuid}).
        /// Also updates local data if desired.
        /// </summary>
        public async Task SavePurchasedInventoryItemAsync(PurchasedInventoryItem purchasedItem)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }

            try
            {
                DocumentReference itemDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("PurchasedItems")
                    .Document("Items")
                    .Collection("List")
                    .Document(purchasedItem.uniqueItemGuid);

                Dictionary<string, object> data = new Dictionary<string, object>
        {
            { "uniqueItemGuid", purchasedItem.uniqueItemGuid },
            { "itemId", purchasedItem.itemId },
            { "itemLevel", purchasedItem.itemLevel }
        };
                Dictionary<string, object> upgradesDict = new Dictionary<string, object>();
                if (purchasedItem.upgrades != null)
                {
                    foreach (var kvp in purchasedItem.upgrades)
                    {
                        upgradesDict[kvp.Key.ToString()] = kvp.Value;
                    }
                }
                data["itemUpgrades"] = upgradesDict;

                await itemDocRef.SetAsync(data, SetOptions.MergeAll);
                Debug.Log($"Purchased item saved: {purchasedItem.uniqueItemGuid} -> {purchasedItem.itemId}.");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save purchased inventory item {purchasedItem.uniqueItemGuid}: {e.Message}");
            }
        }

        /// <summary>
        /// Deletes a purchased inventory item from Firestore: 
        ///  Players/{userId}/PurchasedItems/Items/List/{uniqueItemGuid}.
        /// Also checks all characters to remove the item from sub-collection Items if present.
        /// Finally, removes it locally from MonetizationManager and InventorySave.
        /// </summary>
        /// <param name="uniqueItemGuid">The unique item GUID to delete.</param>
        public async Task DeletePurchasedInventoryItemAsync(string uniqueItemGuid)
        {
            if (user == null)
            {
                Debug.LogError("No user is logged in.");
                return;
            }

            try
            {
                // 1) Remove from "PurchasedItems"
                DocumentReference itemDocRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("PurchasedItems")
                    .Document("Items")
                    .Collection("List")
                    .Document(uniqueItemGuid);

                await itemDocRef.DeleteAsync();
                Debug.Log($"Item {uniqueItemGuid} deleted from PurchasedItems.");

                // 2) Check all characters for this item
                foreach (var cd in GameInstance.Singleton.characterData)
                {
                    int charId = cd.characterId;
                    // Attempt to remove from the character's "Items" sub-collection
                    DocumentReference charItemDoc = firestore
                        .Collection("Players")
                        .Document(user.UserId)
                        .Collection("Characters")
                        .Document(charId.ToString())
                        .Collection("Items")
                        .Document(uniqueItemGuid);

                    await charItemDoc.DeleteAsync();
                    // It's okay if doc doesn't exist, no error is thrown for a missing doc
                }

                // 3) Remove locally from MonetizationManager
                var allItems = MonetizationManager.Singleton.GetPurchasedInventoryItems();
                var foundItem = allItems.Find(i => i.uniqueItemGuid == uniqueItemGuid);
                if (foundItem != null)
                {
                    allItems.Remove(foundItem);
                    // Update the manager
                    MonetizationManager.Singleton.UpdatePurchasedItems(
                        MonetizationManager.Singleton.GetPurchasedCharacters(),
                        MonetizationManager.Singleton.GetPurchasedIcons(),
                        MonetizationManager.Singleton.GetPurchasedFrames(),
                        MonetizationManager.Singleton.GetPurchasedShopItems(),
                        allItems
                    );
                }

                Debug.Log($"Item {uniqueItemGuid} fully deleted locally and online.");
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to delete item {uniqueItemGuid}: {e.Message}");
            }
        }

        /// <summary>
        /// Saves daily rewards data to Firebase.
        /// </summary>
        public async Task SaveDailyRewardsDataAsync(DailyRewardsData dailyData)
        {
            try
            {
                if (user == null) return;

                DocumentReference docRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("DailyRewards")
                    .Document("RewardData");

                Dictionary<string, object> saveData = new Dictionary<string, object>
                {
                    { "firstClaimDate", Timestamp.FromDateTime(dailyData.firstClaimDate.ToUniversalTime()) },
                    { "claimedRewards", dailyData.claimedRewards }
                };

                await docRef.SetAsync(saveData);
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save daily rewards data: {e.Message}");
            }
        }

        /// <summary>
        /// Saves new player rewards data to Firebase.
        /// </summary>
        public async Task SaveNewPlayerRewardsDataAsync(NewPlayerRewardsData newPlayerData)
        {
            try
            {
                if (user == null) return;

                DocumentReference docRef = firestore
                    .Collection("Players")
                    .Document(user.UserId)
                    .Collection("NewPlayerRewards")
                    .Document("RewardData");

                Dictionary<string, object> saveData = new Dictionary<string, object>
                {
                    { "accountCreationDate", Timestamp.FromDateTime(newPlayerData.accountCreationDate.ToUniversalTime()) },
                    { "claimedRewards", newPlayerData.claimedRewards }
                };

                await docRef.SetAsync(saveData);
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save new player rewards data: {e.Message}");
            }
        }
    
    }
}