Mocha-2023-RecRoom-Server/Controllers/APIController.cs

using Mocha2023.Auth;
using Mocha2023.Classes;
using Mocha2023.Classes.DBs;
using Mocha2023.Classes.DBs.DBClasses;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using SixLabors.ImageSharp;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using static Mocha2023.Classes.DBs.DBClasses.PlayerDBClasses;
using JsonSerializer = System.Text.Json.JsonSerializer;

namespace Mocha2023.Controllers
{
    [ApiController]
    [Mocha2023.Classes.ApiProtection]
    public class APIController : ControllerBase
    {
        private const int StoreItemPrice = 100;
        private const int FriendotronGiftContext = (int)PlayerDBClasses.GiftContext.Consumable;
        private const string WeeklyChallengeRewardEquipmentPrefab = "[Basketball]";
        private const string WeeklyChallengeRewardModificationGuid =
            "WOWwmg7jg0mH2g4LJUp6fA";
        private static readonly object CatalogLock = new();
        private static readonly object EquipmentInventoryLock = new();
        private static DateTime CatalogCacheTimestampUtc;
        private static DateTime EquipmentCatalogCacheTimestampUtc;
        private static DateTime ConsumableCatalogCacheTimestampUtc;
        private static List<CatalogSku> CatalogCache = new();
        private static readonly object StorefrontAdminLock = new();
        private static StorefrontAdminState? StorefrontAdminCache;
        private static readonly FriendotronConsumableReward[]
            FriendotronConsumableRewards =
            {
                new("Film (Black & White)", "frOMH6WxDEG1fBqC4_83vg", 0),
                new("Film (Dawn)", "m0bVLwWGj0GuIBSb6wCk6Q", 0),
                new("Film (Sepia)", "A5M-yf9tgUihq1uab3v58g", 0),
                new("High Five Potion (Golden)", "-hy0qD-iUk-v4NHxNzanmg", 0),
                new("High Five Potion (Magic)", "VQSgL2pTLkWx4B3kwYG7UA", 0),
                new("Assorted Donuts", "ZuvkidodzkuOfGLDnTOFyg", 20),
                new("Candy Apples", "EmPvh3I6L0uK_1i8Wy_ylQ", 20),
                new("Cheese Pizza", "5hIAZ9wg5EyG1cILf4FS2A", 0),
                new("Chocolate Donuts", "mMCGPgK3tki5S_15q2Z81A", 10),
                new("Glazed Donuts", "7OZ5AE3uuUyqa0P-2W1ptg", 0),
                new("Hawaiian Pizza", "_jnjYGBcyEWY5Ub4OezXcA", 10),
                new("Tray of Lattes", "P15H1ONBhk-5DYYjid1ttg", 10),
                new("Pepperoni Pizza", "mq23W-RSP0G8iGNLdrcpUw", 10),
                new("Root Beer", "JfnVXFmilU6ysv-VbTAe3A", 0),
                new("Salted Pretzels", "InQ25wQMGkG_bvuD5rf2Ag", 0),
                new("Supreme Pizza", "wUCIKdJSvEmiQHYMyx4X4w", 20),
                new("KO Icon - Grenade", "EAhk3ZZdXEmH5wRAXXT24Q", 20),
                new("KO Icon - Sword & Shield", "5AJin8T2iEG7BzOPOgx2HA", 20),
                new("KO Icon - Winged Skull", "U38Qe6rhEk6mFvArHfYjng", 20),
                new("KO Icon - Tire Track", "J1WqFNUWo0OBi4LGKPDHWw", 20)
            };

        [HttpGet("/")]
        public IActionResult GetNS()
        {

            if (Request.Headers.Accept.Any(value =>
                    value?.Contains("text/html", StringComparison.OrdinalIgnoreCase) == true))
            {
                return Redirect("/recnet/");
            }

            return BuildNameServerResponse();
        }

        [HttpGet("/nameserver")]
        public IActionResult GetNameServer([FromQuery] int? v = null)
        {
            return BuildNameServerResponse();
        }

        private IActionResult BuildNameServerResponse()
        {
            string url = ServerConfig.BaseURL.TrimEnd('/');
            return Ok(new
            {
                Accounts = url + "/acc",
                API = url,
                Auth = url + "/auth",
                BugReporting = url,
                Cards = url,
                CDN = url + "/cdn",
                Chat = url,
                Clubs = url,
                CMS = url,
                Commerce = url,
                Data = url,
                DataCollection = url,
                Discovery = url,
                Econ = url,
                GameLogs = url,
                Geo = url,

                Images = url + "/imageserver-v2",
                Leaderboard = url,
                Link = url,
                Lists = url,
                Matchmaking = url + "/match",
                Moderation = url,
                Notifications = url + "/noti",
                PlatformNotifications = url,
                PlayerSettings = url,
                RoomComments = url,
                Rooms = url + "/roomserver",
                Storage = url,
                Strings = url,
                StringsCDN = url,
                Studio = url,
                Thorn = url,
                Videos = url,
                WWW = url
            });
        }

        [HttpPost("/api/gamesight/event")]
        public IActionResult StubGameSightEvent()
        {

            return Ok(new { success = true });
        }

        [HttpGet("/api/storefronts/v3/giftdropstore/{storeId:int}")]
        public IActionResult StubGetGiftDropStore([FromRoute] int storeId)
        {

            List<CatalogSku> storeItems = storeId == 3
                ? GetWatchStoreSkusWithHairDyes()
                : GetDailyStoreSkus(storeId);

            if (storeId == 3)
            {
                Console.WriteLine(
                    $"[HAIR DYE STOREFRONT] total={storeItems.Count} " +
                    $"dyes={storeItems.Count(IsHairDyeCatalogItem)}");
            }

            return Ok(new CatalogStorefront
            {
                StorefrontType = storeId,
                NextUpdate = DateTime.Today.AddDays(1).ToUniversalTime(),
                StoreItems = storeItems
            });
        }

        [HttpGet("/api/quickPlay/v1/getandclear")]
        public IActionResult StubGetAndClearQuickPlay()
        {
            return Ok(System.Array.Empty<object>());
        }

        [HttpGet("/api/challenge/v2/getCurrent")]
        public IActionResult GetCurrentChallenges()
        {
            var (challengeMapId, startsAt, endsAt) = RecNetDB.GetCurrentChallengeWindow();
            long accountId = AuthStuff.GetPlayerId(Request) ?? 0;
            object[] challenges =
            {
                CurrentChallenge(
                    accountId: accountId,
                    challengeMapId: challengeMapId,
                    id: 1,
                    title: "Complete Crimson Cauldron",
                    description: "Complete Curse of the Crimson Cauldron.",
                    tooltip: "Complete ^CrimsonCauldron.",
                    config: "{\"ct\":6,\"vs\":[2],\"ex\":true,\"in\":true}",
                    goal: 1),
                CurrentChallenge(
                    accountId: accountId,
                    challengeMapId: challengeMapId,
                    id: 2,
                    title: "Complete Quest for the Golden Trophy",
                    description: "Complete Quest for the Golden Trophy.",
                    tooltip: "Complete ^GoldenTrophy.",
                    config: "{\"ct\":6,\"vs\":[2],\"ex\":true,\"in\":true}",
                    goal: 1),
                CurrentChallenge(
                    accountId: accountId,
                    challengeMapId: challengeMapId,
                    id: 3,
                    title: "Beat the Rise of the Jumbotron",
                    description: "Complete The Rise of Jumbotron.",
                    tooltip: "Complete ^TheRiseOfJumbotron.",
                    config: "{\"ct\":6,\"vs\":[2],\"ex\":true,\"in\":true}",
                    goal: 1),
                CurrentChallenge(
                    accountId: accountId,
                    challengeMapId: challengeMapId,
                    id: 4,
                    title: "Complete 5 games of Paintball",
                    description: "Complete 5 games of Paintball.",
                    tooltip: "Finish 5 full games in ^Paintball.",
                    config: "{\"ct\":1,\"ctc\":[{\"ct\":6,\"vs\":[2],\"ex\":true,\"in\":true}],\"cc\":5}",
                    goal: 5),
                CurrentChallenge(
                    accountId: accountId,
                    challengeMapId: challengeMapId,
                    id: 5,
                    title: "Complete 5 games of Dodgeball",
                    description: "Complete 5 games of Dodgeball.",
                    tooltip: "Finish 5 full games in ^Dodgeball.",
                    config: "{\"ct\":1,\"ctc\":[{\"ct\":6,\"vs\":[2],\"ex\":true,\"in\":true}],\"cc\":5}",
                    goal: 5)
            };

            int completedChallengeCount = Enumerable.Range(1, 5)
                .Count(id => RecNetDB.GetChallengeProgress(
                    accountId,
                    challengeMapId,
                    id,
                    ChallengeGoal(id)).Complete);

            if (accountId > 0 && completedChallengeCount >= 3)
            {
                GrantPlayerEquipment(
                    accountId,
                    WeeklyChallengeRewardEquipmentPrefab,
                    WeeklyChallengeRewardModificationGuid);
            }

            Response.Headers.CacheControl = "private, max-age=30";
            return Ok(new
            {
                ChallengeMapId = challengeMapId,
                StartAt = startsAt,
                EndAt = endsAt,
                ServerTime = DateTime.UtcNow,
                Challenges = challenges,
                Gift = new
                {
                    GiftDropId = 52,
                    AvatarItemDesc = string.Empty,
                    Xp = 750,
                    Level = 0,
                    EquipmentPrefabName = WeeklyChallengeRewardEquipmentPrefab,
                    EquipmentModificationGuid = WeeklyChallengeRewardModificationGuid
                },
                ChallengeThemeString = "Mocha Weekly Challenges"
            });
        }

        private static object CurrentChallenge(
            long accountId,
            int challengeMapId,
            int id,
            string title,
            string description,
            string tooltip,
            string config,
            int goal)
        {
            var progress = RecNetDB.GetChallengeProgress(accountId, challengeMapId, id, goal);
            return new
            {
                ChallengeId = id,
                Name = title,
                Config = config,
                Description = description,
                Tooltip = tooltip,
                Complete = progress.Complete
            };
        }

        private static int ChallengeGoal(int challengeId) =>
            challengeId is 4 or 5 ? 5 : 1;

        [HttpPost("/api/challenge/v2/updateProgress")]
        [HttpPut("/api/challenge/v2/updateProgress")]
        public IActionResult UpdateChallengeProgress([FromBody] JsonElement body)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var (currentMapId, _, _) = RecNetDB.GetCurrentChallengeWindow();
            int challengeMapId = FindJsonInt(body, "ChallengeMapId") ?? currentMapId;
            int challengeId = FindJsonInt(body, "ChallengeId") ?? 0;
            if (challengeId is < 1 or > 5)
                return BadRequest(new { success = false, error = "invalid_challenge" });

            int goal = ChallengeGoal(challengeId);
            int? suppliedProgress = FindJsonInt(body, "Progress", "CurrentProgress", "Count");
            bool? suppliedComplete = FindJsonBool(body, "Complete", "Completed", "IsCompleted");
            var existing = RecNetDB.GetChallengeProgress(
                accountId.Value,
                challengeMapId,
                challengeId,
                goal);
            int progress = suppliedProgress ?? (suppliedComplete == true ? goal : existing.Progress + 1);
            bool? completionOverride = suppliedComplete == true ? true : null;
            var saved = RecNetDB.SetChallengeProgress(
                accountId.Value,
                challengeMapId,
                challengeId,
                progress,
                goal,
                completionOverride);

            return Ok(new
            {
                success = true,
                ChallengeMapId = saved.ChallengeMapId,
                ChallengeId = saved.ChallengeId,
                Progress = saved.Progress,
                Goal = saved.Goal,
                Complete = saved.Complete
            });
        }

        private static int? FindJsonInt(JsonElement element, params string[] names)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (var property in element.EnumerateObject())
                {
                    if (names.Any(name => string.Equals(property.Name, name, StringComparison.OrdinalIgnoreCase)) &&
                        ((property.Value.ValueKind == JsonValueKind.Number &&
                          property.Value.TryGetInt32(out int value)) ||
                         (property.Value.ValueKind == JsonValueKind.String &&
                          int.TryParse(property.Value.GetString(), out value))))
                    {
                        return value;
                    }

                    int? nested = FindJsonInt(property.Value, names);
                    if (nested.HasValue)
                        return nested;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (var item in element.EnumerateArray())
                {
                    int? nested = FindJsonInt(item, names);
                    if (nested.HasValue)
                        return nested;
                }
            }

            return null;
        }

        private static bool? FindJsonBool(JsonElement element, params string[] names)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (var property in element.EnumerateObject())
                {
                    if (names.Any(name => string.Equals(property.Name, name, StringComparison.OrdinalIgnoreCase)))
                    {
                        if (property.Value.ValueKind == JsonValueKind.True)
                            return true;
                        if (property.Value.ValueKind == JsonValueKind.False)
                            return false;
                    }

                    bool? nested = FindJsonBool(property.Value, names);
                    if (nested.HasValue)
                        return nested;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (var item in element.EnumerateArray())
                {
                    bool? nested = FindJsonBool(item, names);
                    if (nested.HasValue)
                        return nested;
                }
            }

            return null;
        }

        private static long? FindJsonLong(
    JsonElement element,
    params string[] names)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    bool nameMatches = names.Any(name =>
                        string.Equals(
                            property.Name,
                            name,
                            StringComparison.OrdinalIgnoreCase));

                    if (nameMatches)
                    {
                        if (property.Value.ValueKind == JsonValueKind.Number &&
                            property.Value.TryGetInt64(out long numberValue))
                        {
                            return numberValue;
                        }

                        if (property.Value.ValueKind == JsonValueKind.String &&
                            long.TryParse(
                                property.Value.GetString(),
                                out long stringValue))
                        {
                            return stringValue;
                        }
                    }

                    long? nestedValue = FindJsonLong(property.Value, names);

                    if (nestedValue.HasValue)
                        return nestedValue;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (JsonElement item in element.EnumerateArray())
                {
                    long? nestedValue = FindJsonLong(item, names);

                    if (nestedValue.HasValue)
                        return nestedValue;
                }
            }

            return null;
        }

        private static string? FindJsonString(
            JsonElement element,
            params string[] names)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    bool nameMatches = names.Any(name =>
                        string.Equals(
                            property.Name,
                            name,
                            StringComparison.OrdinalIgnoreCase));

                    if (nameMatches)
                    {
                        string? result = property.Value.ValueKind switch
                        {
                            JsonValueKind.String => property.Value.GetString(),

                            JsonValueKind.Number or
                            JsonValueKind.True or
                            JsonValueKind.False => property.Value.GetRawText(),

                            _ => null
                        };

                        if (!string.IsNullOrWhiteSpace(result))
                            return result;
                    }

                    string? nestedValue = FindJsonString(property.Value, names);

                    if (!string.IsNullOrWhiteSpace(nestedValue))
                        return nestedValue;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (JsonElement item in element.EnumerateArray())
                {
                    string? nestedValue = FindJsonString(item, names);

                    if (!string.IsNullOrWhiteSpace(nestedValue))
                        return nestedValue;
                }
            }

            return null;
        }

        [HttpGet("/api/roomcurrencies/v1/getAllBalances")]
        public IActionResult StubGetAllRoomCurrencyBalances(
            [FromQuery] long roomId)
        {
            return Ok(System.Array.Empty<object>());
        }

        [HttpGet("/acc/parentalcontrol/me")]
        public IActionResult StubGetMyParentalControls()
        {
            return Ok(new
            {
                IsEnabled = false,
                IsJunior = false
            });
        }

        [HttpGet("/subscription/mine/member")]
        public IActionResult GetMySubscriptionMembership()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            bool hasRRPlus = PlayerDB.HasRRPlus(accountId.Value);

            return Ok(hasRRPlus
                ? new[]
                {
                    new
                    {
                        IsActive = true,
                        IsSubscribed = true,
                        Status = "Active",
                        ExpiresAt = "2099-12-31T23:59:59Z"
                    }
                }
                : Array.Empty<object>());
        }

        [HttpPost("/api/CampusCard/v1/UpdateAndGetSubscription")]
        public IActionResult UpdateAndGetSubscription()
        {
            var rawAccountId = AuthStuff.GetPlayerId(Request);

            if (rawAccountId == null)
                return Unauthorized();

            long playerId = (long)rawAccountId;
            int recNetPlayerId = checked((int)playerId);

            bool hasRRPlus = PlayerDB.HasRRPlus(playerId);
            if (!hasRRPlus)
                return Ok(new { subscription = (object?)null, platformAccountSubscribedPlayerId = (int?)null });

            DateTime now = DateTime.UtcNow;

            var response = new
            {
                subscription = new
                {
                    subscriptionId = playerId,
                    recNetPlayerId = recNetPlayerId,

                    platformType = 0,

                    platformId = $"local-{playerId}",
                    platformPurchaseId = $"local-rrplus-{playerId}",

                    level = 1,

                    period = 0,

                    expirationDate = now.AddYears(10),
                    isAutoRenewing = false,
                    createdAt = now.AddDays(-1),
                    modifiedAt = now
                },

                platformAccountSubscribedPlayerId = (int?)null
            };

            return Ok(response);
        }

        [HttpGet("/api/roomkeys/v1/room")]
        public IActionResult StubGetRoomKeys([FromQuery] long roomId)
        {
            return Ok(System.Array.Empty<object>());
        }

        [HttpGet("/api/keepsakes/categories")]
        [HttpGet("/api/keepsakes/v1/categories")]
        public IActionResult StubGetKeepsakeCategories()
        {
            return Ok(System.Array.Empty<object>());
        }

        [HttpGet("/api/influencerpartnerprogram/influencers")]
        public IActionResult GetInfluencers(
            [FromQuery] int take = 1000,
            [FromQuery] string? continuationToken = null)
        {
            int safeTake = Math.Clamp(take, 1, 1000);

            var influencerIds = PlayerDB.Players
                .FindAll()
                .Where(player =>
                    player.PlayerId > 0 &&
                    player.PlayerId <= int.MaxValue &&
                    player.PlayerRoles != null &&
                    player.PlayerRoles.Contains(
                        PlayerDBClasses.PlayerRoles.Influencer))
                .OrderBy(player => player.PlayerId)
                .Take(safeTake)
                .Select(player => (int)player.PlayerId)
                .ToList();

            Console.WriteLine(
                $"[INFLUENCER] Returning {influencerIds.Count}: " +
                string.Join(", ", influencerIds)
            );

            return Ok(new
            {
                influencerIds,
                continuationToken = (string?)null
            });
        }

        [HttpGet("/api/incentivizedreferrals/progress")]
        public IActionResult StubGetIncentivizedReferralProgress()
        {
            return Ok(new
            {
                Progress = 0,
                Goal = 0,
                IsComplete = false,
                Rewards = System.Array.Empty<object>()
            });
        }

        [HttpGet("/api/progressionEvents/active")]
        [HttpGet("/api/progressionEvents/v1/active")]
        public IActionResult GetActiveProgressionEventId()
        {
            return Content("null", "application/json");
        }

        [HttpGet("api/versioncheck/v4")]
        public IActionResult VersionCheck()
        {
            return Ok(new
            {
                ValidVersion = 0,
                VersionStatus = 0,
                UpdateNotificationStage = 0,
                IsVersionIslanded = false,
                IsCrossPlayDisabled = false
            });
        }

        [HttpGet("api/gameconfigs/v1/all")]
        public IActionResult GetGameConfigs()
        {
            string path = Path.Combine(Program.dataDir, "APIS", "GameConfigs.json");
            if (!System.IO.File.Exists(path))
                return NotFound();

            string json = System.IO.File.ReadAllText(path);
            try
            {
                if (JsonNode.Parse(json) is not JsonArray configs)
                    return Content(json, "application/json");

                SetGameConfigValue(
                    configs,
                    "Friendotron_AllowSelfGifting",
                    "True");
                SetGameConfigValue(
                    configs,
                    "Friendotron_MaxUsersPerSession",
                    "1");
                return Content(configs.ToJsonString(), "application/json");
            }
            catch (JsonException)
            {
                return Content(json, "application/json");
            }
        }

        private static void SetGameConfigValue(
            JsonArray configs,
            string key,
            string value)
        {
            bool found = false;
            foreach (JsonNode? node in configs)
            {
                if (node is not JsonObject config ||
                    !string.Equals(
                        config["Key"]?.ToString(),
                        key,
                        StringComparison.Ordinal))
                {
                    continue;
                }

                config["Value"] = value;
                found = true;
            }

            if (!found)
            {
                configs.Add(new JsonObject
                {
                    ["Key"] = key,
                    ["Value"] = value
                });
            }
        }

        [HttpGet("api/config/v1/amplitude")]
        public IActionResult GetAmplitude()
        {
            return Ok(new
            {
                AmplitudeKey = "cb2fb2ecb9953512c29af5bca58f2b4a",
                UseRudderStack = true,
                RudderStackKey = "23NiJHIgu3koaGNCZIiuYvIQNCu",
                UseStatSig = true,
                StatSigKey = "client-SBZkOrjD3r1Cat3f3W8K6sBd11WKlXZXIlCWj6l4Aje",
                StatSigEnvironment = 0
            });
        }

        [HttpGet("/api/avatar/")]
        [HttpGet("/api/avatar")]
        public IActionResult GetAvatarBase()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();
            return Ok(new { AccountId = accountId.Value });
        }

        [HttpGet("/api/config/")]
        [HttpGet("/api/config")]
        public IActionResult GetGeneralConfig()
        {
            return Ok(new
            {
                ServerName = "Mocha",
                GameVersion = ServerConfig.GameVersion,
                MaintenanceMinutes = 0
            });
        }

        [HttpGet("/api/config/v1/freegiftbutton")]
        public IActionResult GetFreeGiftButtonConfig()
        {

            return Ok(new { Enabled = false, Available = false });
        }

        [HttpGet("/api/players/v4/current/contact")]
        public IActionResult GetMyContactInfo()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var account = PlayerDB.Players.FindById(accountId.Value);
            if (account?.Player == null)
                return NotFound();

            return Ok(new
            {
                Email = account.Player.Email ?? string.Empty,
                EmailVerified = !string.IsNullOrWhiteSpace(account.Player.Email),
                Phone = (string?)null,
                PhoneVerified = false
            });
        }

        [HttpGet("/api/playerwarnings")]
        public IActionResult GetMyPlayerWarnings()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var warnings = (PlayerDB.Players.FindById(accountId.Value)?.Player?.PlayerExtra?.Warnings
                ?? new List<string>())
                .Select(warningKey => new { WarningKey = warningKey, Acknowledged = false })
                .ToList();
            return Ok(warnings);
        }

        public class AcknowledgeWarningRequest
        {
            public string? WarningKey { get; set; }
        }

        [HttpPost("/api/playerwarnings/acknowledge")]
        public IActionResult AcknowledgePlayerWarning([FromBody] AcknowledgeWarningRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var account = PlayerDB.Players.FindById(accountId.Value);
            var warnings = account?.Player?.PlayerExtra?.Warnings;
            if (account?.Player?.PlayerExtra != null && warnings != null &&
                !string.IsNullOrWhiteSpace(request.WarningKey))
            {
                warnings.RemoveAll(value => value == request.WarningKey);
                PlayerDB.Players.Update(account);
            }
            return Ok(new { success = true });
        }

        public class ConsumableTransferRequest
        {
            public string? ConsumableItemDesc { get; set; }
            public long ConsumableItemId { get; set; }
            public long ToAccountId { get; set; }
            public int Amount { get; set; } = 1;
        }

        [HttpPost("/api/consumables/v1/transfer")]
        public IActionResult TransferConsumable([FromBody] ConsumableTransferRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();
            if (request.ToAccountId == accountId.Value)
                return BadRequest(new { error = "Can't transfer to yourself." });
            if (request.Amount <= 0)
                return BadRequest(new { error = "Amount must be positive." });
            if (PlayerDB.Players.FindById(request.ToAccountId)?.Player == null)
                return NotFound(new { error = "Recipient not found." });

            string descriptor = request.ConsumableItemDesc ?? string.Empty;
            int owned = PlayerInventoryStore.GetConsumableQuantity(accountId.Value, descriptor, request.ConsumableItemId);
            if (owned < request.Amount)
                return BadRequest(new { error = "You don't have enough of that item." });

            PlayerInventoryStore.SetConsumableQuantity(accountId.Value, descriptor, request.ConsumableItemId, null, owned - request.Amount);
            PlayerInventoryStore.AddConsumable(request.ToAccountId, descriptor, request.ConsumableItemId, null, request.Amount);

            return Ok(new { success = true });
        }

        [HttpGet("/api/customAvatarItems")]
        [HttpGet("/api/customAvatarItems/v1/me")]
        public IActionResult GetMyCustomAvatarItems()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            return Ok(LoadCustomAvatarItems(accountId.Value));
        }

        public class CustomAvatarItemsBulkRequest
        {
            public List<long>? CreatorAccountIds { get; set; }
        }

        [HttpPost("/api/customAvatarItems/v1/bulk")]
        public IActionResult GetCustomAvatarItemsBulk([FromBody] CustomAvatarItemsBulkRequest request)
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();

            var items = (request.CreatorAccountIds ?? new List<long>())
                .Distinct()
                .SelectMany(LoadCustomAvatarItems)
                .ToList();
            return Ok(items);
        }

        public class ItemWishlistRequest
        {
            public string? ItemDesc { get; set; }
        }

        [HttpGet("/api/itemWishlists")]
        public IActionResult GetMyItemWishlist()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var wishlist = PlayerDB.Players.FindById(accountId.Value)?.Player?.PlayerExtra?.ItemWishlist
                ?? new List<string>();
            return Ok(wishlist);
        }

        [HttpPost("/api/itemWishlists/v1/wishlist/")]
        [HttpPost("/api/itemWishlists/v1/wishlist")]
        public IActionResult AddToItemWishlist([FromBody] ItemWishlistRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();
            if (string.IsNullOrWhiteSpace(request.ItemDesc))
                return BadRequest(new { error = "Missing item." });

            var account = PlayerDB.Players.FindById(accountId.Value);
            if (account?.Player == null)
                return Unauthorized();

            account.Player.PlayerExtra ??= new PlayerDBClasses.PlayerExtra();
            account.Player.PlayerExtra.ItemWishlist ??= new List<string>();
            if (!account.Player.PlayerExtra.ItemWishlist.Contains(request.ItemDesc))
            {
                account.Player.PlayerExtra.ItemWishlist.Add(request.ItemDesc);
                PlayerDB.Players.Update(account);
            }
            return Ok(new { success = true, wishlist = account.Player.PlayerExtra.ItemWishlist });
        }

        [HttpDelete("/api/itemWishlists/v1/wishlist/")]
        [HttpDelete("/api/itemWishlists/v1/wishlist")]
        public IActionResult RemoveFromItemWishlist([FromBody] ItemWishlistRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var account = PlayerDB.Players.FindById(accountId.Value);
            var wishlist = account?.Player?.PlayerExtra?.ItemWishlist;
            if (wishlist != null && !string.IsNullOrWhiteSpace(request.ItemDesc))
            {
                wishlist.Remove(request.ItemDesc);
                PlayerDB.Players.Update(account!);
            }
            return Ok(new { success = true });
        }

        public class GenericReportRequest
        {
            public long TargetId { get; set; }
            public string? Reason { get; set; }
            public string? Details { get; set; }
        }

        [HttpPost("/api/rooms/v2/report")]
        public IActionResult ReportRoomV2([FromBody] GenericReportRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var room = RoomDB.Rooms.FindById(request.TargetId);
            DiscordLogger.LogReport(
                $"🚩 **Room reported** - \"{room?.Name ?? $"Room {request.TargetId}"}\" (ID {request.TargetId}) " +
                $"by account {accountId.Value}: {request.Reason ?? "No reason given."} {request.Details}");
            return Ok(new { success = true });
        }

        [HttpPost("/api/clubreporting/v1/report")]
        public IActionResult ReportClub([FromBody] GenericReportRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            DiscordLogger.LogReport(
                $"🚩 **Club reported** - Club {request.TargetId} by account {accountId.Value}: " +
                $"{request.Reason ?? "No reason given."} {request.Details}");
            return Ok(new { success = true });
        }

        [HttpPost("/api/screensharereports/v1/report")]
        public IActionResult ReportScreenShare([FromBody] GenericReportRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            DiscordLogger.LogReport(
                $"🚩 **Screen share reported** - target account {request.TargetId} by account {accountId.Value}: " +
                $"{request.Reason ?? "No reason given."} {request.Details}");
            return Ok(new { success = true });
        }

        [HttpPost("/api/inventions/v1/report")]
        public IActionResult ReportInvention([FromBody] GenericReportRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            DiscordLogger.LogReport(
                $"🚩 **Invention reported** - Invention {request.TargetId} by account {accountId.Value}: " +
                $"{request.Reason ?? "No reason given."} {request.Details}");
            return Ok(new { success = true });
        }

        public class BugReportRequest
        {
            public string? Description { get; set; }
            public string? Category { get; set; }
        }

        [HttpPost("/api/bugreports/v1/report")]
        public IActionResult ReportBug([FromBody] BugReportRequest request)
        {
            var reporter = AuthStuff.GetCurrentPlayer(Request);
            if (reporter?.Player == null)
                return Unauthorized();

            string description = request.Description?.Trim() ?? string.Empty;
            if (description.Length is < 3 or > 4000)
                return BadRequest(new { error = "Description must be 3-4000 characters." });

            var bugReport = new ReportsDB.BugReport
            {
                ReporterId = reporter.PlayerId,
                ReporterUsername = reporter.Player.Username,
                Description = description,
                Category = request.Category?.Trim()
            };
            ReportsDB.BugReports.Insert(bugReport);

            DiscordLogger.LogReport(
                $"🐛 **Bug report** from {reporter.Player.Username ?? reporter.PlayerId.ToString()} " +
                $"({(string.IsNullOrEmpty(bugReport.Category) ? "uncategorized" : bugReport.Category)}): " +
                $"{description}");

            return Ok(new { success = true, id = bugReport.Id });
        }

        [HttpGet("/api/roomconsumables/v1/roomConsumable")]
        public IActionResult GetRoomConsumableCatalog()
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();
            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("/api/roomEarningsDistributions/v1/earningsDistribution")]
        public IActionResult GetRoomEarningsDistribution()
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();
            return Ok(new { TotalEarnings = 0, Distributions = Array.Empty<object>() });
        }

        [HttpPost("/api/roomCurrencies/v2/purchase")]
        [HttpPost("/api/roomconsumables/v1/roomconsumable/{skuId}/purchase/tokens")]
        public IActionResult PurchaseRoomCurrencyOrConsumable()
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();

            return Ok(new { success = true });
        }

        [HttpGet("api/avatar/v1/defaultunlocked")]
        public IActionResult GetDefaultUnlocked()
        {
            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("api/avatar/v1/defaultbaseavataritems")]
        public IActionResult GetDefaultBaseAvatarItems()
        {

            return Ok(Array.Empty<object>());
        }

        [HttpPost("/api/ageverification/generatecode")]
        [HttpGet("/api/ageverification/generatecode")]
        public IActionResult GenerateAgeVerificationCode()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            string code = AgeVerificationDB.GenerateCode(id.Value);
            string verificationUrl = $"{ServerConfig.BaseURL.TrimEnd('/')}/recnet/#ageverification?code={code}";

            return Ok(new
            {
                ActionCode = code,
                VerificationUrl = verificationUrl
            });
        }

        [HttpGet("/api/banappeal/generatecode")]
        public IActionResult GenerateBanAppealCodeDirect()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized(new { error = "You must be logged in." });

            var account = PlayerDB.Players.FindById(accountId.Value);
            PlayerDBClasses.ModerationBlockDetails? details = account?.Player?.PlayerExtra?.ModerationBlockDetails;
            if (account?.Player == null || details == null ||
                !PlayerDB.IsPlayerBanned(accountId.Value, out _))
            {
                return BadRequest(new { error = "This account isn't currently banned." });
            }

            if (string.IsNullOrWhiteSpace(details.AppealCode))
            {
                const string appealCodeChars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
                Span<char> buffer = stackalloc char[10];
                for (int i = 0; i < buffer.Length; i++)
                    buffer[i] = appealCodeChars[System.Random.Shared.Next(appealCodeChars.Length)];
                details.AppealCode = new string(buffer);
                PlayerDB.Players.Update(account);
            }

            return Ok(new
            {
                code = details.AppealCode,
                appealUrl = $"{ServerConfig.BaseURL.TrimEnd('/')}/recnet/banappeal?code={details.AppealCode}",
                alreadySubmitted = details.AppealSubmitted
            });
        }

        private static object ToPlayerEventDto(PlayerEventDB.PlayerEvent evt)
        {
            var creator = PlayerDB.Players.FindById(evt.CreatorAccountId);
            return new
            {
                Id = evt.EventId,
                EventId = evt.EventId,
                CreatorAccountId = evt.CreatorAccountId,
                CreatorDisplayName = creator?.Player?.DisplayName ?? creator?.Player?.Username ?? $"Player {evt.CreatorAccountId}",
                Name = evt.Name,
                Description = evt.Description,
                Image = string.IsNullOrWhiteSpace(evt.ImageName) ? null : $"{ServerConfig.BaseURL.TrimEnd('/')}/imageserver-v2/{evt.ImageName}",
                ImageName = evt.ImageName,
                StartsAt = evt.StartsAt,
                EndsAt = evt.EndsAt,
                RoomId = evt.RoomId,
                ClubId = evt.ClubId,
                Accessibility = evt.Accessibility,
                MultiInstance = evt.MultiInstance,
                Tags = evt.Tags,
                CreatedAt = evt.CreatedAt,
                UpdatedAt = evt.UpdatedAt
            };
        }

        private bool CanManagePlayerEvent(PlayerEventDB.PlayerEvent evt, long accountId)
        {
            if (evt.CreatorAccountId == accountId)
                return true;
            var account = PlayerDB.Players.FindById(accountId);
            return account?.PlayerRoles?.Contains(PlayerDBClasses.PlayerRoles.Developer) == true ||
                account?.PlayerRoles?.Contains(PlayerDBClasses.PlayerRoles.Moderator) == true;
        }

        public class PlayerEventCreateRequest
        {
            public string? Name { get; set; }
            public string? Description { get; set; }
            public string? ImageName { get; set; }
            public DateTime StartsAt { get; set; }
            public DateTime? EndsAt { get; set; }
            public long? RoomId { get; set; }
            public long? ClubId { get; set; }
            public string? Accessibility { get; set; }
            public bool MultiInstance { get; set; }
            public List<string>? Tags { get; set; }
        }

        [HttpPost("/api/playerevents/v2")]
        public IActionResult CreatePlayerEvent([FromBody] PlayerEventCreateRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            string name = (request.Name ?? string.Empty).Trim();
            if (name.Length is < 1 or > 100)
                return BadRequest(new { error = "Event name must be 1-100 characters." });

            var evt = PlayerEventDB.Create(new PlayerEventDB.PlayerEvent
            {
                CreatorAccountId = accountId.Value,
                Name = name,
                Description = (request.Description ?? string.Empty).Trim(),
                ImageName = request.ImageName ?? string.Empty,
                StartsAt = request.StartsAt == default ? DateTime.UtcNow : request.StartsAt.ToUniversalTime(),
                EndsAt = request.EndsAt?.ToUniversalTime(),
                RoomId = request.RoomId,
                ClubId = request.ClubId,
                Accessibility = request.Accessibility is "Private" or "ClubOnly" ? request.Accessibility : "Public",
                MultiInstance = request.MultiInstance,
                Tags = (request.Tags ?? new List<string>()).Take(20).ToList()
            });

            return Ok(ToPlayerEventDto(evt));
        }

        [HttpGet("/api/playerevents/v2/{eventId:long}")]
        [HttpGet("/api/playerevents/v1/{eventId:long}")]
        public IActionResult GetPlayerEvent(long eventId)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var evt = PlayerEventDB.Get(eventId);
            if (evt == null)
                return NotFound(new { error = "Event not found." });

            return Ok(ToPlayerEventDto(evt));
        }

        [HttpDelete("/api/playerevents/v2/delete/{eventId:long}")]
        public IActionResult DeletePlayerEvent(long eventId)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var evt = PlayerEventDB.Get(eventId);
            if (evt == null)
                return NotFound(new { error = "Event not found." });
            if (!CanManagePlayerEvent(evt, accountId.Value))
                return StatusCode(403);

            PlayerEventDB.Delete(eventId);
            return Ok(new { success = true });
        }

        public class PlayerEventFieldUpdate
        {
            public string? Value { get; set; }
        }

        private IActionResult UpdatePlayerEventField(long eventId, Action<PlayerEventDB.PlayerEvent> apply)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var evt = PlayerEventDB.Get(eventId);
            if (evt == null)
                return NotFound(new { error = "Event not found." });
            if (!CanManagePlayerEvent(evt, accountId.Value))
                return StatusCode(403);

            apply(evt);
            PlayerEventDB.Update(evt);
            return Ok(ToPlayerEventDto(evt));
        }

        [HttpPut("/api/playerevents/v2/{eventId:long}/name")]
        public IActionResult UpdatePlayerEventName(long eventId, [FromBody] PlayerEventFieldUpdate request) =>
            UpdatePlayerEventField(eventId, evt =>
            {
                string name = (request.Value ?? string.Empty).Trim();
                if (name.Length is >= 1 and <= 100)
                    evt.Name = name;
            });

        [HttpPut("/api/playerevents/v2/{eventId:long}/description")]
        public IActionResult UpdatePlayerEventDescription(long eventId, [FromBody] PlayerEventFieldUpdate request) =>
            UpdatePlayerEventField(eventId, evt => evt.Description = (request.Value ?? string.Empty).Trim());

        [HttpPut("/api/playerevents/v2/{eventId:long}/image")]
        public IActionResult UpdatePlayerEventImage(long eventId, [FromBody] PlayerEventFieldUpdate request) =>
            UpdatePlayerEventField(eventId, evt => evt.ImageName = request.Value ?? string.Empty);

        public class PlayerEventTimeUpdate
        {
            public DateTime StartsAt { get; set; }
            public DateTime? EndsAt { get; set; }
        }

        [HttpPut("/api/playerevents/v2/{eventId:long}/time")]
        public IActionResult UpdatePlayerEventTime(long eventId, [FromBody] PlayerEventTimeUpdate request) =>
            UpdatePlayerEventField(eventId, evt =>
            {
                if (request.StartsAt != default)
                    evt.StartsAt = request.StartsAt.ToUniversalTime();
                evt.EndsAt = request.EndsAt?.ToUniversalTime();
            });

        public class PlayerEventRoomUpdate
        {
            public long? RoomId { get; set; }
        }

        [HttpPut("/api/playerevents/v2/{eventId:long}/room")]
        public IActionResult UpdatePlayerEventRoom(long eventId, [FromBody] PlayerEventRoomUpdate request) =>
            UpdatePlayerEventField(eventId, evt => evt.RoomId = request.RoomId);

        public class PlayerEventClubUpdate
        {
            public long? ClubId { get; set; }
        }

        [HttpPut("/api/playerevents/v2/{eventId:long}/club")]
        public IActionResult UpdatePlayerEventClub(long eventId, [FromBody] PlayerEventClubUpdate request) =>
            UpdatePlayerEventField(eventId, evt => evt.ClubId = request.ClubId);

        [HttpPut("/api/playerevents/v2/{eventId:long}/accessibility")]
        public IActionResult UpdatePlayerEventAccessibility(long eventId, [FromBody] PlayerEventFieldUpdate request) =>
            UpdatePlayerEventField(eventId, evt =>
            {
                if (request.Value is "Public" or "Private" or "ClubOnly")
                    evt.Accessibility = request.Value;
            });

        public class PlayerEventMultiInstanceUpdate
        {
            public bool MultiInstance { get; set; }
        }

        [HttpPut("/api/playerevents/v2/{eventId:long}/multiinstance")]
        public IActionResult UpdatePlayerEventMultiInstance(long eventId, [FromBody] PlayerEventMultiInstanceUpdate request) =>
            UpdatePlayerEventField(eventId, evt => evt.MultiInstance = request.MultiInstance);

        public class PlayerEventTagsUpdate
        {
            public List<string>? Tags { get; set; }
        }

        [HttpPut("/api/playerevents/v2/{eventId:long}/tags")]
        public IActionResult UpdatePlayerEventTags(long eventId, [FromBody] PlayerEventTagsUpdate request) =>
            UpdatePlayerEventField(eventId, evt => evt.Tags = (request.Tags ?? new List<string>()).Take(20).ToList());

        [HttpGet("/api/playerevents/v1/all/{accountId:long}")]
        public IActionResult GetPlayerEventsForAccount(long accountId)
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();

            return Ok(PlayerEventDB.GetByCreator(accountId).Select(ToPlayerEventDto).ToList());
        }

        [HttpGet("/api/playerevents/v1/club/{clubId:long}")]
        public IActionResult GetPlayerEventsForClub(long clubId)
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();

            return Ok(PlayerEventDB.GetByClub(clubId).Select(ToPlayerEventDto).ToList());
        }

        [HttpGet("/api/playerevents/v1/clubs")]
        public IActionResult GetPlayerEventsForMyClubs()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var clubIds = ClubDB.GetMemberClubs(accountId.Value).Select(club => club.ClubId).ToHashSet();
            var events = clubIds
                .SelectMany(PlayerEventDB.GetByClub)
                .DistinctBy(evt => evt.EventId)
                .Select(ToPlayerEventDto)
                .ToList();
            return Ok(events);
        }

        public class PlayerEventBulkRequest
        {
            public List<long>? EventIds { get; set; }
        }

        [HttpPost("/api/playerevents/v1/bulk")]
        public IActionResult GetPlayerEventsBulk([FromBody] PlayerEventBulkRequest request)
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();

            var ids = request.EventIds ?? new List<long>();
            return Ok(PlayerEventDB.GetByIds(ids).Select(ToPlayerEventDto).ToList());
        }

        public class PlayerEventRespondRequest
        {
            public long EventId { get; set; }
            public string? ResponseType { get; set; }
        }

        [HttpPost("/api/playerevents/v1/respond")]
        public IActionResult RespondToPlayerEvent([FromBody] PlayerEventRespondRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var evt = PlayerEventDB.Get(request.EventId);
            if (evt == null)
                return NotFound(new { error = "Event not found." });

            string responseType = request.ResponseType is "Going" or "Interested" or "NotGoing"
                ? request.ResponseType
                : "Going";
            var response = PlayerEventDB.SetResponse(request.EventId, accountId.Value, responseType);
            return Ok(new { response.EventId, response.AccountId, response.ResponseType, response.CreatedAt });
        }

        [HttpPost("/api/playerevents/v1/deleteResponse")]
        [HttpDelete("/api/playerevents/v1/deleteResponse")]
        public IActionResult DeletePlayerEventResponse([FromBody] PlayerEventRespondRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            PlayerEventDB.DeleteResponse(request.EventId, accountId.Value);
            return Ok(new { success = true });
        }

        [HttpGet("/api/playerevents/v1/{eventId:long}/responses")]
        public IActionResult GetPlayerEventResponses(long eventId)
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();

            var responses = PlayerEventDB.GetResponses(eventId);
            var accountIds = responses.Select(value => value.AccountId).ToHashSet();
            var players = PlayerDB.Players.FindAll()
                .Where(value => accountIds.Contains(value.PlayerId))
                .ToDictionary(value => value.PlayerId);

            return Ok(responses.Select(response =>
            {
                players.TryGetValue(response.AccountId, out var player);
                return new
                {
                    response.AccountId,
                    DisplayName = player?.Player?.DisplayName ?? player?.Player?.Username ?? $"Player {response.AccountId}",
                    response.ResponseType,
                    response.CreatedAt
                };
            }).ToList());
        }

        public class PlayerEventBulkInviteRequest
        {
            public long EventId { get; set; }
            public List<long>? AccountIds { get; set; }
        }

        [HttpPost("/api/playerevents/v1/bulkInvite")]
        public IActionResult BulkInvitePlayerEvent([FromBody] PlayerEventBulkInviteRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var evt = PlayerEventDB.Get(request.EventId);
            if (evt == null)
                return NotFound(new { error = "Event not found." });

            var targets = (request.AccountIds ?? new List<long>()).Take(200).ToList();
            int invited = 0;
            foreach (long targetId in targets)
            {
                if (targetId == accountId.Value)
                    continue;
                if (PlayerEventDB.GetResponse(evt.EventId, targetId) == null)
                    PlayerEventDB.SetResponse(evt.EventId, targetId, "Interested");
                invited++;
            }

            return Ok(new { success = true, invited });
        }

        [HttpPost("/api/playerevents/v1/broadcast")]
        public IActionResult BroadcastPlayerEvent([FromBody] PlayerEventBulkInviteRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var evt = PlayerEventDB.Get(request.EventId);
            if (evt == null || !CanManagePlayerEvent(evt, accountId.Value))
                return NotFound(new { error = "Event not found." });

            return Ok(new { success = true });
        }

        public class PlayerEventReportRequest
        {
            public long EventId { get; set; }
            public string? Reason { get; set; }
        }

        [HttpPost("/api/playerevents/v1/report")]
        public IActionResult ReportPlayerEvent([FromBody] PlayerEventReportRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var evt = PlayerEventDB.Get(request.EventId);
            if (evt == null)
                return NotFound(new { error = "Event not found." });

            DiscordLogger.LogReport(
                $"🚩 **Player event reported** - \"{evt.Name}\" (Event {evt.EventId}) " +
                $"by account {accountId.Value}: {request.Reason ?? "No reason given."}");
            return Ok(new { success = true });
        }

        [HttpGet("/api/objectives/v1/myprogress")]
        public IActionResult GetMyObjectiveProgress()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new
            {
                Objectives = new List<object>(),
                ObjectiveGroups = new List<object>()
            });
        }

        [HttpGet("/api/avatar/v2")]
        public IActionResult GetMyAvatar()
        {
            var player = AuthStuff.GetCurrentPlayer(Request);
            if (player == null)
                return Unauthorized();

            return Ok(player.Player.PlayerExtra.Avatar);
        }

        [HttpPost("/api/avatar/v2/set")]
        public IActionResult SetMyAvatar([FromBody] PlayerDBClasses.Avatar request)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(PlayerDB.SetAvatar((long)id, request));
        }

        [HttpGet("/api/avatar/v4/items")]
        public IActionResult GetMyAvatarItems()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            string path = Path.Combine(
                Program.dataDir,
                "APIS",
                "Items",
                "AvatarItems.json");

            if (!System.IO.File.Exists(path))
                return NotFound();

            return Ok(GetAvatarItemsVisibleToPlayer((long)id, path));
        }

        [HttpGet("/api/avatar/v1/lockeditems")]
        public IActionResult GetMyLockedAvatarItems()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            string path = Path.Combine(
                Program.dataDir,
                "APIS",
                "Items",
                "AvatarItems.json");

            if (!System.IO.File.Exists(path))
                return Ok(Array.Empty<object>());

            return Ok(GetAvatarItemsNotOwnedByPlayer((long)id, path));
        }

        private static List<JsonElement> GetAvatarItemsNotOwnedByPlayer(
            long playerId,
            string path)
        {
            string json = System.IO.File.ReadAllText(path);
            var items = JsonSerializer.Deserialize<List<JsonElement>>(
                json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
                ?? new List<JsonElement>();

            var player = PlayerDB.Players.FindById(playerId);
            IEnumerable<string>? legacyItems = player?.Player?.PlayerExtra?.AvatarItems;

            List<PlayerInventoryStore.AvatarItemOwnership> ownedItems =
                PlayerInventoryStore.GetAvatarItems(playerId, legacyItems);

            HashSet<long> ownedIds = ownedItems
                .Where(item => item.AvatarItemId > 0)
                .Select(item => item.AvatarItemId)
                .ToHashSet();
            HashSet<string> ownedDescriptors = ownedItems
                .Select(item => item.AvatarItemDesc)
                .Where(value => !string.IsNullOrWhiteSpace(value))
                .ToHashSet(StringComparer.OrdinalIgnoreCase);

            return items
                .Where(item =>
                {
                    string descriptor = item.TryGetProperty("AvatarItemDesc", out JsonElement descElement)
                        ? descElement.GetString() ?? string.Empty
                        : string.Empty;
                    long itemId = item.TryGetProperty("AvatarItemId", out JsonElement idElement) &&
                                  idElement.TryGetInt64(out long parsedId)
                        ? parsedId
                        : 0;
                    string friendlyName = item.TryGetProperty("FriendlyName", out JsonElement nameElement)
                        ? nameElement.GetString() ?? string.Empty
                        : string.Empty;
                    int rarity = item.TryGetProperty("Rarity", out JsonElement rarityElement) &&
                                 rarityElement.TryGetInt32(out int parsedRarity)
                        ? parsedRarity
                        : 0;

                    bool owned = (itemId > 0 && ownedIds.Contains(itemId)) ||
                        (!string.IsNullOrWhiteSpace(descriptor) &&
                         ownedDescriptors.Contains(descriptor));
                    bool unfinished = rarity <= 0 && string.IsNullOrWhiteSpace(friendlyName);

                    return !owned && !unfinished && !IsExcludedAvatarItemName(friendlyName);
                })
                .ToList();
        }

        private static List<JsonElement> GetAvatarItemsVisibleToPlayer(
            long playerId,
            string path)
        {
            string json = System.IO.File.ReadAllText(path);
            var items = JsonSerializer.Deserialize<List<JsonElement>>(
                json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
                ?? new List<JsonElement>();

            var player = PlayerDB.Players.FindById(playerId);
            IEnumerable<string>? legacyItems = player?.Player?.PlayerExtra?.AvatarItems;

            List<PlayerInventoryStore.AvatarItemOwnership> ownedItems =
                PlayerInventoryStore.GetAvatarItems(playerId, legacyItems);

            HashSet<long> ownedIds = ownedItems
                .Where(item => item.AvatarItemId > 0)
                .Select(item => item.AvatarItemId)
                .ToHashSet();
            HashSet<string> ownedDescriptors = ownedItems
                .Select(item => item.AvatarItemDesc)
                .Where(value => !string.IsNullOrWhiteSpace(value))
                .ToHashSet(StringComparer.OrdinalIgnoreCase);

            return items
                .Where(item =>
                {
                    string descriptor = item.TryGetProperty("AvatarItemDesc", out JsonElement descElement)
                        ? descElement.GetString() ?? string.Empty
                        : string.Empty;
                    long itemId = item.TryGetProperty("AvatarItemId", out JsonElement idElement) &&
                                  idElement.TryGetInt64(out long parsedId)
                        ? parsedId
                        : 0;

                    return (itemId > 0 && ownedIds.Contains(itemId)) ||
                           (!string.IsNullOrWhiteSpace(descriptor) &&
                            ownedDescriptors.Contains(descriptor));
                })
                .ToList();
        }

        private static bool IsAlpacaShirt(JsonElement item)
        {
            if (item.TryGetProperty("AvatarItemId", out JsonElement itemId) &&
                itemId.TryGetInt64(out long parsedItemId) &&
                parsedItemId == PlayerDB.AlpacaShirtAvatarItemId)
            {
                return true;
            }

            return item.TryGetProperty("FriendlyName", out JsonElement name) &&
                string.Equals(
                    name.GetString(),
                    "Alpaca Shirt",
                    StringComparison.OrdinalIgnoreCase);
        }

        private IActionResult GetJsonItems(string fileName)
        {
            string path = Path.Combine(Program.dataDir, "APIS", "Items", fileName);
            return System.IO.File.Exists(path) ? Content(System.IO.File.ReadAllText(path), "application/json") : Ok(ServerConfig.Bracket);
        }

        private IActionResult GetNormalizedConsumables(long? accountId = null)
        {
            string path = Path.Combine(
                Program.dataDir,
                "APIS",
                "Items",
                "Consumables.json");

            if (!System.IO.File.Exists(path))
                return Ok(Array.Empty<object>());

            try
            {
                JsonNode? root = JsonNode.Parse(System.IO.File.ReadAllText(path));
                if (root is not JsonArray sourceItems)
                {
                    Console.WriteLine(
                        "[CONSUMABLE NORMALIZE] Invalid root; expected JSON array.");
                    return Ok(Array.Empty<object>());
                }

                var normalizedItems = new JsonArray();
                int repairedCreatedAts = 0;
                int repairedKeys = 0;
                int skipped = 0;
                long returnedQuantity = 0;

                Dictionary<long, int>? ownedConsumablesById = null;
                Dictionary<string, int>? ownedConsumablesByDescriptor = null;
                if (accountId.HasValue)
                {
                    List<PlayerInventoryStore.ConsumableOwnership> ownedConsumables =
                        PlayerInventoryStore.GetConsumables(accountId.Value);

                    ownedConsumablesById = ownedConsumables
                        .Where(item => item.ConsumableItemId > 0)
                        .GroupBy(item => item.ConsumableItemId)
                        .ToDictionary(
                            group => group.Key,
                            group => (int)Math.Min(
                                100_000L,
                                group.Sum(item => (long)Math.Max(0, item.Quantity))));

                    ownedConsumablesByDescriptor = ownedConsumables
                        .Where(item => !string.IsNullOrWhiteSpace(item.ConsumableItemDesc))
                        .GroupBy(
                            item => item.ConsumableItemDesc,
                            StringComparer.OrdinalIgnoreCase)
                        .ToDictionary(
                            group => group.Key,
                            group => (int)Math.Min(
                                100_000L,
                                group.Sum(item => (long)Math.Max(0, item.Quantity))),
                            StringComparer.OrdinalIgnoreCase);
                }

                foreach (JsonNode? node in sourceItems)
                {
                    if (node is not JsonObject source)
                    {
                        skipped++;
                        continue;
                    }

                    var item = source.DeepClone().AsObject();
                    List<long> ids = ReadConsumableIds(item);
                    if (ids.Count == 0)
                    {
                        skipped++;
                        continue;
                    }

                    item["Ids"] = new JsonArray(
                        ids.Select(id => JsonValue.Create(id)).ToArray());

                    List<string> createdAts = ReadConsumableCreatedAts(item);
                    string fallbackCreatedAt =
                        NormalizeConsumableTimestamp(ReadString(item, "CreatedAt"))
                        ?? "2023-04-06T00:00:00.0000000Z";

                    if (createdAts.Count != ids.Count)
                    {
                        repairedCreatedAts++;

                        if (createdAts.Count > ids.Count)
                            createdAts = createdAts.Take(ids.Count).ToList();

                        while (createdAts.Count < ids.Count)
                            createdAts.Add(fallbackCreatedAt);
                    }

                    item["CreatedAts"] = new JsonArray(
                        createdAts.Select(value => JsonValue.Create(value)).ToArray());

                    string? descriptor = ReadString(item, "ConsumableItemDesc");
                    string? friendlyName = ReadString(item, "FriendlyName");

                    if (string.IsNullOrWhiteSpace(descriptor))
                    {
                        item["ConsumableItemDesc"] = $"legacy-consumable-{ids[0]}";
                        repairedKeys++;
                    }

                    if (string.IsNullOrWhiteSpace(friendlyName))
                    {
                        friendlyName = $"Consumable {ids[0]}";
                        item["FriendlyName"] = friendlyName;
                        repairedKeys++;
                    }

                    int ownedQuantity;
                    if (accountId.HasValue)
                    {
                        ownedQuantity = 0;

                        if (ownedConsumablesById != null &&
                            ownedConsumablesById.TryGetValue(ids[0], out int byId))
                        {
                            ownedQuantity = Math.Max(ownedQuantity, byId);
                        }

                        if (!string.IsNullOrWhiteSpace(descriptor) &&
                            ownedConsumablesByDescriptor != null &&
                            ownedConsumablesByDescriptor.TryGetValue(descriptor, out int byDescriptor))
                        {
                            ownedQuantity = Math.Max(ownedQuantity, byDescriptor);
                        }
                    }
                    else
                    {
                        ownedQuantity = Math.Max(1, ids.Count);
                    }

                    if (accountId.HasValue && ownedQuantity <= 0)
                        continue;

                    ownedQuantity = Math.Max(1, ownedQuantity);
                    long firstId = ids[0];
                    string firstCreatedAt = createdAts.FirstOrDefault() ?? fallbackCreatedAt;

                    item["Ids"] = new JsonArray(
                        JsonValue.Create(firstId));
                    item["CreatedAts"] = new JsonArray(
                        JsonValue.Create(firstCreatedAt));

                    item["Count"] = ownedQuantity;
                    item["InitialCount"] = ownedQuantity;
                    item["Quantity"] = ownedQuantity;
                    item["IsActive"] = false;
                    item["ActiveDurationMinutes"] = 0;
                    item["IsTransferable"] = false;
                    item["IsOwned"] = true;
                    item["Owned"] = true;
                    item["Purchased"] = true;
                    returnedQuantity += ownedQuantity;

                    if (IsHairDyeFriendlyName(friendlyName))
                    {
                        item["ConsumableItemType"] = 6;
                        item["ItemType"] = 1;
                    }

                    normalizedItems.Add(item);
                }

                Console.WriteLine(
                    $"[CONSUMABLE NORMALIZE] source={sourceItems.Count} " +
                    $"returned={normalizedItems.Count} " +
                    $"quantity={returnedQuantity} countContract=v25 " +
                    $"createdAtsFixed={repairedCreatedAts} " +
                    $"keysFixed={repairedKeys} skipped={skipped}");

                return Content(
                    normalizedItems.ToJsonString(
                        new JsonSerializerOptions
                        {
                            PropertyNamingPolicy = null,
                            WriteIndented = false
                        }),
                    "application/json");
            }
            catch (Exception ex)
            {
                Console.WriteLine(
                    $"[CONSUMABLE NORMALIZE] Failed: {ex.Message}");
                return Ok(Array.Empty<object>());
            }
        }

        private static List<long> ReadConsumableIds(JsonObject item)
        {
            var ids = new List<long>();

            if (item["Ids"] is JsonArray idArray)
            {
                foreach (JsonNode? idNode in idArray)
                {
                    if (TryReadLong(idNode, out long id) && id > 0)
                        ids.Add(id);
                }
            }

            if (ids.Count == 0)
            {
                foreach (string propertyName in new[]
                {
                    "ConsumableItemId",
                    "ItemId",
                    "Id"
                })
                {
                    if (TryReadLong(item[propertyName], out long id) && id > 0)
                    {
                        ids.Add(id);
                        break;
                    }
                }
            }

            return ids.Distinct().ToList();
        }

        private static List<string> ReadConsumableCreatedAts(JsonObject item)
        {
            var values = new List<string>();

            if (item["CreatedAts"] is not JsonArray createdAtArray)
                return values;

            foreach (JsonNode? valueNode in createdAtArray)
            {
                string? value = null;
                try
                {
                    value = valueNode?.GetValue<string>();
                }
                catch
                {
                    value = valueNode?.ToJsonString().Trim('"');
                }

                if (!string.IsNullOrWhiteSpace(value) &&
                    DateTime.TryParse(
                        value,
                        System.Globalization.CultureInfo.InvariantCulture,
                        System.Globalization.DateTimeStyles.RoundtripKind,
                        out DateTime parsed))
                {
                    values.Add(parsed.ToUniversalTime().ToString("O"));
                }
            }

            return values;
        }

        private static string? NormalizeConsumableTimestamp(string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return null;

            return DateTime.TryParse(
                value,
                System.Globalization.CultureInfo.InvariantCulture,
                System.Globalization.DateTimeStyles.RoundtripKind,
                out DateTime parsed)
                ? parsed.ToUniversalTime().ToString("O")
                : null;
        }

        private static string? ReadString(
            JsonObject item,
            string propertyName)
        {
            JsonNode? node = item[propertyName];
            if (node == null)
                return null;

            try
            {
                return node.GetValue<string>();
            }
            catch
            {
                string raw = node.ToJsonString().Trim('"');
                return string.Equals(raw, "null", StringComparison.OrdinalIgnoreCase)
                    ? null
                    : raw;
            }
        }

        private static bool TryReadLong(
            JsonNode? node,
            out long value)
        {
            value = 0;
            if (node == null)
                return false;

            try
            {
                if (node is JsonValue jsonValue &&
                    jsonValue.TryGetValue<long>(out value))
                {
                    return true;
                }
            }
            catch
            {

            }

            return long.TryParse(
                node.ToJsonString().Trim('"'),
                out value);
        }

        private static string GetPlayerEquipmentPath(long accountId)
        {
            return EquipmentInventoryStore.GetPlayerEquipmentPath(accountId);
        }

        private static List<PlayerDBClasses.EquipmentItem> GetOrCreatePlayerEquipment(long accountId)
        {
            return EquipmentInventoryStore.GetOrCreate(accountId);
        }

        private static void SavePlayerEquipment(
            long accountId,
            List<PlayerDBClasses.EquipmentItem> equipment)
        {
            EquipmentInventoryStore.Save(accountId, equipment);
        }

        private static bool OwnsEquipmentItem(
            long accountId,
            string prefabName,
            string modificationGuid)
        {
            if (string.IsNullOrWhiteSpace(prefabName) ||
                string.IsNullOrWhiteSpace(modificationGuid))
            {
                return false;
            }

            return GetOrCreatePlayerEquipment(accountId).Any(item =>
                string.Equals(
                    item.PrefabName,
                    prefabName,
                    StringComparison.OrdinalIgnoreCase) &&
                string.Equals(
                    item.ModificationGuid,
                    modificationGuid,
                    StringComparison.OrdinalIgnoreCase));
        }

        private static void GrantPlayerEquipment(
            long accountId,
            string prefabName,
            string modificationGuid)
        {
            var equipment = GetOrCreatePlayerEquipment(accountId);
            var existingReward = equipment.FirstOrDefault(item =>
                string.Equals(item.PrefabName, prefabName, StringComparison.OrdinalIgnoreCase) &&
                string.Equals(item.ModificationGuid, modificationGuid, StringComparison.OrdinalIgnoreCase));
            if (existingReward != null)
            {
                existingReward.FriendlyName = "Ghost Bow Skin";
                existingReward.Rarity = 50;
                SavePlayerEquipment(accountId, equipment);
                return;
            }

            string masterPath = Path.Combine(Program.dataDir, "APIS", "Items", "Equipment.json");
            PlayerDBClasses.EquipmentItem? reward = null;
            if (System.IO.File.Exists(masterPath))
            {
                var masterEquipment = JsonSerializer.Deserialize<List<PlayerDBClasses.EquipmentItem>>(
                    System.IO.File.ReadAllText(masterPath),
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
                reward = masterEquipment?.FirstOrDefault(item =>
                    string.Equals(item.PrefabName, prefabName, StringComparison.OrdinalIgnoreCase) &&
                    string.Equals(item.ModificationGuid, modificationGuid, StringComparison.OrdinalIgnoreCase));
            }

            if (reward != null)
            {
                reward.FriendlyName = "Ghost Bow Skin";
                reward.Rarity = 50;
            }

            equipment.Add(reward ?? new PlayerDBClasses.EquipmentItem
            {
                PrefabName = prefabName,
                ModificationGuid = modificationGuid,
                FriendlyName = "Ghost Bow Skin",
                Rarity = 50,
                PlatformMask = -1
            });
            SavePlayerEquipment(accountId, equipment);
        }

        private static bool GrantPurchasedEquipment(
            long accountId,
            CatalogSku sku)
        {
            if (!IsEquipmentSkin(sku))
                return false;

            var equipment = GetOrCreatePlayerEquipment(accountId);
            if (equipment.Any(item =>
                    string.Equals(
                        item.PrefabName,
                        sku.EquipmentPrefabName,
                        StringComparison.OrdinalIgnoreCase) &&
                    string.Equals(
                        item.ModificationGuid,
                        sku.EquipmentModificationGuid,
                        StringComparison.OrdinalIgnoreCase)))
            {
                return true;
            }

            equipment.Add(new PlayerDBClasses.EquipmentItem
            {
                PrefabName = sku.EquipmentPrefabName,
                ModificationGuid = sku.EquipmentModificationGuid,
                UnlockedLevel = 0,
                Favorited = false,
                PlatformMask = sku.PlatformMask,
                FriendlyName = sku.FriendlyName,
                Tooltip = sku.Tooltip,
                Rarity = sku.Rarity,
                ThumbnailImage = sku.ThumbnailImage
            });
            SavePlayerEquipment(accountId, equipment);
            return true;
        }

        [HttpGet("/api/equipment/v2/getUnlocked")]
        public IActionResult GetMyEquipment()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            var equipment = GetOrCreatePlayerEquipment((long)id);
            return Ok(equipment);
        }

        [HttpPost("/api/equipment/v1/update")]
        public IActionResult UpdateMyEquipment([FromBody] JsonElement request)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            List<PlayerDBClasses.EquipmentItem> updates;
            try
            {
                JsonElement items = request;
                if (request.ValueKind == JsonValueKind.Object)
                {
                    foreach (JsonProperty property in request.EnumerateObject())
                    {
                        if (property.Name.Equals("items", StringComparison.OrdinalIgnoreCase) ||
                            property.Name.Equals("equipment", StringComparison.OrdinalIgnoreCase) ||
                            property.Name.Equals("results", StringComparison.OrdinalIgnoreCase))
                        {
                            items = property.Value;
                            break;
                        }
                    }
                }

                updates = items.ValueKind switch
                {
                    JsonValueKind.Array =>
                        JsonSerializer.Deserialize<List<PlayerDBClasses.EquipmentItem>>(
                            items.GetRawText(),
                            new JsonSerializerOptions { PropertyNameCaseInsensitive = true }) ??
                        new List<PlayerDBClasses.EquipmentItem>(),
                    JsonValueKind.Object => new List<PlayerDBClasses.EquipmentItem>
                    {
                        JsonSerializer.Deserialize<PlayerDBClasses.EquipmentItem>(
                            items.GetRawText(),
                            new JsonSerializerOptions { PropertyNameCaseInsensitive = true })!
                    },
                    _ => new List<PlayerDBClasses.EquipmentItem>()
                };

                updates.RemoveAll(item => item == null);
            }
            catch (JsonException)
            {
                updates = new List<PlayerDBClasses.EquipmentItem>();
            }

            if (updates.Count == 0)
                return BadRequest(new { success = false, error = "Invalid request body." });

            var equipment = GetOrCreatePlayerEquipment((long)id);

            foreach (var incoming in updates)
            {
                var item = equipment.FirstOrDefault(e => e.ModificationGuid == incoming.ModificationGuid && e.PrefabName == incoming.PrefabName);

                if (item != null)
                    item.Favorited = incoming.Favorited;

            }

            SavePlayerEquipment((long)id, equipment);

            return Ok(new { success = true });
        }

        [HttpPost("/api/gamerewards/v1/request")]
        public IActionResult RequestGameRewards()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            string path = Path.Combine(Program.dataDir, "APIS", "Items", "AvatarItems.json");
            if (!System.IO.File.Exists(path))
                return Ok(new { Rewards = Array.Empty<object>() });

            string json = System.IO.File.ReadAllText(path);
            var items = JsonSerializer.Deserialize<List<JsonElement>>(json, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }) ?? new List<JsonElement>();

            if (items.Count == 0)
                return Ok(new { Rewards = Array.Empty<object>() });

            var random = new Random();
            var rewards = items.OrderBy(_ => random.Next()).Take(Math.Min(3, items.Count)).ToList();

            return Ok(new { Rewards = rewards });
        }

        public class EquipmentUpdateRequest
        {
            public string PrefabName { get; set; } = "";
            public string ModificationGuid { get; set; } = "";
            public bool Favorited { get; set; }
        }

        [HttpGet("/api/PlayerReporting/v1/moderationBlockDetails")]
        public IActionResult GetMyModerationBlockDetails()
        {
            var player = AuthStuff.GetCurrentPlayer(Request);
            if (player == null)
                return Unauthorized();

            return Ok(player.Player.PlayerExtra.ModerationBlockDetails);
        }

        [HttpPost("/api/freegifts/v1/sendmultiple")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> SendMultipleFreeGifts()
        {
            long? senderId = AuthStuff.GetPlayerId(Request);
            if (!senderId.HasValue)
                return Unauthorized();

            ParsedFreeGiftRequest parsed = await ReadFreeGiftRequestAsync();
            parsed.Message = parsed.Message.Trim();
            if (parsed.Message.Length > 200)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "gift_message_too_long"
                });
            }

            Console.WriteLine(
                $"[FRIENDOTRON REQUEST] sender={senderId.Value} " +
                $"recipients=[{string.Join(",", parsed.RecipientIds)}] " +
                $"messageLength={parsed.Message.Length} " +
                $"ContentType={Request.ContentType}, ContentLength={Request.ContentLength ?? 0}");

            List<long> recipientIds = parsed.RecipientIds
                .Where(id =>
                    id > 0 &&
                    id <= int.MaxValue)
                .Distinct()
                .ToList();

            if (recipientIds.Count == 0)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "missing_recipient_ids",
                    contentType = Request.ContentType
                });
            }

            if (recipientIds.Count != 1)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "friendotron_one_recipient_only"
                });
            }

            long recipientId = recipientIds[0];
            if (recipientId != senderId.Value)
            {
                PlayerRelationship? relationship =
                    RelationshipDB.GetRelationship(
                        senderId.Value,
                        recipientId);
                if (relationship?.RelationshipType != RelationshipType.Friend)
                {
                    return StatusCode(StatusCodes.Status403Forbidden, new
                    {
                        success = false,
                        error = "friendotron_recipient_not_friend"
                    });
                }
            }

            HashSet<string> installedConsumables = GetCatalogSkus()
                .Where(IsConsumableCatalogItem)
                .Select(item => item.ConsumableItemDesc)
                .ToHashSet(StringComparer.OrdinalIgnoreCase);

            List<FriendotronConsumableReward> rewardPool =
                FriendotronConsumableRewards
                    .Where(reward => installedConsumables.Contains(
                        reward.ConsumableItemDesc))
                    .ToList();

            if (rewardPool.Count == 0)
            {
                return StatusCode(500, new
                {
                    success = false,
                    error = "friendotron_consumable_pool_empty"
                });
            }

            FriendotronConsumableReward reward =
                rewardPool[Random.Shared.Next(rewardPool.Count)];
            var pendingGift = new GiftPackage
            {
                FromPlayerId = checked((int)senderId.Value),
                Message = parsed.Message,
                AvatarItemDesc = string.Empty,
                ConsumableItemDesc = reward.ConsumableItemDesc,
                ConsumableQuantity = 1,
                EquipmentPrefabName = string.Empty,
                EquipmentModificationGuid = string.Empty,
                CurrencyType = (int)CurrencyType.RecCenterTokens,
                GiftContext = FriendotronGiftContext,
                Rarity = reward.Rarity,
                Platform = -1,
                PlatformMask = -1,
                BalanceType =
                    (int)BalanceType.NonPurchasedNotUsableInP2P,
                IsQuery = false,
                Unique = false
            };

            PlayerDB.FriendotronGiftStatus queueStatus =
                PlayerDB.QueueFriendotronGift(
                    senderId.Value,
                    recipientId,
                    pendingGift,
                    out GiftPackage? package,
                    out DateTime nextAvailableAtUtc);

            if (queueStatus ==
                PlayerDB.FriendotronGiftStatus.DailyLimitReached)
            {
                long retryAfterSeconds = Math.Max(
                    1,
                    (long)Math.Ceiling(
                        (nextAvailableAtUtc - DateTime.UtcNow).TotalSeconds));
                Response.Headers["Retry-After"] = retryAfterSeconds.ToString(
                    System.Globalization.CultureInfo.InvariantCulture);

                Console.WriteLine(
                    $"[FRIENDOTRON DENIED] sender={senderId.Value} " +
                    $"recipient={recipientId} reason=daily_limit " +
                    $"next={nextAvailableAtUtc:O}");

                return StatusCode(StatusCodes.Status429TooManyRequests, new
                {
                    success = false,
                    error = "friendotron_daily_limit",
                    nextGiftAt = nextAvailableAtUtc,
                    retryAfterSeconds
                });
            }

            if (queueStatus != PlayerDB.FriendotronGiftStatus.Success ||
                package == null)
            {
                Console.WriteLine(
                    $"[FRIENDOTRON ERROR] sender={senderId.Value} " +
                    $"recipient={recipientId} status={queueStatus}");

                return queueStatus switch
                {
                    PlayerDB.FriendotronGiftStatus.RecipientNotFound =>
                        NotFound(new
                        {
                            success = false,
                            error = "friendotron_recipient_not_found"
                        }),
                    PlayerDB.FriendotronGiftStatus.RecipientQueueFull =>
                        StatusCode(StatusCodes.Status409Conflict, new
                        {
                            success = false,
                            error = "friendotron_recipient_gift_queue_full"
                        }),
                    _ => StatusCode(
                        StatusCodes.Status500InternalServerError,
                        new
                        {
                            success = false,
                            error = "friendotron_delivery_failed"
                        })
                };
            }

            try
            {
                await NotiController.NotifyGiftAsync(
                    senderId.Value,
                    recipientId,
                    package);
            }
            catch (Exception exception)
            {

                Console.WriteLine(
                    $"[FRIENDOTRON PUSH ERROR] sender={senderId.Value} " +
                    $"recipient={recipientId} package={package.GiftPackageId} " +
                    $"error={exception.Message}");
            }

            Console.WriteLine(
                $"[FRIENDOTRON SENT] sender={senderId.Value} " +
                $"recipient={recipientId} reward={reward.FriendlyName} " +
                $"stars={reward.Stars} rarity={reward.Rarity} " +
                $"package={package.GiftPackageId} " +
                $"next={nextAvailableAtUtc:O}");

            return Ok();
        }

        [HttpPost("/api/avatar/v2/gifts/generate")]
        [HttpPost("/api/avatar/v3/gifts/generate")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> GenerateGiftPackage()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            var player = PlayerDB.Players.FindById(playerId.Value);
            if (player?.Player == null)
                return NotFound();
            if (player.PlayerRoles?.Contains(PlayerRoles.Developer) != true)
            {
                return StatusCode(StatusCodes.Status403Forbidden, new
                {
                    success = false,
                    error = "developer_only_legacy_reward"
                });
            }

            ParsedFreeGiftRequest parsed = await ReadFreeGiftRequestAsync();
            parsed.Message = parsed.Message.Trim();
            if (parsed.Message.Length > 200)
                return BadRequest(new { success = false, error = "gift_message_too_long" });

            player.Player.PlayerExtra ??= new PlayerExtra();
            player.Player.PlayerExtra.AvatarItems ??= new List<string>();

            HashSet<string> ownedItems =
                player.Player.PlayerExtra.AvatarItems.ToHashSet(
                    StringComparer.OrdinalIgnoreCase);

            List<CatalogSku> availableGifts = GetCatalogSkus()
                .Where(IsUsableStoreItem)
                .Where(item =>
                    !string.IsNullOrWhiteSpace(item.AvatarItemDesc) &&
                    !ownedItems.Contains(item.AvatarItemDesc))
                .ToList();

            if (availableGifts.Count == 0)
            {
                return NotFound(new
                {
                    success = false,
                    error = "no_available_gifts"
                });
            }

            CatalogSku gift =
                availableGifts[Random.Shared.Next(availableGifts.Count)];

            GiftPackage? package = PlayerDB.QueueGiftPackage(
                playerId.Value,
                new GiftPackage
                {
                    FromPlayerId = 0,
                    Message = parsed.Message,
                    AvatarItemDesc = gift.AvatarItemDesc,
                    ConsumableItemDesc = gift.ConsumableItemDesc,
                    EquipmentPrefabName = gift.EquipmentPrefabName,
                    EquipmentModificationGuid =
                        gift.EquipmentModificationGuid,
                    CurrencyType = gift.CurrencyType,
                    GiftContext = parsed.GiftContext,
                    Rarity = gift.Rarity,
                    Platform = -1,
                    PlatformMask = gift.PlatformMask,
                    IsQuery = gift.GiftDrop.IsQuery,
                    Unique = gift.GiftDrop.Unique
                });

            if (package == null)
                return StatusCode(500);

            await NotiController.NotifyGiftAsync(
                senderPlayerId: 0,
                receiverPlayerId: playerId.Value,
                package);

            return Ok(package);
        }

        private sealed class FriendotronConsumableReward
        {
            public FriendotronConsumableReward(
                string friendlyName,
                string consumableItemDesc,
                int rarity)
            {
                FriendlyName = friendlyName;
                ConsumableItemDesc = consumableItemDesc;
                Rarity = rarity;
            }

            public string FriendlyName { get; }
            public string ConsumableItemDesc { get; }
            public int Rarity { get; }
            public int Stars => (Rarity / 10) + 1;
        }

        private sealed class ParsedFreeGiftRequest
        {
            public HashSet<long> RecipientIds { get; } = new();
            public string Message { get; set; } = string.Empty;
            public int GiftContext { get; set; }
        }

        private static readonly string[] FreeGiftRecipientKeys =
        {
    "ToPlayerIds",
    "toPlayerIds",
    "to_player_ids",
    "PlayerIds",
    "playerIds",
    "RecipientIds",
    "recipientIds",
    "AccountIds",
    "accountIds",
    "ToPlayerId",
    "toPlayerId",
    "PlayerId",
    "playerId",
    "RecipientId",
    "recipientId",
    "AccountId",
    "accountId",
    "Ids",
    "ids"
};

        private async Task<ParsedFreeGiftRequest> ReadFreeGiftRequestAsync()
        {
            var result = new ParsedFreeGiftRequest();

            foreach (string key in FreeGiftRecipientKeys)
            {
                foreach (string? value in Request.Query[key])
                    AddIdsFromText(value, result.RecipientIds);
            }

            result.Message =
                Request.Query["Message"].FirstOrDefault() ??
                Request.Query["message"].FirstOrDefault() ??
                string.Empty;

            if (int.TryParse(
                Request.Query["GiftContext"].FirstOrDefault() ??
                Request.Query["giftContext"].FirstOrDefault(),
                out int queryContext))
            {
                result.GiftContext = queryContext;
            }

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();

                foreach (string key in FreeGiftRecipientKeys)
                {
                    foreach (string? value in form[key])
                        AddIdsFromText(value, result.RecipientIds);
                }

                result.Message =
                    form["Message"].FirstOrDefault() ??
                    form["message"].FirstOrDefault() ??
                    result.Message;

                if (int.TryParse(
                    form["GiftContext"].FirstOrDefault() ??
                    form["giftContext"].FirstOrDefault(),
                    out int formContext))
                {
                    result.GiftContext = formContext;
                }

                return result;
            }

            if (!Request.Body.CanRead)
                return result;

            using var reader = new StreamReader(
                Request.Body,
                Encoding.UTF8,
                detectEncodingFromByteOrderMarks: false,
                bufferSize: 4096,
                leaveOpen: true);

            string body = await reader.ReadToEndAsync();

            if (string.IsNullOrWhiteSpace(body))
                return result;

            try
            {
                using JsonDocument document = JsonDocument.Parse(body);
                JsonElement root = document.RootElement;

                CollectRecipientIds(root, result.RecipientIds);

                result.Message =
                    FindJsonString(root, "Message", "message") ??
                    result.Message;

                result.GiftContext =
                    FindJsonInt(root, "GiftContext", "giftContext") ??
                    result.GiftContext;
            }
            catch (JsonException exception)
            {
                Console.WriteLine(
                    $"[FREE GIFTS] Invalid JSON: {exception.Message}");

                AddIdsFromText(body, result.RecipientIds);
            }

            return result;
        }

        private static void CollectRecipientIds(
            JsonElement element,
            HashSet<long> recipientIds)
        {
            switch (element.ValueKind)
            {
                case JsonValueKind.Array:
                    foreach (JsonElement child in element.EnumerateArray())
                        AddIdsFromJsonValue(child, recipientIds);
                    break;

                case JsonValueKind.Object:
                    bool foundKnownProperty = false;

                    foreach (JsonProperty property in element.EnumerateObject())
                    {
                        if (FreeGiftRecipientKeys.Any(key =>
                            string.Equals(
                                key,
                                property.Name,
                                StringComparison.OrdinalIgnoreCase)))
                        {
                            foundKnownProperty = true;
                            AddIdsFromJsonValue(property.Value, recipientIds);
                        }
                    }

                    if (!foundKnownProperty)
                    {
                        foreach (JsonProperty property in element.EnumerateObject())
                        {
                            if (property.Value.ValueKind is
                                JsonValueKind.Object or JsonValueKind.Array)
                            {
                                CollectRecipientIds(
                                    property.Value,
                                    recipientIds);
                            }
                        }
                    }

                    break;

                case JsonValueKind.Number:
                case JsonValueKind.String:
                    AddIdsFromJsonValue(element, recipientIds);
                    break;
            }
        }

        private static void AddIdsFromJsonValue(
            JsonElement value,
            HashSet<long> recipientIds)
        {
            switch (value.ValueKind)
            {
                case JsonValueKind.Number:
                    if (value.TryGetInt64(out long number))
                        recipientIds.Add(number);
                    break;

                case JsonValueKind.String:
                    AddIdsFromText(value.GetString(), recipientIds);
                    break;

                case JsonValueKind.Array:
                    foreach (JsonElement child in value.EnumerateArray())
                        AddIdsFromJsonValue(child, recipientIds);
                    break;

                case JsonValueKind.Object:
                    CollectRecipientIds(value, recipientIds);
                    break;
            }
        }

        private static void AddIdsFromText(
            string? value,
            HashSet<long> recipientIds)
        {
            if (string.IsNullOrWhiteSpace(value))
                return;

            string cleaned = value
                .Replace("[", " ")
                .Replace("]", " ")
                .Replace("{", " ")
                .Replace("}", " ")
                .Replace("\"", " ")
                .Replace("'", " ");

            string[] pieces = cleaned.Split(
                new[]
                {
            ',', ';', '|', ' ', '\t', '\r', '\n'
                },
                StringSplitOptions.RemoveEmptyEntries |
                StringSplitOptions.TrimEntries);

            foreach (string piece in pieces)
            {
                string candidate = piece;

                int equalsIndex = candidate.LastIndexOf('=');
                if (equalsIndex >= 0)
                    candidate = candidate[(equalsIndex + 1)..];

                int colonIndex = candidate.LastIndexOf(':');
                if (colonIndex >= 0)
                    candidate = candidate[(colonIndex + 1)..];

                if (long.TryParse(candidate, out long playerId))
                    recipientIds.Add(playerId);
            }
        }

        [HttpGet("/api/relationships/v2/get")]
        [HttpGet("/api/relationships/")]
        [HttpGet("/api/relationships")]
        public IActionResult GetMyRelationships([FromQuery] long? id = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Ok(Array.Empty<ClientRelationshipDTO>());

            return Ok(RelationshipDB.GetClientRelationships(accountId.Value));
        }

        [HttpPost("/api/relationships/sendfriendintroductions")]
        public IActionResult SendFriendIntroductions()
        {

            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();
            return Ok(new { success = true, introductions = Array.Empty<object>() });
        }

        public class AddFriendWithCodeRequest
        {
            public string? Code { get; set; }
        }

        [HttpPost("/api/relationships/v1/addfriendwithcode")]
        public IActionResult AddFriendWithCode([FromBody] AddFriendWithCodeRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            string username = (request.Code ?? string.Empty).Trim().TrimStart('@');
            if (username.Length == 0)
                return BadRequest(new { error = "Enter a friend code." });

            var target = PlayerDB.Players.FindAll().FirstOrDefault(value =>
                string.Equals(value.Player?.Username, username, StringComparison.OrdinalIgnoreCase));
            if (target?.Player == null)
                return NotFound(new { error = "No player found with that code." });
            if (target.PlayerId == accountId.Value)
                return BadRequest(new { error = "That's your own code." });

            RelationshipDB.AddFriend(accountId.Value, target.PlayerId);
            return Ok(RelationshipDB.GetClientRelationship(accountId.Value, target.PlayerId));
        }

        [HttpGet("/api/messages/v2/get")]
        public IActionResult GetMyMessages()
        {
            long? id = AuthStuff.GetPlayerId(Request);
            if (!id.HasValue)
                return Unauthorized();

            List<NotificationDB.ClientNotification> messages =
                NotificationDB.GetMessages(id.Value);
            Console.WriteLine(
                $"[MESSAGES GET] player={id.Value} count={messages.Count} " +
                $"types=[{string.Join(",", messages.Select(value => value.Type))}]");
            return Ok(messages);
        }

        [HttpPost("/api/messages/v2/send")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> SendPlayerMessage(
            [FromForm] long ToPlayerId,
            [FromForm] int Type,
            [FromForm] string? Data,
            [FromForm] long? RoomId)
        {
            long? senderPlayerId = AuthStuff.GetPlayerId(Request);
            if (!senderPlayerId.HasValue)
                return Unauthorized();
            if (ToPlayerId <= 0 ||
                ToPlayerId == senderPlayerId.Value ||
                PlayerDB.Players.FindById(ToPlayerId)?.Player == null)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "invalid_message_recipient"
                });
            }

            var recipientRelationship =
                RelationshipDB.GetClientRelationship(
                    ToPlayerId,
                    senderPlayerId.Value);
            if ((Type is
                     (int)NotificationDB.MessageType.GameInvite or
                     (int)NotificationDB.MessageType.GameInviteV2) &&
                (recipientRelationship?.Ignored is 1 or 3))
            {
                return StatusCode(403, new
                {
                    success = false,
                    error = "gameplay_invites_not_allowed"
                });
            }

            NotificationDB.ClientNotification message;
            if (Type is
                (int)NotificationDB.MessageType.GameInvite or
                (int)NotificationDB.MessageType.GameInviteV2)
            {
                RoomInstance? instance = PlayerDB
                    .GetPlayerHeartbeat(senderPlayerId.Value)
                    .roomInstance;
                if (instance == null)
                {
                    return BadRequest(new
                    {
                        success = false,
                        error = "sender_not_in_room"
                    });
                }

                if (!Sessions.IsConfirmedParticipant(
                        senderPlayerId.Value,
                        instance.roomInstanceId))
                {
                    return StatusCode(409, new
                    {
                        success = false,
                        error = "room_instance_membership_not_confirmed"
                    });
                }

                if (RoomId.HasValue && RoomId.Value > 0 &&
                    RoomId.Value != instance.roomId)
                {
                    return StatusCode(409, new
                    {
                        success = false,
                        error = "room_invite_source_mismatch",
                        requestedRoomId = RoomId.Value,
                        currentRoomId = instance.roomId
                    });
                }

                message = await NotiController.NotifyRoomInviteAsync(
                    senderPlayerId.Value,
                    ToPlayerId,
                    instance.roomId,
                    instance.roomInstanceId,
                    instance.photonRoomId);
            }
            else
            {
                NotificationDB.MessageType messageType =
                    Enum.IsDefined(typeof(NotificationDB.MessageType), Type)
                        ? (NotificationDB.MessageType)Type
                        : NotificationDB.MessageType.TextMessage;

                message = NotificationDB.CreatePlayerMessage(
                    senderPlayerId.Value,
                    ToPlayerId,
                    messageType,
                    Data,
                    RoomId);

                await NotiController.NotifyMessageAsync(ToPlayerId, message);
            }

            Console.WriteLine(
                $"[MESSAGES SEND] from={senderPlayerId.Value} " +
                $"to={ToPlayerId} type={Type} room={RoomId?.ToString() ?? "none"} " +
                $"messageId={message.Id}");

            return NoContent();
        }

        [HttpPost("/api/messages/v2/delete")]
        [HttpDelete("/api/messages/v2/delete")]
        [HttpPost("/api/messages/v3/delete")]
        [HttpDelete("/api/messages/v3/delete")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> DeleteMyMessages()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            HashSet<long> ids = await ReadLongValuesAsync(
                "MessageIds", "messageIds", "MessageId", "messageId", "id");
            int acceptedCheers = PlayerDB.ResolvePlayerCheers(
                playerId.Value,
                ids,
                CheerStatus.Accepted);
            int deleted = NotificationDB.DeleteMessages(playerId.Value, ids);
            return Ok(new
            {
                success = true,
                deleted,
                acceptedCheers
            });
        }

        [HttpPost("/api/messages/v1/sendMultiple")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> SendMultipleMessages()
        {
            long? senderPlayerId = AuthStuff.GetPlayerId(Request);
            if (!senderPlayerId.HasValue)
                return Unauthorized();

            HashSet<long> recipientIds = await ReadLongValuesAsync(
                "ToPlayerIds",
                "toPlayerIds",
                "RecipientPlayerIds",
                "recipientPlayerIds",
                "RecipientIds",
                "recipientIds",
                "PlayerIds",
                "playerIds",
                "ToAccountIds",
                "toAccountIds");

            HashSet<long> aboutIds = await ReadLongValuesAsync(
                "AboutPlayerId",
                "aboutPlayerId",
                "AboutAccountId",
                "aboutAccountId");

            long aboutPlayerId = aboutIds.FirstOrDefault();
            if (aboutPlayerId > 0 &&
                PlayerDB.Players.FindById(aboutPlayerId)?.Player == null)
            {
                Console.WriteLine(
                    $"[MESSAGES SEND MULTIPLE] sender={senderPlayerId.Value} " +
                    $"about={aboutPlayerId} rejected=about_player_not_found");
                return NotFound(new
                {
                    success = false,
                    error = "about_player_not_found"
                });
            }

            long[] validRecipients = recipientIds
                .Where(id =>
                    id > 0 &&
                    id <= int.MaxValue &&
                    id != senderPlayerId.Value &&
                    (aboutPlayerId <= 0 || id != aboutPlayerId) &&
                    PlayerDB.Players.FindById(id)?.Player != null)
                .Distinct()
                .Take(50)
                .ToArray();

            if (validRecipients.Length == 0)
            {
                Console.WriteLine(
                    $"[MESSAGES SEND MULTIPLE] sender={senderPlayerId.Value} " +
                    $"about={aboutPlayerId} rejected=no_valid_recipients");
                return BadRequest(new
                {
                    success = false,
                    error = "missing_recipient_ids"
                });
            }

            if (aboutPlayerId > 0)
            {
                foreach (long receiverPlayerId in validRecipients)
                {
                    await NotiController.NotifyFriendIntroductionAsync(
                        senderPlayerId.Value,
                        receiverPlayerId,
                        aboutPlayerId);
                }

                Console.WriteLine(
                    $"[MESSAGES SEND MULTIPLE] sender={senderPlayerId.Value} " +
                    $"type={(int)NotificationDB.MessageType.FriendIntroduction} " +
                    $"about={aboutPlayerId} recipients=" +
                    $"[{string.Join(",", validRecipients)}] " +
                    $"sent={validRecipients.Length}");

                return Ok();
            }

            (int type, string data) = await ReadMultipleMessagePayloadAsync();
            NotificationDB.MessageType messageType =
                Enum.IsDefined(typeof(NotificationDB.MessageType), type)
                    ? (NotificationDB.MessageType)type
                    : NotificationDB.MessageType.TextMessage;

            bool isGameInvite = messageType is
                NotificationDB.MessageType.GameInvite or
                NotificationDB.MessageType.GameInviteV2;
            RoomInstance? inviteInstance = null;
            if (isGameInvite)
            {
                inviteInstance = PlayerDB
                    .GetPlayerHeartbeat(senderPlayerId.Value)
                    .roomInstance;
                if (inviteInstance == null)
                {
                    return BadRequest(new
                    {
                        success = false,
                        error = "sender_not_in_room"
                    });
                }

                if (!Sessions.IsConfirmedParticipant(
                        senderPlayerId.Value,
                        inviteInstance.roomInstanceId))
                {
                    return StatusCode(409, new
                    {
                        success = false,
                        error = "room_instance_membership_not_confirmed"
                    });
                }
            }

            var deliveredRecipients = new List<long>();
            var blockedRecipients = new List<long>();
            foreach (long receiverPlayerId in validRecipients)
            {
                if (isGameInvite)
                {
                    var relationship = RelationshipDB.GetClientRelationship(
                        receiverPlayerId,
                        senderPlayerId.Value);
                    if (relationship?.Ignored is 1 or 3)
                    {
                        blockedRecipients.Add(receiverPlayerId);
                        continue;
                    }

                    await NotiController.NotifyRoomInviteAsync(
                        senderPlayerId.Value,
                        receiverPlayerId,
                        inviteInstance!.roomId,
                        inviteInstance.roomInstanceId,
                        inviteInstance.photonRoomId);
                    deliveredRecipients.Add(receiverPlayerId);
                }
                else
                {
                    NotificationDB.ClientNotification message =
                        NotificationDB.CreatePlayerMessage(
                        senderPlayerId.Value,
                        receiverPlayerId,
                        messageType,
                        data);

                    await NotiController.NotifyMessageAsync(
                        receiverPlayerId,
                        message);
                    deliveredRecipients.Add(receiverPlayerId);
                }
            }

            Console.WriteLine(
                $"[MESSAGES SEND MULTIPLE] sender={senderPlayerId.Value} " +
                $"type={(int)messageType} recipients=" +
                $"[{string.Join(",", deliveredRecipients)}] " +
                $"sent={deliveredRecipients.Count} " +
                $"blocked={blockedRecipients.Count}");

            return Ok();
        }

        private async Task<(int Type, string Data)>
            ReadMultipleMessagePayloadAsync()
        {
            string? rawType =
                Request.Query["Type"].FirstOrDefault() ??
                Request.Query["type"].FirstOrDefault() ??
                Request.Query["MessageType"].FirstOrDefault() ??
                Request.Query["messageType"].FirstOrDefault();
            string data =
                Request.Query["Data"].FirstOrDefault() ??
                Request.Query["data"].FirstOrDefault() ??
                string.Empty;

            if (Request.HasFormContentType)
            {
                IFormCollection form =
                    await Request.ReadFormAsync(HttpContext.RequestAborted);
                rawType =
                    form["Type"].FirstOrDefault() ??
                    form["type"].FirstOrDefault() ??
                    form["MessageType"].FirstOrDefault() ??
                    form["messageType"].FirstOrDefault() ??
                    rawType;
                data =
                    form["Data"].FirstOrDefault() ??
                    form["data"].FirstOrDefault() ??
                    data;
            }
            else if (Request.Body.CanRead)
            {
                Request.EnableBuffering();
                if (Request.Body.CanSeek)
                    Request.Body.Position = 0;

                using var reader = new StreamReader(
                    Request.Body,
                    Encoding.UTF8,
                    detectEncodingFromByteOrderMarks: false,
                    leaveOpen: true);
                string body = await reader.ReadToEndAsync();
                if (Request.Body.CanSeek)
                    Request.Body.Position = 0;

                if (!string.IsNullOrWhiteSpace(body))
                {
                    try
                    {
                        using JsonDocument document = JsonDocument.Parse(body);
                        JsonElement root = document.RootElement;
                        rawType =
                            FindJsonInt(
                                root,
                                "Type",
                                "type",
                                "MessageType",
                                "messageType")?
                            .ToString() ??
                            rawType;
                        data =
                            FindJsonString(root, "Data", "data") ??
                            data;
                    }
                    catch (JsonException)
                    {

                    }
                }
            }

            return (
                int.TryParse(rawType, out int type)
                    ? type
                    : (int)NotificationDB.MessageType.TextMessage,
                data);
        }

        [HttpGet("/playersettings")]
        public IActionResult GetMySettings()
        {
            var player = AuthStuff.GetCurrentPlayer(Request);
            if (player == null)
                return Unauthorized();

            return Ok(player.Player.PlayerExtra.Settings);
        }

        [HttpPut("/playersettings")]
        [RequestSizeLimit(16 * 1024)]
        public IActionResult SetMySettings([FromForm] string key, [FromForm] string value)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            PlayerDB.SetPlayerSetting(key, value ?? "", (long)id);

            return NoContent();
        }

        [HttpGet("/econ/customAvatarItems/v1/owned")]
        public IActionResult GetMyOwnedCustomAvatarItems([FromQuery] int skip, [FromQuery] int take)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            skip = Math.Max(0, skip);
            take = Math.Clamp(take <= 0 ? 100 : take, 1, 100);

            List<JsonObject> items = LoadCustomAvatarItems(accountId.Value);
            List<JsonObject> page = items.Skip(skip).Take(take).ToList();

            return Ok(new
            {
                Results = page,
                TotalResults = items.Count
            });
        }

        [HttpGet("/api/checklist/v1/current")]
        public IActionResult GetMyChecklist()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("/api/players/v2/progression/bulk")]
        public IActionResult GetProgressionForPlayers([FromQuery] List<long> id)
        {
            var authId = AuthStuff.GetPlayerId(Request);
            if (authId == null)
                return Unauthorized();

            if (id == null || id.Count == 0)
                return Ok(new List<PlayerDBClasses.PlayerProgressionDTO>());

            var progressions = PlayerDB.GetProgressionBulk(id);

            return Ok(progressions);
        }

        [HttpPost("/api/players/v2/progression/update")]
        [HttpPost("/api/players/v1/progression/update")]
        [HttpPost("/api/progression/v1/update")]
        [RequestSizeLimit(32 * 1024)]
        public async Task<IActionResult> UpdateMyProgression()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            var current = PlayerDB.Players.FindById(playerId.Value);
            if (current?.Player == null)
                return NotFound(new { success = false, error = "player_not_found" });
            if (current.PlayerRoles?.Contains(PlayerRoles.Developer) != true)
            {
                return StatusCode(StatusCodes.Status403Forbidden, new
                {
                    success = false,
                    error = "server_authoritative_progression"
                });
            }

            var values = new Dictionary<string, string>(
                StringComparer.OrdinalIgnoreCase);

            foreach (var queryValue in Request.Query)
                values[queryValue.Key] = queryValue.Value.ToString();

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();
                foreach (var formValue in form)
                    values[formValue.Key] = formValue.Value.ToString();
            }
            else if ((Request.ContentLength ?? 0) > 0)
            {
                using var reader = new StreamReader(Request.Body);
                string body = await reader.ReadToEndAsync();

                if (!string.IsNullOrWhiteSpace(body))
                {
                    try
                    {
                        using JsonDocument document = JsonDocument.Parse(body);
                        AddJsonValues(document.RootElement, values);
                    }
                    catch (JsonException)
                    {
                        foreach (var bodyValue in
                            Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(
                                "?" + body))
                        {
                            values[bodyValue.Key] = bodyValue.Value.ToString();
                        }
                    }
                }
            }

            int level = current.Player.Level;
            int xp = current.Player.XP;

            string? levelText = GetValue(values,
                "Level", "level", "NewLevel", "newLevel");
            string? xpText = GetValue(values,
                "XP", "Xp", "xp", "Experience", "experience", "NewXP", "newXp");
            string? xpDeltaText = GetValue(values,
                "XPDelta", "xpDelta", "ExperienceDelta", "experienceDelta", "AddXP", "addXp");

            if (int.TryParse(levelText, out int parsedLevel))
                level = parsedLevel;
            if (int.TryParse(xpText, out int parsedXp))
                xp = parsedXp;
            if (int.TryParse(xpDeltaText, out int xpDelta))
                xp = Math.Max(0, xp + xpDelta);

            var progression = PlayerDB.SetProgression(
                playerId.Value,
                level,
                xp);

            return progression == null
                ? StatusCode(500, new { success = false, error = "progression_update_failed" })
                : Ok(progression);
        }

        [HttpGet("/api/playerReputation/v2/bulk")]
        public IActionResult GetReputationBulk([FromQuery] List<long> id)
        {
            var authId = AuthStuff.GetPlayerId(Request);
            if (authId == null)
                return Unauthorized();

            if (id == null || id.Count == 0)
                return Ok(new List<PlayerDBClasses.Reputation>());

            var results = PlayerDB.GetReputationBulk(id);
            return Ok(results);
        }

        [HttpPost("/api/PlayerReporting/v1/hile")]
        public IActionResult PlayerReportingHile()
        {
            var authId = AuthStuff.GetPlayerId(Request);
            if (authId == null)
                return Unauthorized();

            return Ok(false);
        }

        [HttpGet("api/config/v2")]
        public IActionResult GetConfigV2()
        {
            string path = Path.Combine(Program.dataDir, "APIS", "ConfigV2.json");
            return System.IO.File.Exists(path) ? Content(System.IO.File.ReadAllText(path), "application/json") : NotFound();
        }

        [HttpGet("/api/avatar/v3/saved")]
        public IActionResult GetSavedAvatars()
        {
            var player = AuthStuff.GetCurrentPlayer(Request);
            if (player?.Player == null)
                return Unauthorized();

            player.Player.PlayerExtra ??= new PlayerDBClasses.PlayerExtra();
            player.Player.PlayerExtra.SavedAvatars ??= new List<PlayerDBClasses.SavedOutfit>();
            var saved = player.Player.PlayerExtra.SavedAvatars;

            var photoEntries = saved.Where(s => !HasSavedOutfitState(s)).ToList();
            foreach (var photoEntry in photoEntries)
                MigrateLegacyPhotoEntry(player, photoEntry);

            if (photoEntries.Count > 0)
            {
                foreach (var photoEntry in photoEntries)
                    saved.Remove(photoEntry);
                PlayerDB.Players.Update(player);
            }

            var result = saved
                .OrderBy(s => s.Slot)
                .Select(s => new
                {
                    Slot = s.Slot,
                    OutfitSelections = s.OutfitSelections,
                    FaceFeatures = s.FaceFeatures,
                    SkinColor = s.SkinColor,
                    HairColor = s.HairColor,
                    PreviewImageName = s.PreviewImageName
                }).ToList();

            return Ok(result);
        }

        [HttpPost("/api/avatar/v3/saved/set")]
        [HttpPost("/api/avatar/v4/saved/set")]
        [RequestSizeLimit(256 * 1024)]
        public IActionResult SetSavedAvatar([FromBody] PlayerDBClasses.SavedOutfit request)
        {
            var player = AuthStuff.GetCurrentPlayer(Request);
            if (player?.Player == null)
                return Unauthorized();

            if (request == null)
                return BadRequest(new { success = false, error = "Invalid request body." });

            if (request.Slot > 350)
                return BadRequest(new { success = false, error = "Invalid outfit slot." });

            if (!HasSavedOutfitState(request))
            {
                return BadRequest(new
                {
                    success = false,
                    error = "An outfit save must include avatar data."
                });
            }

            if ((request.OutfitSelections?.Length ?? 0) > 64_000 ||
                (request.FaceFeatures?.Length ?? 0) > 64_000 ||
                (request.SkinColor?.Length ?? 0) > 1_024 ||
                (request.HairColor?.Length ?? 0) > 1_024 ||
                request.PreviewImageName?.Length > 260)
            {
                return BadRequest(new { success = false, error = "Outfit data is too large." });
            }

            player.Player.PlayerExtra ??= new PlayerDBClasses.PlayerExtra();
            player.Player.PlayerExtra.SavedAvatars ??= new List<PlayerDBClasses.SavedOutfit>();

            if (request.Slot < 0)
            {
                request.Slot = Enumerable.Range(0, 100).FirstOrDefault(slot =>
                    player.Player.PlayerExtra.SavedAvatars.All(saved => saved.Slot != slot), -1);
                if (request.Slot < 0)
                    return Conflict(new { success = false, error = "All saved outfit slots are in use." });
            }

            var existing = player.Player.PlayerExtra.SavedAvatars.FirstOrDefault(x => x.Slot == request.Slot);
            if (existing != null)
            {
                existing.OutfitSelections = request.OutfitSelections;
                existing.FaceFeatures = request.FaceFeatures;
                existing.SkinColor = request.SkinColor;
                existing.HairColor = request.HairColor;
                existing.PreviewImageName = request.PreviewImageName;
            }
            else
            {
                player.Player.PlayerExtra.SavedAvatars.Add(request);
            }

            PlayerDB.Players.Update(player);

            return Ok(new
            {
                success = true,
                slot = request.Slot,
                previewImageName = request.PreviewImageName,
                url = request.PreviewImageName != null ? $"{ServerConfig.BaseURL}/imageserver-v2/{request.PreviewImageName}" : null
            });
        }

        private static bool HasSavedOutfitState(PlayerDBClasses.SavedOutfit outfit)
        {
            return !string.IsNullOrWhiteSpace(outfit.OutfitSelections) ||
                   !string.IsNullOrWhiteSpace(outfit.FaceFeatures) ||
                   !string.IsNullOrWhiteSpace(outfit.SkinColor) ||
                   !string.IsNullOrWhiteSpace(outfit.HairColor);
        }

        private static void MigrateLegacyPhotoEntry(
            PlayerDBClasses.FullPlayer player,
            PlayerDBClasses.SavedOutfit entry)
        {
            string? path = NormalizeLegacyImagePath(entry.PreviewImageName);
            if (path == null)
                return;

            string? profilePath = NormalizeLegacyImagePath(player.Player?.ProfileImage);
            if (string.Equals(path, profilePath, StringComparison.OrdinalIgnoreCase))
                return;

            string fullPath = Path.Combine(
                Program.dataDir,
                "Images",
                path.Replace('/', Path.DirectorySeparatorChar));
            if (!System.IO.File.Exists(fullPath))
                return;

            RecNetDB.SavedImages.Upsert(new RecNetDB.SavedImage
            {
                PhotoPath = path,
                AccountId = player.PlayerId,
                SavedImageType = 1,
                Accessibility = 1,
                CreatedAt = System.IO.File.GetCreationTimeUtc(fullPath)
            });
        }

        private static string? NormalizeLegacyImagePath(string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return null;

            string clean = value.Trim().Replace('\\', '/');
            if (Uri.TryCreate(clean, UriKind.Absolute, out var uri))
            {
                string? marker = new[] { "/imageserver-v2/", "/imageserver/" }
                    .FirstOrDefault(candidate => uri.AbsolutePath.Contains(
                        candidate,
                        StringComparison.OrdinalIgnoreCase));
                if (marker == null)
                    return null;
                int markerIndex = uri.AbsolutePath.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
                clean = Uri.UnescapeDataString(uri.AbsolutePath[(markerIndex + marker.Length)..]);
            }

            clean = clean.TrimStart('/');
            if (!clean.Contains('/'))
                clean = $"PlayerImages/{Path.GetFileName(clean)}";

            string[] segments = clean.Split('/', StringSplitOptions.RemoveEmptyEntries);
            if (clean.Length > 260 || segments.Length == 0 ||
                clean.Any(char.IsControl) || clean.Contains(':') ||
                Path.IsPathRooted(clean) || segments.Any(segment => segment is "." or ".."))
            {
                return null;
            }

            string extension = Path.GetExtension(clean);
            if (!new[] { ".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp" }
                    .Contains(extension, StringComparer.OrdinalIgnoreCase))
            {
                return null;
            }

            return string.Join('/', segments);
        }

        [HttpGet("/api/PlayerReporting/v1/voteToKickReasons")]
        [HttpGet("/api/images/v2/named")]
        [HttpGet("/api/gamerewards/v1/pending")]
        [HttpGet("/api/roomkeys/v1/mine")]
        [HttpGet("/api/roomcurrencies/v1/currencies")]
        [HttpGet("/api/AppIntegrity/v1/iosproducts")]
        [HttpGet("/api/externalfriendinvite/v1/gettextmessagereferrers")]
        [HttpGet("/api/images/")]
        [HttpGet("/api/images")]
        [HttpGet("/api/incentivizedreferrals/")]
        [HttpGet("/api/incentivizedreferrals")]
        [HttpGet("/api/inventions/")]
        [HttpGet("/api/inventions")]
        [HttpGet("/api/inventions/v1/versions")]
        [HttpGet("/api/keepsakes")]
        [HttpGet("/api/keepsakes/events")]
        [HttpGet("/api/progressionEvents")]
        [HttpGet("/api/roomEarningsDistributions")]
        [HttpGet("/api/roomconsumables")]
        [HttpGet("/api/roomcurrencies")]
        [HttpGet("/api/roomkeys/")]
        [HttpGet("/api/roomkeys/v1/")]
        [HttpGet("/api/storefronts/")]
        [HttpGet("/api/storefronts")]
        [HttpGet("/api/storefronts/v1/objectives")]
        [HttpGet("/api/testcasemanagement/")]
        [HttpGet("/api/testcasemanagement/v1/testcase/")]
        [HttpGet("/api/testcasemanagement/v1/testplans")]
        [HttpGet("/api/testcasemanagement/v1/testpasssummary")]
        [HttpGet("/api/ugcPurchasables")]
        [HttpGet("/api/consumables/")]
        [HttpGet("/api/consumables")]
        public IActionResult TodoImplement()
        {
            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("/api/CampusCard/PS5RecRoomPlusEnabledForAllPlayers")]
        [HttpGet("/api/apple/musicpromotion/active")]
        [HttpGet("/api/playstationplus/membership")]
        [HttpGet("/api/roomkeys/v1/owns")]
        public IActionResult TodoImplementFalse() => Ok(false);

        [HttpGet("/api/roomcurrencies/v1/getBalance")]
        [HttpGet("/api/storefronts/v1/trialInvention/duration")]
        public IActionResult TodoImplementZero() => Ok(0);

        [HttpGet("/api/apple/musicpromotion/code")]
        [HttpGet("/api/inventions/v1/fulllineageowner")]
        [HttpGet("/api/royale/v1/current")]
        public IActionResult TodoImplementNull() => Ok(null);

        [HttpPost("/api/AppIntegrity/v1/iospaymentqueuefailed")]
        [HttpPost("/api/PlayerReporting/v1/instantKick")]
        [HttpPost("/api/PlayerReporting/v3/voteToKick")]
        [HttpPost("/api/checklist/v1/complete")]
        [HttpPost("/api/externalfriendinvite/v1/createplatforminvite")]
        [HttpPost("/api/externalfriendinvite/v1/sendtextmessageinvite")]
        [HttpPost("/api/gamerewards/v1/select")]
        [HttpPost("/api/incentivizedreferrals/claim")]
        [HttpPost("/api/inventions/v1/delete")]
        [HttpDelete("/api/inventions/v1/delete")]
        [HttpPost("/api/inventions/v1/dormskinsfromids")]
        [HttpPost("/api/inventions/v1/unpublish")]
        [HttpPost("/api/inventions/v1/updateprice")]
        [HttpPost("/api/inventions/v3/publish")]
        [HttpPost("/api/inventions/v4/addversion")]
        [HttpPost("/api/objectives/v1/completegroup")]
        [HttpPost("/api/objectives/v1/updateobjective")]
        [HttpPost("/api/playstationplus/expire")]
        [HttpPost("/api/roomconsumables/v1/roomConsumable/awardBulk")]
        [HttpPost("/api/roomcurrencies/v1/awardCurrency/bulk")]
        [HttpPost("/api/roomcurrencies/v1/createCurrency")]
        [HttpPost("/api/roomcurrencies/v1/createPurchaseOffer")]
        [HttpPost("/api/roomcurrencies/v1/deletePurchaseOffer")]
        [HttpPost("/api/roomcurrencies/v1/updateCurrency")]
        [HttpPost("/api/roomcurrencies/v1/updatePurchaseOffer")]
        [HttpPost("/api/roomkeys/v1/awardbulk")]
        [HttpPost("/api/roomkeys/v1/create")]
        [HttpPost("/api/roomkeys/v1/revoke")]
        [HttpPost("/api/royale/v2/matchcomplete")]
        [HttpPost("/api/storefronts/v1/PurchaseRoomKeyWithCurrency")]
        [HttpPost("/api/storefronts/v1/buyForFreeGiftButton")]
        [HttpPost("/api/storefronts/v1/buyProgressionEventXpBoost")]
        [HttpPost("/api/storefronts/v1/buyPurchaseReminder")]
        [HttpPost("/api/storefronts/v1/buyRoomKey")]
        [HttpPost("/api/storefronts/v1/trialInvention")]
        [HttpPost("/api/storefronts/v2/buyElite")]
        [HttpPost("/api/storefronts/v2/buyTier")]
        [HttpPost("/api/roomconsumables/v1/roomconsumable/{skuId}/purchase/currency")]
        public IActionResult AckOnly()
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();
            return Ok(new { success = true });
        }

        [HttpGet("/api/roomcurrencies/v1/getPurchaseOffersBatch")]
        [HttpPost("/api/roomcurrencies/v1/getPurchaseOffersBatch")]
        [HttpPost("/api/roomkeys/v1/owns/bulk")]
        public IActionResult AckOnlyEmptyList()
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();
            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("/api/avatar/v2/gifts")]
        public IActionResult GetPendingGiftPackages()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            List<GiftPackage> pendingGifts =
                PlayerDB.GetPendingGiftPackages(playerId.Value);
            object[] gifts = pendingGifts
                .Select(gift => ToClientGiftPackage(gift, playerId.Value))
                .ToArray();
            string packageSummary = string.Join(",", pendingGifts.Select(gift =>
                $"{gift.GiftPackageId}:from{NormalizeGiftSenderId(gift.FromPlayerId, playerId.Value)}:" +
                GiftKind(gift)));

            Console.WriteLine(
                $"[GIFTS] pending player={playerId.Value} count={gifts.Length} " +
                $"packages=[{packageSummary}]");
            return Ok(gifts);
        }

        [HttpPost("/api/avatar/v2/gifts/consume")]
        [HttpPost("/api/avatar/v2/gifts/consume/")]
        [RequestSizeLimit(32 * 1024)]
        public async Task<IActionResult> ConsumeGiftPackage()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            long? giftPackageId = await ReadGiftPackageIdAsync();
            if (!giftPackageId.HasValue || giftPackageId.Value <= 0)
            {
                return BadRequest(new
                {
                    Success = false,
                    Error = "missing_gift_package_id"
                });
            }

            GiftPackage? consumed = PlayerDB.ConsumeGiftPackage(
                playerId.Value,
                giftPackageId.Value);

            if (consumed == null)
            {
                return NotFound(new
                {
                    Success = false,
                    Error = "gift_package_not_found"
                });
            }

            List<GiftPackage> remaining =
                PlayerDB.GetPendingGiftPackages(playerId.Value);
            await NotiController.NotifyGiftConsumedAsync(
                playerId.Value,
                consumed.GiftPackageId,
                remaining);

            Console.WriteLine(
                $"[GIFTS] consumed player={playerId.Value} " +
                $"gift={consumed.GiftPackageId} remaining={remaining.Count}");

            return Ok(ToClientGiftPackage(consumed, playerId.Value));
        }

        private static object ToClientGiftPackage(
            GiftPackage gift,
            long recipientPlayerId)
        {
            return new
            {
                AvatarItemDesc = EmptyIfWhiteSpace(gift.AvatarItemDesc),
                AvatarItemType = 0,
                BalanceType = gift.BalanceType ??
                    (int)BalanceType.NonPurchasedNotUsableInP2P,
                ConsumableItemDesc = EmptyIfWhiteSpace(gift.ConsumableItemDesc),
                Currency = gift.Currency,
                CurrencyType = gift.CurrencyType,
                EquipmentModificationGuid =
                    EmptyIfWhiteSpace(gift.EquipmentModificationGuid),
                EquipmentPrefabName =
                    EmptyIfWhiteSpace(gift.EquipmentPrefabName),
                FromGiftDropId = 0,
                FromPlayerId = NormalizeGiftSenderId(
                    gift.FromPlayerId,
                    recipientPlayerId),
                GiftContext = NormalizeGiftContext(gift.GiftContext),
                GiftRarity = gift.Rarity,
                Id = gift.GiftPackageId,
                Level = 0,
                Message = gift.Message ?? string.Empty,
                Platform = gift.Platform,
                PlatformsToSpawnOn = gift.PlatformMask,
                Xp = gift.XP
            };
        }

        private static int NormalizeGiftSenderId(
            int senderId,
            long recipientPlayerId)
        {

            if (senderId > 0 && senderId == recipientPlayerId)
                return recipientPlayerId == 1 ? 2 : 1;
            return senderId;
        }

        private static int NormalizeGiftContext(int context) =>
            context is (int)PlayerDBClasses.GiftContext.Default
                or (int)PlayerDBClasses.GiftContext.Store_RecCenter
                ? (int)PlayerDBClasses.GiftContext.Game_Drop
                : context;

        private static string GiftKind(GiftPackage gift) =>
            gift.Currency != 0 ? "tokens" :
            gift.XP > 0 ? "xp" :
            !string.IsNullOrWhiteSpace(gift.ConsumableItemDesc) ? "consumable" :
            !string.IsNullOrWhiteSpace(gift.EquipmentModificationGuid) ? "equipment" :
            !string.IsNullOrWhiteSpace(gift.AvatarItemDesc) ? "avatar" :
            "empty";

        private static string EmptyIfWhiteSpace(string? value) =>
            string.IsNullOrWhiteSpace(value) ? string.Empty : value;

        private async Task<long?> ReadGiftPackageIdAsync()
        {
            string[] names =
            {
                "GiftPackageId",
                "giftPackageId",
                "PackageId",
                "packageId",
                "Id",
                "id"
            };

            foreach (string name in names)
            {
                if (long.TryParse(
                        Request.Query[name].FirstOrDefault(),
                        out long queryValue))
                {
                    return queryValue;
                }
            }

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();
                foreach (string name in names)
                {
                    if (long.TryParse(
                            form[name].FirstOrDefault(),
                            out long formValue))
                    {
                        return formValue;
                    }
                }

                return null;
            }

            if (!Request.Body.CanRead ||
                ((Request.ContentLength ?? 0) <= 0 &&
                 Request.Headers.TransferEncoding.Count == 0))
            {
                return null;
            }

            try
            {
                using JsonDocument document =
                    await JsonDocument.ParseAsync(Request.Body);
                return FindJsonLong(document.RootElement, names);
            }
            catch (JsonException)
            {
                return null;
            }
        }

        [HttpGet("/api/consumables/v2/getUnlocked")]
        public IActionResult GetUnlockedConsumables()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            Response.Headers.CacheControl = "no-store, no-cache, must-revalidate";
            Response.Headers.Pragma = "no-cache";
            Response.Headers.Expires = "0";

            PlayerInventoryStore.EnsureConsumablesInitialized(accountId.Value);
            return GetNormalizedConsumables(accountId.Value);
        }

        [HttpGet("/cdn/config/LoadingScreenTipData")]
        public IActionResult GetLoadingScreenTipData()
        {
            return GetLoadingScreenData();
        }

        [HttpGet("/api/playerevents/v1")]
        [HttpGet("/api/playerevents/v1/all")]
        public IActionResult GetAllPlayerEvents()
        {
            return Ok(new
            {
                Created = Array.Empty<object>(),
                Responses = Array.Empty<object>()
            });
        }

        [HttpGet("/api/customAvatarItems/v1/isCreationAllowedForAccount")]
        public IActionResult GetCustomAvatarItemsIsCreationAllowedForAccount()
        {
            return Ok(new
            {
                success = true,
                value = (object?)null
            });
        }

        [HttpGet("/api/influencerpartnerprogram/myinfluencer")]
        [HttpGet("/api/influencerpartnerprogram/v1/myinfluencer")]
        public IActionResult GetMySupportedInfluencer()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            FullPlayer? account = PlayerDB.Players.FindById(accountId.Value);
            int supportedInfluencerId = account?.Player?.SupportedInfluencerId ?? 0;

            Console.WriteLine(
                $"[INFLUENCER MY] account={accountId.Value} " +
                $"supported={supportedInfluencerId}");

            return Ok(supportedInfluencerId);
        }

        [HttpGet("/api/influencerpartnerprogram/influencer")]
        [HttpGet("/api/influencerpartnerprogram/v1/influencer")]
        public IActionResult GetSupportedInfluencer(
            [FromQuery] int accountId)
        {
            if (accountId <= 0)
                return Content("null", "application/json");

            FullPlayer? account = PlayerDB.Players.FindById((long)accountId);
            int supportedInfluencerId = account?.Player?.SupportedInfluencerId ?? 0;

            Console.WriteLine(
                $"[INFLUENCER GET] account={accountId} " +
                $"supported={supportedInfluencerId}");

            return Ok(supportedInfluencerId);
        }

        [HttpGet("/api/influencerpartnerprogram/isinfluencer")]
        [HttpGet("/api/influencerpartnerprogram/accountisinfluencer")]
        [HttpGet("/api/influencerpartnerprogram/v1/isinfluencer")]
        public IActionResult GetAccountIsInfluencer(
            [FromQuery] int accountId)
        {
            if (accountId <= 0)
                return Ok(false);

            FullPlayer? account = PlayerDB.Players.FindById((long)accountId);
            bool isInfluencer = account?.PlayerRoles?.Contains(
                PlayerDBClasses.PlayerRoles.Influencer) == true;

            Console.WriteLine(
                $"[INFLUENCER CHECK] account={accountId} " +
                $"isInfluencer={isInfluencer}");

            return Ok(isInfluencer);
        }

        [HttpPost("/api/influencerpartnerprogram/support")]
        [HttpPost("/api/influencerpartnerprogram/support/{influencerAccountId:int}")]
        public async Task<IActionResult> SupportInfluencer(
            [FromRoute] int? influencerAccountId = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            int? requestedInfluencerId =
                await ReadInfluencerAccountIdAsync(influencerAccountId);

            if (!requestedInfluencerId.HasValue)
            {
                return BadRequest(new
                {
                    error = "missing_influencer_account_id"
                });
            }

            if (requestedInfluencerId.Value == 0)
                return SetSupportedInfluencer(accountId.Value, 0);

            if (requestedInfluencerId.Value < 0)
            {
                return BadRequest(new
                {
                    error = "invalid_influencer_account_id"
                });
            }

            if (accountId.Value == requestedInfluencerId.Value)
            {
                return BadRequest(new
                {
                    error = "cannot_support_self"
                });
            }

            FullPlayer? influencer =
                PlayerDB.Players.FindById((long)requestedInfluencerId.Value);

            if (influencer?.Player == null ||
                influencer.PlayerRoles?.Contains(
                    PlayerDBClasses.PlayerRoles.Influencer) != true)
            {
                return NotFound(new
                {
                    error = "influencer_not_found"
                });
            }

            return SetSupportedInfluencer(
                accountId.Value,
                requestedInfluencerId.Value);
        }

        [HttpDelete("/api/influencerpartnerprogram/support")]
        [HttpDelete("/api/influencerpartnerprogram/support/{influencerAccountId:int}")]
        [HttpPost("/api/influencerpartnerprogram/unsupport")]
        [HttpPost("/api/influencerpartnerprogram/remove")]
        public IActionResult RemoveSupportedInfluencer(
            [FromRoute] int? influencerAccountId = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            return SetSupportedInfluencer(accountId.Value, 0);
        }

        private IActionResult SetSupportedInfluencer(
            long accountId,
            int supportedInfluencerId)
        {
            FullPlayer? account = PlayerDB.Players.FindById(accountId);
            if (account?.Player == null)
                return NotFound(new { error = "account_not_found" });

            account.Player.SupportedInfluencerId = supportedInfluencerId;

            if (!PlayerDB.Players.Update(account))
            {
                return StatusCode(
                    StatusCodes.Status500InternalServerError,
                    new { error = "support_update_failed" });
            }

            Console.WriteLine(
                $"[INFLUENCER SUPPORT] supporter={accountId} " +
                $"influencer={supportedInfluencerId} persisted=true");

            return Ok(new
            {
                Value = true,
                Success = true,
                ErrorId = (string?)null,
                Error = (string?)null,
                LocalizationContext = (object?)null,
                InfluencerAccountId = supportedInfluencerId,
                SupportedInfluencerId = supportedInfluencerId
            });
        }

        private async Task<int?> ReadInfluencerAccountIdAsync(
            int? routeInfluencerAccountId)
        {
            if (routeInfluencerAccountId.HasValue)
                return routeInfluencerAccountId.Value;

            string[] names =
            {
                "influencerAccountId",
                "InfluencerAccountId",
                "accountId",
                "AccountId",
                "id",
                "Id"
            };

            foreach (string name in names)
            {
                if (int.TryParse(
                        Request.Query[name].FirstOrDefault(),
                        out int queryValue))
                {
                    return queryValue;
                }
            }

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync(
                    HttpContext.RequestAborted);

                foreach (string name in names)
                {
                    if (int.TryParse(
                            form[name].FirstOrDefault(),
                            out int formValue))
                    {
                        return formValue;
                    }
                }

                return null;
            }

            if (!Request.Body.CanRead ||
                ((Request.ContentLength ?? 0) <= 0 &&
                 Request.Headers.TransferEncoding.Count == 0))
            {
                return null;
            }

            using var reader = new StreamReader(
                Request.Body,
                Encoding.UTF8,
                detectEncodingFromByteOrderMarks: true,
                bufferSize: 4_096,
                leaveOpen: true);

            string rawBody = await reader.ReadToEndAsync(
                HttpContext.RequestAborted);
            rawBody = rawBody.Trim();

            if (rawBody.Length == 0)
                return null;

            if (int.TryParse(rawBody.Trim('"'), out int rawValue))
                return rawValue;

            try
            {
                using JsonDocument document = JsonDocument.Parse(rawBody);
                JsonElement root = document.RootElement;

                if (root.ValueKind == JsonValueKind.Number &&
                    root.TryGetInt32(out int numberValue))
                {
                    return numberValue;
                }

                if (root.ValueKind == JsonValueKind.String &&
                    int.TryParse(root.GetString(), out int stringValue))
                {
                    return stringValue;
                }

                return FindJsonInt(root, names);
            }
            catch (JsonException)
            {
                return null;
            }
        }

        [HttpPost("/api/consumables/v1/consume")]
        public async Task<IActionResult> ConsumeConsumable()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            JsonElement? request = null;
            try
            {
                if (Request.Body.CanRead &&
                    ((Request.ContentLength ?? 0) > 0 ||
                     Request.Headers.TransferEncoding.Count > 0))
                {
                    using JsonDocument document =
                        await JsonDocument.ParseAsync(
                            Request.Body,
                            cancellationToken: HttpContext.RequestAborted);
                    request = document.RootElement.Clone();
                }
            }
            catch (JsonException)
            {

            }

            long? consumableId = request.HasValue
                ? FindJsonLong(request.Value, "Id", "id")
                : null;
            long? requestedDelta = request.HasValue
                ? FindJsonLong(
                    request.Value,
                    "DeltaCount",
                    "deltaCount")
                : null;
            int delta = requestedDelta is > 0 and <= int.MaxValue
                ? (int)requestedDelta.Value
                : 1;

            string disposition = "missing_id";
            int? loggedPreviousQuantity = null;
            int? loggedRemainingQuantity = null;
            if (consumableId is > 0)
            {
                bool resolved = TryGetConsumableInfo(
                    consumableId.Value,
                    out string descriptor,
                    out string friendlyName,
                    out bool isHairDye,
                    out string createdAt);

                if (!resolved)
                {
                    resolved = TryGetOwnedConsumableInfo(
                        accountId.Value,
                        consumableId.Value,
                        out descriptor,
                        out friendlyName,
                        out isHairDye,
                        out createdAt);
                }

                if (resolved)
                {
                    bool consumed = PlayerInventoryStore.TryConsumeConsumable(
                        accountId.Value,
                        descriptor,
                        consumableId.Value,
                        delta,
                        out int previousQuantity,
                        out int remainingQuantity);

                    disposition = consumed ? "consumed" : "already_spent";
                    if (consumed)
                    {
                        loggedPreviousQuantity = previousQuantity;
                        loggedRemainingQuantity = remainingQuantity;

                        if (isHairDye)
                        {
                            PlayerDB.SetPlayerSetting(
                                $"Avatar.HairDye.{descriptor}",
                                "True",
                                accountId.Value);

                            Console.WriteLine(
                                $"[HAIR DYE CONSUME] player={accountId.Value} " +
                                $"id={consumableId.Value} name={friendlyName} " +
                                $"desc={descriptor}");
                        }

                        if (remainingQuantity <= 0)
                        {
                            await NotiController.NotifyConsumableRemovedAsync(
                                accountId.Value,
                                consumableId.Value,
                                descriptor,
                                createdAt,
                                previousQuantity,
                                remainingQuantity);
                        }
                    }
                }
                else
                {
                    disposition = "unknown_id";
                }
            }

            Console.WriteLine(
                $"[CONSUMABLE CONSUME] player={accountId.Value} " +
                $"id={consumableId?.ToString() ?? "none"} delta={delta} " +
                $"result={disposition} " +
                $"before={loggedPreviousQuantity?.ToString() ?? "n/a"} " +
                $"remaining={loggedRemainingQuantity?.ToString() ?? "n/a"}");

            return Ok(new
            {
                error = string.Empty,
                success = true,
                value = (object?)null
            });
        }

        private static bool TryGetConsumableInfo(
            long consumableId,
            out string descriptor,
            out string friendlyName,
            out bool isHairDye,
            out string createdAt)
        {
            descriptor = string.Empty;
            friendlyName = string.Empty;
            isHairDye = false;
            createdAt = "2023-04-06T00:00:00.0000000Z";

            string path = Path.Combine(
                Program.dataDir,
                "APIS",
                "Items",
                "Consumables.json");

            if (!System.IO.File.Exists(path))
                return false;

            try
            {
                JsonNode? root = JsonNode.Parse(System.IO.File.ReadAllText(path));
                if (root is not JsonArray items)
                    return false;

                foreach (JsonNode? node in items)
                {
                    if (node is not JsonObject item)
                    {
                        continue;
                    }

                    List<long> ids = ReadConsumableIds(item);
                    int mappingIndex = ids.IndexOf(consumableId);
                    if (mappingIndex < 0)
                        continue;

                    friendlyName = ReadString(item, "FriendlyName") ?? string.Empty;
                    descriptor = ReadString(item, "ConsumableItemDesc") ?? string.Empty;
                    if (string.IsNullOrWhiteSpace(descriptor))
                        descriptor = $"legacy-consumable-{consumableId}";
                    isHairDye = IsHairDyeFriendlyName(friendlyName);
                    List<string> createdAts = ReadConsumableCreatedAts(item);
                    createdAt = mappingIndex < createdAts.Count
                        ? createdAts[mappingIndex]
                        : NormalizeConsumableTimestamp(
                            ReadString(item, "CreatedAt"))
                          ?? createdAt;
                    return true;
                }
            }
            catch (Exception ex) when (ex is JsonException or IOException)
            {
                Console.WriteLine(
                    $"[CONSUMABLE LOOKUP] Could not read Consumables.json: {ex.Message}");
            }

            return false;
        }

        private static bool TryGetOwnedConsumableInfo(
            long accountId,
            long consumableId,
            out string descriptor,
            out string friendlyName,
            out bool isHairDye,
            out string createdAt)
        {
            descriptor = string.Empty;
            friendlyName = string.Empty;
            isHairDye = false;
            createdAt = "2023-04-06T00:00:00.0000000Z";

            try
            {
                PlayerInventoryStore.ConsumableOwnership? owned =
                    PlayerInventoryStore.GetConsumables(accountId)
                        .FirstOrDefault(item =>
                            item.ConsumableItemId == consumableId &&
                            item.Quantity > 0);

                if (owned == null)
                    return false;

                descriptor = string.IsNullOrWhiteSpace(owned.ConsumableItemDesc)
                    ? $"legacy-consumable-{consumableId}"
                    : owned.ConsumableItemDesc.Trim();
                friendlyName = string.IsNullOrWhiteSpace(owned.FriendlyName)
                    ? descriptor
                    : owned.FriendlyName.Trim();
                isHairDye = IsHairDyeFriendlyName(friendlyName);

                Console.WriteLine(
                    $"[CONSUMABLE LOOKUP] player={accountId} id={consumableId} " +
                    "source=owned_inventory_fallback");
                return true;
            }
            catch (Exception ex) when (ex is JsonException or IOException)
            {
                Console.WriteLine(
                    $"[CONSUMABLE LOOKUP] Could not read player inventory: {ex.Message}");
                return false;
            }
        }

        private static bool TryGetHairDyeDescriptor(
            long consumableId,
            out string descriptor,
            out string friendlyName)
        {
            descriptor = string.Empty;
            friendlyName = string.Empty;

            string path = Path.Combine(
                Program.dataDir,
                "APIS",
                "Items",
                "Consumables.json");

            if (!System.IO.File.Exists(path))
                return false;

            try
            {
                JsonNode? root = JsonNode.Parse(System.IO.File.ReadAllText(path));
                if (root is not JsonArray items)
                    return false;

                foreach (JsonNode? node in items)
                {
                    if (node is not JsonObject item ||
                        !ReadConsumableIds(item).Contains(consumableId))
                    {
                        continue;
                    }

                    friendlyName = ReadString(item, "FriendlyName") ?? string.Empty;
                    if (!IsHairDyeFriendlyName(friendlyName))
                        return false;

                    descriptor = ReadString(item, "ConsumableItemDesc") ?? string.Empty;
                    return !string.IsNullOrWhiteSpace(descriptor);
                }
            }
            catch (JsonException ex)
            {
                Console.WriteLine(
                    $"[HAIR DYE CONSUME] Could not parse Consumables.json: {ex.Message}");
            }
            catch (IOException ex)
            {
                Console.WriteLine(
                    $"[HAIR DYE CONSUME] Could not read Consumables.json: {ex.Message}");
            }

            return false;
        }

        [HttpGet("/api/storefronts/v4/balance/{currencyType:int}")]
        public IActionResult GetStorefrontBalance(int currencyType)
        {
            var accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            if (!Enum.IsDefined(typeof(CurrencyType), currencyType))
                return BadRequest(new { error = "invalid_currency" });

            var parsedCurrency = (CurrencyType)currencyType;
            int balance = PlayerDB.GetCurrencyBalance(
                accountId.Value,
                parsedCurrency);
            int balanceType = (int)BalanceType.NonPurchasedDefault;

            return Ok(new[]
            {
                new
                {
                    Balance = (long)balance,
                    CurrencyType = currencyType,
                    BalanceType = balanceType
                }
            });
        }

        [HttpPost("/api/storefronts/v2/balance")]
        public async Task<IActionResult> GetStorefrontBalancesV2()
        {
            var accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            HashSet<long> requestedTypes = await ReadLongValuesAsync(
                "currencyType", "CurrencyType",
                "currencyTypes", "CurrencyTypes",
                "type", "Type");

            int balanceType = (int)BalanceType.NonPurchasedDefault;

            IEnumerable<CurrencyType> typesToReturn = requestedTypes.Count > 0
                ? requestedTypes
                    .Where(value => Enum.IsDefined(typeof(CurrencyType), (int)value))
                    .Select(value => (CurrencyType)value)
                    .Distinct()
                : PlayerDB.GetAllCurrencyBalances(accountId.Value)
                    .Select(entry => entry.CurrencyType);

            var balances = typesToReturn
                .Select(currency => new
                {
                    Balance = (long)PlayerDB.GetCurrencyBalance(accountId.Value, currency),
                    CurrencyType = (int)currency,
                    BalanceType = balanceType
                })
                .ToArray();

            return Ok(balances);
        }

        [HttpGet("/api/storefronts/v1/balanceAddType/{currencyType:int}/{balanceAddType:int}")]
        public IActionResult GetStorefrontBalanceByAddType(
            int currencyType,
            int balanceAddType)
        {
            var account = AuthStuff.GetCurrentPlayer(Request);
            if (account?.Player == null)
                return Unauthorized();

            if (!Enum.IsDefined(typeof(CurrencyType), currencyType) ||
                !Enum.IsDefined(typeof(BalanceType), balanceAddType))
            {
                return BadRequest(new { error = "invalid_balance_type" });
            }

            int totalBalance = PlayerDB.GetCurrencyBalance(
                account.PlayerId,
                (CurrencyType)currencyType);
            bool isPlayStation = account.PlatformIds?.Any(platform =>
                platform.Platform == Platforms.PlayStation) == true;

            int applicableBalanceType = (int)(isPlayStation
                ? BalanceType.PlayStationNonPurchasedP2P
                : BalanceType.NonPlayStationNonPurchasedP2P);
            long balance = balanceAddType == applicableBalanceType
                ? totalBalance
                : 0L;

            return Ok(new
            {
                Balance = balance,
                CurrencyType = currencyType,
                BalanceType = balanceAddType,
                BalanceAddType = balanceAddType
            });
        }

        [HttpGet("/subscription/subscriberCount/{accountId}")]
        public IActionResult GetSubscriberCount(long accountId)
        {

            return Ok(PlayerDB.GetSubscriberCount(accountId));
        }

        [HttpGet("/subscription/details/{accountId:long}")]
        public IActionResult GetSubscriptionDetails(long accountId)
        {
            if (accountId <= 0 || accountId > int.MaxValue)
            {
                return BadRequest(new
                {
                    error = "invalid_account_id"
                });
            }

            int subscriberCount = PlayerDB.GetSubscriberCount(accountId);
            Console.WriteLine(
                $"[SUBSCRIPTION DETAILS] account={accountId} " +
                $"club=0 subscribers={subscriberCount}");

            return Ok(new
            {
                accountId,
                clubId = 0,
                subscriberCount
            });
        }

        [HttpGet("/subscription/details/{subscription}")]
        public IActionResult GetNamedSubscriptionDetails(string subscription)
        {
            Console.WriteLine(
                $"[SUBSCRIPTION DETAILS] name={subscription} simulated=empty");

            return Content("{}", "application/json");
        }

        [HttpPost("/subscription/{accountId:long}")]
        [HttpPut("/subscription/{accountId:long}")]
        [HttpPost("/subscription/{accountId:long}/subscribe")]
        [HttpPut("/subscription/{accountId:long}/subscribe")]
        public IActionResult SubscribeToPlayer(long accountId)
        {
            var subscriberId = AuthStuff.GetPlayerId(Request);
            if (subscriberId == null)
                return Unauthorized();

            if (!PlayerDB.SetSubscription(
                    (long)subscriberId,
                    accountId,
                    subscribe: true))
                return BadRequest(new { success = false, error = "invalid_player" });

            return Ok(new
            {
                AccountId = accountId,
                SubscriberId = subscriberId,
                IsSubscribed = true,
                Subscribed = true,
                SubscriberCount = PlayerDB.GetSubscriberCount(accountId)
            });
        }

        [HttpDelete("/subscription/{accountId:long}")]
        [HttpDelete("/subscription/{accountId:long}/unsubscribe")]
        [HttpPost("/subscription/{accountId:long}/unsubscribe")]
        [HttpPut("/subscription/{accountId:long}/unsubscribe")]
        public IActionResult UnsubscribeFromPlayer(long accountId)
        {
            var subscriberId = AuthStuff.GetPlayerId(Request);
            if (subscriberId == null)
                return Unauthorized();

            if (!PlayerDB.SetSubscription(
                    (long)subscriberId,
                    accountId,
                    subscribe: false))
                return BadRequest(new { success = false, error = "invalid_player" });

            return Ok(new
            {
                AccountId = accountId,
                SubscriberId = subscriberId,
                IsSubscribed = false,
                Subscribed = false,
                SubscriberCount = PlayerDB.GetSubscriberCount(accountId)
            });
        }

        [HttpGet("/subscription/{accountId:long}")]
        [HttpGet("/subscription/{accountId:long}/status")]
        [HttpGet("/subscription/subscribed/{accountId:long}")]
        public IActionResult GetPlayerSubscription(long accountId)
        {
            var subscriberId = AuthStuff.GetPlayerId(Request);
            if (subscriberId == null)
                return Unauthorized();

            bool subscribed = PlayerDB.IsSubscribed(
                (long)subscriberId,
                accountId);
            return Ok(new
            {
                AccountId = accountId,
                SubscriberId = subscriberId,
                IsSubscribed = subscribed,
                Subscribed = subscribed,
                SubscriberCount = PlayerDB.GetSubscriberCount(accountId)
            });
        }

        [HttpGet("/api/customAvatarItems/v2/fromCreator/{creatorId}")]
        public IActionResult GetCustomAvatarItemsFromCreator(long creatorId)
        {
            List<JsonObject> items = LoadCustomAvatarItems(creatorId);
            return Ok(new
            {
                CreatorId = creatorId,
                Results = items,
                TotalResults = items.Count
            });
        }

        [HttpGet("/api/customAvatarItems/v1/isCreationEnabled")]
        [HttpGet("/api/customAvatarItems/v1/isRenderingEnabled")]
        public IActionResult CustomAvatarItemsIsEnabled()
        {
            return Ok(true);
        }

        [HttpGet("/api/roomconsumables/v1/roomConsumable/room/{roomId}")]
        public IActionResult GetRoomConsumablesForRoom(long roomId)
        {

            Console.WriteLine(
                $"[ROOM CONSUMABLES] room={roomId} definitions=0 compatibility=april-2023");

            return Ok(Array.Empty<object>());
        }

        [HttpGet("/api/roomconsumables/v1/roomConsumable/room/{roomId}/me")]
        public IActionResult GetRoomConsumablesForRoomMe(long roomId)
        {

            long? accountId = AuthStuff.GetPlayerId(Request);

            Console.WriteLine(
                $"[ROOM CONSUMABLES] room={roomId} account={accountId?.ToString() ?? "unknown"} " +
                "inventory=0 compatibility=april-2023");

            return Ok(Array.Empty<object>());
        }

        [HttpPost("/api/sanitize/v1")]
        public IActionResult SanitizeV1([FromBody] SanitizeRequest request)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id != null)
            {
                var player = PlayerDB.Players.FindById((long)id);
                var username = player?.Player?.Username;
                var severity = ProfanityFilter.GetSeverity(request.Value);

                switch (severity)
                {
                    case ProfanitySeverity.SevereBypass:
                        PlayerDB.BanPlayer((long)id, 2147483647, "Attempted to bypass filter with slur/severe language");
                        DiscordLogger.LogSanitize($"🔨 **PERMA BANNED** — `{username ?? "unknown"}` (ID: `{id}`) tried to bypass filter: {request.Value}");
                        break;

                    case ProfanitySeverity.Severe:
                        PlayerDB.BanPlayer((long)id, 1814400, "Slur/severe language");
                        DiscordLogger.LogSanitize($"🔨 **3 WEEK BAN** — `{username ?? "unknown"}` (ID: `{id}`) said: {request.Value}");
                        break;

                    default:
                        DiscordLogger.LogSanitizeChat((long)id, request.Value, username);
                        break;
                }
            }

            var cleaned = ProfanityFilter.Blur(request.Value);
            return Ok(JsonSerializer.Serialize(cleaned));
        }

        [HttpPost("/api/sanitize/v1/isPure")]
        public IActionResult SanitizeV1IsPure()
        {
            return Ok(new
            {
                IsPure = true
            });
        }

        [HttpGet("/api/AppIntegrity/v1/token")]
        [HttpPost("/api/AppIntegrity/v1/verify")]
        public IActionResult AppIntegrityStub()
        {
            return Ok(new { valid = true });
        }

        [HttpGet("/api/PlayersBanned/v1/check/{accountId}")]
        public IActionResult PlayersBannedCheck(long accountId)
        {
            bool isBanned = PlayerDB.IsPlayerBanned(accountId, out var details);

            return Ok(new
            {
                accountId,
                isBanned,
                banExpiresAt = isBanned ? DateTimeOffset.FromUnixTimeSeconds(details!.ModerationSetUnixTime + details.Duration).UtcDateTime : (DateTime?)null,
                reason = isBanned ? details!.Message : (string?)null
            });
        }

        [HttpGet("/api/challenge/v1/current")]
        [HttpGet("/api/challenge/v1/all")]
        public IActionResult ChallengeStub()
        {
            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("/api/communityboard/v1/get")]
        public IActionResult CommunityBoardStub()
        {
            return Ok(new
            {
                Results = Array.Empty<object>(),
                TotalResults = 0
            });
        }

        [HttpGet("/api/communityboard/v2/current")]
        public IActionResult CommunityBoardCurrent()
        {
            string path = Path.Combine(Program.dataDir, "communityboard.json");

            if (!System.IO.File.Exists(path))
            {
                string defaultJson = @"{
                ""Id"": 1,
                ""Title"": ""Community Board"",
                ""Posts"": []
            }";
                System.IO.File.WriteAllText(path, defaultJson);
                Console.WriteLine($"[CommunityBoard] No communityboard.json found, created default template at {path}");
            }

            try
            {
                string rewritten = LoadingScreenImageService.RewriteConfiguration(
                    System.IO.File.ReadAllText(path));
                return Content(rewritten, "application/json");
            }
            catch (Exception ex) when (ex is IOException or JsonException)
            {
                Console.WriteLine($"[CommunityBoard] Could not rewrite image URLs: {ex.Message}");
                return Content(System.IO.File.ReadAllText(path), "application/json");
            }
        }

        [HttpPost("/api/communityboard/v2/current")]
        [HttpPut("/api/communityboard/v2/current")]
        [RequestSizeLimit(256 * 1024)]
        public async Task<IActionResult> SetCommunityBoardCurrent([FromBody] JsonElement request)
        {
            var player = AuthStuff.GetCurrentPlayer(Request);
            if (player?.Player == null)
                return Unauthorized();
            if (player.PlayerRoles?.Any(role =>
                    role is PlayerDBClasses.PlayerRoles.Developer or
                        PlayerDBClasses.PlayerRoles.Moderator) != true)
                return StatusCode(403);

            string path = Path.Combine(Program.dataDir, "communityboard.json");
            string json = JsonSerializer.Serialize(request, new JsonSerializerOptions { WriteIndented = true });
            System.IO.File.WriteAllText(path, json);
            await NotiController.BroadcastAnnouncementsUpdatedAsync();

            try
            {
                string rewritten = LoadingScreenImageService.RewriteConfiguration(json);
                return Content(rewritten, "application/json");
            }
            catch (JsonException ex)
            {
                Console.WriteLine($"[CommunityBoard] Saved board but could not rewrite image URLs: {ex.Message}");
                return Ok(request);
            }
        }

        [HttpPost("/api/externalfriendinvite/v1/send")]
        public IActionResult ExternalFriendInviteStub()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new { success = true });
        }

        [HttpPost("/api/gamesight/v1/event")]
        public IActionResult GamesightStub()
        {
            return Ok();
        }

        [HttpGet("/api/incentivizedreferrals/v1/status")]
        public IActionResult IncentivizedReferralsStub()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new
            {
                referralCode = (string?)null,
                referralsCompleted = 0,
                rewardsAvailable = Array.Empty<object>()
            });
        }

        [HttpGet("/api/keepsakes/v1/mine")]
        [HttpGet("/api/keepsakes/mine")]
        public IActionResult KeepsakesStub()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new
            {
                KeepsakeInstances = Array.Empty<object>(),
                CollectionRecords = Array.Empty<object>(),
                CollectedKeepsakeIds = Array.Empty<long>()
            });
        }

        [HttpGet("/api/itemWishlists/v1/wishlist/me")]
        public IActionResult ItemWishlistMe()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(CreateWishlistItems(id.Value));
        }

        [HttpPut("/api/itemWishlists/v1/wishlist/me/{purchasableItemId:int}")]
        public IActionResult AddItemToWishlist(int purchasableItemId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            if (!PlayerDB.SetWishlistItem(id.Value, purchasableItemId, wished: true))
                return BadRequest(new { success = false, error = "wishlist_limit_or_invalid_item" });

            return Ok(new
            {
                WishlistItemId = DeterministicWishlistId(id.Value, purchasableItemId),
                AccountId = id.Value,
                PurchasableItemId = purchasableItemId,
                CreatedAt = DateTime.UtcNow
            });
        }

        [HttpDelete("/api/itemWishlists/v1/wishlist/me/{purchasableItemId:int}")]
        public IActionResult RemoveItemFromWishlist(int purchasableItemId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            PlayerDB.SetWishlistItem(id.Value, purchasableItemId, wished: false);
            return Ok(new
            {
                success = true,
                AccountId = id.Value,
                PurchasableItemId = purchasableItemId
            });
        }

        [HttpGet("/api/itemWishlists/v1/wishlist/{accountId:long}")]
        public IActionResult GetAccountWishlist(long accountId)
        {
            if (PlayerDB.Players.FindById(accountId) == null)
                return NotFound();
            return Ok(CreateWishlistItems(accountId));
        }

        private static object[] CreateWishlistItems(long accountId) =>
            PlayerDB.GetWishlist(accountId)
                .Select(purchasableItemId => (object)new
                {
                    WishlistItemId = DeterministicWishlistId(accountId, purchasableItemId),
                    AccountId = accountId,
                    PurchasableItemId = purchasableItemId,
                    CreatedAt = DateTime.UnixEpoch
                })
                .ToArray();

        private static Guid DeterministicWishlistId(long accountId, int itemId)
        {
            byte[] bytes = System.Security.Cryptography.MD5.HashData(
                Encoding.UTF8.GetBytes($"wishlist:{accountId}:{itemId}"));
            return new Guid(bytes);
        }

        [HttpPost("/api/offlineinvite/v1/send")]
        [HttpPost("/api/offlineinvite/send")]
        [HttpPost("/api/offlineinvite/{targetPlayerId:long}")]
        [HttpPost("/api/offlineinvite/v1/{targetPlayerId:long}")]
        [HttpPost("/api/offlineinvite/send/{targetPlayerId:long}")]
        [HttpPost("/api/offlineinvite/{targetPlayerId:long}/send")]
        [HttpPost("/api/offlineinvite/v1/send/{targetPlayerId:long}")]
        [HttpPost("/api/offlineinvite/{targetPlayerId:long}/{requestedRoomInstanceId:long}")]
        [HttpPost("/api/offlineinvite/v1/{targetPlayerId:long}/{requestedRoomInstanceId:long}")]
        [HttpPost("/api/offlineinvite/v1/send/{targetPlayerId:long}/{requestedRoomInstanceId:long}")]
        [HttpPut("/api/offlineinvite/{targetPlayerId:long}")]
        [HttpPut("/api/offlineinvite/v1/{targetPlayerId:long}")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> SendOfflineInvite(
            long? targetPlayerId = null,
            long? requestedRoomInstanceId = null,
            long? roomInstanceId = null)
        {
            long? inviterPlayerId = AuthStuff.GetPlayerId(Request);
            if (!inviterPlayerId.HasValue)
                return Unauthorized();

            HashSet<long> targetPlayerIds = await ReadLongValuesAsync(
                "id", "playerId", "PlayerId", "accountId", "AccountId",
                "targetPlayerId", "TargetPlayerId", "targetAccountId", "TargetAccountId",
                "inviteePlayerId", "InviteePlayerId", "inviteeAccountId", "InviteeAccountId",
                "playerIds", "PlayerIds", "accountIds", "AccountIds");
            if (targetPlayerId.HasValue && targetPlayerId.Value > 0)
                targetPlayerIds.Add(targetPlayerId.Value);
            targetPlayerIds.Remove(inviterPlayerId.Value);

            HashSet<long> claimedInstanceIds = await ReadLongValuesAsync(
                "roomInstanceId", "RoomInstanceId",
                "requestedRoomInstanceId", "RequestedRoomInstanceId",
                "targetRoomInstanceId", "TargetRoomInstanceId");
            if (requestedRoomInstanceId is > 0)
                claimedInstanceIds.Add(requestedRoomInstanceId.Value);
            if (roomInstanceId is > 0)
                claimedInstanceIds.Add(roomInstanceId.Value);
            targetPlayerIds.ExceptWith(claimedInstanceIds);

            Heartbeat? heartbeat = PlayerDB.GetPlayerHeartbeat(inviterPlayerId.Value);
            RoomInstance? room = heartbeat?.roomInstance;
            if (room == null)
                return BadRequest(new { success = false, error = "inviter_not_in_room" });

            if (!Sessions.IsConfirmedParticipant(
                    inviterPlayerId.Value,
                    room.roomInstanceId))
            {
                return StatusCode(409, new
                {
                    success = false,
                    error = "room_instance_membership_not_confirmed"
                });
            }

            if (claimedInstanceIds.Any(value =>
                    value != room.roomInstanceId))
            {
                return StatusCode(409, new
                {
                    success = false,
                    error = "room_invite_source_mismatch",
                    requestedRoomInstanceIds = claimedInstanceIds,
                    currentRoomInstanceId = room.roomInstanceId
                });
            }

            if (targetPlayerIds.Count == 0)
                return BadRequest(new { success = false, error = "missing_target_player" });

            var invited = new List<long>();
            var missing = new List<long>();
            var blocked = new List<long>();
            foreach (long receiverPlayerId in targetPlayerIds.Take(100))
            {
                if (PlayerDB.Players.FindById(receiverPlayerId)?.Player == null)
                {
                    missing.Add(receiverPlayerId);
                    continue;
                }

                var relationship = RelationshipDB.GetClientRelationship(
                    receiverPlayerId,
                    inviterPlayerId.Value);
                if (relationship?.Ignored is 1 or 3)
                {
                    blocked.Add(receiverPlayerId);
                    continue;
                }

                await NotiController.NotifyRoomInviteAsync(
                    inviterPlayerId.Value,
                    receiverPlayerId,
                    room.roomId,
                    room.roomInstanceId,
                    room.photonRoomId);
                invited.Add(receiverPlayerId);
            }

            bool success = invited.Count > 0;
            Console.WriteLine(
                $"[OFFLINE INVITE] inviter={inviterPlayerId.Value} " +
                $"targets={string.Join(',', targetPlayerIds)} " +
                $"invited={string.Join(',', invited)} " +
                $"missing={string.Join(',', missing)} " +
                $"blocked={blocked.Count} " +
                $"room={room.roomId} instance={room.roomInstanceId} " +
                $"requestedInstance={string.Join(',', claimedInstanceIds)} " +
                $"path={Request.Path} contentType={Request.ContentType ?? "null"}");

            return Ok(new
            {
                Success = success,
                Result = success ? 0 : 1,
                Error = success ? string.Empty : "invite_failed",
                RoomId = room.roomId,
                RoomInstanceId = room.roomInstanceId,
                InvitedPlayerIds = invited,
                MissingPlayerIds = missing,
                BlockedPlayerIds = blocked,
                Results = invited.Select(playerId => new
                {
                    PlayerId = playerId,
                    Error = string.Empty
                }).ToArray()
            });
        }

        [HttpPost("/api/platformlogin/v1/link")]
        public IActionResult PlatformLoginStub()
        {
            return Ok(new { success = true });
        }

        [HttpGet("/api/playerwarnings/v1/mine")]
        public IActionResult PlayerWarningsStub()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(Array.Empty<object>());
        }

        [HttpGet("/api/playstationplus/v1/membership")]
        public IActionResult PlaystationPlusMembership()
        {
            return Ok(new
            {
                isMember = false,
                expiresAt = (DateTime?)null
            });
        }

        [HttpPost("/api/playstationplus/v1/expire")]
        public IActionResult PlaystationPlusExpire()
        {
            return Ok();
        }

        [HttpGet("/api/progressionEvents/v1/all")]
        public IActionResult ProgressionEventsStub()
        {
            return Ok(Array.Empty<object>());
        }

        [HttpGet("/api/roomEarningsDistributions/v1/mine")]
        public IActionResult RoomEarningsDistributionsStub()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            var results = RoomDB.Rooms.Find(room =>
                    room.CreatorAccountId == id.Value && !room.IsDorm)
                .Select(CreateRoomEarningsDistribution)
                .ToList();

            return Ok(new
            {
                Results = results,
                TotalResults = results.Count
            });
        }

        [HttpGet("/api/roomEarningsDistributions/v1/earningsDistribution/{roomId:long}")]
        public IActionResult GetRoomEarningsDistribution(long roomId)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            var room = RoomDB.GetRoom(roomId);
            return room == null
                ? NotFound()
                : Ok(CreateRoomEarningsDistribution(room));
        }

        [HttpPost("/api/rooms/v1/verifyRole")]
        public async Task<IActionResult> VerifyRoomRole()
        {
            var accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();
            if (!Request.HasFormContentType)
                return BadRequest(new { success = false, error = "Expected room role form data." });

            var form = await Request.ReadFormAsync(HttpContext.RequestAborted);
            if (!long.TryParse(form["roomId"].FirstOrDefault(), out long roomId))
                return BadRequest(new { success = false, error = "A valid room ID is required." });

            var room = RoomDB.GetRoom(roomId);
            if (room == null)
                return NotFound();

            int.TryParse(form["role"].FirstOrDefault(), out int claimedRole);
            var assignedRole = room.CreatorAccountId == accountId.Value
                ? RoomDBClasses.Role.Creator
                : room.Roles?.FirstOrDefault(role => role.AccountId == accountId.Value)?.Role
                    ?? RoomDBClasses.Role.None;
            string? context = form["context"].FirstOrDefault();

            if (claimedRole != (int)assignedRole)
            {
                Console.WriteLine(
                    $"[ROOM ROLE VERIFY] room={roomId} account={accountId.Value} " +
                    $"claimed={claimedRole} assigned={(int)assignedRole} context={context ?? "null"}");
            }

            return Ok();
        }

        private static RoomEarningsDistributionResponse CreateRoomEarningsDistribution(
            RoomDBClasses.Room room)
        {
            var mapping = new Dictionary<int, byte>();
            if (room.CreatorAccountId is > 0 and <= int.MaxValue)
                mapping[(int)room.CreatorAccountId] = 100;

            return new RoomEarningsDistributionResponse
            {
                roomId = room.RoomId,
                earningsDistributionMapping = mapping,
                earningsDistributionMethod = 0
            };
        }

        private sealed class RoomEarningsDistributionResponse
        {
            public long roomId { get; set; }
            public Dictionary<int, byte> earningsDistributionMapping { get; set; } = new();
            public int earningsDistributionMethod { get; set; }
        }

        [HttpGet("/api/royale/v1/status")]
        public IActionResult RoyaleStatusStub()
        {
            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("/api/subscriptionseasons/v1/seasons/current")]
        public IActionResult SubscriptionSeasonsCurrent()
        {
            return Ok(new
            {
                seasonId = 0,
                name = "",
                startsAt = DateTime.UtcNow,
                endsAt = DateTime.UtcNow.AddDays(30)
            });
        }

        [HttpGet("/api/ugcPurchasables/v1/mine")]
        public IActionResult UgcPurchasablesStub()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new
            {
                Results = Array.Empty<object>(),
                TotalResults = 0
            });
        }

        [HttpGet("/cdn/{*filePath}")]
        public IActionResult GetCDNFile(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath))
                return NotFound();

            string normalized = filePath.Replace('\\', '/').TrimStart('/');
            if (normalized.Contains("..", StringComparison.Ordinal) ||
                Path.IsPathRooted(normalized))
            {
                return BadRequest();
            }

            if (normalized.StartsWith("room/invention/", StringComparison.OrdinalIgnoreCase))
                normalized = normalized[5..];
            if (normalized.StartsWith("invention/room/", StringComparison.OrdinalIgnoreCase))
                normalized = normalized[10..];

            string cdnRoot = Path.GetFullPath(Path.Combine(Program.dataDir, "CDN"));
            var candidates = new List<string>
            {
                Path.Combine(cdnRoot, normalized.Replace('/', Path.DirectorySeparatorChar))
            };

            string safeName = Path.GetFileName(normalized);
            if (!string.IsNullOrWhiteSpace(safeName))
            {

                candidates.Add(Path.Combine(cdnRoot, "assetbundles", safeName));
                candidates.Add(Path.Combine(cdnRoot, "assetbundle", safeName));
                candidates.Add(Path.Combine(cdnRoot, "unity", safeName));
                candidates.Add(Path.Combine(cdnRoot, "invention", safeName));
                candidates.Add(Path.Combine(cdnRoot, "room", safeName));

                if (safeName.EndsWith(".inv", StringComparison.OrdinalIgnoreCase))
                {
                    string extensionless = safeName[..^4];
                    if (!string.IsNullOrWhiteSpace(extensionless))
                    {
                        candidates.Add(Path.Combine(cdnRoot, "invention", extensionless));
                        candidates.Add(Path.Combine(cdnRoot, "room", extensionless));
                    }
                }
                else
                {
                    string baseName = Path.GetFileNameWithoutExtension(safeName);
                    if (string.IsNullOrWhiteSpace(baseName))
                        baseName = safeName;
                    string invName = baseName + ".inv";
                    candidates.Add(Path.Combine(cdnRoot, "invention", invName));
                    candidates.Add(Path.Combine(cdnRoot, "room", invName));
                }
            }

            string? path = null;
            foreach (string candidate in candidates)
            {
                string resolved;
                try
                {
                    resolved = Path.GetFullPath(candidate);
                }
                catch (Exception exception) when (
                    exception is ArgumentException or NotSupportedException or PathTooLongException)
                {
                    continue;
                }

                if (!resolved.StartsWith(cdnRoot + Path.DirectorySeparatorChar,
                        StringComparison.OrdinalIgnoreCase) ||
                    !System.IO.File.Exists(resolved))
                {
                    continue;
                }

                path = resolved;
                break;
            }

            if (path == null)
                return NotFound();

            var contentType = Path.GetExtension(path).ToLowerInvariant() switch
            {
                ".png" => "image/png",
                ".jpg" or ".jpeg" => "image/jpeg",
                ".gif" => "image/gif",
                ".webp" => "image/webp",
                ".mp4" or ".m4v" => "video/mp4",
                ".mov" => "video/quicktime",
                ".webm" => "video/webm",
                ".wav" => "audio/wav",
                ".assetbundle" => "application/octet-stream",
                ".json" => "application/json",
                ".txt" => "text/plain",
                _ => "application/octet-stream"
            };

            Response.Headers.CacheControl = "public,max-age=31536000,immutable";
            return PhysicalFile(
                path,
                contentType,
                enableRangeProcessing: contentType.StartsWith(
                    "video/",
                    StringComparison.OrdinalIgnoreCase));
        }

        [HttpGet("/purchase/v1/hasspentmoney")]
        public IActionResult HasSpentMoney()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new { hasSpentMoney = false });
        }

        [HttpGet("/purchasecampaign/allcurrent/v2")]
        public IActionResult PurchaseCampaignAllCurrent()
        {
            return Ok(Array.Empty<object>());
        }

        [HttpGet("/api/apple/musicpromotion")]
        public IActionResult AppleMusicPromotionStub()
        {
            return Ok(new { eligible = false });
        }

        [HttpGet("/preferences")]
        public IActionResult GetPreferences()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            return Ok(new
            {
                NotificationPreferences = new[]
                {
                    0,
                    1,
                    2,
                    3,
                    4,
                    5,
                    6,
                    7,
                    8,
                    9,
                    10
                }
            });
        }

        [HttpGet("api/storefronts/v1/adcarouselitems")]
        public IActionResult GetAdCarouselItems()
        {

            List<CatalogSku> catalog = GetCatalogSkus()
                .Where(IsUsableStoreItem)
                .ToList();

            List<int> purchasableIds = catalog
                .Select(item => item.PurchasableItemId)
                .Where(id => id > 0)
                .Distinct()
                .ToList();

            int avatarItems = catalog.Count(IsAvatarCatalogItem);
            int equipmentSkins = catalog.Count(IsEquipmentSkin);
            int consumables = catalog.Count(IsConsumableCatalogItem);

            Console.WriteLine(
                $"[ALL-I-GOT STORE] items={purchasableIds.Count} " +
                $"avatar={avatarItems} skins={equipmentSkins} consumables={consumables}");

            var items = new[]
            {
                new StorefrontAdCarouselItem
                {
                    AdCarouselItemId = 1,
                    ImageName = "DefaultPFP.png",
                    Title = "The All-I-Got Store",
                    Description =
                        $"Everything Mocha has: {avatarItems} avatar items, " +
                        $"{equipmentSkins} skins, and {consumables} consumables. " +
                        $"100 tokens each.",
                    PurchasableItemIds = purchasableIds,
                    PurchaseReminderId = null
                }
            };
            return Ok(items);
        }

        [HttpGet("/api/rooms/v1/filters")]
        public IActionResult GetRoomFilters()
        {
            string[] pinnedTags = { "rro", "quest", "base" };
            string[] popularTags = { "rro", "quest", "base" };
            string[] tags =
            {
                "rro", "quest", "base", "pvp", "game", "hangout",
                "art", "music", "sports", "parkour", "story"
            };

            Console.WriteLine(
                $"[ROOM FILTERS] format=object pinned={pinnedTags.Length} " +
                $"popular={popularTags.Length} tags={tags.Length}");

            return Ok(new
            {
                PinnedTags = pinnedTags,
                PopularTags = popularTags,
                Tags = tags
            });
        }

        [HttpGet("/api/relationships/v2/sendfriendrequest")]
        [HttpPost("/api/relationships/v2/sendfriendrequest")]
        public async Task<IActionResult> SendFriendRequest()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            long targetId = (await ReadLongValuesAsync(
                "id", "playerId", "PlayerId", "accountId", "AccountId",
                "targetPlayerId", "TargetPlayerId", "targetAccountId", "TargetAccountId"))
                .FirstOrDefault();
            if (targetId <= 0)
                return BadRequest(new { success = false, error = "missing_target_player" });

            ClientRelationshipDTO? before =
                RelationshipDB.GetClientRelationship(accountId.Value, targetId);

            PlayerRelationship? relationship = PlayerDB.SendFriendRequest(
                accountId.Value,
                targetId);
            if (relationship == null)
                return BadRequest(new { success = false, error = "invalid_player" });

            ClientRelationshipDTO? clientRelationship =
                RelationshipDB.GetClientRelationship(accountId.Value, targetId);
            if (clientRelationship == null)
            {
                return StatusCode(500, new
                {
                    success = false,
                    error = "relationship_not_persisted"
                });
            }

            await NotifyRelationshipMutationAsync(
                accountId.Value,
                targetId,
                before,
                clientRelationship);

            return Ok(clientRelationship);
        }

        [HttpGet("/api/relationships/v2/addfriend")]
        [HttpPost("/api/relationships/v2/addfriend")]
        [HttpGet("/api/relationships/v2/acceptfriendrequest")]
        [HttpPost("/api/relationships/v2/acceptfriendrequest")]
        public async Task<IActionResult> AcceptFriendRequest()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            long requesterId = (await ReadLongValuesAsync(
                "id", "playerId", "PlayerId", "accountId", "AccountId",
                "requesterPlayerId", "RequesterPlayerId", "requesterAccountId", "RequesterAccountId"))
                .FirstOrDefault();
            if (requesterId <= 0)
                return BadRequest(new { success = false, error = "missing_requester_player" });

            ClientRelationshipDTO? before =
                RelationshipDB.GetClientRelationship(accountId.Value, requesterId);

            PlayerRelationship? relationship = PlayerDB.AcceptFriendRequest(
                accountId.Value,
                requesterId);

            relationship ??= PlayerDB.SendFriendRequest(accountId.Value, requesterId);
            if (relationship == null)
                return BadRequest(new { success = false, error = "invalid_player" });

            ClientRelationshipDTO? clientRelationship =
                RelationshipDB.GetClientRelationship(accountId.Value, requesterId);
            if (clientRelationship == null)
            {
                return StatusCode(500, new
                {
                    success = false,
                    error = "relationship_not_persisted"
                });
            }

            await NotifyRelationshipMutationAsync(
                accountId.Value,
                requesterId,
                before,
                clientRelationship);

            return Ok(clientRelationship);
        }

        [HttpPost("/api/relationships/v3/{id:long}")]
        public async Task<IActionResult> AddFriendV3(long id)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            ClientRelationshipDTO? before =
                RelationshipDB.GetClientRelationship(accountId.Value, id);

            PlayerRelationship? relationship = PlayerDB.SendFriendRequest(
                accountId.Value,
                id);
            if (relationship == null)
                return BadRequest(new { success = false, error = "invalid_player" });

            ClientRelationshipDTO? clientRelationship =
                RelationshipDB.GetClientRelationship(accountId.Value, id);
            if (clientRelationship == null)
            {
                return StatusCode(500, new
                {
                    success = false,
                    error = "relationship_not_persisted"
                });
            }

            await NotifyRelationshipMutationAsync(
                accountId.Value,
                id,
                before,
                clientRelationship);

            return Ok(clientRelationship);
        }

        [HttpDelete("/api/relationships/v3/{id:long}")]
        [HttpDelete("/api/relationships/v2/removefriend/{id:long}")]
        public async Task<IActionResult> RemoveFriend(long id)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            bool removed = PlayerDB.RemoveFriend(accountId.Value, id);
            if (!removed)
                return NotFound();

            await NotiController.NotifyFriendRemovedAsync(
                accountId.Value,
                id);
            return NoContent();
        }

        [HttpGet("/api/relationships/v2/removefriend")]
        [HttpPost("/api/relationships/v2/removefriend")]
        public async Task<IActionResult> RemoveFriendV2([FromQuery] long id)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            if (id <= 0 || id == accountId.Value)
                return BadRequest(new { success = false, error = "invalid_player" });

            bool removed = PlayerDB.RemoveFriend(accountId.Value, id);
            if (removed)
            {
                await NotiController.NotifyFriendRemovedAsync(
                    accountId.Value,
                    id);
            }

            Console.WriteLine(
                $"[RELATIONSHIP REMOVE] source={accountId.Value} target={id} " +
                $"removed={removed} route=v2-query live={removed}");

            return Ok();
        }

        private static async Task NotifyRelationshipMutationAsync(
            long actorPlayerId,
            long otherPlayerId,
            ClientRelationshipDTO? before,
            ClientRelationshipDTO after)
        {
            bool unchanged = before != null &&
                before.PlayerID == after.PlayerID &&
                before.RelationshipType == after.RelationshipType &&
                before.Favorited == after.Favorited &&
                before.Muted == after.Muted &&
                before.Ignored == after.Ignored;
            if (unchanged)
                return;

            RelationshipType finalType =
                (RelationshipType)after.RelationshipType;
            RelationshipType? previousType = before == null
                ? null
                : (RelationshipType)before.RelationshipType;

            if (finalType == RelationshipType.Friend &&
                previousType != RelationshipType.Friend)
            {
                await NotiController.NotifyFriendAcceptedAsync(
                    actorPlayerId,
                    otherPlayerId);
                return;
            }

            if (finalType == RelationshipType.OutgoingFriendRequest &&
                previousType != RelationshipType.OutgoingFriendRequest)
            {
                await NotiController.NotifyFriendRequestAsync(
                    actorPlayerId,
                    otherPlayerId);
                return;
            }

            await NotiController.NotifyRelationshipFlagsChangedAsync(
                actorPlayerId,
                otherPlayerId,
                "friendship-change");
        }

        [HttpGet("/api/relationships/mutualfriends")]
        public IActionResult GetMutualFriends([FromQuery] long id)
        {
            var accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var mine = PlayerDB.GetRelationships((long)accountId)
                .Where(value => value.RelationshipType == RelationshipType.Friend)
                .Select(value => value.PlayerID)
                .ToHashSet();
            var theirs = PlayerDB.GetRelationships(id)
                .Where(value => value.RelationshipType == RelationshipType.Friend)
                .Select(value => value.PlayerID);

            return Ok(theirs.Where(mine.Contains).ToArray());
        }

        [HttpPost("/api/PlayerReporting/v3/create")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> CreatePlayerReportV3()
        {
            var reporter = AuthStuff.GetCurrentPlayer(Request);

            if (reporter?.Player == null)
                return Unauthorized();

            JsonElement requestData;

            try
            {
                if (Request.HasFormContentType)
                {
                    var form = await Request.ReadFormAsync(
                        HttpContext.RequestAborted);

                    var formData = form.ToDictionary(
                        entry => entry.Key,
                        entry => entry.Value.ToString(),
                        StringComparer.OrdinalIgnoreCase);

                    requestData = JsonSerializer.SerializeToElement(formData);
                }
                else
                {
                    using var reader = new StreamReader(
                        Request.Body,
                        Encoding.UTF8,
                        detectEncodingFromByteOrderMarks: true,
                        leaveOpen: true);

                    string rawBody = await reader.ReadToEndAsync(
                        HttpContext.RequestAborted);

                    if (string.IsNullOrWhiteSpace(rawBody))
                    {
                        requestData = JsonSerializer.SerializeToElement(
                            new Dictionary<string, string>());
                    }
                    else
                    {
                        try
                        {
                            using JsonDocument document =
                                JsonDocument.Parse(rawBody);

                            requestData = document.RootElement.Clone();
                        }
                        catch (JsonException)
                        {
                            var parsedData =
                                Microsoft.AspNetCore.WebUtilities.QueryHelpers
                                    .ParseQuery(rawBody)
                                    .ToDictionary(
                                        entry => entry.Key,
                                        entry => entry.Value.ToString(),
                                        StringComparer.OrdinalIgnoreCase);

                            if (parsedData.Count == 0)
                                parsedData["RawBody"] = rawBody;

                            requestData =
                                JsonSerializer.SerializeToElement(parsedData);
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                Console.WriteLine(
                    $"[PLAYER REPORT] Failed reading request: {exception}");

                return BadRequest(new
                {
                    success = false,
                    error = "invalid_report_body"
                });
            }

            long reporterId = reporter.PlayerId;
            string? reporterUsername = reporter.Player.Username;

            long? reportedPlayerId = FindJsonLong(
                requestData,
                "PlayerIdReported",
                "ReportedPlayerId",
                "ReportedAccountId",
                "TargetPlayerId",
                "TargetAccountId",
                "SuspectPlayerId");

            var reportedPlayer = reportedPlayerId.HasValue
                ? PlayerDB.Players.FindById(reportedPlayerId.Value)
                : null;

            string? reportedUsername =
                reportedPlayer?.Player?.Username ??
                FindJsonString(
                    requestData,
                    "UsernameReported",
                    "ReportedPlayerUsername",
                    "ReportedUsername",
                    "TargetUsername");

            int? reportCategory = FindJsonInt(
                requestData,
                "ReportCategory",
                "ReportCategoryId",
                "CategoryId",
                "ReportType");

            string? details = FindJsonString(
                requestData,
                "Details",
                "Description",
                "Comment",
                "Message",
                "AdditionalDetails",
                "Notes");

            long? roomId = FindJsonLong(
                requestData,
                "RoomId",
                "SourceRoomId");

            string? roomInstanceType = FindJsonString(
                requestData,
                "RoomInstanceType",
                "InstanceType",
                "RoomType");

            Guid reportId = Guid.NewGuid();

            var storedReport = new ReportsDB.PlayerReport
            {
                Id = reportId,
                ReporterId = reporterId,
                ReporterUsername = reporterUsername,
                ReportedPlayerId = reportedPlayerId,
                ReportedUsername = reportedUsername,
                ReportCategory = reportCategory,
                Details = details,
                RoomId = roomId,
                RoomInstanceType = roomInstanceType
            };
            ReportsDB.PlayerReports.Insert(storedReport);

            DiscordLogger.LogPlayerReport(
                reportId,
                reporterId,
                reporterUsername,
                reportedPlayerId,
                reportedUsername,
                reportCategory,
                details,
                roomId,
                roomInstanceType);

            Console.WriteLine(
                $"[PLAYER REPORT] Report ID: {reportId}");

            Console.WriteLine(
                $"[PLAYER REPORT] Reporter: " +
                $"{reporterUsername ?? "unknown"} ({reporterId})");

            Console.WriteLine(
                $"[PLAYER REPORT] Reported: " +
                $"{reportedUsername ?? "unknown"} " +
                $"({reportedPlayerId?.ToString() ?? "unknown"})");

            Console.WriteLine(
                $"[PLAYER REPORT] Payload: {requestData.GetRawText()}");

            bool reporterIsDeveloper =
                reporter.PlayerRoles?.Contains(PlayerRoles.Developer) == true;
            bool reporterIsModerator =
                reporter.PlayerRoles?.Contains(PlayerRoles.Moderator) == true;

            if ((reporterIsDeveloper || reporterIsModerator) &&
                TryParseReportBanCommand(
                    details,
                    out int banDurationSeconds,
                    out string banReason))
            {
                if (!reportedPlayerId.HasValue ||
                    reportedPlayer?.Player == null)
                {
                    Console.WriteLine(
                        $"[REPORT BAN] reporter={reporterId} rejected=true " +
                        "reason=reported_player_not_found");
                }
                else if (reportedPlayerId.Value == reporterId)
                {
                    Console.WriteLine(
                        $"[REPORT BAN] reporter={reporterId} rejected=true " +
                        "reason=self_ban");
                }
                else
                {
                    bool targetIsDeveloper =
                        reportedPlayer.PlayerRoles?.Contains(
                            PlayerRoles.Developer) == true;

                    if (targetIsDeveloper && !reporterIsDeveloper)
                    {
                        Console.WriteLine(
                            $"[REPORT BAN] reporter={reporterId} " +
                            $"target={reportedPlayerId.Value} rejected=true " +
                            "reason=moderator_cannot_ban_developer");
                    }
                    else
                    {
                        PlayerDB.BanPlayer(
                            reportedPlayerId.Value,
                            banDurationSeconds,
                            banReason,
                            checked((ulong)reporterId));

                        storedReport.Status = banDurationSeconds > 0 &&
                            banDurationSeconds < int.MaxValue
                                ? "TimedOut"
                                : "Banned";
                        storedReport.ResolvedByAccountId = reporterId;
                        storedReport.ResolvedByUsername = reporterUsername;
                        storedReport.ResolvedAt = DateTime.UtcNow;
                        storedReport.ResolutionNote = banReason;
                        storedReport.ActionDurationSeconds = banDurationSeconds;
                        ReportsDB.PlayerReports.Update(storedReport);

                        Console.WriteLine(
                            $"[REPORT BAN] reporter={reporterId} " +
                            $"target={reportedPlayerId.Value} " +
                            $"durationSeconds={banDurationSeconds} " +
                            $"reason={banReason}");
                    }
                }
            }

            return Ok(new
            {
                success = true
            });
        }

        [HttpPut("/reports/{reportId:guid}")]
        [RequestSizeLimit(16 * 1024 * 1024)]
        public async Task<IActionResult> UploadCrashReport(Guid reportId)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
            {
                return Unauthorized(new
                {
                    success = false,
                    reportId,
                    error = "authentication_required"
                });
            }

            string reportsDirectory = Path.Combine(
                Program.dataDir,
                "Debug",
                "CrashReports");
            Directory.CreateDirectory(reportsDirectory);

            bool isJson =
                Request.ContentType?.Contains(
                    "json",
                    StringComparison.OrdinalIgnoreCase) == true;
            string extension = isJson ? ".json" : ".bin";
            string reportPath = Path.Combine(
                reportsDirectory,
                reportId.ToString("D") + extension);

            try
            {
                await using var reportFile = new FileStream(
                    reportPath,
                    FileMode.Create,
                    FileAccess.Write,
                    FileShare.Read,
                    bufferSize: 81920,
                    useAsync: true);
                await Request.Body.CopyToAsync(
                    reportFile,
                    HttpContext.RequestAborted);
            }
            catch (OperationCanceledException)
            {
                return StatusCode(499, new
                {
                    success = false,
                    reportId,
                    error = "crash_report_upload_cancelled"
                });
            }
            catch (Exception exception)
            {
                Console.WriteLine(
                    $"[CRASH REPORT] Failed report={reportId}: {exception}");
                return StatusCode(
                    StatusCodes.Status500InternalServerError,
                    new
                    {
                        success = false,
                        reportId,
                        error = "crash_report_storage_failed"
                    });
            }

            long storedBytes = new FileInfo(reportPath).Length;
            Console.WriteLine(
                $"[CRASH REPORT] Stored report={reportId} " +
                $"account={accountId.Value} bytes={storedBytes} " +
                $"contentType={Request.ContentType ?? "unknown"}");

            return Ok(new
            {
                success = true,
                id = reportId,
                reportId
            });
        }

        [HttpPut("/reports/{reportId:guid}/attachments/{fileName}")]
        [RequestSizeLimit(16 * 1024 * 1024)]
        public async Task<IActionResult> UploadCrashReportAttachment(
            Guid reportId,
            string fileName)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
            {
                return Unauthorized(new
                {
                    success = false,
                    reportId,
                    error = "authentication_required"
                });
            }

            string safeFileName = Path.GetFileName(fileName);
            if (string.IsNullOrWhiteSpace(safeFileName) ||
                safeFileName != fileName)
            {
                return BadRequest(new
                {
                    success = false,
                    reportId,
                    error = "invalid_attachment_name"
                });
            }

            string attachmentsDirectory = Path.Combine(
                Program.dataDir,
                "Debug",
                "CrashReports",
                reportId.ToString("D") + "_attachments");
            Directory.CreateDirectory(attachmentsDirectory);

            string attachmentPath = Path.Combine(
                attachmentsDirectory,
                safeFileName);

            try
            {
                await using var attachmentFile = new FileStream(
                    attachmentPath,
                    FileMode.Create,
                    FileAccess.Write,
                    FileShare.Read,
                    bufferSize: 81920,
                    useAsync: true);
                await Request.Body.CopyToAsync(
                    attachmentFile,
                    HttpContext.RequestAborted);
            }
            catch (OperationCanceledException)
            {
                return StatusCode(499, new
                {
                    success = false,
                    reportId,
                    error = "crash_report_attachment_upload_cancelled"
                });
            }
            catch (Exception exception)
            {
                Console.WriteLine(
                    $"[CRASH REPORT] Failed attachment report={reportId} " +
                    $"file={safeFileName}: {exception}");
                return StatusCode(
                    StatusCodes.Status500InternalServerError,
                    new
                    {
                        success = false,
                        reportId,
                        error = "crash_report_attachment_storage_failed"
                    });
            }

            long storedBytes = new FileInfo(attachmentPath).Length;
            Console.WriteLine(
                $"[CRASH REPORT] Stored attachment report={reportId} " +
                $"file={safeFileName} account={accountId.Value} " +
                $"bytes={storedBytes}");

            return Ok(new
            {
                success = true,
                id = reportId,
                reportId,
                fileName = safeFileName
            });
        }

        private static bool TryParseReportBanCommand(
            string? details,
            out int durationSeconds,
            out string reason)
        {
            durationSeconds = 0;
            reason = string.Empty;

            string command = details?.Trim() ?? string.Empty;
            int separatorIndex = command.IndexOf(':');
            if (separatorIndex <= 1 || separatorIndex == command.Length - 1)
                return false;

            string duration = command[..separatorIndex];
            reason = command[(separatorIndex + 1)..].Trim();

            if (duration.Any(char.IsWhiteSpace) ||
                reason.Length is < 1 or > 500)
            {
                return false;
            }

            char unit = duration[^1];
            string quantityText = duration[..^1];
            if (quantityText.Length == 0 ||
                quantityText.Any(character => !char.IsAsciiDigit(character)) ||
                !long.TryParse(quantityText, out long quantity) ||
                quantity <= 0)
            {
                return false;
            }

            long multiplier = unit switch
            {
                'm' => 60,
                'h' => 60 * 60,
                'd' => 24 * 60 * 60,
                'w' => 7 * 24 * 60 * 60,
                _ => 0
            };
            if (multiplier == 0 ||
                quantity > int.MaxValue / multiplier)
            {
                return false;
            }

            durationSeconds = checked((int)(quantity * multiplier));
            return true;
        }

        [HttpGet("/api/messages/v1/favoriteFriendOnlineStatus")]
        public IActionResult GetFavoriteFriendOnlineStatus()
        {
            var accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var statuses = PlayerDB.GetRelationships((long)accountId)
                .Where(value =>
                    value.RelationshipType == RelationshipType.Friend &&
                    value.Favorited)
                .Select(value => new
                {
                    PlayerId = value.PlayerID,
                    IsOnline = PlayerDB.GetPlayerHeartbeat(value.PlayerID).isOnline
                });

            return Ok(statuses);
        }

        [HttpPost("purchase/v1/cleanuppending")]
        public IActionResult CleanupPendingPurchases()
        {
            return Ok(new { cleaned = 0, status = "ok" });
        }

        [HttpGet("api/playerevents/v1/tagfilters")]
        [HttpGet("api/playerevents/v1/filters")]
        public IActionResult GetPlayerEventTagFilters()
        {
            string[] filters = { "social", "competitive", "creative" };

            return Ok(new
            {
                PinnedTags = Array.Empty<string>(),
                PopularTags = filters,
                Tags = filters
            });
        }

        [HttpGet("api/playerevents/v1/room/{roomId}")]
        public IActionResult GetPlayerEventsForRoom(long roomId)
        {
            return Ok(Array.Empty<object>());
        }

        [HttpGet("api/inventions/v1/room")]
        public IActionResult GetInventionsForRoom(
            [FromQuery] long id,
            [FromQuery] long roomId = 0,
            [FromQuery] int skip = 0,
            [FromQuery] int take = 100)
        {
            long resolvedRoomId = roomId > 0 ? roomId : id;
            object[] results = CreatorFeatureDB.SearchInventions(
                    roomId: resolvedRoomId > 0 ? resolvedRoomId : null,
                    skip: skip,
                    take: take)
                .Select(CreatorFeatureDB.ToClientInvention)
                .ToArray();
            return Ok(results);
        }

        private static readonly string[] ChatMemberIdKeys =
        {
            "MemberIds", "memberIds",
            "Members", "members",
            "ThreadMembers", "threadMembers",
            "WithMembers", "withMembers",
            "AccountIds", "accountIds",
            "PlayerAccountIds", "playerAccountIds",
            "PlayerIds", "playerIds",
            "UserIds", "userIds",
            "Ids", "ids",
            "RecipientIds", "recipientIds",
            "Recipients", "recipients",
            "ReceiverIds", "receiverIds",
            "TargetIds", "targetIds",
            "TargetPlayerIds", "targetPlayerIds",
            "OtherPlayerIds", "otherPlayerIds",
            "ToAccountIds", "toAccountIds",
            "ToPlayerIds", "toPlayerIds",
            "WithPlayerIds", "withPlayerIds",
            "AccountId", "accountId",
            "PlayerAccountId", "playerAccountId",
            "PlayerId", "playerId",
            "UserId", "userId",
            "RecipientId", "recipientId",
            "ReceiverId", "receiverId",
            "TargetId", "targetId",
            "OtherPlayerId", "otherPlayerId",
            "Id", "id",
            "a"
        };

        private static readonly string[] ChatMessageKeys =
        {

            "MessageContents", "messageContents",
            "Contents", "contents",
            "Message", "message",
            "Body", "body",
            "Text", "text",
            "Content", "content"
        };

        [HttpGet("thread")]
        public IActionResult GetThreads(
            [FromQuery] int maxCount = 50,
            [FromQuery] int mode = 0)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            object[] threads = ChatDB
                .GetThreadsForPlayer(accountId.Value, maxCount)
                .Select(thread => BuildChatThreadDto(thread, accountId.Value, messageCount: 50))
                .ToArray();

            return Ok(threads);
        }

        [HttpPost("thread/withmembers")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> GetOrCreateThreadWithMembers()
        {

            return await CreateOrOpenChatThreadAsync(wrapResult: false);
        }

        [HttpPost("thread")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> CreateThread()
        {
            ParsedChatThreadRequest parsed = await ReadChatThreadRequestAsync();
            string? messageContents = await ReadChatMessageBodyAsync();

            if (!string.IsNullOrWhiteSpace(messageContents))
            {
                return await SendOrCreateChatMessageAsync(
                    parsed,
                    messageContents);
            }

            return await CreateOrOpenChatThreadAsync(parsed);
        }

        [HttpGet("thread/{threadId:long}")]
        public IActionResult GetThread(
            long threadId,
            [FromQuery] int messageCount = 50)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            ChatDB.ChatThread? thread = ChatDB.GetThread(threadId, accountId.Value);
            if (thread == null)
                return NotFound();

            messageCount = Math.Clamp(messageCount, 1, 100);
            object dto = BuildChatThreadDto(
                thread,
                accountId.Value,
                messageCount);

            Console.WriteLine(
                $"[CHAT OPEN] thread={threadId} viewer={accountId.Value} " +
                $"messages={ChatDB.GetMessages(threadId, accountId.Value, messageCount).Count}");

            return Ok(dto);
        }

        [HttpGet("thread/{threadId:long}/messages")]
        [HttpGet("thread/{threadId:long}/message")]
        public IActionResult GetThreadMessages(
            long threadId,
            [FromQuery] int maxCount = 50,
            [FromQuery] long? beforeMessageId = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            if (ChatDB.GetThread(threadId, accountId.Value) == null)
                return NotFound();

            object[] messages = ChatDB
                .GetMessages(threadId, accountId.Value, maxCount, beforeMessageId)
                .Select(BuildChatMessageDto)
                .ToArray();

            return Ok(messages);
        }

        [HttpPost("thread/{threadId:long}/message/{messageId:long}/read")]
        [HttpPut("thread/{threadId:long}/message/{messageId:long}/read")]
        public IActionResult MarkThreadMessageRead(long threadId, long messageId)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            if (!ChatDB.MarkMessageRead(threadId, messageId, accountId.Value))
                return NotFound();

            Console.WriteLine(
                $"[CHAT READ] thread={threadId} message={messageId} " +
                $"viewer={accountId.Value}");

            return NoContent();
        }

        [HttpPost("thread/{threadId:long}/message")]
        [HttpPost("thread/{threadId:long}/messages")]
        [HttpPost("thread/{threadId:long}")]
        [RequestSizeLimit(32 * 1024)]
        public async Task<IActionResult> SendThreadMessage(long threadId)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            ChatDB.ChatThread? thread = ChatDB.GetThread(threadId, accountId.Value);
            if (thread == null)
            {
                return NotFound(new
                {
                    chatMessage = (object?)null,
                    chatResult = 2
                });
            }

            string? rawContents = await ReadChatMessageBodyAsync();
            if (string.IsNullOrWhiteSpace(rawContents))
            {
                return BadRequest(new
                {
                    chatMessage = (object?)null,
                    chatResult = 1
                });
            }

            string contents = NormalizeChatMessageContents(rawContents);
            ChatDB.ChatMessage? message = ChatDB.AddMessage(
                threadId,
                accountId.Value,
                contents);

            if (message == null)
            {
                return BadRequest(new
                {
                    chatMessage = (object?)null,
                    chatResult = 6
                });
            }

            object messageDto = BuildChatMessageDto(message);
            long[] recipients = thread.MemberIds
                .Where(id => id != accountId.Value)
                .Distinct()
                .ToArray();

            await Task.WhenAll(recipients.Select(memberId =>
                NotiController.NotifyChatMessageReceivedAsync(
                    memberId,
                    messageDto)));

            Console.WriteLine(
                $"[CHAT LIVE] message={message.MessageId} thread={threadId} " +
                $"sender={accountId.Value} recipients={string.Join(',', recipients)}");

            return Ok(new
            {
                chatMessage = messageDto,
                chatResult = 0
            });
        }

        [HttpDelete("thread/{threadId:long}")]
        public IActionResult LeaveOrDeleteThread(long threadId)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            return ChatDB.LeaveThread(threadId, accountId.Value)
                ? NoContent()
                : NotFound();
        }

        private async Task<IActionResult> CreateOrOpenChatThreadAsync(
            ParsedChatThreadRequest? parsedRequest = null,
            bool wrapResult = true)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            ParsedChatThreadRequest parsed =
                parsedRequest ?? await ReadChatThreadRequestAsync();
            HashSet<long> selectedIds = ResolveChatMemberIds(
                parsed,
                accountId.Value);

            LogChatRequest(parsed, selectedIds);

            if (selectedIds.Count == 0)
            {
                return BadRequest(new
                {
                    chatThread = (object?)null,
                    chatResult = 1
                });
            }

            if (selectedIds.Count > 99)
            {
                return BadRequest(new
                {
                    chatThread = (object?)null,
                    chatResult = 8
                });
            }

            ChatDB.ChatThread? existingThread = ChatDB.FindThreadWithMembers(
                accountId.Value,
                selectedIds);
            bool createdNewThread = existingThread == null;

            ChatDB.ChatThread thread = existingThread ?? ChatDB.GetOrCreateThread(
                accountId.Value,
                selectedIds,
                parsed.Name,
                parsed.Type);

            object dto = BuildChatThreadDto(
                thread,
                accountId.Value,
                messageCount: 50);

            if (createdNewThread)
            {
                ChatDB.ChatMessage? starterMessage = ChatDB
                    .GetMessages(
                        thread.ThreadId,
                        accountId.Value,
                        maxCount: 1)
                    .FirstOrDefault();

                if (starterMessage != null)
                {
                    object starterMessageDto = BuildChatMessageDto(starterMessage);
                    long[] liveRecipients = thread.MemberIds
                        .Where(id => id > 0)
                        .Distinct()
                        .ToArray();

                    await Task.WhenAll(liveRecipients.Select(memberId =>
                        NotiController.NotifyChatMessageReceivedAsync(
                            memberId,
                            starterMessageDto)));

                    Console.WriteLine(
                        $"[CHAT LIVE] created thread={thread.ThreadId} " +
                        $"starter={starterMessage.MessageId} " +
                        $"recipients={string.Join(',', liveRecipients)}");
                }
            }

            Console.WriteLine(
                $"[CHAT] opened thread={thread.ThreadId} requester={accountId.Value} " +
                $"members={string.Join(',', thread.MemberIds)} new={createdNewThread}");

            if (!wrapResult)
            {
                Console.WriteLine(
                    $"[CHAT RESPONSE] route=/thread/withmembers format=direct " +
                    $"thread={thread.ThreadId}");
                return Ok(dto);
            }

            Console.WriteLine(
                $"[CHAT RESPONSE] route=/thread format=wrapped " +
                $"thread={thread.ThreadId}");

            return Ok(new
            {
                chatThread = dto,
                chatResult = 0
            });
        }

        private async Task<IActionResult> SendOrCreateChatMessageAsync(
            ParsedChatThreadRequest parsed,
            string rawMessageContents)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            HashSet<long> selectedIds = ResolveChatMemberIds(
                parsed,
                accountId.Value);
            LogChatRequest(parsed, selectedIds);

            if (selectedIds.Count == 0)
            {
                return BadRequest(new
                {
                    chatThread = (object?)null,
                    chatResult = 1
                });
            }

            if (selectedIds.Count > 99)
            {
                return BadRequest(new
                {
                    chatThread = (object?)null,
                    chatResult = 8
                });
            }

            ChatDB.ChatThread thread = ChatDB.GetOrCreateThread(
                accountId.Value,
                selectedIds,
                parsed.Name,
                parsed.Type);

            string contents = NormalizeChatMessageContents(rawMessageContents);
            ChatDB.ChatMessage? message = ChatDB.AddMessage(
                thread.ThreadId,
                accountId.Value,
                contents);

            if (message == null)
            {
                return BadRequest(new
                {
                    chatThread = (object?)null,
                    chatResult = 6
                });
            }

            object messageDto = BuildChatMessageDto(message);
            long[] recipients = thread.MemberIds
                .Where(id => id != accountId.Value)
                .Distinct()
                .ToArray();

            await Task.WhenAll(recipients.Select(memberId =>
                NotiController.NotifyChatMessageReceivedAsync(
                    memberId,
                    messageDto)));

            object threadDto = BuildChatThreadDto(
                thread,
                accountId.Value,
                messageCount: 50);

            Console.WriteLine(
                $"[CHAT LIVE] message={message.MessageId} thread={thread.ThreadId} " +
                $"sender={accountId.Value} recipients={string.Join(',', recipients)}");

            return Ok(new
            {
                chatResult = 0,
                chatThread = threadDto
            });
        }

        private static HashSet<long> ResolveChatMemberIds(
            ParsedChatThreadRequest parsed,
            long requestingAccountId)
        {
            parsed.MemberIds.Remove(requestingAccountId);
            parsed.CandidateIds.Remove(requestingAccountId);

            HashSet<long> validExplicitIds = parsed.MemberIds
                .Where(ChatPlayerExists)
                .ToHashSet();

            HashSet<long> selectedIds = validExplicitIds.Count > 0
                ? validExplicitIds
                : parsed.CandidateIds
                    .Where(ChatPlayerExists)
                    .ToHashSet();

            selectedIds.Remove(requestingAccountId);
            return selectedIds;
        }

        private void LogChatRequest(
            ParsedChatThreadRequest parsed,
            IEnumerable<long> selectedIds)
        {
            Console.WriteLine(
                $"[CHAT REQUEST] contentType={Request.ContentType ?? "none"} " +
                $"contentLength={(Request.ContentLength?.ToString() ?? "null")} " +
                $"explicit={string.Join(',', parsed.MemberIds)} " +
                $"candidates={string.Join(',', parsed.CandidateIds)} " +
                $"selected={string.Join(',', selectedIds)} " +
                $"body={parsed.RawBodyPreview}");
        }

        private static bool ChatPlayerExists(long playerId) =>
            playerId > 0 && PlayerDB.Players.FindById(playerId)?.Player != null;

        private object BuildChatThreadDto(
            ChatDB.ChatThread thread,
            long viewerAccountId,
            int messageCount)
        {
            messageCount = Math.Clamp(messageCount, 1, 100);

            object[] messages = ChatDB
                .GetMessages(thread.ThreadId, viewerAccountId, messageCount)
                .Select(BuildChatMessageDto)
                .ToArray();

            int[] playerIds = thread.MemberIds
                .Where(id => id is > 0 and <= int.MaxValue)
                .Select(id => checked((int)id))
                .ToArray();

            return new
            {
                chatThreadId = thread.ThreadId,
                playerIds,
                lastReadMessageId = ChatDB.GetLastReadMessageId(
                    thread.ThreadId,
                    viewerAccountId),
                messages,
                chatThreadName = thread.Name,
                snoozedUntil = (DateTime?)null,
                isFavorited = false
            };
        }

        private static object BuildChatMessageDto(ChatDB.ChatMessage message)
        {
            int senderPlayerId = message.SenderAccountId is >= int.MinValue and <= int.MaxValue
                ? checked((int)message.SenderAccountId)
                : 0;

            return new
            {
                chatMessageId = message.MessageId,
                chatThreadId = message.ThreadId,
                senderPlayerId,
                timeSent = message.CreatedAt,
                contents = message.Body,
                moderationState = 0
            };
        }

        private async Task<ParsedChatThreadRequest> ReadChatThreadRequestAsync()
        {
            var parsed = new ParsedChatThreadRequest();

            foreach (KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues> entry in Request.Query)
            {
                bool memberKey = IsChatMemberKey(entry.Key);
                foreach (string? value in entry.Value)
                {
                    if (memberKey)
                        AddChatIds(value, parsed.MemberIds);
                    AddChatIds(value, parsed.CandidateIds);
                }
            }

            parsed.Name =
                Request.Query["Name"].FirstOrDefault() ??
                Request.Query["name"].FirstOrDefault();

            if (int.TryParse(
                    Request.Query["Type"].FirstOrDefault() ??
                    Request.Query["type"].FirstOrDefault(),
                    out int queryType))
            {
                parsed.Type = queryType;
            }

            if (Request.HasFormContentType)
            {
                IFormCollection form = await Request.ReadFormAsync();

                foreach (KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues> entry in form)
                {
                    bool memberKey = IsChatMemberKey(entry.Key);

                    if (memberKey || LooksLikeChatIdData(entry.Key))
                    {
                        AddChatIds(
                            entry.Key,
                            memberKey ? parsed.MemberIds : parsed.CandidateIds);
                    }

                    foreach (string? value in entry.Value)
                    {
                        if (memberKey)
                            AddChatIds(value, parsed.MemberIds);
                        AddChatIds(value, parsed.CandidateIds);
                    }
                }

                parsed.Name ??=
                    form["Name"].FirstOrDefault() ??
                    form["name"].FirstOrDefault();

                if (int.TryParse(
                        form["Type"].FirstOrDefault() ??
                        form["type"].FirstOrDefault(),
                        out int formType))
                {
                    parsed.Type = formType;
                }

                return parsed;
            }

            Request.EnableBuffering();
            if (Request.Body.CanSeek)
                Request.Body.Position = 0;

            string rawBody;
            using (var reader = new StreamReader(
                       Request.Body,
                       Encoding.UTF8,
                       detectEncodingFromByteOrderMarks: true,
                       bufferSize: 4096,
                       leaveOpen: true))
            {
                rawBody = await reader.ReadToEndAsync();
            }

            if (Request.Body.CanSeek)
                Request.Body.Position = 0;

            parsed.RawBodyPreview = MakeChatBodyPreview(rawBody);
            if (string.IsNullOrWhiteSpace(rawBody))
                return parsed;

            try
            {
                using JsonDocument document = JsonDocument.Parse(rawBody);
                ReadChatThreadJson(
                    document.RootElement,
                    parsed,
                    memberContext: document.RootElement.ValueKind != JsonValueKind.Object);
            }
            catch (JsonException)
            {
                foreach (string pair in rawBody.Split(
                             '&',
                             StringSplitOptions.RemoveEmptyEntries))
                {
                    string[] parts = pair.Split('=', 2);
                    string key = Uri.UnescapeDataString(parts[0].Replace('+', ' '));
                    string value = parts.Length > 1
                        ? Uri.UnescapeDataString(parts[1].Replace('+', ' '))
                        : string.Empty;

                    bool memberKey = IsChatMemberKey(key);
                    if (memberKey)
                        AddChatIds(value, parsed.MemberIds);
                    AddChatIds(value, parsed.CandidateIds);

                    if (string.Equals(key, "name", StringComparison.OrdinalIgnoreCase))
                        parsed.Name = value;
                    else if (string.Equals(key, "type", StringComparison.OrdinalIgnoreCase) &&
                             int.TryParse(value, out int bodyType))
                        parsed.Type = bodyType;
                }
            }

            AddChatIds(rawBody, parsed.CandidateIds);
            return parsed;
        }

        private static void ReadChatThreadJson(
            JsonElement element,
            ParsedChatThreadRequest parsed,
            bool memberContext)
        {
            switch (element.ValueKind)
            {
                case JsonValueKind.Number:
                    if (element.TryGetInt64(out long number) && number > 0)
                    {
                        parsed.CandidateIds.Add(number);
                        if (memberContext)
                            parsed.MemberIds.Add(number);
                    }
                    return;

                case JsonValueKind.String:
                {
                    string? value = element.GetString();
                    AddChatIds(value, parsed.CandidateIds);
                    if (memberContext)
                        AddChatIds(value, parsed.MemberIds);

                    if (!string.IsNullOrWhiteSpace(value) &&
                        (value.TrimStart().StartsWith('{') ||
                         value.TrimStart().StartsWith('[')))
                    {
                        try
                        {
                            using JsonDocument nested = JsonDocument.Parse(value);
                            ReadChatThreadJson(nested.RootElement, parsed, memberContext);
                        }
                        catch (JsonException)
                        {
                        }
                    }
                    return;
                }

                case JsonValueKind.Array:
                    foreach (JsonElement item in element.EnumerateArray())
                        ReadChatThreadJson(item, parsed, memberContext: true);
                    return;

                case JsonValueKind.Object:
                    foreach (JsonProperty property in element.EnumerateObject())
                    {
                        if (string.Equals(property.Name, "name", StringComparison.OrdinalIgnoreCase) &&
                            property.Value.ValueKind == JsonValueKind.String)
                        {
                            parsed.Name = property.Value.GetString();
                            continue;
                        }

                        if (string.Equals(property.Name, "type", StringComparison.OrdinalIgnoreCase) &&
                            property.Value.TryGetInt32(out int type))
                        {
                            parsed.Type = type;
                            continue;
                        }

                        ReadChatThreadJson(
                            property.Value,
                            parsed,
                            memberContext || IsChatMemberKey(property.Name));
                    }
                    return;
            }
        }

        private static bool IsChatMemberKey(string? key)
        {
            if (string.IsNullOrWhiteSpace(key))
                return false;

            if (ChatMemberIdKeys.Contains(key, StringComparer.OrdinalIgnoreCase))
                return true;

            string normalized = new string(key
                .Where(char.IsLetterOrDigit)
                .Select(char.ToLowerInvariant)
                .ToArray());

            return normalized.Contains("memberid") ||
                   normalized.Contains("playerid") ||
                   normalized.Contains("accountid") ||
                   normalized.Contains("userid") ||
                   normalized.Contains("recipientid") ||
                   normalized.Contains("receiverid") ||
                   normalized.Contains("targetid") ||
                   normalized is "members" or "players" or "accounts" or
                       "recipients" or "receivers" or "ids";
        }

        private static bool LooksLikeChatIdData(string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            string trimmed = value.Trim();
            return char.IsDigit(trimmed[0]) ||
                   trimmed[0] is '[' or '{' or '"';
        }

        private static string MakeChatBodyPreview(string? body)
        {
            if (string.IsNullOrWhiteSpace(body))
                return "<empty>";

            string oneLine = body
                .Replace("\r", " ")
                .Replace("\n", " ")
                .Trim();

            return oneLine.Length <= 500
                ? oneLine
                : oneLine[..500] + "...";
        }

        private async Task<string?> ReadChatMessageBodyAsync()
        {
            foreach (string key in ChatMessageKeys)
            {
                string? value = Request.Query[key].FirstOrDefault();
                if (!string.IsNullOrWhiteSpace(value))
                    return value;
            }

            if (Request.HasFormContentType)
            {
                IFormCollection form = await Request.ReadFormAsync();
                foreach (string key in ChatMessageKeys)
                {
                    string? value = form[key].FirstOrDefault();
                    if (!string.IsNullOrWhiteSpace(value))
                        return value;
                }

                return null;
            }

            Request.EnableBuffering();
            if (Request.Body.CanSeek)
                Request.Body.Position = 0;

            string rawBody;
            using (var reader = new StreamReader(
                       Request.Body,
                       Encoding.UTF8,
                       detectEncodingFromByteOrderMarks: true,
                       bufferSize: 4096,
                       leaveOpen: true))
            {
                rawBody = await reader.ReadToEndAsync();
            }

            if (Request.Body.CanSeek)
                Request.Body.Position = 0;

            if (string.IsNullOrWhiteSpace(rawBody))
                return null;

            try
            {
                using JsonDocument document = JsonDocument.Parse(rawBody);
                string? found = FindChatContents(
                    document.RootElement,
                    ChatMessageKeys,
                    allowBareString: true);

                if (!string.IsNullOrWhiteSpace(found))
                    return found;

                if (document.RootElement.ValueKind == JsonValueKind.Object &&
                    (TryGetJsonPropertyIgnoreCase(
                         document.RootElement,
                         "Data",
                         out _) ||
                     TryGetJsonPropertyIgnoreCase(
                         document.RootElement,
                         "Type",
                         out _)))
                {
                    return document.RootElement.GetRawText();
                }
            }
            catch (JsonException)
            {
                foreach (string pair in rawBody.Split(
                             '&',
                             StringSplitOptions.RemoveEmptyEntries))
                {
                    string[] parts = pair.Split('=', 2);
                    string key = Uri.UnescapeDataString(
                        parts[0].Replace('+', ' '));
                    string value = parts.Length > 1
                        ? Uri.UnescapeDataString(parts[1].Replace('+', ' '))
                        : string.Empty;

                    if (ChatMessageKeys.Contains(
                            key,
                            StringComparer.OrdinalIgnoreCase) &&
                        !string.IsNullOrWhiteSpace(value))
                    {
                        return value;
                    }
                }

                return rawBody.Trim().Trim('"');
            }

            return null;
        }

        private static string? FindChatContents(
            JsonElement element,
            IReadOnlyCollection<string> keys,
            bool allowBareString)
        {
            if (element.ValueKind == JsonValueKind.String)
            {
                return allowBareString
                    ? element.GetString()
                    : null;
            }

            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    if (!keys.Contains(
                            property.Name,
                            StringComparer.OrdinalIgnoreCase))
                    {
                        continue;
                    }

                    return property.Value.ValueKind == JsonValueKind.String
                        ? property.Value.GetString()
                        : property.Value.GetRawText();
                }

                foreach (JsonProperty property in element.EnumerateObject())
                {
                    string? nested = FindChatContents(
                        property.Value,
                        keys,
                        allowBareString: false);
                    if (!string.IsNullOrWhiteSpace(nested))
                        return nested;
                }
            }

            if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (JsonElement item in element.EnumerateArray())
                {
                    string? nested = FindChatContents(
                        item,
                        keys,
                        allowBareString: false);
                    if (!string.IsNullOrWhiteSpace(nested))
                        return nested;
                }
            }

            return null;
        }

        private static bool TryGetJsonPropertyIgnoreCase(
            JsonElement element,
            string name,
            out JsonElement value)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    if (string.Equals(
                            property.Name,
                            name,
                            StringComparison.OrdinalIgnoreCase))
                    {
                        value = property.Value;
                        return true;
                    }
                }
            }

            value = default;
            return false;
        }

        private static string NormalizeChatMessageContents(string rawContents)
        {
            string value = rawContents.Trim();

            try
            {
                using JsonDocument document = JsonDocument.Parse(value);

                if (document.RootElement.ValueKind == JsonValueKind.String)
                {
                    value = document.RootElement.GetString() ?? string.Empty;
                }
                else if (document.RootElement.ValueKind is
                         JsonValueKind.Object or JsonValueKind.Array)
                {
                    return document.RootElement.GetRawText();
                }
            }
            catch (JsonException)
            {
            }

            return JsonSerializer.Serialize(new
            {
                Data = value,
                Type = 0,
                Version = 1,
                Blocks = new[]
                {
                    new
                    {
                        Placeholder = value,
                        Type = "Text"
                    }
                }
            });
        }

        private static void AddChatIds(string? value, ISet<long> output)
        {
            if (string.IsNullOrWhiteSpace(value))
                return;

            foreach (System.Text.RegularExpressions.Match match in
                     System.Text.RegularExpressions.Regex.Matches(
                         value,
                         @"(?<![0-9])-?[0-9]+"))
            {
                if (long.TryParse(match.Value, out long id) && id > 0)
                    output.Add(id);
            }
        }

        private sealed class ParsedChatThreadRequest
        {
            public HashSet<long> MemberIds { get; } = new();
            public HashSet<long> CandidateIds { get; } = new();
            public string? Name { get; set; }
            public int Type { get; set; }
            public string RawBodyPreview { get; set; } = "<not-read>";
        }

        [HttpGet("api/inventions/v1/featured")]
        public IActionResult GetFeaturedInventions(
            [FromQuery] int skip = 0,
            [FromQuery] int take = 100)
        {
            return Ok(CreatorFeatureDB.SearchInventions(skip: skip, take: take)
                .Select(CreatorFeatureDB.ToClientInvention)
                .ToArray());
        }

        [HttpPost("/api/inventions/v6/save")]
        [HttpPost("/api/inventions/v5/save")]
        [HttpPost("/api/inventions/v4/save")]
        [HttpPost("/api/inventions/v3/save")]
        [HttpPost("/api/inventions/v2/save")]
        [HttpPost("/api/inventions/v1/save")]
        [HttpPut("/api/inventions/v6/save")]
        [HttpPut("/api/inventions/v5/save")]
        [HttpPut("/api/inventions/v4/save")]
        [HttpPut("/api/inventions/v3/save")]
        [HttpPut("/api/inventions/v2/save")]
        [HttpPut("/api/inventions/v1/save")]
        [HttpGet("/api/inventions/v3/update")]
        [HttpGet("/api/inventions/v2/update")]
        [HttpGet("/api/inventions/v1/update")]
        [HttpPost("/api/inventions/v3/update")]
        [HttpPost("/api/inventions/v2/update")]
        [HttpPost("/api/inventions/v1/update")]
        [HttpPut("/api/inventions/v3/update")]
        [HttpPut("/api/inventions/v2/update")]
        [HttpPut("/api/inventions/v1/update")]
        [HttpPost("/api/inventions/v6")]
        [HttpPut("/api/inventions/v6")]
        [HttpPost("/api/inventions/v5")]
        [HttpPut("/api/inventions/v5")]
        [HttpPost("/api/inventions/v4")]
        [HttpPut("/api/inventions/v4")]
        [HttpPost("/api/inventions/v3")]
        [HttpPut("/api/inventions/v3")]
        [HttpPost("/api/inventions/v2")]
        [HttpPut("/api/inventions/v2")]
        [HttpPost("/api/inventions/v1")]
        [HttpPut("/api/inventions/v1")]
        [RequestSizeLimit(10 * 1024 * 1024)]
        [RequestFormLimits(MultipartBodyLengthLimit = 10 * 1024 * 1024)]
        public async Task<IActionResult> SaveInvention()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            JsonElement request;
            var createdFiles = new List<string>();
            try
            {
                if (Request.HasFormContentType)
                {
                    IFormCollection form = await Request.ReadFormAsync(
                        HttpContext.RequestAborted);
                    var payload = new JsonObject();
                    foreach (KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues> field
                             in form)
                    {
                        if (field.Value.Count > 0)
                            payload[field.Key] = field.Value[field.Value.Count - 1];
                    }

                    IFormFile? previewFile = form.Files.FirstOrDefault(
                        IsInventionPreviewFile);
                    IFormFile? dataFile = form.Files
                        .Where(file =>
                            !ReferenceEquals(file, previewFile) &&
                            !IsInventionPreviewFile(file))
                        .OrderByDescending(IsInventionDataFile)
                        .ThenByDescending(file => file.Length)
                        .FirstOrDefault();

                    if (previewFile == null && dataFile == null && form.Files.Count > 0)
                    {
                        IFormFile first = form.Files[0];
                        if (IsInventionPreviewFile(first))
                            previewFile = first;
                        else
                            dataFile = first;
                    }

                    if (previewFile != null && previewFile.Length > 0)
                    {
                        string imageName = await SaveInventionPreviewAsync(
                            previewFile,
                            createdFiles,
                            HttpContext.RequestAborted);
                        payload["ImageName"] = imageName;
                        payload["Image"] = imageName;
                        payload["PreviewImageName"] = imageName;
                    }

                    if (dataFile != null && dataFile.Length > 0)
                    {
                        string dataBlob = await SaveInventionDataAsync(
                            dataFile,
                            createdFiles,
                            HttpContext.RequestAborted);
                        payload["DataBlob"] = dataBlob;
                        payload["DataBlobName"] = Path.GetFileName(dataBlob);
                        payload["Filename"] = Path.GetFileName(dataBlob);
                    }

                    request = JsonSerializer.SerializeToElement(payload);
                }
                else if ((Request.ContentLength ?? 0) > 0)
                {
                    using JsonDocument document = await JsonDocument.ParseAsync(
                        Request.Body,
                        cancellationToken: HttpContext.RequestAborted);
                    request = document.RootElement.Clone();
                }
                else
                {

                    using JsonDocument emptyDocument = JsonDocument.Parse("{}");
                    request = emptyDocument.RootElement.Clone();
                }

                request = NormalizeInventionRequest(request, createdFiles);
                request = MergeInventionQuery(request, Request.Query);
            }
            catch (JsonException)
            {
                DeleteNewInventionFiles(createdFiles);
                return BadRequest(new { Success = false, Error = "invalid_invention_payload" });
            }
            catch (InvalidDataException exception)
            {
                DeleteNewInventionFiles(createdFiles);
                return BadRequest(new { Success = false, Error = exception.Message });
            }
            catch (IOException exception)
            {
                DeleteNewInventionFiles(createdFiles);
                Console.WriteLine($"[INVENTIONS] upload failed: {exception.Message}");
                return StatusCode(
                    StatusCodes.Status500InternalServerError,
                    new { Success = false, Error = "invention_file_save_failed" });
            }

            try
            {
                CreatorFeatureDB.InventionRecord record =
                    CreatorFeatureDB.SaveInvention(accountId.Value, request);

                Console.WriteLine(
                    $"[INVENTIONS] saved={record.InventionId} " +
                    $"creator={accountId.Value} room={record.RoomId} " +
                    $"version={record.Version}");

                bool hasValidObjects = CreatorFeatureDB.HasValidInventionBlob(record);
                object clientValue = CreatorFeatureDB.ToClientInvention(record);
                if (!hasValidObjects)
                {
                    Console.WriteLine(
                        $"[INVENTIONS] missing-object-blob id={record.InventionId} " +
                        $"creator={record.CreatorAccountId} dataBlob={record.DataBlob}");
                }

                object? clientVersion = CreatorFeatureDB.ToClientInventionVersion(record);
                return Ok(new
                {

                    Result = hasValidObjects ? 0 : 8,
                    InventionResponse = clientValue,
                    InventionVersionResponse = clientVersion,

                    InventionId = record.InventionId,
                    Id = record.InventionId,
                    Version = record.Version,
                    Success = hasValidObjects,
                    CanSpawn = hasValidObjects,
                    Error = hasValidObjects ? null : "invention_object_blob_missing",
                    Value = clientValue,
                    Invention = clientValue,
                    CurrentVersion = clientVersion
                });
            }
            catch (UnauthorizedAccessException exception)
            {
                DeleteNewInventionFiles(createdFiles);
                return StatusCode(
                    StatusCodes.Status403Forbidden,
                    new { Success = false, Error = exception.Message });
            }
            catch (ArgumentException exception)
            {
                DeleteNewInventionFiles(createdFiles);
                return BadRequest(new { Success = false, Error = exception.Message });
            }
        }

        private static JsonElement MergeInventionQuery(
            JsonElement request,
            IQueryCollection query)
        {
            if (query.Count == 0)
                return request;

            JsonObject payload = request.ValueKind == JsonValueKind.Object
                ? JsonNode.Parse(request.GetRawText())?.AsObject() ?? new JsonObject()
                : new JsonObject { ["Value"] = request.GetRawText() };

            foreach (KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues> field
                     in query)
            {
                if (payload.ContainsKey(field.Key) && payload[field.Key] != null)
                    continue;
                if (field.Value.Count == 1)
                    payload[field.Key] = field.Value[0];
                else if (field.Value.Count > 1)
                    payload[field.Key] = new JsonArray(
                        field.Value.Select(value => JsonValue.Create(value)).ToArray());
            }

            MergeNestedInventionMetadata(payload);
            return JsonSerializer.SerializeToElement(payload);
        }

        private static JsonElement NormalizeInventionRequest(
            JsonElement request,
            ICollection<string> createdFiles)
        {
            JsonObject payload = request.ValueKind == JsonValueKind.Object
                ? JsonNode.Parse(request.GetRawText())?.AsObject() ?? new JsonObject()
                : new JsonObject { ["Value"] = request.GetRawText() };

            MergeNestedInventionMetadata(payload);
            PromoteUploadedInventionBlob(payload, createdFiles);
            return JsonSerializer.SerializeToElement(payload);
        }

        private static void MergeNestedInventionMetadata(JsonObject payload)
        {
            foreach (string key in new[]
                     {
                         "invention", "Invention", "metadata", "Metadata",
                         "inventionData", "InventionData",
                         "inventionMetadata", "InventionMetadata",
                         "request", "Request", "payload", "Payload",
                         "data", "Data", "value", "Value", "json", "Json"
                     })
            {
                if (!payload.TryGetPropertyValue(key, out JsonNode? node) || node == null)
                    continue;

                JsonObject? nested = node as JsonObject;
                if (nested == null && node is JsonValue value &&
                    value.TryGetValue<string>(out string? raw) &&
                    !string.IsNullOrWhiteSpace(raw))
                {
                    try
                    {
                        nested = JsonNode.Parse(raw) as JsonObject;
                    }
                    catch (JsonException)
                    {
                    }
                }

                if (nested == null)
                    continue;

                foreach (KeyValuePair<string, JsonNode?> property in nested.ToArray())
                {
                    if (!payload.ContainsKey(property.Key) || payload[property.Key] == null)
                        payload[property.Key] = property.Value?.DeepClone();
                }
            }
        }

        private static void PromoteUploadedInventionBlob(
            JsonObject payload,
            ICollection<string> createdFiles)
        {
            string? raw = ReadJsonNodeString(
                payload,
                "DataBlob", "dataBlob", "DataBlobName", "dataBlobName",
                "Filename", "filename", "FileName", "fileName",
                "ObjectDataFilename", "objectDataFilename",
                "ObjectDataBlob", "objectDataBlob",
                "BlobName", "blobName");
            if (string.IsNullOrWhiteSpace(raw))
                return;

            string normalized = raw.Replace('\\', '/').Trim();
            if (normalized.StartsWith("/cdn/", StringComparison.OrdinalIgnoreCase))
                normalized = normalized[5..];
            normalized = normalized.TrimStart('/');
            if (normalized.Contains("..", StringComparison.Ordinal))
                throw new InvalidDataException("The invention blob path is invalid.");

            string safeName = Path.GetFileName(normalized);
            if (safeName.Length == 0 || safeName.Length > 180)
                throw new InvalidDataException("The invention blob name is invalid.");

            string baseName = Path.GetFileNameWithoutExtension(safeName);
            if (string.IsNullOrWhiteSpace(baseName))
                baseName = safeName;
            string canonicalName = safeName.EndsWith(
                    ".inv",
                    StringComparison.OrdinalIgnoreCase)
                ? safeName
                : baseName + ".inv";

            string inventionDirectory = Path.Combine(Program.dataDir, "CDN", "invention");
            Directory.CreateDirectory(inventionDirectory);
            string inventionPath = Path.Combine(inventionDirectory, canonicalName);
            string existingInventionPath = Path.Combine(inventionDirectory, safeName);
            string uploadedRoomPath = Path.Combine(Program.dataDir, "CDN", "room", safeName);
            string uploadedCanonicalRoomPath = Path.Combine(
                Program.dataDir,
                "CDN",
                "room",
                canonicalName);

            string? sourcePath = new[]
                {
                    existingInventionPath,
                    uploadedRoomPath,
                    uploadedCanonicalRoomPath
                }
                .FirstOrDefault(System.IO.File.Exists);
            if (!System.IO.File.Exists(inventionPath) && sourcePath != null)
            {
                System.IO.File.Copy(sourcePath, inventionPath, overwrite: false);
                createdFiles.Add(inventionPath);
            }

            string storedPath = "invention/" + canonicalName;
            payload["DataBlob"] = storedPath;
            payload["dataBlob"] = storedPath;
            payload["DataBlobName"] = canonicalName;
            payload["Filename"] = canonicalName;
            payload["ObjectDataFilename"] = canonicalName;
            payload["ObjectDataBlob"] = canonicalName;
        }

        private static string? ReadJsonNodeString(
            JsonObject payload,
            params string[] keys)
        {
            foreach (string key in keys)
            {
                if (!payload.TryGetPropertyValue(key, out JsonNode? node) || node == null)
                    continue;
                if (node is JsonValue value && value.TryGetValue<string>(out string? text))
                    return text;
                string raw = node.ToJsonString().Trim();
                if (raw.Length > 1 && raw[0] == '"' && raw[^1] == '"')
                {
                    try
                    {
                        return JsonSerializer.Deserialize<string>(raw);
                    }
                    catch (JsonException)
                    {
                    }
                }
                return raw;
            }
            return null;
        }

        private static bool IsInventionDataFile(IFormFile file)
        {
            string fieldName = file.Name ?? string.Empty;
            if (fieldName.Contains("object", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Contains("blob", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Contains("data", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Equals("file", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Contains("invention", StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            string extension = Path.GetExtension(file.FileName);
            return !extension.Equals(".png", StringComparison.OrdinalIgnoreCase) &&
                   !extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase) &&
                   !extension.Equals(".jpeg", StringComparison.OrdinalIgnoreCase) &&
                   !extension.Equals(".webp", StringComparison.OrdinalIgnoreCase) &&
                   !extension.Equals(".gif", StringComparison.OrdinalIgnoreCase) &&
                   !extension.Equals(".bmp", StringComparison.OrdinalIgnoreCase);
        }

        private static bool IsInventionPreviewFile(IFormFile file)
        {
            string fieldName = file.Name ?? string.Empty;
            if (fieldName.Contains("preview", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Contains("thumbnail", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Contains("image", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Contains("photo", StringComparison.OrdinalIgnoreCase) ||
                fieldName.Contains("icon", StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            if (file.ContentType?.StartsWith(
                    "image/",
                    StringComparison.OrdinalIgnoreCase) == true)
            {
                return true;
            }

            string extension = Path.GetExtension(file.FileName);
            return extension.Equals(".png", StringComparison.OrdinalIgnoreCase) ||
                   extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase) ||
                   extension.Equals(".jpeg", StringComparison.OrdinalIgnoreCase) ||
                   extension.Equals(".webp", StringComparison.OrdinalIgnoreCase) ||
                   extension.Equals(".gif", StringComparison.OrdinalIgnoreCase) ||
                   extension.Equals(".bmp", StringComparison.OrdinalIgnoreCase);
        }

        private static async Task<string> SaveInventionPreviewAsync(
            IFormFile file,
            ICollection<string> createdFiles,
            CancellationToken cancellationToken)
        {
            const long maxPreviewBytes = 8L * 1024L * 1024L;
            if (file.Length <= 0 || file.Length > maxPreviewBytes)
                throw new InvalidDataException("Invention previews must be 8 MB or smaller.");

            byte[] bytes;
            await using (var buffer = new MemoryStream())
            {
                await file.CopyToAsync(buffer, cancellationToken);
                bytes = buffer.ToArray();
            }

            SixLabors.ImageSharp.ImageInfo? info = Image.Identify(bytes);
            SixLabors.ImageSharp.Formats.IImageFormat? format = Image.DetectFormat(bytes);
            if (info == null || format == null ||
                info.Width <= 0 || info.Height <= 0 ||
                info.Width > 8192 || info.Height > 8192 ||
                (long)info.Width * info.Height > 40_000_000)
            {
                throw new InvalidDataException("The invention preview is not a safe image.");
            }

            string extension = format.FileExtensions
                .Select(value => value.Trim().TrimStart('.').ToLowerInvariant())
                .FirstOrDefault(value => value.Length is > 0 and <= 8 &&
                    value.All(char.IsLetterOrDigit)) ?? "png";
            string filename = $"{Guid.NewGuid():N}.{extension}";
            string relativePath = $"Inventions/{filename}";
            string directory = Path.Combine(Program.dataDir, "Images", "Inventions");
            Directory.CreateDirectory(directory);
            string path = Path.Combine(directory, filename);
            await System.IO.File.WriteAllBytesAsync(path, bytes, cancellationToken);
            createdFiles.Add(path);
            return relativePath;
        }

        private static async Task<string> SaveInventionDataAsync(
            IFormFile file,
            ICollection<string> createdFiles,
            CancellationToken cancellationToken)
        {
            const long maxDataBytes = 9L * 1024L * 1024L;
            if (file.Length <= 0 || file.Length > maxDataBytes)
                throw new InvalidDataException("Invention data must be 9 MB or smaller.");

            string filename = $"{Guid.NewGuid():N}.inv";
            string directory = Path.Combine(Program.dataDir, "CDN", "invention");
            Directory.CreateDirectory(directory);
            string path = Path.Combine(directory, filename);
            await using (var output = new FileStream(
                path,
                FileMode.CreateNew,
                FileAccess.Write,
                FileShare.None,
                81_920,
                FileOptions.Asynchronous | FileOptions.SequentialScan))
            {
                await file.CopyToAsync(output, cancellationToken);
            }
            createdFiles.Add(path);
            return $"invention/{filename}";
        }

        private static void DeleteNewInventionFiles(IEnumerable<string> paths)
        {
            foreach (string path in paths)
            {
                try
                {
                    if (System.IO.File.Exists(path))
                        System.IO.File.Delete(path);
                }
                catch (IOException)
                {
                }
                catch (UnauthorizedAccessException)
                {
                }
            }
        }

        [HttpGet("api/customAvatarItems/v1/hot")]
        public IActionResult GetHotCustomAvatarItems()
        {
            var items = new[]
            {
        new { itemId = 101, name = "Fire Hoodie", tags = new[] { "hot", "new" } },
        new { itemId = 102, name = "Drip Sneakers", tags = new[] { "hot" } },
        new { itemId = 103, name = "Sus Hat", tags = new[] { "trending" } }
    };
            return Ok(items);
        }

        [HttpGet("/config/categories")]
        public IActionResult GetConfigCategories()
        {
            string path = Path.Combine(Program.dataDir, "APIS", "GameConfigs.json");
            if (!System.IO.File.Exists(path))
                return Ok(new { Categories = Array.Empty<object>() });

            string json = System.IO.File.ReadAllText(path);
            var entries = JsonSerializer.Deserialize<List<Dictionary<string, object>>>(json, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
            if (entries == null)
                return Ok(new { Categories = Array.Empty<object>() });

            var categoryEntry = entries.FirstOrDefault(entry => entry.TryGetValue("Key", out var key) && key?.ToString() == "Growth.RoomCategoriesJson");
            if (categoryEntry == null || !categoryEntry.TryGetValue("Value", out var value) || value == null)
                return Ok(new { Categories = Array.Empty<object>() });

            try
            {
                JsonElement categories = JsonSerializer.Deserialize<JsonElement>(
                    value.ToString() ?? "[]");
                return Ok(new { Categories = categories });
            }
            catch
            {
                return Ok(new { Categories = Array.Empty<object>() });
            }
        }

        [HttpGet("/api/PlayerCheer/v1/images")]
        public IActionResult GetPlayerCheersForImages([FromQuery] List<string> imageIds)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new Dictionary<string, object>());
        }

        [HttpPost("/api/PlayerCheer/v1/create")]
        [RequestSizeLimit(64 * 1024)]
        public async Task<IActionResult> CreatePlayerCheer()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            var values = new Dictionary<string, string>(
                StringComparer.OrdinalIgnoreCase);

            foreach (var queryValue in Request.Query)
                values[queryValue.Key] = queryValue.Value.ToString();

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();
                foreach (var formValue in form)
                    values[formValue.Key] = formValue.Value.ToString();
            }
            else
            {
                string body;
                using (var reader = new StreamReader(Request.Body))
                    body = await reader.ReadToEndAsync();

                if (string.IsNullOrWhiteSpace(body))
                    body = string.Empty;

                try
                {
                    if (!string.IsNullOrWhiteSpace(body))
                    {
                        using var document = JsonDocument.Parse(body);
                        AddJsonValues(document.RootElement, values);
                    }
                }
                catch (JsonException)
                {

                    foreach (var bodyValue in
                        Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(
                            "?" + body))
                    {
                        values[bodyValue.Key] = bodyValue.Value.ToString();
                    }
                }
            }

            foreach (string embeddedValue in values.Values.ToArray())
            {
                if (!embeddedValue.TrimStart().StartsWith('{'))
                    continue;

                try
                {
                    using var embedded = JsonDocument.Parse(embeddedValue);
                    AddJsonValues(embedded.RootElement, values);
                }
                catch (JsonException)
                {

                }
            }

            string? targetText = GetValue(values,
                "ReceiverAccountId", "ReceiverPlayerId", "ReceiverId",
                "CheerReceiverAccountId", "CheerReceiverPlayerId",
                "CheeredAccountId", "CheeredPlayerId", "PlayerToCheerId",
                "TargetAccountId", "TargetPlayerId", "ToAccountId",
                "ToPlayerId", "PlayerId", "PlayerID", "AccountId", "id");
            string? categoryText = GetValue(values,
                "CheerCategory", "CheerCategoryId", "CheerType",
                "Category", "CategoryId", "cheer");
            string? anonymousText = GetValue(values,
                "Anonymous", "anonymous", "IsAnonymous", "isAnonymous",
                "SendAnonymously", "sendAnonymously");

            if (!long.TryParse(targetText, out long receiverId))
            {

                var targetValue = values.FirstOrDefault(value =>
                    (value.Key.Contains("player", StringComparison.OrdinalIgnoreCase) ||
                     value.Key.Contains("account", StringComparison.OrdinalIgnoreCase) ||
                     value.Key.Contains("receiver", StringComparison.OrdinalIgnoreCase) ||
                     value.Key.Contains("target", StringComparison.OrdinalIgnoreCase)) &&
                    long.TryParse(value.Value, out long candidate) &&
                    candidate != (long)id);

                if (!long.TryParse(targetValue.Value, out receiverId))
                    return BadRequest(new { success = false, error = "invalid_player" });
            }

            if (!TryParseCheerCategory(categoryText, out CheerCategory category))
                category = CheerCategory.General;

            bool anonymous = ParseLooseBoolean(anonymousText);

            var cheer = PlayerDB.GivePlayerCheer(
                (long)id,
                receiverId,
                category,
                out NotificationDB.ClientNotification? notification,
                anonymous);

            if (cheer != null && notification != null)
            {

                await NotiController.NotifyCheerAsync(
                    receiverId,
                    notification,
                    (int)category);
            }

            Console.WriteLine(
                $"[PLAYER CHEER] sender={id.Value} receiver={receiverId} " +
                $"category={category} anonymous={anonymous} " +
                $"created={cheer != null}");

            return cheer == null
                ? BadRequest(new
                {
                    success = false,
                    message = "Unable to send cheer. Check the player and your available cheers.",
                    error = "invalid_player_or_no_cheer_credit"
                })
                : Ok(new
                {
                    success = true,
                    message = "Cheer sent.",
                    cheerId = cheer.CheerId,
                    notificationId = cheer.NotificationId,
                    remainingCheerCredits = PlayerDB
                        .GetReputationBulk(new List<long> { id.Value })
                        .FirstOrDefault()?.CheerCredit ?? 0
                });
        }

        [HttpGet("/api/PlayerCheer/v1/pending")]
        public IActionResult GetPendingPlayerCheers()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            return Ok(PlayerDB.GetPendingPlayerCheers(playerId.Value)
                .Select(cheer => new
                {
                    cheerId = cheer.CheerId,
                    notificationId = cheer.NotificationId,
                    fromPlayerId = cheer.Anonymous
                        ? 0
                        : cheer.GiverPlayerId,
                    receiverPlayerId = cheer.ReceiverPlayerId,
                    cheerCategory = (int)cheer.CheerCategory,
                    anonymous = cheer.Anonymous,
                    status = (int)cheer.Status,
                    createdAt = cheer.CreatedAt
                }));
        }

        [HttpPost("/api/PlayerCheer/v1/accept")]
        [RequestSizeLimit(16 * 1024)]
        public Task<IActionResult> AcceptPlayerCheer() =>
            ResolvePlayerCheerAsync(CheerStatus.Accepted);

        [HttpPost("/api/PlayerCheer/v1/dismiss")]
        [RequestSizeLimit(16 * 1024)]
        public Task<IActionResult> DismissPlayerCheer() =>
            ResolvePlayerCheerAsync(CheerStatus.Dismissed);

        private async Task<IActionResult> ResolvePlayerCheerAsync(
            CheerStatus status)
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            HashSet<long> ids = await ReadLongValuesAsync(
                "CheerIds", "cheerIds", "CheerId", "cheerId",
                "NotificationIds", "notificationIds",
                "NotificationId", "notificationId",
                "MessageIds", "messageIds", "MessageId", "messageId",
                "Id", "id");

            if (ids.Count == 0)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "missing_cheer_id"
                });
            }

            List<PlayerCheerRecord> matching =
                PlayerDB.GetPendingPlayerCheers(playerId.Value)
                    .Where(cheer =>
                        ids.Contains(cheer.CheerId) ||
                        ids.Contains(cheer.NotificationId))
                    .ToList();

            int resolved = PlayerDB.ResolvePlayerCheers(
                playerId.Value,
                ids,
                status);

            int deleted = NotificationDB.DeleteMessages(
                playerId.Value,
                matching.Select(cheer => cheer.NotificationId));

            return Ok(new
            {
                success = resolved > 0,
                resolved,
                deleted,
                status = status.ToString()
            });
        }

        [HttpPost("/api/PlayerCheer/v1/SetSelectedCheer")]
        [RequestSizeLimit(16 * 1024)]
        public async Task<IActionResult> SetSelectedCheer()
        {
            var player = AuthStuff.GetCurrentPlayer(Request);
            if (player?.Player == null)
                return Unauthorized();

            string? categoryText = Request.Query["CheerCategory"].FirstOrDefault();
            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();
                categoryText ??= form["CheerCategory"].FirstOrDefault();
            }

            if (!int.TryParse(categoryText, out int rawCategory) ||
                !Enum.IsDefined(typeof(CheerCategory), rawCategory))
                return BadRequest();

            bool isDeveloper = player.PlayerRoles?.Contains(
                PlayerDBClasses.PlayerRoles.Developer) == true;
            if (!isDeveloper &&
                rawCategory == (int)CheerCategory.RecRoomDeveloper)
                return StatusCode(403);

            player.Player.Reputation ??= new Reputation();
            player.Player.Reputation.IsCheerful = true;
            player.Player.Reputation.SelectedCheer = (CheerCategory)rawCategory;
            PlayerDB.Players.Update(player);
            return NoContent();
        }

        private static string? GetValue(
            Dictionary<string, string> values,
            params string[] keys)
        {
            foreach (string key in keys)
            {
                if (values.TryGetValue(key, out string? value) &&
                    !string.IsNullOrWhiteSpace(value))
                    return value;
            }

            return null;
        }

        private static void AddJsonValues(
            JsonElement element,
            Dictionary<string, string> values)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (var property in element.EnumerateObject())
                {
                    if (property.Value.ValueKind is JsonValueKind.Object or
                        JsonValueKind.Array)
                    {
                        AddJsonValues(property.Value, values);
                    }
                    else
                    {
                        values[property.Name] = property.Value.ToString();
                    }
                }

                return;
            }

            if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (var item in element.EnumerateArray())
                    AddJsonValues(item, values);
            }
        }

        private static bool TryParseCheerCategory(
            string? value,
            out CheerCategory category)
        {
            category = CheerCategory.General;
            if (string.IsNullOrWhiteSpace(value))
                return false;

            if (int.TryParse(value, out int rawCategory) &&
                Enum.IsDefined(typeof(CheerCategory), rawCategory))
            {
                category = (CheerCategory)rawCategory;
                return category is CheerCategory.General or
                    CheerCategory.Helpful or
                    CheerCategory.Sportmanship or
                    CheerCategory.GreatHost or
                    CheerCategory.Creative;
            }

            string normalized = value.Replace(" ", string.Empty)
                .Replace("Sportsmanship", "Sportmanship",
                    StringComparison.OrdinalIgnoreCase)
                .Replace("GoodSport", "Sportmanship",
                    StringComparison.OrdinalIgnoreCase);
            return Enum.TryParse(normalized, true, out category) &&
                   category is CheerCategory.General or
                       CheerCategory.Helpful or
                       CheerCategory.Sportmanship or
                       CheerCategory.GreatHost or
                       CheerCategory.Creative;
        }

        private static bool ParseLooseBoolean(string? value)
        {
            if (bool.TryParse(value, out bool parsed))
                return parsed;

            return string.Equals(value, "1", StringComparison.Ordinal) ||
                   string.Equals(value, "yes", StringComparison.OrdinalIgnoreCase) ||
                   string.Equals(value, "on", StringComparison.OrdinalIgnoreCase);
        }

        [HttpGet("/api/Leaderboard/v1/room/{roomId}")]
        public IActionResult GetRoomLeaderboard(long roomId)
        {
            return Ok(new
            {
                RoomId = roomId,
                Results = Array.Empty<object>(),
                TotalResults = 0
            });
        }

        [HttpGet("/api/catalog/v1/all")]
        public IActionResult GetCatalogAll(
            [FromQuery] bool onlyAvailableSkus = false)
        {
            return Ok(GetCatalogSkus());
        }

        [HttpPost("/api/storefronts/v1/purchase")]
        [HttpPost("/api/storefronts/v1/purchase/{skuId:long}")]
        [HttpPost("/api/storefronts/v2/purchase")]
        [HttpPost("/api/storefronts/v2/purchase/{skuId:long}")]
        [HttpPost("/api/storefronts/v2/buyItem")]
        [HttpPost("/api/storefronts/v3/purchase")]
        [HttpPost("/api/storefronts/v3/purchase/{skuId:long}")]
        [HttpPost("/api/storefronts/v4/purchase")]
        [HttpPost("/api/storefronts/v4/purchase/{skuId:long}")]
        [HttpPost("/api/catalog/v1/purchase")]
        [HttpPost("/api/catalog/v1/purchase/{skuId:long}")]
        [HttpPost("/purchase/v1/purchase")]
        [RequestSizeLimit(128 * 1024)]
        public async Task<IActionResult> PurchaseCatalogItem()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            ParsedCatalogPurchaseRequest purchaseRequest =
                await ReadCatalogPurchaseRequestAsync();
            purchaseRequest.Message = purchaseRequest.Message.Trim();
            if (purchaseRequest.Message.Length > 200)
            {
                return BadRequest(new
                {
                    Success = false,
                    Error = "gift_message_too_long"
                });
            }
            long? requestedSkuId = purchaseRequest.SkuId;

            Console.WriteLine(
                $"[STORE PURCHASE] buyer={accountId.Value} " +
                $"sku={requestedSkuId?.ToString() ?? "null"} " +
                $"recipient={purchaseRequest.RecipientPlayerId?.ToString() ?? "none"} " +
                $"giftContext={purchaseRequest.GiftContext}");

            if (!requestedSkuId.HasValue)
                return BadRequest(new { Success = false, Error = "missing_sku" });

            CatalogSku? sku = GetCatalogSkus().FirstOrDefault(value =>
                value.SkuId == requestedSkuId.Value ||
                value.PurchasableItemId == requestedSkuId.Value ||
                (value.AvatarItemId > 0 && value.AvatarItemId == requestedSkuId.Value) ||
                (IsConsumableCatalogItem(value) && value.ItemId == requestedSkuId.Value));

            if (sku == null)
                return NotFound(new { Success = false, Error = "sku_not_found" });

            long recipientId = purchaseRequest.RecipientPlayerId.GetValueOrDefault();
            bool isGift = recipientId > 0 && recipientId != accountId.Value;

            if (isGift)
            {
                if (recipientId > int.MaxValue ||
                    PlayerDB.Players.FindById(recipientId)?.Player == null)
                {
                    return NotFound(new
                    {
                        Success = false,
                        Error = "gift_recipient_not_found"
                    });
                }

                bool gifted = TryPurchaseCatalogSkuAsGift(
                    accountId.Value,
                    recipientId,
                    sku,
                    purchaseRequest.Message,
                    purchaseRequest.GiftContext,
                    out int giftBalance,
                    out bool recipientAlreadyOwned,
                    out GiftPackage? giftPackage);

                if (!gifted)
                {
                    return BadRequest(new
                    {
                        Success = false,
                        Error = "insufficient_funds",
                        Balance = giftBalance,
                        Price = StoreItemPrice
                    });
                }

                if (giftPackage != null)
                {
                    await NotiController.NotifyGiftAsync(
                        accountId.Value,
                        recipientId,
                        giftPackage);
                }

                Console.WriteLine(
                    $"[STORE GIFT] from={accountId.Value} to={recipientId} " +
                    $"sku={sku.SkuId} item={sku.FriendlyName} " +
                    $"package={giftPackage?.GiftPackageId ?? 0} " +
                    $"alreadyOwned={recipientAlreadyOwned}");

                return Ok(new
                {
                    Success = true,
                    Result = 0,
                    PurchaseResult = 0,
                    WasGift = true,
                    RecipientPlayerId = recipientId,
                    GiftPackageId = giftPackage?.GiftPackageId ?? 0,
                    AlreadyOwned = recipientAlreadyOwned,
                    Balance = giftBalance,
                    CurrencyType = (int)PlayerDBClasses.CurrencyType.RecCenterTokens,
                    BalanceType = (int)PlayerDBClasses.BalanceType.NonPurchasedDefault,
                    NewBalance = giftBalance,
                    Price = StoreItemPrice,
                    SkuId = sku.SkuId,
                    PurchasableItemId = sku.PurchasableItemId,
                    ItemId = sku.ItemId,
                    AvatarItemId = sku.AvatarItemId,
                    ConsumableItemDesc = sku.ConsumableItemDesc,
                    BalanceUpdates = PlayerDB.GetAllCurrencyBalances(accountId.Value)
                        .Select(entry => new
                        {
                            Result = 0,
                            PurchaseResult = 0,
                            Balance = entry.CurrencyType == PlayerDBClasses.CurrencyType.RecCenterTokens
                                ? giftBalance
                                : entry.Balance,
                            CurrencyType = (int)entry.CurrencyType,
                            Data = entry.CurrencyType == PlayerDBClasses.CurrencyType.RecCenterTokens
                                ? new object[]
                                {
                                    new
                                    {
                                        SkuId = sku.SkuId,
                                        ItemId = sku.ItemId,
                                        AvatarItemId = sku.AvatarItemId,
                                        PurchasableItemId = sku.PurchasableItemId,
                                        ConsumableItemDesc = sku.ConsumableItemDesc,
                                        AvatarItemDesc = sku.AvatarItemDesc,
                                        FriendlyName = sku.FriendlyName,
                                        Quantity = 1,
                                        Amount = 1,
                                        CurrencyType = (int)PlayerDBClasses.CurrencyType.RecCenterTokens,
                                        Result = 0
                                    }
                                }
                                : Array.Empty<object>()
                        })
                        .ToArray()
                });
            }

            bool purchased = TryPurchaseCatalogSku(
                accountId.Value,
                sku,
                out int newBalance,
                out bool alreadyOwned);

            if (!purchased)
            {
                return BadRequest(new
                {
                    Success = false,
                    Error = "insufficient_funds",
                    Balance = newBalance,
                    Price = StoreItemPrice
                });
            }

            return Ok(new
            {
                Success = true,
                Result = 0,
                PurchaseResult = 0,
                WasGift = false,
                AlreadyOwned = alreadyOwned,
                Balance = newBalance,
                CurrencyType = (int)PlayerDBClasses.CurrencyType.RecCenterTokens,
                BalanceType = (int)PlayerDBClasses.BalanceType.NonPurchasedDefault,
                NewBalance = newBalance,
                Price = StoreItemPrice,
                SkuId = sku.SkuId,
                PurchasableItemId = sku.PurchasableItemId,
                ItemId = sku.ItemId,
                AvatarItemId = sku.AvatarItemId,
                ConsumableItemDesc = sku.ConsumableItemDesc,
                BalanceUpdates = PlayerDB.GetAllCurrencyBalances(accountId.Value)
                    .Select(entry => new
                    {
                        Result = 0,
                        PurchaseResult = 0,
                        Balance = entry.CurrencyType == PlayerDBClasses.CurrencyType.RecCenterTokens
                            ? newBalance
                            : entry.Balance,
                        CurrencyType = (int)entry.CurrencyType,
                        Data = entry.CurrencyType == PlayerDBClasses.CurrencyType.RecCenterTokens
                            ? new object[]
                            {
                                new
                                {
                                    SkuId = sku.SkuId,
                                    ItemId = sku.ItemId,
                                    AvatarItemId = sku.AvatarItemId,
                                    PurchasableItemId = sku.PurchasableItemId,
                                    ConsumableItemDesc = sku.ConsumableItemDesc,
                                    AvatarItemDesc = sku.AvatarItemDesc,
                                    FriendlyName = sku.FriendlyName,
                                    Quantity = 1,
                                    Amount = 1,
                                    CurrencyType = (int)PlayerDBClasses.CurrencyType.RecCenterTokens,
                                    Result = 0
                                }
                            }
                            : Array.Empty<object>()
                    })
                    .ToArray()
            });
        }

        private sealed class ParsedCatalogPurchaseRequest
        {
            public long? SkuId { get; set; }
            public long? RecipientPlayerId { get; set; }
            public string Message { get; set; } = string.Empty;
            public int GiftContext { get; set; }
        }

        private async Task<ParsedCatalogPurchaseRequest>
            ReadCatalogPurchaseRequestAsync()
        {
            string[] skuNames =
            {
                "skuId", "sku", "id", "itemId",
                "avatarItemId", "purchasableItemId"
            };
            string[] recipientNames =
            {
                "giftRecipientPlayerId", "giftRecipientAccountId",
                "recipientPlayerId", "recipientAccountId", "recipientId",
                "receiverPlayerId", "receiverAccountId",
                "toPlayerId", "toAccountId",
                "targetPlayerId", "targetAccountId",
                "giftToPlayerId", "giftToAccountId", "giftPlayerId"
            };
            string[] messageNames =
            {
                "giftMessage", "message", "note"
            };
            string[] contextNames =
            {
                "giftContext", "context"
            };

            var result = new ParsedCatalogPurchaseRequest();

            if (Request.RouteValues.TryGetValue("skuId", out object? routeValue) &&
                long.TryParse(routeValue?.ToString(), out long routeSkuId))
            {
                result.SkuId = routeSkuId;
            }

            result.SkuId ??= ReadLongFromValues(Request.Query, skuNames);
            result.RecipientPlayerId ??=
                ReadLongFromValues(Request.Query, recipientNames);
            result.Message = ReadStringFromValues(Request.Query, messageNames) ??
                result.Message;
            result.GiftContext =
                (int)(ReadLongFromValues(Request.Query, contextNames) ??
                result.GiftContext);

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();
                result.SkuId ??= ReadLongFromValues(form, skuNames);
                result.RecipientPlayerId ??=
                    ReadLongFromValues(form, recipientNames);
                result.Message = ReadStringFromValues(form, messageNames) ??
                    result.Message;
                result.GiftContext =
                    (int)(ReadLongFromValues(form, contextNames) ??
                    result.GiftContext);
            }
            else if (Request.Body.CanRead &&
                     (Request.ContentLength.GetValueOrDefault() > 0 ||
                      Request.Headers.TransferEncoding.Count > 0))
            {
                try
                {
                    using JsonDocument document =
                        await JsonDocument.ParseAsync(Request.Body);
                    JsonElement root = document.RootElement;
                    result.SkuId ??= FindLongByNames(root, skuNames);
                    result.RecipientPlayerId ??=
                        FindLongByNames(root, recipientNames);
                    result.RecipientPlayerId ??=
                        FindGiftRecipientFromNestedObject(root);
                    result.Message = FindStringByNames(root, messageNames) ??
                        result.Message;
                    long? giftContext = FindLongByNames(root, contextNames);
                    if (giftContext.HasValue)
                        result.GiftContext = checked((int)giftContext.Value);
                }
                catch (JsonException exception)
                {
                    Console.WriteLine(
                        $"[STORE PURCHASE] invalid request JSON: {exception.Message}");
                }
            }

            return result;
        }

        private static long? ReadLongFromValues(
            IEnumerable<KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues>> values,
            IEnumerable<string> names)
        {
            var nameSet = names.ToHashSet(StringComparer.OrdinalIgnoreCase);
            foreach (var pair in values)
            {
                if (nameSet.Contains(pair.Key) &&
                    long.TryParse(pair.Value.FirstOrDefault(), out long value))
                {
                    return value;
                }
            }
            return null;
        }

        private static string? ReadStringFromValues(
            IEnumerable<KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues>> values,
            IEnumerable<string> names)
        {
            var nameSet = names.ToHashSet(StringComparer.OrdinalIgnoreCase);
            foreach (var pair in values)
            {
                if (!nameSet.Contains(pair.Key))
                    continue;
                string? value = pair.Value.FirstOrDefault();
                if (!string.IsNullOrWhiteSpace(value))
                    return value;
            }
            return null;
        }

        private static long? FindLongByNames(
            JsonElement element,
            IEnumerable<string> names)
        {
            var nameSet = names.ToHashSet(StringComparer.OrdinalIgnoreCase);
            return FindLongByNames(element, nameSet);
        }

        private static long? FindLongByNames(
            JsonElement element,
            HashSet<string> names)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    if (names.Contains(property.Name))
                    {
                        if (property.Value.ValueKind == JsonValueKind.Number &&
                            property.Value.TryGetInt64(out long numeric))
                        {
                            return numeric;
                        }

                        if (property.Value.ValueKind == JsonValueKind.String &&
                            long.TryParse(property.Value.GetString(), out long text))
                        {
                            return text;
                        }
                    }

                    long? nested = FindLongByNames(property.Value, names);
                    if (nested.HasValue)
                        return nested;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (JsonElement child in element.EnumerateArray())
                {
                    long? nested = FindLongByNames(child, names);
                    if (nested.HasValue)
                        return nested;
                }
            }

            return null;
        }

        private static long? FindGiftRecipientFromNestedObject(
            JsonElement element,
            bool recipientContext = false)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    bool nextRecipientContext = recipientContext ||
                        property.Name.Contains("recipient", StringComparison.OrdinalIgnoreCase) ||
                        property.Name.Contains("receiver", StringComparison.OrdinalIgnoreCase) ||
                        property.Name.Contains("giftTo", StringComparison.OrdinalIgnoreCase) ||
                        string.Equals(property.Name, "to", StringComparison.OrdinalIgnoreCase) ||
                        string.Equals(property.Name, "target", StringComparison.OrdinalIgnoreCase);

                    if (recipientContext &&
                        (string.Equals(property.Name, "PlayerId", StringComparison.OrdinalIgnoreCase) ||
                         string.Equals(property.Name, "AccountId", StringComparison.OrdinalIgnoreCase)))
                    {
                        if (property.Value.ValueKind == JsonValueKind.Number &&
                            property.Value.TryGetInt64(out long numeric))
                        {
                            return numeric;
                        }

                        if (property.Value.ValueKind == JsonValueKind.String &&
                            long.TryParse(property.Value.GetString(), out long text))
                        {
                            return text;
                        }
                    }

                    long? nested = FindGiftRecipientFromNestedObject(
                        property.Value,
                        nextRecipientContext);
                    if (nested.HasValue)
                        return nested;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (JsonElement child in element.EnumerateArray())
                {
                    long? nested = FindGiftRecipientFromNestedObject(
                        child,
                        recipientContext);
                    if (nested.HasValue)
                        return nested;
                }
            }

            return null;
        }

        private static string? FindStringByNames(
            JsonElement element,
            IEnumerable<string> names)
        {
            var nameSet = names.ToHashSet(StringComparer.OrdinalIgnoreCase);
            return FindStringByNames(element, nameSet);
        }

        private static string? FindStringByNames(
            JsonElement element,
            HashSet<string> names)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    if (names.Contains(property.Name) &&
                        property.Value.ValueKind == JsonValueKind.String)
                    {
                        return property.Value.GetString();
                    }

                    string? nested = FindStringByNames(property.Value, names);
                    if (!string.IsNullOrWhiteSpace(nested))
                        return nested;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (JsonElement child in element.EnumerateArray())
                {
                    string? nested = FindStringByNames(child, names);
                    if (!string.IsNullOrWhiteSpace(nested))
                        return nested;
                }
            }

            return null;
        }

        private bool TryPurchaseCatalogSkuAsGift(
            long senderAccountId,
            long recipientAccountId,
            CatalogSku sku,
            string? message,
            int giftContext,
            out int newBalance,
            out bool alreadyOwned,
            out GiftPackage? giftPackage)
        {
            newBalance = PlayerDB.GetCurrencyBalance(
                senderAccountId,
                PlayerDBClasses.CurrencyType.RecCenterTokens);
            giftPackage = null;

            alreadyOwned = IsAvatarCatalogItem(sku)
                ? PlayerDB.OwnsAvatarItem(recipientAccountId, sku.AvatarItemDesc)
                : IsEquipmentSkin(sku)
                    ? OwnsEquipmentItem(
                        recipientAccountId,
                        sku.EquipmentPrefabName,
                        sku.EquipmentModificationGuid)
                    : false;

            if (alreadyOwned)
                return true;

            if (!PlayerDB.TrySpendCurrency(
                    senderAccountId,
                    PlayerDBClasses.CurrencyType.RecCenterTokens,
                    StoreItemPrice,
                    out newBalance))
            {
                return false;
            }

            var pendingGift = new GiftPackage
            {
                FromPlayerId = checked((int)senderAccountId),
                Message = message ?? string.Empty,
                AvatarItemDesc = sku.AvatarItemDesc,
                ConsumableItemDesc = sku.ConsumableItemDesc,
                EquipmentPrefabName = sku.EquipmentPrefabName,
                EquipmentModificationGuid = sku.EquipmentModificationGuid,
                CurrencyType = (int)PlayerDBClasses.CurrencyType.RecCenterTokens,
                GiftContext = giftContext == 0
                    ? (int)PlayerDBClasses.GiftContext.Store_RecCenter
                    : giftContext,
                Rarity = sku.Rarity,
                Platform = -1,
                PlatformMask = sku.PlatformMask,
                BalanceType = (int)BalanceType.NonPurchasedNotUsableInP2P,
                IsQuery = sku.GiftDrop.IsQuery,
                Unique = !IsConsumableCatalogItem(sku)
            };

            giftPackage = PlayerDB.QueueGiftPackage(
                recipientAccountId,
                pendingGift);

            if (giftPackage != null)
                return true;

            int? refunded = PlayerDB.SetCurrencyBalance(
                senderAccountId,
                PlayerDBClasses.CurrencyType.RecCenterTokens,
                StoreItemPrice,
                add: true);
            if (refunded.HasValue)
                newBalance = refunded.Value;
            return false;
        }

        private static List<CatalogSku> GetCatalogSkus()
        {
            string avatarPath = Path.Combine(Program.dataDir, "APIS", "Items", "AvatarItems.json");
            string equipmentPath = Path.Combine(Program.dataDir, "APIS", "Items", "Equipment.json");
            string consumablesPath = Path.Combine(Program.dataDir, "APIS", "Items", "Consumables.json");

            bool hasAvatarCatalog = System.IO.File.Exists(avatarPath);
            bool hasEquipmentCatalog = System.IO.File.Exists(equipmentPath);
            bool hasConsumableCatalog = System.IO.File.Exists(consumablesPath);
            if (!hasAvatarCatalog && !hasEquipmentCatalog && !hasConsumableCatalog)
                return new List<CatalogSku>();

            DateTime avatarTimestamp = hasAvatarCatalog ? System.IO.File.GetLastWriteTimeUtc(avatarPath) : DateTime.MinValue;
            DateTime equipmentTimestamp = hasEquipmentCatalog ? System.IO.File.GetLastWriteTimeUtc(equipmentPath) : DateTime.MinValue;
            DateTime consumableTimestamp = hasConsumableCatalog ? System.IO.File.GetLastWriteTimeUtc(consumablesPath) : DateTime.MinValue;

            lock (CatalogLock)
            {
                if (CatalogCache.Count > 0 &&
                    avatarTimestamp == CatalogCacheTimestampUtc &&
                    equipmentTimestamp == EquipmentCatalogCacheTimestampUtc &&
                    consumableTimestamp == ConsumableCatalogCacheTimestampUtc)
                    return CatalogCache;

                var catalog = new List<CatalogSku>();
                var jsonOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };

                if (hasAvatarCatalog)
                {
                    var avatarItems = JsonSerializer.Deserialize<List<CatalogSourceItem>>(System.IO.File.ReadAllText(avatarPath), jsonOptions) ?? new();
                    catalog.AddRange(avatarItems.Select(CreateAvatarCatalogSku));
                }

                if (hasEquipmentCatalog)
                {
                    var equipmentItems = JsonSerializer.Deserialize<List<PlayerDBClasses.EquipmentItem>>(System.IO.File.ReadAllText(equipmentPath), jsonOptions) ?? new();
                    catalog.AddRange(equipmentItems
                        .Where(item => !string.IsNullOrWhiteSpace(item.PrefabName) && !string.IsNullOrWhiteSpace(item.ModificationGuid))
                        .Select(CreateEquipmentCatalogSku));
                }

                if (hasConsumableCatalog)
                {
                    using JsonDocument document = JsonDocument.Parse(System.IO.File.ReadAllText(consumablesPath));
                    IEnumerable<JsonElement> consumables = document.RootElement.ValueKind == JsonValueKind.Array
                        ? document.RootElement.EnumerateArray().Select(item => item.Clone())
                        : Enumerable.Empty<JsonElement>();
                    catalog.AddRange(consumables.Select(CreateConsumableCatalogSku));
                }

                CatalogCache = catalog.Where(IsUsableStoreItem)
                    .GroupBy(GetCatalogIdentity, StringComparer.OrdinalIgnoreCase)
                    .Select(group => group.First()).ToList();
                CatalogCacheTimestampUtc = avatarTimestamp;
                EquipmentCatalogCacheTimestampUtc = equipmentTimestamp;
                ConsumableCatalogCacheTimestampUtc = consumableTimestamp;
                return CatalogCache;
            }
        }

        private static CatalogSku CreateAvatarCatalogSku(
            CatalogSourceItem item,
            int index)
        {
            int purchasableItemId = 1_000_000 + index;
            string friendlyName = string.IsNullOrWhiteSpace(item.FriendlyName)
                ? $"Avatar Item {item.AvatarItemId}"
                : item.FriendlyName.Trim();
            CatalogGiftDrop giftDrop = CreateCatalogGiftDrop(item, index);

            return new CatalogSku
            {
                Id = purchasableItemId,
                SkuId = purchasableItemId,
                PurchasableItemId = purchasableItemId,
                Type = 0,
                IsFeatured = true,
                ItemId = item.AvatarItemId,
                AvatarItemId = item.AvatarItemId,
                AvatarItemType = item.AvatarItemType,
                ItemType = item.AvatarItemType,
                AvatarItemDesc = item.AvatarItemDesc ?? string.Empty,
                FriendlyName = friendlyName,
                Tooltip = item.Tooltip ?? string.Empty,
                ThumbnailImage = item.ThumbnailImage ?? string.Empty,
                Rarity = item.Rarity,
                PlatformMask = item.PlatformMask,
                IsBaseAvatarItem = item.IsBaseAvatarItem,
                HasRealName = !string.IsNullOrWhiteSpace(item.FriendlyName),
                CreatedAt = item.CreatedAt,
                Prices = CreateCatalogPrices(),
                GiftDrop = giftDrop,
                GiftDrops = new List<CatalogGiftDrop> { giftDrop }
            };
        }

        private static CatalogSku CreateEquipmentCatalogSku(
            PlayerDBClasses.EquipmentItem item,
            int index)
        {
            int purchasableItemId = 2_000_000 + index;
            string friendlyName = GetEquipmentFriendlyName(item, index);
            CatalogGiftDrop giftDrop = CreateCatalogGiftDrop(item, index, friendlyName);

            return new CatalogSku
            {
                Id = purchasableItemId,
                SkuId = purchasableItemId,
                PurchasableItemId = purchasableItemId,
                Type = 0,
                IsFeatured = true,
                ItemId = purchasableItemId,
                AvatarItemId = 0,
                AvatarItemType = 0,
                ItemType = 0,
                AvatarItemDesc = string.Empty,
                EquipmentPrefabName = item.PrefabName.Trim(),
                EquipmentModificationGuid = item.ModificationGuid.Trim(),
                FriendlyName = friendlyName,
                Tooltip = item.Tooltip ?? string.Empty,
                ThumbnailImage = item.ThumbnailImage ?? string.Empty,
                Rarity = item.Rarity,
                PlatformMask = item.PlatformMask,
                IsBaseAvatarItem = false,
                HasRealName = !string.IsNullOrWhiteSpace(item.FriendlyName),
                Prices = CreateCatalogPrices(),
                GiftDrop = giftDrop,
                GiftDrops = new List<CatalogGiftDrop> { giftDrop }
            };
        }

        private static CatalogSku CreateConsumableCatalogSku(JsonElement item, int index)
        {
            int purchasableItemId = 3_000_000 + index;
            string desc = GetJsonString(item, "ConsumableItemDesc", "ConsumableDesc", "ItemDesc", "DescriptionId");
            if (string.IsNullOrWhiteSpace(desc))
                desc = GetJsonString(item, "FriendlyName", "Name");
            string friendlyName = GetJsonString(item, "FriendlyName", "Name");
            bool hasRealName = !string.IsNullOrWhiteSpace(friendlyName);
            if (string.IsNullOrWhiteSpace(friendlyName))
                friendlyName = $"Consumable {index + 1}";

            bool isHairDye = IsHairDyeFriendlyName(friendlyName);
            int rarity = GetJsonInt(item, "Rarity");
            int itemType = GetJsonInt(item, "ConsumableItemType", "ItemType", "Type");

            if (isHairDye)
                itemType = 1;

            var giftDrop = new CatalogGiftDrop
            {
                GiftDropId = purchasableItemId,
                FriendlyName = friendlyName,
                Tooltip = GetJsonString(item, "Tooltip", "Description"),
                ConsumableItemDesc = desc,
                ItemType = itemType,
                ConsumableItemType = isHairDye ? 6 : itemType,
                Rarity = rarity,
                IsQuery = false,
                Unique = false,
                Level = rarity,
                Context = 100010,
                ThumbnailImage = GetJsonString(item, "ThumbnailImage", "Thumbnail", "ImageName")
            };

            return new CatalogSku
            {
                Id = purchasableItemId,
                SkuId = purchasableItemId,
                PurchasableItemId = purchasableItemId,
                Type = 0,
                IsFeatured = true,
                ItemId = GetJsonLong(
                    item,
                    "ConsumableItemId",
                    "ItemId",
                    "Id",
                    defaultValue: purchasableItemId),
                ItemType = itemType,
                ConsumableItemType = isHairDye ? 6 : itemType,
                ConsumableItemDesc = desc,
                FriendlyName = friendlyName,
                Tooltip = GetJsonString(item, "Tooltip", "Description"),
                ThumbnailImage = giftDrop.ThumbnailImage,
                Rarity = rarity,
                PlatformMask = GetJsonInt(item, "PlatformMask", defaultValue: -1),
                HasRealName = hasRealName,

                IsOwned = isHairDye,
                Owned = isHairDye,
                Purchased = isHairDye,

                Prices = CreateCatalogPrices(),
                GiftDrop = giftDrop,
                GiftDrops = new List<CatalogGiftDrop> { giftDrop }
            };
        }

        private static string GetJsonString(JsonElement item, params string[] names)
        {
            foreach (JsonProperty property in item.EnumerateObject())
                if (names.Any(name => string.Equals(name, property.Name, StringComparison.OrdinalIgnoreCase)))
                    return property.Value.ValueKind == JsonValueKind.String ? property.Value.GetString() ?? string.Empty : property.Value.ToString();
            return string.Empty;
        }

        private static int GetJsonInt(JsonElement item, string name, int defaultValue = 0) => GetJsonInt(item, new[] { name }, defaultValue);
        private static int GetJsonInt(JsonElement item, string name1, string name2, string name3) => GetJsonInt(item, new[] { name1, name2, name3 }, 0);
        private static int GetJsonInt(JsonElement item, string[] names, int defaultValue)
        {
            foreach (JsonProperty property in item.EnumerateObject())
                if (names.Any(name => string.Equals(name, property.Name, StringComparison.OrdinalIgnoreCase)))
                {
                    if (property.Value.TryGetInt32(out int value)) return value;
                    if (int.TryParse(property.Value.ToString(), out value)) return value;
                }
            return defaultValue;
        }

        private static long GetJsonLong(JsonElement item, string name1, string name2, string name3, long defaultValue)
        {
            foreach (JsonProperty property in item.EnumerateObject())
                if (property.Name.Equals(name1, StringComparison.OrdinalIgnoreCase) || property.Name.Equals(name2, StringComparison.OrdinalIgnoreCase) || property.Name.Equals(name3, StringComparison.OrdinalIgnoreCase))
                {
                    if (property.Value.TryGetInt64(out long value)) return value;
                    if (long.TryParse(property.Value.ToString(), out value)) return value;
                }
            return defaultValue;
        }

        private static List<CatalogPrice> CreateCatalogPrices() =>
            new()
            {
                new CatalogPrice
                {
                    CurrencyType = (int)PlayerDBClasses.CurrencyType.RecCenterTokens,
                    Price = StoreItemPrice
                }
            };

        private static string GetEquipmentFriendlyName(
            PlayerDBClasses.EquipmentItem item,
            int index)
        {
            if (!string.IsNullOrWhiteSpace(item.FriendlyName))
                return item.FriendlyName.Trim();

            string prefabName = item.PrefabName?.Trim().Trim('[', ']') ?? string.Empty;
            if (string.IsNullOrWhiteSpace(prefabName))
                return $"Equipment Skin {index + 1}";

            return prefabName.EndsWith("Skin", StringComparison.OrdinalIgnoreCase)
                ? prefabName
                : $"{prefabName} Skin";
        }

        private async Task<long?> ReadPurchaseSkuIdAsync()
        {
            string[] names =
            {
                "skuId",
                "sku",
                "id",
                "itemId",
                "avatarItemId",
                "purchasableItemId"
            };

            if (Request.RouteValues.TryGetValue("skuId", out object? routeValue) &&
                long.TryParse(routeValue?.ToString(), out long routeSkuId))
                return routeSkuId;

            foreach (string name in names)
            {
                if (long.TryParse(Request.Query[name].FirstOrDefault(), out long queryValue))
                    return queryValue;
            }

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();
                foreach (string name in names)
                {
                    if (long.TryParse(form[name].FirstOrDefault(), out long formValue))
                        return formValue;
                }
            }
            else if (Request.Body.CanRead &&
                     (Request.ContentLength.GetValueOrDefault() > 0 ||
                      Request.Headers.TransferEncoding.Count > 0))
            {
                try
                {
                    using JsonDocument document = await JsonDocument.ParseAsync(Request.Body);
                    return FindSkuId(document.RootElement, names);
                }
                catch (JsonException)
                {
                    return null;
                }
            }

            return null;
        }

        private static long? FindSkuId(JsonElement element, string[] names)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    if (names.Any(name => string.Equals(
                            name,
                            property.Name,
                            StringComparison.OrdinalIgnoreCase)))
                    {
                        if (property.Value.ValueKind == JsonValueKind.Number &&
                            property.Value.TryGetInt64(out long number))
                            return number;
                        if (property.Value.ValueKind == JsonValueKind.String &&
                            long.TryParse(property.Value.GetString(), out long textNumber))
                            return textNumber;
                    }

                    long? nested = FindSkuId(property.Value, names);
                    if (nested.HasValue)
                        return nested;
                }
            }
            else if (element.ValueKind == JsonValueKind.Array)
            {
                foreach (JsonElement child in element.EnumerateArray())
                {
                    long? nested = FindSkuId(child, names);
                    if (nested.HasValue)
                        return nested;
                }
            }

            return null;
        }

        private sealed class CatalogSourceItem
        {
            public string? AvatarItemDesc { get; set; }
            public int AvatarItemType { get; set; }
            public int PlatformMask { get; set; } = -1;
            public string? FriendlyName { get; set; }
            public string? Tooltip { get; set; }
            public int Rarity { get; set; }
            public long AvatarItemId { get; set; }
            public bool IsBaseAvatarItem { get; set; }
            public DateTime CreatedAt { get; set; }
            public string? ThumbnailImage { get; set; }
        }

        private static CatalogGiftDrop CreateCatalogGiftDrop(
            CatalogSourceItem item,
            int index)
        {
            return new CatalogGiftDrop
            {
                GiftDropId = 1_000_000 + index,
                FriendlyName = string.IsNullOrWhiteSpace(item.FriendlyName)
                    ? $"Avatar Item {item.AvatarItemId}"
                    : item.FriendlyName.Trim(),
                Tooltip = item.Tooltip ?? string.Empty,
                AvatarItemDesc = item.AvatarItemDesc ?? string.Empty,
                ConsumableItemDesc = string.Empty,
                EquipmentPrefabName = string.Empty,
                EquipmentModificationGuid = string.Empty,
                Rarity = item.Rarity,
                IsQuery = false,
                Unique = true,
                Level = item.Rarity,
                Context = 100010,
                ThumbnailImage = item.ThumbnailImage ?? string.Empty
            };
        }

        private static CatalogGiftDrop CreateCatalogGiftDrop(
            PlayerDBClasses.EquipmentItem item,
            int index,
            string friendlyName)
        {
            return new CatalogGiftDrop
            {
                GiftDropId = 2_000_000 + index,
                FriendlyName = friendlyName,
                Tooltip = item.Tooltip ?? string.Empty,
                AvatarItemDesc = string.Empty,
                ConsumableItemDesc = string.Empty,
                EquipmentPrefabName = item.PrefabName?.Trim() ?? string.Empty,
                EquipmentModificationGuid = item.ModificationGuid?.Trim() ?? string.Empty,
                Rarity = item.Rarity,
                IsQuery = false,
                Unique = true,
                Level = item.Rarity,
                Context = 100010,
                ThumbnailImage = item.ThumbnailImage ?? string.Empty
            };
        }

        private static List<CatalogSku> GetWatchStoreSkusWithHairDyes()
        {
            List<CatalogSku> storeItems = GetDailyStoreSkus(3);
            var identities = storeItems
                .Select(GetCatalogIdentity)
                .ToHashSet(StringComparer.OrdinalIgnoreCase);

            IEnumerable<CatalogSku> hairDyes = GetCatalogSkus()
                .Where(IsHairDyeCatalogItem)
                .GroupBy(GetCatalogIdentity, StringComparer.OrdinalIgnoreCase)
                .Select(group => group.First())
                .OrderBy(item => item.FriendlyName, StringComparer.OrdinalIgnoreCase);

            foreach (CatalogSku hairDye in hairDyes)
            {
                if (identities.Add(GetCatalogIdentity(hairDye)))
                    storeItems.Add(hairDye);
            }

            return storeItems;
        }

        private static bool IsHairDyeFriendlyName(string? friendlyName) =>
            !string.IsNullOrWhiteSpace(friendlyName) &&
            friendlyName.Contains("Hair Dye", StringComparison.OrdinalIgnoreCase);

        private static bool IsHairDyeCatalogItem(CatalogSku? item) =>
            item != null &&
            IsConsumableCatalogItem(item) &&
            IsHairDyeFriendlyName(item.FriendlyName);

        private static List<CatalogSku> GetDailyStoreSkus(int storeId)
        {

            List<CatalogSku> catalog = GetCatalogSkus();

            return catalog
                .Where(IsUsableStoreItem)
                .GroupBy(GetCatalogIdentity, StringComparer.OrdinalIgnoreCase)
                .Select(group => group.First())
                .OrderBy(item => item.FriendlyName, StringComparer.OrdinalIgnoreCase)
                .ToList();
        }

        private static bool IsEquipmentSkin(CatalogSku? item) =>
            item != null &&
            !string.IsNullOrWhiteSpace(item.EquipmentPrefabName) &&
            !string.IsNullOrWhiteSpace(item.EquipmentModificationGuid);

        private static bool IsAvatarCatalogItem(CatalogSku? item) =>
            item != null &&
            !string.IsNullOrWhiteSpace(item.AvatarItemDesc);

        private static bool IsConsumableCatalogItem(CatalogSku? item) =>
            item != null && !string.IsNullOrWhiteSpace(item.ConsumableItemDesc);

        private static bool IsExcludedAvatarItemName(string? friendlyName) =>
            !string.IsNullOrWhiteSpace(friendlyName) &&
            (friendlyName.Contains("Custom", StringComparison.OrdinalIgnoreCase) ||
             friendlyName.Contains("Owner", StringComparison.OrdinalIgnoreCase) ||
             friendlyName.Contains("Shirt", StringComparison.OrdinalIgnoreCase));

        private static bool IsUnfinishedCatalogItem(CatalogSku item) =>
            item.Rarity <= 0 && !item.HasRealName;

        private static bool IsUsableStoreItem(CatalogSku? item) =>
            item != null && !string.IsNullOrWhiteSpace(item.FriendlyName) &&
            (IsAvatarCatalogItem(item) || IsEquipmentSkin(item) || IsConsumableCatalogItem(item)) &&
            !(IsAvatarCatalogItem(item) && IsExcludedAvatarItemName(item.FriendlyName)) &&
            !IsUnfinishedCatalogItem(item);

        private static string GetCatalogIdentity(CatalogSku item) =>
            IsEquipmentSkin(item)
                ? $"equipment|{item.EquipmentPrefabName}|{item.EquipmentModificationGuid}"
                : IsConsumableCatalogItem(item)
                    ? $"consumable|{item.ConsumableItemDesc}"
                    : $"avatar|{item.AvatarItemDesc}";

        private static bool TryPurchaseCatalogSku(
            long accountId,
            CatalogSku sku,
            out int newBalance,
            out bool alreadyOwned)
        {
            if (IsConsumableCatalogItem(sku))
            {
                alreadyOwned = false;
                if (!PlayerDB.TrySpendCurrency(
                        accountId,
                        PlayerDBClasses.CurrencyType.RecCenterTokens,
                        StoreItemPrice,
                        out newBalance))
                {
                    return false;
                }

                PlayerInventoryStore.AddConsumable(
                    accountId,
                    sku.ConsumableItemDesc,
                    sku.ItemId,
                    sku.FriendlyName,
                    amount: 1);
                return true;
            }

            if (!IsEquipmentSkin(sku))
            {
                return PlayerDB.TryPurchaseAvatarItem(
                    accountId,
                    sku.AvatarItemDesc,
                    StoreItemPrice,
                    out newBalance,
                    out alreadyOwned);
            }

            lock (EquipmentInventoryLock)
            {
                newBalance = PlayerDB.GetCurrencyBalance(
                    accountId,
                    PlayerDBClasses.CurrencyType.RecCenterTokens);
                alreadyOwned = OwnsEquipmentItem(
                    accountId,
                    sku.EquipmentPrefabName,
                    sku.EquipmentModificationGuid);

                if (alreadyOwned)
                    return true;

                if (!PlayerDB.TrySpendCurrency(
                        accountId,
                        PlayerDBClasses.CurrencyType.RecCenterTokens,
                        StoreItemPrice,
                        out newBalance))
                {
                    return false;
                }

                try
                {
                    if (GrantPurchasedEquipment(accountId, sku))
                        return true;
                }
                catch (IOException)
                {

                }
                catch (UnauthorizedAccessException)
                {

                }

                int? refundedBalance = PlayerDB.SetCurrencyBalance(
                    accountId,
                    PlayerDBClasses.CurrencyType.RecCenterTokens,
                    StoreItemPrice,
                    add: true);
                newBalance = refundedBalance ?? newBalance;
                return false;
            }
        }

        private static ulong GetDailyStoreSortKey(
            CatalogSku item,
            DateTime storeDate,
            int storeId,
            long rotationNonce)
        {
            string value = $"{storeDate:yyyyMMdd}|{storeId}|{rotationNonce}|{GetCatalogIdentity(item)}|{item.SkuId}";
            unchecked
            {
                const ulong offset = 14695981039346656037UL;
                const ulong prime = 1099511628211UL;
                ulong hash = offset;
                foreach (char character in value)
                {
                    hash ^= character;
                    hash *= prime;
                }

                return hash;
            }
        }

        public static StorefrontAdminInfo GetStorefrontAdminInfo()
        {
            (long rotationNonce, List<long> customSkuIds) = GetStorefrontSelectionState();
            Dictionary<long, CatalogSku> catalog = GetCatalogSkus()
                .ToDictionary(item => item.SkuId);
            List<StorefrontAdminItem> customItems = customSkuIds
                .Select(skuId => catalog.GetValueOrDefault(skuId))
                .Where(IsUsableStoreItem)
                .Cast<CatalogSku>()
                .Select(ToStorefrontAdminItem)
                .ToList();

            return new StorefrontAdminInfo
            {
                RotationNonce = rotationNonce,
                CustomItems = customItems,
                NextRefresh = DateTime.Today.AddDays(1).ToUniversalTime()
            };
        }

        public static List<StorefrontAdminItem> GetWebsiteStorefrontItems(
            int storeId = 3) =>
            GetCatalogSkus()
                .Where(IsUsableStoreItem)
                .OrderBy(item => IsAvatarCatalogItem(item) ? 0 : IsEquipmentSkin(item) ? 1 : 2)
                .ThenBy(item => item.FriendlyName, StringComparer.OrdinalIgnoreCase)
                .Select(ToStorefrontAdminItem)
                .ToList();

        public static bool TryPurchaseWebsiteStoreItem(
            long accountId,
            long skuId,
            out StorefrontAdminItem? purchasedItem,
            out int newBalance,
            out bool alreadyOwned,
            out string error)
        {
            CatalogSku? sku = GetCatalogSkus().FirstOrDefault(value =>
                value.SkuId == skuId ||
                value.PurchasableItemId == skuId ||
                (value.AvatarItemId > 0 && value.AvatarItemId == skuId) ||
                (IsConsumableCatalogItem(value) && value.ItemId == skuId));
            if (sku == null)
            {
                purchasedItem = null;
                newBalance = PlayerDB.GetCurrencyBalance(
                    accountId,
                    PlayerDBClasses.CurrencyType.RecCenterTokens);
                alreadyOwned = false;
                error = "That shop item could not be found.";
                return false;
            }

            bool purchased = TryPurchaseCatalogSku(
                accountId,
                sku,
                out newBalance,
                out alreadyOwned);
            purchasedItem = ToStorefrontAdminItem(sku);
            error = purchased
                ? string.Empty
                : "You do not have enough tokens for that item.";
            return purchased;
        }

        public static (List<StorefrontAdminItem> Items, int Total) SearchStorefrontCatalog(
            string? search,
            string? type = null,
            int skip = 0,
            int take = 30)
        {
            string term = search?.Trim() ?? string.Empty;
            string requestedType = type?.Trim().ToLowerInvariant() ?? string.Empty;

            IEnumerable<StorefrontAdminItem> query = GetCatalogSkus()
                .Where(IsUsableStoreItem)
                .Where(item => string.IsNullOrWhiteSpace(term) ||
                    item.FriendlyName.Contains(term, StringComparison.OrdinalIgnoreCase) ||
                    item.AvatarItemDesc.Contains(term, StringComparison.OrdinalIgnoreCase) ||
                    item.ConsumableItemDesc.Contains(term, StringComparison.OrdinalIgnoreCase) ||
                    item.EquipmentPrefabName.Contains(term, StringComparison.OrdinalIgnoreCase) ||
                    item.EquipmentModificationGuid.Contains(term, StringComparison.OrdinalIgnoreCase) ||
                    item.AvatarItemId.ToString().Contains(term, StringComparison.OrdinalIgnoreCase) ||
                    item.SkuId.ToString().Contains(term, StringComparison.OrdinalIgnoreCase))
                .Select(ToStorefrontAdminItem)
                .Where(item => requestedType switch
                {
                    "avatar" => !string.IsNullOrWhiteSpace(item.AvatarItemDesc),
                    "equipment" => !string.IsNullOrWhiteSpace(item.EquipmentPrefabName) &&
                        !string.IsNullOrWhiteSpace(item.EquipmentModificationGuid),
                    "consumable" => !string.IsNullOrWhiteSpace(item.ConsumableItemDesc),
                    _ => true
                })
                .OrderByDescending(item => item.Rarity)
                .ThenBy(item => item.FriendlyName, StringComparer.OrdinalIgnoreCase);

            int total = query.Count();
            List<StorefrontAdminItem> items = query
                .Skip(Math.Max(0, skip))
                .Take(Math.Clamp(take, 1, 50))
                .ToList();

            return (items, total);
        }

        public static StorefrontAdminItem? GetStorefrontCatalogItem(long skuId) =>
            GetCatalogSkus()
                .Where(IsUsableStoreItem)
                .Where(item => item.SkuId == skuId)
                .Select(ToStorefrontAdminItem)
                .FirstOrDefault();

        public static bool IsWebsiteStoreItemOwned(
            long accountId,
            StorefrontAdminItem item)
        {
            if (!string.IsNullOrWhiteSpace(item.EquipmentPrefabName) &&
                !string.IsNullOrWhiteSpace(item.EquipmentModificationGuid))
            {
                return OwnsEquipmentItem(
                    accountId,
                    item.EquipmentPrefabName,
                    item.EquipmentModificationGuid);
            }

            if (!string.IsNullOrWhiteSpace(item.ConsumableItemDesc))
            {
                return PlayerInventoryStore.GetConsumableQuantity(
                    accountId,
                    item.ConsumableItemDesc) > 0;
            }

            return PlayerDB.OwnsAvatarItem(accountId, item.AvatarItemDesc);
        }

        public static bool TryAddCustomStoreItem(long skuId, out string error)
        {
            CatalogSku? item = GetCatalogSkus()
                .FirstOrDefault(candidate => candidate.SkuId == skuId);
            if (!IsUsableStoreItem(item))
            {
                error = "That catalog item could not be found.";
                return false;
            }

            lock (StorefrontAdminLock)
            {
                StorefrontAdminState state = LoadStorefrontAdminState();
                if (state.CustomSkuIds.Contains(skuId))
                {
                    error = "That item is already pinned in the shop.";
                    return false;
                }

                if (state.CustomSkuIds.Count >= 10)
                {
                    error = "The shop already has the maximum of 10 custom items.";
                    return false;
                }

                state.CustomSkuIds.Add(skuId);
                SaveStorefrontAdminState(state);
            }

            error = string.Empty;
            return true;
        }

        public static bool RemoveCustomStoreItem(long skuId)
        {
            lock (StorefrontAdminLock)
            {
                StorefrontAdminState state = LoadStorefrontAdminState();
                if (!state.CustomSkuIds.Remove(skuId))
                    return false;
                SaveStorefrontAdminState(state);
                return true;
            }
        }

        public static long RefreshStorefrontRotation()
        {
            lock (StorefrontAdminLock)
            {
                StorefrontAdminState state = LoadStorefrontAdminState();
                state.RotationNonce = state.RotationNonce == long.MaxValue
                    ? 1
                    : state.RotationNonce + 1;
                SaveStorefrontAdminState(state);
                return state.RotationNonce;
            }
        }

        private static StorefrontAdminItem ToStorefrontAdminItem(CatalogSku item) =>
            new()
            {
                SkuId = item.SkuId,
                AvatarItemId = item.AvatarItemId,
                AvatarItemType = item.AvatarItemType,
                FriendlyName = item.FriendlyName,
                AvatarItemDesc = item.AvatarItemDesc,
                ConsumableItemDesc = item.ConsumableItemDesc,
                EquipmentPrefabName = item.EquipmentPrefabName,
                EquipmentModificationGuid = item.EquipmentModificationGuid,
                ThumbnailImage = item.ThumbnailImage,
                Rarity = item.Rarity,
                Price = StoreItemPrice
            };

        private static (long rotationNonce, List<long> customSkuIds)
            GetStorefrontSelectionState()
        {
            lock (StorefrontAdminLock)
            {
                StorefrontAdminState state = LoadStorefrontAdminState();
                return (state.RotationNonce, state.CustomSkuIds.ToList());
            }
        }

        private static StorefrontAdminState LoadStorefrontAdminState()
        {
            if (StorefrontAdminCache != null)
                return StorefrontAdminCache;

            string path = GetStorefrontAdminPath();
            try
            {
                if (System.IO.File.Exists(path))
                {
                    StorefrontAdminCache = JsonSerializer.Deserialize<StorefrontAdminState>(
                        System.IO.File.ReadAllText(path),
                        new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
                }
            }
            catch (JsonException)
            {
                StorefrontAdminCache = null;
            }

            StorefrontAdminCache ??= new StorefrontAdminState();
            StorefrontAdminCache.CustomSkuIds ??= new List<long>();
            return StorefrontAdminCache;
        }

        private static void SaveStorefrontAdminState(StorefrontAdminState state)
        {
            string path = GetStorefrontAdminPath();
            string? directory = Path.GetDirectoryName(path);
            if (!string.IsNullOrWhiteSpace(directory))
                Directory.CreateDirectory(directory);
            System.IO.File.WriteAllText(
                path,
                JsonSerializer.Serialize(state, new JsonSerializerOptions { WriteIndented = true }));
        }

        private static string GetStorefrontAdminPath() =>
            Path.Combine(Program.dataDir, "StorefrontAdmin.json");

        private sealed class StorefrontAdminState
        {
            public long RotationNonce { get; set; }
            public List<long> CustomSkuIds { get; set; } = new();
        }

        public sealed class StorefrontAdminInfo
        {
            public long RotationNonce { get; set; }
            public DateTime NextRefresh { get; set; }
            public List<StorefrontAdminItem> CustomItems { get; set; } = new();
        }

        public sealed class StorefrontAdminItem
        {
            public long SkuId { get; set; }
            public long AvatarItemId { get; set; }
            public int AvatarItemType { get; set; }
            public string FriendlyName { get; set; } = string.Empty;
            public string AvatarItemDesc { get; set; } = string.Empty;
            public string ConsumableItemDesc { get; set; } = string.Empty;
            public string EquipmentPrefabName { get; set; } = string.Empty;
            public string EquipmentModificationGuid { get; set; } = string.Empty;
            public string ThumbnailImage { get; set; } = string.Empty;
            public int Rarity { get; set; }
            public int Price { get; set; }
        }

        public sealed class CatalogStorefront
        {
            public int StorefrontType { get; set; }
            public DateTime NextUpdate { get; set; }
            public List<CatalogSku> StoreItems { get; set; } = new();
        }

        public sealed class StorefrontAdCarouselItem
        {
            public int AdCarouselItemId { get; set; }
            public string ImageName { get; set; } = string.Empty;
            public string Title { get; set; } = string.Empty;
            public string Description { get; set; } = string.Empty;
            public List<int> PurchasableItemIds { get; set; } = new();
            public int? PurchaseReminderId { get; set; }
        }

        public sealed class CatalogPrice
        {
            public int CurrencyType { get; set; }
            public int Price { get; set; }
        }

        public sealed class CatalogGiftDrop
        {
            public int GiftDropId { get; set; }
            public string FriendlyName { get; set; } = string.Empty;
            public string Tooltip { get; set; } = string.Empty;
            public string AvatarItemDesc { get; set; } = string.Empty;
            public string ConsumableItemDesc { get; set; } = string.Empty;
            public string EquipmentPrefabName { get; set; } = string.Empty;
            public string EquipmentModificationGuid { get; set; } = string.Empty;
            public int ItemType { get; set; }
            public int ConsumableItemType { get; set; }
            public int Rarity { get; set; }
            public bool IsQuery { get; set; }
            public bool Unique { get; set; }
            public int Level { get; set; }
            public int Context { get; set; }
            public string ThumbnailImage { get; set; } = string.Empty;
        }

        public sealed class CatalogSku
        {
            public long Id { get; set; }
            public long SkuId { get; set; }
            public int PurchasableItemId { get; set; }
            public int Type { get; set; }
            public bool IsFeatured { get; set; }
            public long ItemId { get; set; }
            public long AvatarItemId { get; set; }
            public int ItemType { get; set; }
            public int ConsumableItemType { get; set; }
            public int AvatarItemType { get; set; }
            public string AvatarItemDesc { get; set; } = string.Empty;
            public string ConsumableItemDesc { get; set; } = string.Empty;
            public string EquipmentPrefabName { get; set; } = string.Empty;
            public string EquipmentModificationGuid { get; set; } = string.Empty;
            public string FriendlyName { get; set; } = string.Empty;
            public string Tooltip { get; set; } = string.Empty;
            public string ThumbnailImage { get; set; } = string.Empty;
            public int Rarity { get; set; }
            public int PlatformMask { get; set; } = -1;
            public int CurrencyType { get; set; } = (int)PlayerDBClasses.CurrencyType.RecCenterTokens;
            public int Price { get; set; } = StoreItemPrice;
            public int OriginalPrice { get; set; } = StoreItemPrice;
            public int DiscountedPrice { get; set; } = StoreItemPrice;
            public bool IsAvailable { get; set; } = true;
            public bool IsPurchasable { get; set; } = true;
            public bool IsEnabled { get; set; } = true;
            public bool IsOwned { get; set; }
            public bool Owned { get; set; }
            public bool Purchased { get; set; }
            public bool IsBaseAvatarItem { get; set; }
            public bool HasRealName { get; set; } = true;
            public DateTime CreatedAt { get; set; }
            public List<CatalogPrice> Prices { get; set; } = new();
            public CatalogGiftDrop GiftDrop { get; set; } = new();
            public List<CatalogGiftDrop> GiftDrops { get; set; } = new();
        }

        [HttpGet("/api/customAvatarItems/v1/featured")]
        public IActionResult GetFeaturedCustomAvatarItems()
        {
            return Ok(Array.Empty<object>());
        }

        [HttpGet("/api/inventions/v1/{inventionId:long}/version")]
        [HttpGet("/api/inventions/v2/{inventionId:long}/version")]
        public IActionResult GetInventionVersionByPath(long inventionId)
        {
            CreatorFeatureDB.InventionRecord? record =
                CreatorFeatureDB.GetInvention(inventionId);
            if (record == null)
                return NotFound(new { Success = false, Error = "invention_not_found" });

            object? version = CreatorFeatureDB.ToClientInventionVersion(record);
            return version == null
                ? StatusCode(
                    StatusCodes.Status409Conflict,
                    new { Success = false, Error = "invention_object_blob_missing" })
                : Ok(version);
        }

        [HttpGet("/api/inventions/v1/version")]
        public IActionResult GetInventionVersion(
            [FromQuery] long inventionId,
            [FromQuery] long id = 0,
            [FromQuery] int version = 0)
        {
            long resolvedId = inventionId > 0 ? inventionId : id;
            CreatorFeatureDB.InventionRecord? record =
                CreatorFeatureDB.GetInvention(resolvedId);
            if (record == null)
                return NotFound();

            object? currentVersion = CreatorFeatureDB.ToClientInventionVersion(record);
            return currentVersion == null
                ? StatusCode(
                    StatusCodes.Status409Conflict,
                    new { Success = false, Error = "invention_object_blob_missing" })
                : Ok(currentVersion);
        }

        [HttpGet("/api/storefronts/v1/toptoday")]
        public IActionResult GetTopStorefrontsToday()
        {
            return Ok(GetCatalogSkus());
        }

        [HttpGet("/api/inventions/v1/toptoday")]
        public IActionResult GetTopInventionsToday(
            [FromQuery] int skip = 0,
            [FromQuery] int take = 100)
        {
            return Ok(CreatorFeatureDB.SearchInventions(skip: skip, take: take)
                .Select(CreatorFeatureDB.ToClientInvention)
                .ToArray());
        }

        [HttpGet("/subscription/top/creators/today")]
        public IActionResult GetTopSubscriptionCreatorsToday()
        {
            return Ok(Array.Empty<object>());
        }

        private static object ToSavedImageDto(RecNetDB.SavedImage savedImage)
        {
            long imageId = ImageController.GetOrCreateSavedImageId(savedImage);
            return new
            {
                Id = imageId,
                ImageId = imageId,
                SavedImageId = imageId,
                AccountId = savedImage.AccountId,
                RoomId = savedImage.RoomId,
                PlayerEventId = savedImage.PlayerEventId,
                Url = $"{ServerConfig.BaseURL.TrimEnd('/')}/imageserver/{savedImage.PhotoPath}",
                LookupName = savedImage.LookupName,
                Accessibility = savedImage.Accessibility,
                CreatedAt = savedImage.CreatedAt
            };
        }

        [HttpGet("/api/images/v5/player/{accountId:long}")]
        public IActionResult GetPlayerImagesV5(
            long accountId,
            [FromQuery] int sort = 0)
        {
            var images = RecNetDB.SavedImages.Find(value => value.AccountId == accountId)
                .OrderByDescending(value => value.CreatedAt)
                .Select(ToSavedImageDto)
                .ToList();
            return Ok(images);
        }

        [HttpGet("/api/images/v1/listsaved")]
        public IActionResult ListSavedImages()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            var images = RecNetDB.SavedImages.Find(value => value.AccountId == accountId.Value)
                .OrderByDescending(value => value.CreatedAt)
                .Select(ToSavedImageDto)
                .ToList();
            return Ok(images);
        }

        public class SavedImageBulkRequest
        {
            public List<string>? PhotoPaths { get; set; }
        }

        [HttpPost("/api/images/v5/bulk")]
        public IActionResult GetSavedImagesBulk([FromBody] SavedImageBulkRequest request)
        {
            if (AuthStuff.GetPlayerId(Request) == null)
                return Unauthorized();

            var paths = (request.PhotoPaths ?? new List<string>()).ToHashSet(StringComparer.OrdinalIgnoreCase);
            var images = RecNetDB.SavedImages.Find(value => paths.Contains(value.PhotoPath))
                .Select(ToSavedImageDto)
                .ToList();
            return Ok(images);
        }

        public class DeleteSavedImageRequest
        {
            public string? PhotoPath { get; set; }
        }

        [HttpPost("/api/images/v1/deletesaved")]
        [HttpDelete("/api/images/v1/deletesaved")]
        public IActionResult DeleteSavedImage([FromBody] DeleteSavedImageRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            string path = request.PhotoPath ?? string.Empty;
            var image = RecNetDB.SavedImages.FindById(path);
            if (image == null || image.AccountId != accountId.Value)
                return NotFound(new { error = "Saved image not found." });

            RecNetDB.SavedImages.Delete(path);
            return Ok(new { success = true });
        }

        [HttpPost("/api/images/v1/sendlink")]
        public IActionResult SendSavedImageLink([FromBody] DeleteSavedImageRequest request)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId == null)
                return Unauthorized();

            string path = request.PhotoPath ?? string.Empty;
            var image = RecNetDB.SavedImages.FindById(path);
            if (image == null)
                return NotFound(new { error = "Saved image not found." });

            return Ok(new { success = true, url = $"{ServerConfig.BaseURL.TrimEnd('/')}/imageserver/{image.PhotoPath}" });
        }

        [HttpGet("/api/images/v1/slideshow")]
        public IActionResult GetImageSlideshow()
        {
            string imageRoot = Path.GetFullPath(
                Path.Combine(Program.dataDir, "Images"));
            string requiredPrefix = imageRoot
                .TrimEnd(
                    Path.DirectorySeparatorChar,
                    Path.AltDirectorySeparatorChar) +
                Path.DirectorySeparatorChar;

            bool TryResolveSavedImage(
                RecNetDB.SavedImage savedImage,
                out string relativePath,
                out string fullPath)
            {
                relativePath = savedImage.PhotoPath
                    .Replace('\\', '/')
                    .TrimStart('/');
                fullPath = string.Empty;
                if (string.IsNullOrWhiteSpace(relativePath) ||
                    relativePath.Split('/').Any(segment => segment is "." or ".."))
                {
                    return false;
                }

                try
                {
                    fullPath = Path.GetFullPath(
                        Path.Combine(imageRoot, relativePath));
                    return fullPath.StartsWith(
                               requiredPrefix,
                               StringComparison.OrdinalIgnoreCase) &&
                           System.IO.File.Exists(fullPath);
                }
                catch
                {
                    return false;
                }
            }

            var images = RecNetDB.SavedImages.FindAll()
                .Where(savedImage =>
                    savedImage.SavedImageType == 1 &&
                    savedImage.Accessibility == 1 &&
                    savedImage.AccountId is > 0 and <= int.MaxValue)
                .Select(savedImage =>
                {
                    if (!TryResolveSavedImage(
                            savedImage,
                            out string relativePath,
                            out _))
                    {
                        return null;
                    }

                    var player = PlayerDB.Players.FindById(
                        savedImage.AccountId);
                    if (player?.Player == null)
                        return null;

                    var room = savedImage.RoomId is > 0
                        ? RoomDB.Rooms.FindById(savedImage.RoomId.Value)
                        : null;
                    long imageId =
                        ImageController.GetOrCreateSavedImageId(savedImage);

                    return new SlideshowImageResponse
                    {
                        Id = imageId,
                        ImageId = imageId,
                        SavedImageId = imageId,
                        ImageName = relativePath,
                        Username =
                            player.Player.Username ??
                            player.Player.DisplayName ??
                            $"Player{player.PlayerId}",
                        PlayerName =
                            player.Player.Username ??
                            player.Player.DisplayName ??
                            $"Player{player.PlayerId}",
                        PlayerId = checked((int)player.PlayerId),
                        RoomName = room?.Name ?? "Rec Room",
                        RoomId = savedImage.RoomId
                    };
                })
                .Where(image => image != null)
                .Cast<SlideshowImageResponse>()
                .GroupBy(
                    image => image.ImageName,
                    StringComparer.OrdinalIgnoreCase)
                .Select(group => group.First())
                .ToList();

            if (images.Count == 0)
            {
                var fallbackPlayer =
                    (AuthStuff.GetPlayerId(Request) is long callerId
                        ? PlayerDB.Players.FindById(callerId)
                        : null) ??
                    PlayerDB.Players.FindAll()
                        .FirstOrDefault(player => player.Player != null);
                int fallbackPlayerId =
                    fallbackPlayer?.PlayerId is > 0 and <= int.MaxValue
                        ? checked((int)fallbackPlayer.PlayerId)
                        : 1;
                string fallbackPlayerName =
                    fallbackPlayer?.Player?.Username ??
                    fallbackPlayer?.Player?.DisplayName ??
                    "Mocha";
                string rroRoot = Path.Combine(imageRoot, "RROs");

                if (Directory.Exists(rroRoot))
                {
                    images.AddRange(Directory
                        .EnumerateFiles(rroRoot, "*", SearchOption.AllDirectories)
                        .Where(file => new[]
                        {
                            ".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp"
                        }.Contains(
                            Path.GetExtension(file),
                            StringComparer.OrdinalIgnoreCase))
                        .Select(file =>
                        {
                            long imageId = Math.Max(
                                System.IO.File.GetCreationTimeUtc(file).Ticks,
                                1);
                            return new SlideshowImageResponse
                            {
                                Id = imageId,
                                ImageId = imageId,
                                SavedImageId = imageId,
                                ImageName = Path
                                    .GetRelativePath(imageRoot, file)
                                    .Replace('\\', '/'),
                                Username = fallbackPlayerName,
                                PlayerName = fallbackPlayerName,
                                PlayerId = fallbackPlayerId,
                                RoomName = Path.GetFileNameWithoutExtension(file),
                                RoomId = null
                            };
                        }));
                }
            }

            for (int index = images.Count - 1; index > 0; index--)
            {
                int swapIndex = Random.Shared.Next(index + 1);
                (images[index], images[swapIndex]) =
                    (images[swapIndex], images[index]);
            }

            DateTime validTill = DateTime.UtcNow.AddMinutes(5);
            Console.WriteLine(
                $"[IMAGE SLIDESHOW] images={images.Count} " +
                $"order=random loop=wrap validTill={validTill:O}");

            return Ok(new
            {
                ValidTill = validTill,
                Images = images
            });
        }

        private sealed class SlideshowImageResponse
        {
            public long Id { get; init; }
            public long ImageId { get; init; }
            public long SavedImageId { get; init; }
            public string ImageName { get; init; } = string.Empty;
            public string Username { get; init; } = string.Empty;
            public string PlayerName { get; init; } = string.Empty;
            public int PlayerId { get; init; }
            public string RoomName { get; init; } = string.Empty;
            public long? RoomId { get; init; }
        }

        private IActionResult GetLoadingScreenData()
        {
            string path = Path.Combine(Program.dataDir, "loadingscreen.json");

            if (System.IO.File.Exists(path))
            {
                try
                {
                    string rewritten = LoadingScreenImageService.RewriteConfiguration(
                        System.IO.File.ReadAllText(path));
                    return Content(rewritten, "application/json");
                }
                catch (Exception ex) when (ex is IOException or JsonException)
                {
                    Console.WriteLine($"[loading screen config] {ex.Message}");
                }
            }

            return Ok(new[]
            {
                new
                {
                    ImageName = "RROs/DormRoom.jpg",
                    Message = "Welcome to Mocha! Meet up with friends and explore community rooms.",
                    PlatformMask = -1,
                    RoomNames = Array.Empty<string>(),
                    Title = "Welcome to Mocha"
                },
                new
                {
                    ImageName = "RROs/RecCenter.jpg",
                    Message = "Open the People menu to find, friend, and subscribe to other players.",
                    PlatformMask = -1,
                    RoomNames = Array.Empty<string>(),
                    Title = "Play together"
                }
            });
        }

        [HttpPost("/api/objectives/v1/cleargroup")]
        public IActionResult ClearObjectiveGroup()
        {
            return Ok(new
            {
                success = true
            });
        }

        [HttpGet("/cdn/sigs/{buildId}")]
        public IActionResult GetBuildSignature(string buildId)
        {
            Response.Headers.CacheControl = "public, max-age=3600";
            return Content("p1", "text/plain");
        }

        [HttpPost("/api/screensharereports")]
        public IActionResult CreateScreenShareReport([FromBody] JsonElement request)
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            DiscordLogger.Log($"🖥️ Screen share report submitted by player ID `{id}`");

            return Ok(new { success = true });
        }

        [HttpGet("/api/config/v1/azurespeech")]
        [HttpGet("/api/config/v1/backtrace")]
        public IActionResult DisabledFeatureConfigStub()
        {
            return Ok(new { enabled = false });
        }

        [HttpGet("/api/keepsakes/globalconfig")]
        [HttpGet("/api/keepsakes/config")]
        [HttpGet("/api/keepsakes/v1/globalconfig")]
        [HttpGet("/api/keepsakes/v1/config")]
        public IActionResult KeepsakesGlobalConfig()
        {
            return Ok(new
            {
                Enabled = true,
                MaxKeepsakesPerRoom = 0,
                CollectionEnabled = true
            });
        }

        [HttpGet("/api/keepsakes/rooms/{roomId}")]
        [HttpGet("/api/keepsakes/room/{roomId}")]
        [HttpGet("/api/keepsakes/v1/rooms/{roomId}")]
        [HttpGet("/api/keepsakes/v1/room/{roomId}")]
        public IActionResult KeepsakesForRoom(long roomId)
        {
            return Ok(new
            {
                RoomId = roomId,
                KeepsakeInstances = Array.Empty<object>(),
                CollectionRecords = Array.Empty<object>(),
                CollectedKeepsakeIds = Array.Empty<long>()
            });
        }

        private IActionResult ReadAnnouncementList()
        {
            string path = Path.Combine(Program.dataDir, "announcements.json");

            if (!System.IO.File.Exists(path))
                return Ok(Array.Empty<object>());

            string json = System.IO.File.ReadAllText(path);

            if (string.IsNullOrWhiteSpace(json))
                return Ok(Array.Empty<object>());

            try
            {
                using JsonDocument document = JsonDocument.Parse(json);

                if (document.RootElement.ValueKind != JsonValueKind.Array)
                {
                    Console.WriteLine("[Announcements] announcements.json must contain a JSON array.");
                    return Ok(Array.Empty<object>());
                }

                Response.Headers.CacheControl = "no-store, no-cache, must-revalidate";
                Response.Headers.Pragma = "no-cache";
                Response.Headers.Expires = "0";

                Console.WriteLine($"[Announcements] Returning: {json}");

                return Content(json, "application/json");
            }
            catch (JsonException exception)
            {
                Console.WriteLine($"[Announcements] Invalid JSON: {exception.Message}");
                return Ok(Array.Empty<object>());
            }
        }

        [HttpGet("/announcements/v2/mine/unread")]
        public IActionResult GetUnreadAnnouncements()
        {

            return Ok(Array.Empty<object>());
        }

        [HttpGet("/announcements/v2/subscription/mine/unread")]
        public IActionResult GetUnreadSubscriptionAnnouncements()
        {
            return Ok(Array.Empty<object>());
        }

        [HttpGet("/api/announcement/v1/get")]
        public IActionResult GetAnnouncements()
        {
            return ReadAnnouncementList();
        }

        [HttpPost("/announcements/v2/mine/read")]
        [HttpPost("/announcements/v2/mine/markread")]
        [HttpPost("/announcements/v2/subscription/mine/read")]
        public IActionResult MarkAnnouncementsRead()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            return Ok(new { Success = true });
        }

        [HttpPost("/api/announcement/v1/refresh")]
        public async Task<IActionResult> RefreshAnnouncements()
        {
            long? playerId = AuthStuff.GetPlayerId(Request);
            if (!playerId.HasValue)
                return Unauthorized();

            await NotiController.NotifyAnnouncementsUpdatedAsync(playerId.Value);
            return Ok(new { Success = true });
        }

        [HttpPost("/api/relationships/v1/bulkignoreplatformusers")]
        public IActionResult BulkIgnorePlatformUsers()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(new { success = true });
        }

        [HttpGet("/api/relationships/v1/favorite")]
        public IActionResult GetFavoriteRelationship([FromQuery] long id)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            ClientRelationshipDTO? relationship =
                RelationshipDB.GetClientRelationship(accountId.Value, id);
            return Ok(relationship != null &&
                      (relationship.Favorited & 1) != 0);
        }

        [HttpGet("/thread/club/{clubId:long}")]
        public IActionResult GetClubThreads(
            long clubId,
            [FromQuery] int maxCount = 10,
            [FromQuery] int mode = 0)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            return Ok(Array.Empty<object>());
        }

        [HttpPost("/pageview/consume")]
        public IActionResult ConsumePageView() => NoContent();

        [HttpPost("/api/ugcPurchasables/v1/items/bulk")]
        public IActionResult UgcPurchasablesBulk()
        {
            var id = AuthStuff.GetPlayerId(Request);
            if (id == null)
                return Unauthorized();

            return Ok(Array.Empty<object>());
        }

        [HttpPost("/api/PlayerReporting/v1/deviceId")]
        public IActionResult PlayerReportingDeviceId()
        {
            var id = AuthStuff.GetPlayerId(Request);
            return Ok(new { accountId = id });
        }

        [HttpGet("/api/testcasemanagement/v1/cases")]
        public IActionResult TestCaseManagementStub()
        {
            return Ok(ServerConfig.Bracket);
        }

        [HttpGet("/api/customAvatarItems/v1/design")]
        public IActionResult GetCustomAvatarItemDesign()
        {
            long? rawPlayerId = AuthStuff.GetPlayerId(Request);

            if (!rawPlayerId.HasValue)
                return Unauthorized();

            long playerId = rawPlayerId.Value;

            string directory = Path.Combine(
                Program.dataDir,
                "CustomAvatarItems",
                playerId.ToString()
            );

            string designPath = Path.Combine(directory, "design.json");

            Console.WriteLine(
                $"[CUSTOM AVATAR ITEMS] Player ({playerId}) requested their design."
            );

            if (!System.IO.File.Exists(designPath))
            {

                return Ok(new
                {
                    customAvatarItemId = 0,
                    creatorPlayerId = playerId,
                    design = new { }
                });
            }

            try
            {
                string json = System.IO.File.ReadAllText(designPath);

                return Content(
                    json,
                    "application/json",
                    Encoding.UTF8
                );
            }
            catch (Exception ex)
            {
                Console.WriteLine(
                    $"[CUSTOM AVATAR ITEMS] Failed reading design: {ex}"
                );

                return StatusCode(500, new
                {
                    success = false,
                    error = "Failed to load custom avatar item design."
                });
            }
        }

        [HttpPost("/api/customAvatarItems/v1")]
        [RequestSizeLimit(12 * 1024 * 1024)]
        public async Task<IActionResult> CreateCustomAvatarItem()
        {
            long? rawPlayerId = AuthStuff.GetPlayerId(Request);
            if (!rawPlayerId.HasValue)
                return Unauthorized();

            long playerId = rawPlayerId.Value;
            string metadataJson = string.Empty;
            IFormFile? thumbnailImage = null;

            if (Request.HasFormContentType)
            {
                IFormCollection form;
                try
                {
                    form = await Request.ReadFormAsync(HttpContext.RequestAborted);
                }
                catch (InvalidDataException ex)
                {
                    Console.WriteLine(
                        $"[CUSTOM AVATAR ITEMS] Invalid multipart request from player ({playerId}): {ex.Message}");
                    return BadRequest(new { success = false, error = "Invalid multipart form." });
                }

                metadataJson = new[]
                    {
                        "metadata",
                        "Metadata",
                        "data",
                        "Data",
                        "json",
                        "Json"
                    }
                    .Select(name => form[name].FirstOrDefault())
                    .FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))
                    ?? string.Empty;

                thumbnailImage = form.Files.GetFile("thumbnailImage")
                    ?? form.Files.GetFile("ThumbnailImage")
                    ?? form.Files.FirstOrDefault();
            }
            else
            {
                using var reader = new StreamReader(
                    Request.Body,
                    Encoding.UTF8,
                    detectEncodingFromByteOrderMarks: true,
                    leaveOpen: true);
                metadataJson = await reader.ReadToEndAsync();
            }

            Console.WriteLine(
                $"[CUSTOM AVATAR ITEMS] Player ({playerId}) metadata: {metadataJson}");

            if (string.IsNullOrWhiteSpace(metadataJson))
            {
                return BadRequest(new
                {
                    success = false,
                    error = "Custom avatar item metadata was empty."
                });
            }

            JsonNode? receivedJson;
            try
            {
                receivedJson = JsonNode.Parse(metadataJson);
            }
            catch (JsonException ex)
            {
                Console.WriteLine(
                    $"[CUSTOM AVATAR ITEMS] Invalid metadata JSON from player ({playerId}): {ex.Message}");
                return BadRequest(new
                {
                    success = false,
                    error = "Custom avatar item metadata contained invalid JSON."
                });
            }

            if (receivedJson is not JsonObject item)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "Custom avatar item metadata must be a JSON object."
                });
            }

            long customAvatarItemId = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            while (LoadCustomAvatarItems(playerId).Any(existing =>
                       ReadCustomAvatarItemId(existing) == customAvatarItemId))
            {
                customAvatarItemId++;
            }

            string createdAt = DateTime.UtcNow.ToString("O");
            item["CustomAvatarItemId"] = customAvatarItemId;
            item["customAvatarItemId"] = customAvatarItemId;
            item["Id"] ??= customAvatarItemId;
            item["CreatorPlayerId"] = playerId;
            item["creatorPlayerId"] = playerId;
            item["CreatorAccountId"] ??= playerId;
            item["CreatedAt"] ??= createdAt;
            item["createdAt"] ??= createdAt;

            string directory = Path.Combine(
                Program.dataDir,
                "CustomAvatarItems",
                playerId.ToString());
            string designPath = Path.Combine(directory, "design.json");
            string itemsPath = Path.Combine(directory, "items.json");

            try
            {
                Directory.CreateDirectory(directory);

                if (thumbnailImage is { Length: > 0 })
                {
                    string imageDirectory = Path.Combine(
                        Program.dataDir,
                        "Images",
                        "CustomAvatarItems",
                        playerId.ToString());
                    Directory.CreateDirectory(imageDirectory);

                    string extension = string.Equals(
                            thumbnailImage.ContentType,
                            "image/jpeg",
                            StringComparison.OrdinalIgnoreCase)
                        ? ".jpg"
                        : ".png";
                    string imageName = customAvatarItemId + extension;
                    string imagePath = Path.Combine(imageDirectory, imageName);

                    await using (FileStream stream = new(
                        imagePath,
                        FileMode.Create,
                        FileAccess.Write,
                        FileShare.None))
                    {
                        await thumbnailImage.CopyToAsync(
                            stream,
                            HttpContext.RequestAborted);
                    }

                    string relativeImagePath =
                        $"CustomAvatarItems/{playerId}/{imageName}";
                    item["ThumbnailImage"] = relativeImagePath;
                    item["thumbnailImage"] = relativeImagePath;
                }

                JsonNode designToSave = item["Design"]?.DeepClone()
                    ?? item["design"]?.DeepClone()
                    ?? item.DeepClone();

                await System.IO.File.WriteAllTextAsync(
                    designPath,
                    designToSave.ToJsonString(new JsonSerializerOptions
                    {
                        WriteIndented = true
                    }),
                    HttpContext.RequestAborted);

                JsonArray items = new();
                if (System.IO.File.Exists(itemsPath))
                {
                    try
                    {
                        items = JsonNode.Parse(
                                    await System.IO.File.ReadAllTextAsync(
                                        itemsPath,
                                        HttpContext.RequestAborted)) as JsonArray
                                ?? new JsonArray();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(
                            $"[CUSTOM AVATAR ITEMS] Existing items file was invalid: {ex.Message}");
                    }
                }

                items.Add(item.DeepClone());
                await System.IO.File.WriteAllTextAsync(
                    itemsPath,
                    items.ToJsonString(new JsonSerializerOptions
                    {
                        WriteIndented = true
                    }),
                    HttpContext.RequestAborted);

                Console.WriteLine(
                    $"[CUSTOM AVATAR ITEMS] Created item ({customAvatarItemId}) for player ({playerId}).");

                return Content(
                    item.ToJsonString(),
                    "application/json",
                    Encoding.UTF8);
            }
            catch (Exception ex)
            {
                Console.WriteLine(
                    $"[CUSTOM AVATAR ITEMS] Failed saving item: {ex}");
                return StatusCode(500, new
                {
                    success = false,
                    error = "Failed to save custom avatar item."
                });
            }
        }

        private static List<JsonObject> LoadCustomAvatarItems(long playerId)
        {
            string itemsPath = Path.Combine(
                Program.dataDir,
                "CustomAvatarItems",
                playerId.ToString(),
                "items.json");

            if (!System.IO.File.Exists(itemsPath))
                return new List<JsonObject>();

            try
            {
                JsonNode? root = JsonNode.Parse(System.IO.File.ReadAllText(itemsPath));
                if (root is not JsonArray array)
                    return new List<JsonObject>();

                return array
                    .OfType<JsonObject>()
                    .Select(value => value.DeepClone().AsObject())
                    .OrderByDescending(ReadCustomAvatarItemId)
                    .ToList();
            }
            catch (Exception ex)
            {
                Console.WriteLine(
                    $"[CUSTOM AVATAR ITEMS] Could not read items for player ({playerId}): {ex.Message}");
                return new List<JsonObject>();
            }
        }

        private static long ReadCustomAvatarItemId(JsonObject item)
        {
            foreach (string key in new[] { "CustomAvatarItemId", "customAvatarItemId", "Id", "id" })
            {
                if (TryReadLong(item[key], out long id))
                    return id;
            }

            return 0;
        }

        [HttpGet("/reminder/currentTokenBundles/v2")]
        public IActionResult GetCurrentTokenBundles()
        {
            DateTime expiresAt = DateTime.UtcNow.AddYears(10);

            var bundles = new List<TokenBundleResponse>
    {
        CreateTokenBundle(
            id: 9_000_001,
            productId: "mocha.tokens.2500",
            baseTokens: 2_500,
            bonusTokens: 0,
            displayPrice: "$1.99",
            expiresAt
        ),

        CreateTokenBundle(
            id: 9_000_002,
            productId: "mocha.tokens.5500",
            baseTokens: 5_000,
            bonusTokens: 500,
            displayPrice: "$3.99",
            expiresAt
        ),

        CreateTokenBundle(
            id: 9_000_003,
            productId: "mocha.tokens.12000",
            baseTokens: 10_000,
            bonusTokens: 2_000,
            displayPrice: "$7.99",
            expiresAt
        ),

        CreateTokenBundle(
            id: 9_000_004,
            productId: "mocha.tokens.35000",
            baseTokens: 25_000,
            bonusTokens: 10_000,
            displayPrice: "$19.99",
            expiresAt
        ),

        CreateTokenBundle(
            id: 9_000_005,
            productId: "mocha.tokens.70000",
            baseTokens: 50_000,
            bonusTokens: 20_000,
            displayPrice: "$34.99",
            expiresAt
        )
    };

            return Ok(bundles);
        }

        [HttpPost("/api/relationships/v1/ignore")]
        [HttpPost("/api/relationships/v2/ignore")]
        [HttpPost("/api/relationships/v1/block")]
        [HttpPost("/api/relationships/v2/block")]
        [HttpPut("/api/relationships/v1/ignore")]
        [HttpPut("/api/relationships/v2/ignore")]
        [HttpPut("/api/relationships/v1/block")]
        [HttpPut("/api/relationships/v2/block")]
        public Task<IActionResult> IgnorePlayer()
        {
            return SetRelationshipFlag(
                RelationshipFlag.Ignored,
                forcedEnabled: null);
        }

        [HttpPost("/api/relationships/v1/mute")]
        [HttpPost("/api/relationships/v2/mute")]
        [HttpPut("/api/relationships/v1/mute")]
        [HttpPut("/api/relationships/v2/mute")]
        public Task<IActionResult> MutePlayer()
        {
            return SetRelationshipFlag(
                RelationshipFlag.Muted,
                forcedEnabled: null);
        }

        [HttpPost("/api/relationships/v1/unignore")]
        [HttpPost("/api/relationships/v2/unignore")]
        [HttpPost("/api/relationships/v1/unblock")]
        [HttpPost("/api/relationships/v2/unblock")]
        [HttpDelete("/api/relationships/v1/ignore")]
        [HttpDelete("/api/relationships/v2/ignore")]
        [HttpDelete("/api/relationships/v1/block")]
        [HttpDelete("/api/relationships/v2/block")]
        public Task<IActionResult> UnignorePlayer()
        {
            return SetRelationshipFlag(
                RelationshipFlag.Ignored,
                forcedEnabled: false);
        }

        [HttpPost("/api/relationships/v1/unmute")]
        [HttpPost("/api/relationships/v2/unmute")]
        [HttpDelete("/api/relationships/v1/mute")]
        [HttpDelete("/api/relationships/v2/mute")]
        public Task<IActionResult> UnmutePlayer()
        {
            return SetRelationshipFlag(
                RelationshipFlag.Muted,
                forcedEnabled: false);
        }

        [HttpPost("/api/relationships/v1/favorite")]
        [HttpPost("/api/relationships/v2/favorite")]
        [HttpPut("/api/relationships/v1/favorite")]
        [HttpPut("/api/relationships/v2/favorite")]
        public Task<IActionResult> FavoritePlayer()
        {
            return SetRelationshipFlag(
                RelationshipFlag.Favorited,
                forcedEnabled: null);
        }

        [HttpPost("/api/relationships/v1/unfavorite")]
        [HttpPost("/api/relationships/v2/unfavorite")]
        [HttpDelete("/api/relationships/v1/favorite")]
        [HttpDelete("/api/relationships/v2/favorite")]
        public Task<IActionResult> UnfavoritePlayer()
        {
            return SetRelationshipFlag(
                RelationshipFlag.Favorited,
                forcedEnabled: false);
        }

        private enum RelationshipFlag
        {
            Ignored,
            Muted,
            Favorited
        }

        private async Task<IActionResult> SetRelationshipFlag(
            RelationshipFlag flag,
            bool? forcedEnabled)
        {
            long? sourceId = AuthStuff.GetPlayerId(Request);

            if (sourceId == null)
                return Unauthorized();

            var action = await ReadRelationshipAction(
                flag switch
                {
                    RelationshipFlag.Ignored =>
                        new[] { "Ignored", "IsIgnored", "Ignore", "Blocked", "IsBlocked", "Block" },
                    RelationshipFlag.Muted =>
                        new[] { "Muted", "IsMuted", "Mute" },
                    RelationshipFlag.Favorited =>
                        new[] { "Favorited", "IsFavorited", "Favorite" },
                    _ => Array.Empty<string>()
                });

            if (action == null)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "missing_target_player"
                });
            }

            bool enabled = forcedEnabled ?? action.Value.Enabled;

            var relationship = PlayerDB.SetRelationshipFlags(
                sourceId.Value,
                action.Value.TargetId,
                ignored: flag == RelationshipFlag.Ignored ? enabled : null,
                muted: flag == RelationshipFlag.Muted ? enabled : null,
                favorited: flag == RelationshipFlag.Favorited ? enabled : null);

            if (relationship == null)
            {
                return BadRequest(new
                {
                    success = false,
                    error = "relationship_update_failed"
                });
            }

            ClientRelationshipDTO? clientRelationship =
                RelationshipDB.GetClientRelationship(
                    sourceId.Value,
                    action.Value.TargetId);

            if (clientRelationship == null)
            {
                return StatusCode(500, new
                {
                    success = false,
                    error = "relationship_not_persisted"
                });
            }

            string actionName = flag switch
            {
                RelationshipFlag.Ignored =>
                    enabled ? "block" : "unblock",
                RelationshipFlag.Muted =>
                    enabled ? "mute" : "unmute",
                RelationshipFlag.Favorited =>
                    enabled ? "favorite" : "unfavorite",
                _ => "relationship-change"
            };

            await NotiController.NotifyRelationshipFlagsChangedAsync(
                sourceId.Value,
                action.Value.TargetId,
                actionName);

            Console.WriteLine(
                $"[RELATIONSHIP] source={sourceId.Value} " +
                $"target={action.Value.TargetId} action={actionName} " +
                $"ignored={clientRelationship.Ignored} " +
                $"muted={clientRelationship.Muted} " +
                $"favorited={clientRelationship.Favorited} live=true");

            return Ok(clientRelationship);
        }

        private async Task<(long TargetId, bool Enabled)?>
            ReadRelationshipAction(string[] enabledKeys)
        {
            var values = new Dictionary<string, string>(
                StringComparer.OrdinalIgnoreCase);

            foreach (var entry in Request.Query)
                values[entry.Key] = entry.Value.ToString();

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync();

                foreach (var entry in form)
                    values[entry.Key] = entry.Value.ToString();
            }
            else
            {
                using var reader = new StreamReader(Request.Body);
                string body = await reader.ReadToEndAsync();

                if (!string.IsNullOrWhiteSpace(body))
                {
                    try
                    {
                        using var document = JsonDocument.Parse(body);
                        AddJsonValues(document.RootElement, values);
                    }
                    catch (JsonException)
                    {
                        foreach (var entry in
                            Microsoft.AspNetCore.WebUtilities.QueryHelpers
                                .ParseQuery("?" + body))
                        {
                            values[entry.Key] = entry.Value.ToString();
                        }

                        if (long.TryParse(
                            body.Trim().Trim('"', '\''),
                            out long rawTargetId))
                        {
                            values["accountId"] =
                                rawTargetId.ToString();
                        }
                    }
                }
            }

            string? targetText = GetValue(
                values,
                "TargetAccountId",
                "TargetPlayerId",
                "AccountId",
                "PlayerId",
                "PlayerID",
                "targetId",
                "id");

            if (!long.TryParse(targetText, out long targetId) ||
                targetId <= 0)
            {
                return null;
            }

            bool enabled = true;

            string? enabledText = GetValue(
                values,
                enabledKeys
                    .Concat(new[]
                    {
                "Enabled",
                "Value",
                "State"
                    })
                    .ToArray());

            if (bool.TryParse(enabledText, out bool parsedBool))
            {
                enabled = parsedBool;
            }
            else if (int.TryParse(enabledText, out int parsedInt))
            {
                enabled = parsedInt != 0;
            }

            return (targetId, enabled);
        }

        private async Task<HashSet<long>> ReadLongValuesAsync(params string[] keys)
        {
            var result = new HashSet<long>();
            var keySet = keys.ToHashSet(StringComparer.OrdinalIgnoreCase);

            foreach (var entry in Request.Query)
            {
                if (keySet.Contains(entry.Key))
                    AddLongValuesFromText(entry.Value.ToString(), result);
            }

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync(HttpContext.RequestAborted);
                foreach (var entry in form)
                {
                    if (keySet.Contains(entry.Key))
                        AddLongValuesFromText(entry.Value.ToString(), result);
                }
            }
            else
            {

                Request.EnableBuffering();
                if (Request.Body.CanSeek)
                    Request.Body.Position = 0;

                using var reader = new StreamReader(
                    Request.Body,
                    Encoding.UTF8,
                    detectEncodingFromByteOrderMarks: false,
                    leaveOpen: true);

                string body = await reader.ReadToEndAsync();
                if (Request.Body.CanSeek)
                    Request.Body.Position = 0;

                if (!string.IsNullOrWhiteSpace(body))
                {
                    try
                    {
                        using JsonDocument document = JsonDocument.Parse(body);
                        CollectLongValues(
                            document.RootElement,
                            keySet,
                            result,
                            collectAll: document.RootElement.ValueKind == JsonValueKind.Array);
                    }
                    catch (JsonException)
                    {
                        foreach (var entry in Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery("?" + body))
                        {
                            if (keySet.Contains(entry.Key))
                                AddLongValuesFromText(entry.Value.ToString(), result);
                        }

                        AddLongValuesFromText(body, result);
                    }
                }
            }

            return result;
        }

        private static void CollectLongValues(
            JsonElement element,
            HashSet<string> keys,
            HashSet<long> result,
            bool collectAll)
        {
            switch (element.ValueKind)
            {
                case JsonValueKind.Object:
                    foreach (JsonProperty property in element.EnumerateObject())
                    {
                        bool propertyMatches = keys.Contains(property.Name);
                        CollectLongValues(
                            property.Value,
                            keys,
                            result,
                            collectAll || propertyMatches);
                    }
                    break;

                case JsonValueKind.Array:
                    foreach (JsonElement item in element.EnumerateArray())
                        CollectLongValues(item, keys, result, collectAll);
                    break;

                case JsonValueKind.Number when collectAll:
                    if (element.TryGetInt64(out long numericValue) && numericValue > 0)
                        result.Add(numericValue);
                    break;

                case JsonValueKind.String when collectAll:
                    AddLongValuesFromText(element.GetString(), result);
                    break;
            }
        }

        private static void AddLongValuesFromText(
            string? text,
            HashSet<long> result)
        {
            if (string.IsNullOrWhiteSpace(text))
                return;

            string cleaned = text.Replace("[", " ").Replace("]", " ")
                .Replace("{", " ").Replace("}", " ").Replace("\"", " ")
                .Replace("'", " ");

            foreach (string part in cleaned.Split(
                         new[] { ',', ';', '|', ' ', '\t', '\r', '\n', '=', ':' },
                         StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
            {
                if (long.TryParse(part, out long value) && value > 0)
                    result.Add(value);
            }
        }

        private static TokenBundleResponse CreateTokenBundle(
            int id,
            string productId,
            int baseTokens,
            int bonusTokens,
            string displayPrice,
            DateTime expiresAt)
        {
            int totalTokens = baseTokens + bonusTokens;

            return new TokenBundleResponse
            {
                Id = id,
                TokenBundleId = id,
                BundleId = id,
                SkuId = id,
                PurchasableItemId = id,

                ProductId = productId,
                PlatformProductId = productId,
                Sku = productId,

                Name = $"{totalTokens:N0} Tokens",
                DisplayName = $"{totalTokens:N0} Tokens",

                TokenAmount = baseTokens,
                BaseTokenAmount = baseTokens,
                BonusTokenAmount = bonusTokens,
                BonusTokens = bonusTokens,
                Tokens = totalTokens,
                TotalTokens = totalTokens,

                Price = displayPrice,
                DisplayPrice = displayPrice,
                CurrencyCode = "CAD",

                ExpirationDate = expiresAt,
                ExpiresAt = expiresAt,
                EndDate = expiresAt,

                IsActive = true,
                IsAvailable = true,

                GiftDrops = Array.Empty<object>(),
                BonusGiftDrops = Array.Empty<object>()
            };
        }

        public sealed class TokenBundleResponse
        {
            public int Id { get; set; }
            public int TokenBundleId { get; set; }
            public int BundleId { get; set; }
            public int SkuId { get; set; }
            public int PurchasableItemId { get; set; }

            public string ProductId { get; set; } = "";
            public string PlatformProductId { get; set; } = "";
            public string Sku { get; set; } = "";

            public string Name { get; set; } = "";
            public string DisplayName { get; set; } = "";

            public int TokenAmount { get; set; }
            public int BaseTokenAmount { get; set; }
            public int BonusTokenAmount { get; set; }
            public int BonusTokens { get; set; }
            public int Tokens { get; set; }
            public int TotalTokens { get; set; }

            public string Price { get; set; } = "";
            public string DisplayPrice { get; set; } = "";
            public string CurrencyCode { get; set; } = "";

            public DateTime ExpirationDate { get; set; }
            public DateTime ExpiresAt { get; set; }
            public DateTime EndDate { get; set; }

            public bool IsActive { get; set; }
            public bool IsAvailable { get; set; }

            public object[] GiftDrops { get; set; } = Array.Empty<object>();
            public object[] BonusGiftDrops { get; set; } = Array.Empty<object>();
        }

        public class SanitizeRequest
        {
            public string Value { get; set; } = string.Empty;
        }
    }
}