using System.Text.Json;
using Mocha2023.Auth;
using Mocha2023.Classes;
using Mocha2023.Classes.DBs;
using Mocha2023.Classes.DBs.DBClasses;
using Microsoft.AspNetCore.Mvc;

namespace Mocha2023.Controllers
{
    [ApiController]
    [ApiProtection]
    public sealed class CreatorFeatureController : ControllerBase
    {
        private const int MaxSmallPayloadBytes = 64 * 1024;

        [HttpPost("/api/meetupcodes/v1")]
        [HttpPut("/api/meetupcodes/v1")]
        [HttpPost("/api/meetupcodes/v1/create")]
        [HttpPut("/api/meetupcodes/v1/create")]
        [HttpPost("/api/meetups/v1/create")]
        [HttpPut("/api/meetups/v1/create")]
        [HttpPost("/api/meetup/v1/create")]
        [HttpPost("/api/codes/v1/create")]
        [HttpPost("/api/players/v1/meetupcode")]
        [HttpPut("/api/players/v1/meetupcode")]
        [HttpPost("/api/players/v1/meetupcode/create")]
        [RequestSizeLimit(MaxSmallPayloadBytes)]
        public async Task<IActionResult> CreateMeetupCode()
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            PlayerDBClasses.Heartbeat heartbeat =
                PlayerDB.GetPlayerHeartbeat(accountId.Value);
            PlayerDBClasses.RoomInstance? instance = heartbeat.roomInstance;
            if (instance == null || instance.roomId <= 0 ||
                instance.roomInstanceId <= 0)
            {
                return BadRequest(new
                {
                    Success = false,
                    Error = "You must be inside a live room before creating a meetup code."
                });
            }

            Dictionary<string, string> values = await ReadValuesAsync();
            int maxUses = ReadInt(values, 100,
                "maxUses", "MaxUses", "uses", "Uses");
            int lifetimeMinutes = ReadInt(values, 360,
                "lifetimeMinutes", "LifetimeMinutes", "expiresInMinutes");

            CreatorFeatureDB.MeetupCodeRecord code =
                CreatorFeatureDB.CreateMeetupCode(
                    accountId.Value,
                    instance.roomId,
                    instance.subRoomId,
                    instance.roomInstanceId,
                    maxUses,
                    lifetimeMinutes);

            Console.WriteLine(
                $"[MEETUP CODE CREATE] code={code.Code} creator={accountId.Value} " +
                $"room={code.RoomId} instance={code.RoomInstanceId}");

            object dto = CreatorFeatureDB.ToClientMeetupCode(code);
            return Ok(new
            {
                Success = true,
                Value = dto,
                MeetupCode = code.Code,
                Code = code.Code,
                RoomId = code.RoomId,
                RoomInstanceId = code.RoomInstanceId,
                ExpiresAt = code.ExpiresAtUtc
            });
        }

        [HttpGet("/api/meetupcodes/v1/{code}")]
        [HttpGet("/api/meetups/v1/{code}")]
        [HttpGet("/api/meetup/v1/{code}")]
        [HttpGet("/api/codes/v1/{code}")]
        [HttpGet("/api/players/v1/meetupcode/{code}")]
        public IActionResult GetMeetupCode(string code)
        {
            if (!AuthStuff.GetPlayerId(Request).HasValue)
                return Unauthorized();

            CreatorFeatureDB.MeetupCodeRecord? record =
                CreatorFeatureDB.GetMeetupCode(code);
            return record == null
                ? NotFound(new { Success = false, Error = "meetup_code_not_found" })
                : Ok(CreatorFeatureDB.ToClientMeetupCode(record));
        }

        [HttpPost("/api/meetupcodes/v1/redeem")]
        [HttpPut("/api/meetupcodes/v1/redeem")]
        [HttpPost("/api/meetupcodes/v1/join")]
        [HttpPut("/api/meetupcodes/v1/join")]
        [HttpPost("/api/meetups/v1/redeem")]
        [HttpPost("/api/meetups/v1/join")]
        [HttpPost("/api/meetup/v1/redeem")]
        [HttpPost("/api/meetup/v1/join")]
        [HttpPost("/api/codes/v1/redeem")]
        [HttpPost("/api/codes/v1/join")]
        [HttpPost("/api/players/v1/meetupcode/redeem")]
        [HttpPut("/api/players/v1/meetupcode/redeem")]
        [HttpPost("/api/players/v1/meetupcode/join")]
        [HttpPost("/api/meetupcodes/v1/redeem/{code}")]
        [HttpPut("/api/meetupcodes/v1/redeem/{code}")]
        [HttpPost("/api/meetupcodes/v1/join/{code}")]
        [HttpPut("/api/meetupcodes/v1/join/{code}")]
        [HttpPost("/api/meetupcodes/v1/{code}")]
        [HttpPut("/api/meetupcodes/v1/{code}")]
        [HttpPost("/api/meetups/v1/{code}")]
        [HttpPut("/api/meetups/v1/{code}")]
        [RequestSizeLimit(MaxSmallPayloadBytes)]
        public async Task<IActionResult> RedeemMeetupCode(string? code = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            Dictionary<string, string> values = await ReadValuesAsync();
            code ??= ReadString(values,
                "code", "Code", "meetupCode", "MeetupCode", "inviteCode");

            CreatorFeatureDB.MeetupCodeRecord? record =
                CreatorFeatureDB.GetMeetupCode(code);
            if (record == null)
            {
                return NotFound(new
                {
                    Success = false,
                    Error = "meetup_code_not_found",
                    ErrorMessage = "That meetup code is invalid or expired."
                });
            }

            PlayerDBClasses.Heartbeat? heartbeat = Sessions.JoinInvitedRoomInstance(
                accountId.Value,
                record.RoomInstanceId,
                record.CreatorAccountId,
                record.RoomId);
            if (heartbeat?.roomInstance == null)
            {
                return NotFound(new
                {
                    Success = false,
                    Error = "meetup_room_unavailable",
                    ErrorMessage = "The room for this meetup code is no longer available."
                });
            }

            CreatorFeatureDB.RecordMeetupCodeUse(record.Code);
            PlayerDB.RecordRoomVisit(accountId.Value, record.RoomId);
            await NotiController.NotifyPlayerPresenceUpdatedAsync(accountId.Value);

            Console.WriteLine(
                $"[MEETUP CODE JOIN] code={record.Code} player={accountId.Value} " +
                $"room={record.RoomId} instance={record.RoomInstanceId}");
            return Ok(heartbeat);
        }

        [HttpDelete("/api/meetupcodes/v1/{code}")]
        [HttpDelete("/api/meetups/v1/{code}")]
        public IActionResult RevokeMeetupCode(string code)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();
            return CreatorFeatureDB.RevokeMeetupCode(code, accountId.Value)
                ? Ok(new { Success = true })
                : NotFound(new { Success = false, Error = "meetup_code_not_found" });
        }

        [HttpGet("/api/cloudvariables/v1")]
        [HttpGet("/api/cloudvariables/v1/room/{roomId:long}")]
        [HttpGet("/api/roomvariables/v1")]
        [HttpGet("/api/roomvariables/v1/room/{roomId:long}")]
        [HttpGet("/api/roomvariables/v1/{roomId:long}")]
        [HttpGet("/api/cloudvariables/v1/list/{roomId:long}")]
        [HttpGet("/roomserver/rooms/{roomId:long}/variables")]
        [HttpGet("/roomserver/rooms/{roomId:long}/cloudvariables")]
        public IActionResult GetCloudVariables(long? roomId = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            long resolvedRoomId = ResolveRoomId(roomId);
            if (resolvedRoomId <= 0 || RoomDB.GetRoom(resolvedRoomId) == null)
                return NotFound(new { Success = false, Error = "room_not_found" });

            bool routeDefaultsShared = IsRoomVariableRoute();
            bool sharedOnly = ReadBoolFromQuery(
                routeDefaultsShared,
                "sharedOnly", "SharedOnly", "globalOnly", "GlobalOnly");
            long scopeAccountId = sharedOnly ? 0 : accountId.Value;

            List<object> values = CreatorFeatureDB
                .GetCloudVariables(
                    resolvedRoomId,
                    scopeAccountId,
                    includeShared: !sharedOnly)
                .Select(CreatorFeatureDB.ToClientCloudVariable)
                .ToList();

            return Ok(new
            {
                Results = values,
                Variables = values,
                TotalResults = values.Count,
                RoomId = resolvedRoomId
            });
        }

        [HttpGet("/api/cloudvariables/v1/{key}")]
        [HttpGet("/api/cloudvariables/v1/room/{roomId:long}/{key}")]
        [HttpGet("/api/cloudvariables/v1/{roomId:long}/{key}")]
        [HttpGet("/api/roomvariables/v1/{key}")]
        [HttpGet("/api/roomvariables/v1/room/{roomId:long}/{key}")]
        [HttpGet("/api/roomvariables/v1/{roomId:long}/{key}")]
        [HttpGet("/roomserver/rooms/{roomId:long}/cloudvariables/{key}")]
        public IActionResult GetCloudVariable(string key, long? roomId = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            long resolvedRoomId = ResolveRoomId(roomId);
            if (resolvedRoomId <= 0)
                return BadRequest(new { Success = false, Error = "room_id_required" });

            bool roomScopedRoute = IsRoomVariableRoute();
            CreatorFeatureDB.CloudVariableRecord? value = roomScopedRoute
                ? CreatorFeatureDB.GetCloudVariable(resolvedRoomId, 0, key)
                    ?? CreatorFeatureDB.GetCloudVariable(
                        resolvedRoomId,
                        accountId.Value,
                        key)
                : CreatorFeatureDB.GetCloudVariable(
                    resolvedRoomId,
                    accountId.Value,
                    key)
                    ?? CreatorFeatureDB.GetCloudVariable(resolvedRoomId, 0, key);

            return value == null
                ? NotFound(new { Success = false, Error = "cloud_variable_not_found" })
                : Ok(CreatorFeatureDB.ToClientCloudVariable(value));
        }

        [HttpPost("/api/cloudvariables/v1")]
        [HttpPut("/api/cloudvariables/v1")]
        [HttpPatch("/api/cloudvariables/v1")]
        [HttpPost("/api/cloudvariables/v1/{key}")]
        [HttpPut("/api/cloudvariables/v1/{key}")]
        [HttpPost("/api/cloudvariables/v1/room/{roomId:long}")]
        [HttpPut("/api/cloudvariables/v1/room/{roomId:long}")]
        [HttpPost("/api/cloudvariables/v1/room/{roomId:long}/{key}")]
        [HttpPut("/api/cloudvariables/v1/room/{roomId:long}/{key}")]
        [HttpPatch("/api/cloudvariables/v1/room/{roomId:long}/{key}")]
        [HttpPost("/api/cloudvariables/v1/{roomId:long}/{key}")]
        [HttpPut("/api/cloudvariables/v1/{roomId:long}/{key}")]
        [HttpPatch("/api/cloudvariables/v1/{roomId:long}/{key}")]
        [HttpPost("/api/roomvariables/v1")]
        [HttpPut("/api/roomvariables/v1")]
        [HttpPatch("/api/roomvariables/v1")]
        [HttpPost("/api/roomvariables/v1/{roomId:long}")]
        [HttpPut("/api/roomvariables/v1/{roomId:long}")]
        [HttpPost("/api/roomvariables/v1/room/{roomId:long}/{key}")]
        [HttpPut("/api/roomvariables/v1/room/{roomId:long}/{key}")]
        [HttpPatch("/api/roomvariables/v1/room/{roomId:long}/{key}")]
        [HttpPost("/api/roomvariables/v1/{roomId:long}/{key}")]
        [HttpPut("/api/roomvariables/v1/{roomId:long}/{key}")]
        [HttpPatch("/api/roomvariables/v1/{roomId:long}/{key}")]
        [HttpPost("/roomserver/rooms/{roomId:long}/cloudvariables")]
        [HttpPut("/roomserver/rooms/{roomId:long}/cloudvariables")]
        [HttpPost("/roomserver/rooms/{roomId:long}/variables")]
        [HttpPut("/roomserver/rooms/{roomId:long}/variables")]
        [HttpPost("/roomserver/rooms/{roomId:long}/cloudvariables/{key}")]
        [HttpPut("/roomserver/rooms/{roomId:long}/cloudvariables/{key}")]
        [RequestSizeLimit(MaxSmallPayloadBytes)]
        public async Task<IActionResult> SetCloudVariable(
            long? roomId = null,
            string? key = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            Dictionary<string, string> values = await ReadValuesAsync();
            long resolvedRoomId = ResolveRoomId(roomId, values);
            RoomDBClasses.Room? room = RoomDB.GetRoom(resolvedRoomId);
            if (room == null)
                return NotFound(new { Success = false, Error = "room_not_found" });

            key ??= ReadString(values,
                "key", "Key", "name", "Name", "variable", "Variable");
            if (string.IsNullOrWhiteSpace(key))
                return BadRequest(new { Success = false, Error = "cloud_variable_key_required" });

            bool isShared = ReadBool(values, IsRoomVariableRoute(),
                "shared", "Shared", "isShared", "IsShared",
                "global", "Global", "roomScoped", "RoomScoped") ||
                string.Equals(
                    ReadString(values, "scope", "Scope"),
                    "room",
                    StringComparison.OrdinalIgnoreCase) ||
                string.Equals(
                    ReadString(values, "scope", "Scope"),
                    "global",
                    StringComparison.OrdinalIgnoreCase);

            if (isShared && !CanWriteSharedCloudVariable(room, accountId.Value))
            {
                return StatusCode(
                    StatusCodes.Status403Forbidden,
                    new { Success = false, Error = "shared_cloud_variable_requires_room_access" });
            }

            string valueJson = ReadValueJson(values);
            long scopeAccountId = isShared ? 0 : accountId.Value;

            try
            {
                CreatorFeatureDB.CloudVariableRecord record =
                    CreatorFeatureDB.SetCloudVariable(
                        resolvedRoomId,
                        scopeAccountId,
                        key,
                        valueJson,
                        accountId.Value);

                Console.WriteLine(
                    $"[CLOUD VARIABLE SET] room={resolvedRoomId} key={record.Key} " +
                    $"scope={(isShared ? "room" : "player")} by={accountId.Value} " +
                    $"version={record.Version}");

                return Ok(new
                {
                    Success = true,
                    Value = CreatorFeatureDB.ToClientCloudVariable(record),
                    Variable = CreatorFeatureDB.ToClientCloudVariable(record)
                });
            }
            catch (ArgumentException exception)
            {
                return BadRequest(new { Success = false, Error = exception.Message });
            }
            catch (InvalidOperationException exception)
            {
                return StatusCode(
                    StatusCodes.Status409Conflict,
                    new { Success = false, Error = exception.Message });
            }
        }

        [HttpPost("/api/cloudvariables/v1/batch")]
        [HttpPut("/api/cloudvariables/v1/batch")]
        [HttpPost("/api/cloudvariables/v1/room/{roomId:long}/batch")]
        [HttpPut("/api/cloudvariables/v1/room/{roomId:long}/batch")]
        [HttpPost("/api/roomvariables/v1/batch")]
        [HttpPut("/api/roomvariables/v1/batch")]
        [HttpPost("/roomserver/rooms/{roomId:long}/cloudvariables/batch")]
        [HttpPut("/roomserver/rooms/{roomId:long}/cloudvariables/batch")]
        [RequestSizeLimit(MaxSmallPayloadBytes)]
        public async Task<IActionResult> SetCloudVariablesBatch(long? roomId = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            JsonElement root;
            try
            {
                using JsonDocument document = await JsonDocument.ParseAsync(
                    Request.Body,
                    cancellationToken: HttpContext.RequestAborted);
                root = document.RootElement.Clone();
            }
            catch (JsonException)
            {
                return BadRequest(new { Success = false, Error = "invalid_cloud_variable_payload" });
            }

            long bodyRoomId = root.ValueKind == JsonValueKind.Object
                ? ReadJsonLong(root, "roomId", "contextRoomId") ?? 0
                : 0;

            if (root.ValueKind == JsonValueKind.Object &&
                (TryGetJsonProperty(root, "variables", out JsonElement nested) ||
                 TryGetJsonProperty(root, "values", out nested) ||
                 TryGetJsonProperty(root, "items", out nested)))
            {
                root = nested;
            }

            if (root.ValueKind != JsonValueKind.Array)
                return BadRequest(new { Success = false, Error = "cloud_variable_array_required" });

            long resolvedRoomId = ResolveRoomId(roomId);
            if (resolvedRoomId <= 0 && bodyRoomId > 0)
                resolvedRoomId = bodyRoomId;
            RoomDBClasses.Room? room = RoomDB.GetRoom(resolvedRoomId);
            if (room == null)
                return NotFound(new { Success = false, Error = "room_not_found" });

            var saved = new List<object>();
            foreach (JsonElement item in root.EnumerateArray().Take(100))
            {
                if (item.ValueKind != JsonValueKind.Object)
                    continue;

                string? key = ReadJsonString(item, "key", "name", "variable");
                if (string.IsNullOrWhiteSpace(key))
                    continue;

                bool shared = ReadJsonNullableBool(item,
                    "shared", "isShared", "global", "roomScoped")
                    ?? IsRoomVariableRoute();
                shared = shared ||
                    string.Equals(
                        ReadJsonString(item, "scope"),
                        "room",
                        StringComparison.OrdinalIgnoreCase) ||
                    string.Equals(
                        ReadJsonString(item, "scope"),
                        "global",
                        StringComparison.OrdinalIgnoreCase);
                if (shared && !CanWriteSharedCloudVariable(room, accountId.Value))
                {
                    return StatusCode(
                        StatusCodes.Status403Forbidden,
                        new
                        {
                            Success = false,
                            Error = "shared_cloud_variable_requires_room_access",
                            Key = key
                        });
                }

                string valueJson = "null";
                if (TryGetJsonProperty(item, "valueJson", out JsonElement valueElement) ||
                    TryGetJsonProperty(item, "value", out valueElement) ||
                    TryGetJsonProperty(item, "data", out valueElement))
                {
                    valueJson = valueElement.ValueKind == JsonValueKind.String
                        ? JsonSerializer.Serialize(valueElement.GetString())
                        : valueElement.GetRawText();
                }

                try
                {
                    CreatorFeatureDB.CloudVariableRecord record =
                        CreatorFeatureDB.SetCloudVariable(
                            resolvedRoomId,
                            shared ? 0 : accountId.Value,
                            key,
                            valueJson,
                            accountId.Value);
                    saved.Add(CreatorFeatureDB.ToClientCloudVariable(record));
                }
                catch (ArgumentException exception)
                {
                    return BadRequest(new
                    {
                        Success = false,
                        Error = exception.Message,
                        Key = key
                    });
                }
                catch (InvalidOperationException exception)
                {
                    return StatusCode(
                        StatusCodes.Status409Conflict,
                        new { Success = false, Error = exception.Message, Key = key });
                }
            }

            return Ok(new
            {
                Success = true,
                Results = saved,
                Variables = saved,
                Count = saved.Count,
                RoomId = resolvedRoomId
            });
        }

        [HttpDelete("/api/cloudvariables/v1/{key}")]
        [HttpDelete("/api/cloudvariables/v1/room/{roomId:long}/{key}")]
        [HttpDelete("/api/cloudvariables/v1/{roomId:long}/{key}")]
        [HttpDelete("/api/roomvariables/v1/{key}")]
        [HttpDelete("/api/roomvariables/v1/room/{roomId:long}/{key}")]
        [HttpDelete("/api/roomvariables/v1/{roomId:long}/{key}")]
        [HttpDelete("/roomserver/rooms/{roomId:long}/cloudvariables/{key}")]
        public IActionResult DeleteCloudVariable(string key, long? roomId = null)
        {
            long? accountId = AuthStuff.GetPlayerId(Request);
            if (!accountId.HasValue)
                return Unauthorized();

            long resolvedRoomId = ResolveRoomId(roomId);
            RoomDBClasses.Room? room = RoomDB.GetRoom(resolvedRoomId);
            if (room == null)
                return NotFound(new { Success = false, Error = "room_not_found" });

            bool shared = ReadBoolFromQuery(
                IsRoomVariableRoute(),
                "shared", "Shared", "global", "Global");
            if (shared && !CanEditRoom(room, accountId.Value))
                return StatusCode(StatusCodes.Status403Forbidden);

            bool removed = CreatorFeatureDB.DeleteCloudVariable(
                resolvedRoomId,
                shared ? 0 : accountId.Value,
                key);
            return removed
                ? Ok(new { Success = true })
                : NotFound(new { Success = false, Error = "cloud_variable_not_found" });
        }

        private static bool TryGetJsonProperty(
            JsonElement element,
            string name,
            out JsonElement value)
        {
            if (element.ValueKind == JsonValueKind.Object)
            {
                foreach (JsonProperty property in element.EnumerateObject())
                {
                    if (property.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                    {
                        value = property.Value;
                        return true;
                    }
                }
            }
            value = default;
            return false;
        }

        private static string? ReadJsonString(
            JsonElement element,
            params string[] names)
        {
            foreach (string name in names)
            {
                if (!TryGetJsonProperty(element, name, out JsonElement value))
                    continue;
                return value.ValueKind == JsonValueKind.String
                    ? value.GetString()
                    : value.ToString();
            }
            return null;
        }

        private static long? ReadJsonLong(
            JsonElement element,
            params string[] names)
        {
            foreach (string name in names)
            {
                if (!TryGetJsonProperty(element, name, out JsonElement value))
                    continue;
                if (value.ValueKind == JsonValueKind.Number && value.TryGetInt64(out long number))
                    return number;
                if (long.TryParse(value.ToString().Trim('"'), out number))
                    return number;
            }
            return null;
        }

        private static bool? ReadJsonNullableBool(
            JsonElement element,
            params string[] names)
        {
            foreach (string name in names)
            {
                if (!TryGetJsonProperty(element, name, out JsonElement value))
                    continue;
                if (value.ValueKind == JsonValueKind.True)
                    return true;
                if (value.ValueKind == JsonValueKind.False)
                    return false;
                if (bool.TryParse(value.ToString(), out bool boolean))
                    return boolean;
                if (int.TryParse(value.ToString(), out int number))
                    return number != 0;
            }
            return null;
        }

        private async Task<Dictionary<string, string>> ReadValuesAsync()
        {
            var values = new Dictionary<string, string>(
                StringComparer.OrdinalIgnoreCase);

            foreach (KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues> item
                     in Request.Query)
            {
                if (item.Value.Count > 0)
                    values[item.Key] = item.Value[item.Value.Count - 1] ?? string.Empty;
            }

            if (Request.HasFormContentType)
            {
                var form = await Request.ReadFormAsync(HttpContext.RequestAborted);
                foreach (KeyValuePair<string, Microsoft.Extensions.Primitives.StringValues> item
                         in form)
                {
                    if (item.Value.Count > 0)
                        values[item.Key] = item.Value[item.Value.Count - 1] ?? string.Empty;
                }
                return values;
            }

            if ((Request.ContentLength ?? 0) <= 0 &&
                Request.Headers.TransferEncoding.Count == 0)
                return values;

            using var reader = new StreamReader(Request.Body);
            string rawBody = await reader.ReadToEndAsync(HttpContext.RequestAborted);
            if (string.IsNullOrWhiteSpace(rawBody))
                return values;

            values["__raw"] = rawBody;
            try
            {
                using JsonDocument document = JsonDocument.Parse(rawBody);
                JsonElement root = document.RootElement;
                if (root.ValueKind == JsonValueKind.Object)
                {
                    foreach (JsonProperty property in root.EnumerateObject())
                    {
                        values[property.Name] = property.Value.ValueKind == JsonValueKind.String
                            ? property.Value.GetString() ?? string.Empty
                            : property.Value.GetRawText();
                    }
                }
                else if (root.ValueKind == JsonValueKind.String)
                {
                    values["value"] = root.GetString() ?? string.Empty;
                    values["code"] = root.GetString() ?? string.Empty;
                }
                else
                {
                    values["value"] = root.GetRawText();
                }
            }
            catch (JsonException)
            {
                values["value"] = rawBody.Trim();
                values["code"] = rawBody.Trim().Trim('"');
            }

            return values;
        }

        private long ResolveRoomId(
            long? routeRoomId,
            IReadOnlyDictionary<string, string>? values = null)
        {
            if (routeRoomId.GetValueOrDefault() > 0)
                return routeRoomId!.Value;

            foreach (string key in new[] { "roomId", "RoomId", "contextRoomId" })
            {
                string? value = values != null && values.TryGetValue(key, out string? bodyValue)
                    ? bodyValue
                    : Request.Query[key].FirstOrDefault();
                if (long.TryParse(value?.Trim('"'), out long parsed) && parsed > 0)
                    return parsed;
            }

            long? accountId = AuthStuff.GetPlayerId(Request);
            if (accountId.HasValue)
                return PlayerDB.GetPlayerHeartbeat(accountId.Value).roomInstance?.roomId ?? 0;
            return 0;
        }

        private bool IsRoomVariableRoute()
        {
            string path = Request.Path.Value ?? string.Empty;
            return path.Contains("roomvariables", StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWith("/roomserver/", StringComparison.OrdinalIgnoreCase);
        }

        private static bool CanWriteSharedCloudVariable(
            RoomDBClasses.Room room,
            long accountId)
        {
            if (CanEditRoom(room, accountId))
                return true;

            PlayerDBClasses.Heartbeat heartbeat =
                PlayerDB.GetPlayerHeartbeat(accountId);
            return heartbeat.isOnline &&
                   heartbeat.roomInstance?.roomId == room.RoomId;
        }

        private static bool CanEditRoom(RoomDBClasses.Room room, long accountId) =>
            room.CreatorAccountId == accountId ||
            room.Roles?.Any(value =>
                value.AccountId == accountId &&
                value.Role is RoomDBClasses.Role.Creator or
                    RoomDBClasses.Role.CoOwner or
                    RoomDBClasses.Role.TemporaryCoOwner) == true;

        private static string ReadValueJson(
            IReadOnlyDictionary<string, string> values)
        {
            if (values.TryGetValue("__raw", out string? requestRaw) &&
                !string.IsNullOrWhiteSpace(requestRaw))
            {
                try
                {
                    using JsonDocument document = JsonDocument.Parse(requestRaw);
                    JsonElement root = document.RootElement;
                    if (root.ValueKind == JsonValueKind.Object)
                    {
                        foreach (string propertyName in new[]
                                 {
                                     "valueJson", "ValueJson", "value",
                                     "Value", "data", "Data"
                                 })
                        {
                            if (TryGetJsonProperty(
                                    root,
                                    propertyName,
                                    out JsonElement propertyValue))
                            {
                                return propertyValue.GetRawText();
                            }
                        }
                    }
                    else
                    {
                        return root.GetRawText();
                    }
                }
                catch (JsonException)
                {
                }
            }

            string? raw = ReadString(values,
                "valueJson", "ValueJson", "value", "Value", "data", "Data");
            if (raw == null && values.TryGetValue("__raw", out requestRaw))
                raw = requestRaw;
            if (string.IsNullOrWhiteSpace(raw))
                return "null";

            try
            {
                using JsonDocument document = JsonDocument.Parse(raw);
                return document.RootElement.GetRawText();
            }
            catch (JsonException)
            {
                return JsonSerializer.Serialize(raw);
            }
        }

        private static string? ReadString(
            IReadOnlyDictionary<string, string> values,
            params string[] keys)
        {
            foreach (string key in keys)
            {
                if (!values.TryGetValue(key, out string? value))
                    continue;
                string cleaned = value.Trim();
                if (cleaned.Length >= 2 && cleaned[0] == '"' && cleaned[^1] == '"')
                {
                    try
                    {
                        return JsonSerializer.Deserialize<string>(cleaned);
                    }
                    catch (JsonException)
                    {
                    }
                }
                return cleaned;
            }
            return null;
        }

        private static int ReadInt(
            IReadOnlyDictionary<string, string> values,
            int fallback,
            params string[] keys) =>
            int.TryParse(ReadString(values, keys)?.Trim('"'), out int result)
                ? result
                : fallback;

        private static bool ReadBool(
            IReadOnlyDictionary<string, string> values,
            bool fallback,
            params string[] keys)
        {
            string? raw = ReadString(values, keys)?.Trim('"');
            if (bool.TryParse(raw, out bool result))
                return result;
            return int.TryParse(raw, out int number) ? number != 0 : fallback;
        }

        private bool ReadBoolFromQuery(bool fallback, params string[] keys)
        {
            foreach (string key in keys)
            {
                string? raw = Request.Query[key].FirstOrDefault();
                if (bool.TryParse(raw, out bool result))
                    return result;
                if (int.TryParse(raw, out int number))
                    return number != 0;
            }
            return fallback;
        }
    }
}