using System.Security.Principal;
using System.Text.RegularExpressions;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Campus_live_rewrite.api;
using Campus_live_rewrite.api.dbs;
using Campus_live_rewrite.api.server;
using Campus_live_rewrite.api.server.Classes;
using Campus_live_rewrite.api.server.Classes.db_class;
using System.IdentityModel.Tokens.Jwt;
using static Campus_live_rewrite.api.server.Moderation_Detail;
using Microsoft.AspNetCore.Http.HttpResults;
using static Campus_live_rewrite.api.server.Classes.db_class.RoomDBClasses;
using System.ComponentModel.DataAnnotations;
using System.Text.Json.Nodes;


namespace Campus_live_rewrite.Controllers
{
    [Route("Room_server")]
    public class RoomController : ControllerBase
    {
        [HttpGet("rooms")]
        public ContentResult Room_server_rooms([FromQuery] ulong? roomid = null, [FromQuery] string? name = null, [FromQuery] ulong? include = null, [FromQuery] int? unityAssetTarget = null, [FromQuery] int? unityAssetVersion = null)
        {
            try
            {
                // DELETE by roomid
                if (HttpContext.Request.Method == HttpMethods.Delete && roomid.HasValue)
                {
                    var (account, error) = AuthHelper.ValidateToken(HttpContext);
                    if (error != null)
                        return error;

                    RoomDBClasses.RoomRoot room = RoomDB.GetRoom(roomid.Value);
                    if (room == null)
                    {
                        return new ContentResult()
                        {
                            Content = JsonConvert.SerializeObject(new
                            {
                                Success = false,
                                Value = (string?)null,
                                ErrorId = "Rooms.DoesntExist",
                                Error = "This room does not exist!"
                            }),
                            ContentType = "application/json",
                            StatusCode = 200
                        };
                    }

                    if (room.CreatorAccountId != account.Id)
                    {
                        return new ContentResult()
                        {
                            Content = JsonConvert.SerializeObject(new
                            {
                                Success = false,
                                Value = (string?)null,
                                ErrorId = "Rooms.PermissionDenied",
                                Error = "You are not the owner of this room!"
                            }),
                            ContentType = "application/json",
                            StatusCode = 200
                        };
                    }

                    RoomDB.DeleteRoom(roomid.Value);

                    return new ContentResult()
                    {
                        Content = "[]",
                        ContentType = "application/json",
                        StatusCode = 200
                    };
                }

                // Lookup by roomid
                if (roomid.HasValue)
                {
                    RoomDBClasses.RoomRoot existingRoom = RoomDB.GetRoom(roomid.Value);
                    if (existingRoom == null)
                    {
                        return new ContentResult()
                        {
                            Content = "[]",
                            ContentType = "application/json",
                            StatusCode = 200
                        };
                    }

                    return new ContentResult()
                    {
                        Content = JsonConvert.SerializeObject(StripUnservableSaves(DirectLookup(existingRoom))),
                        ContentType = "application/json",
                        StatusCode = 200
                    };
                }

                // Lookup by name
                if (!string.IsNullOrEmpty(name))
                {
                    RoomDBClasses.RoomRoot room = RoomDB.GetRoomByName(name);
                    if (room == null)
                    {
                        return new ContentResult()
                        {
                            Content = "",
                            ContentType = "application/json",
                            StatusCode = 404
                        };
                    }

                    return new ContentResult()
                    {
                        Content = JsonConvert.SerializeObject(StripUnservableSaves(room)),
                        ContentType = "application/json",
                        StatusCode = 200
                    };
                }

                // Neither roomid nor name provided
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 404
                };
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 404
                };
            }
        }


        // Strip a subroom's CurrentSave when its .room blob cannot be served.
        //
        // The client loads a room from the CurrentSave embedded in the ROOM OBJECT, not
        // from the /saves endpoint - so filtering /saves alone was not enough, and
        // "Error downloading subroom data! (Code 8715)" persisted. It requests
        // /cdn/room/<DataBlob>, which 404s when the file is absent from
        // Data/CDN/RoomBlobs (the cdn.rec.net fallback is dead - those blobs are no
        // longer public), and the load aborts.
        //
        // Joining an existing instance never fetches the blob (state replicates over
        // Photon from whoever is already inside), which is exactly why Rec Center worked
        // via a friend but failed alone.
        //
        // Nulling CurrentSave makes the room load its default Unity scene - the same
        // path rooms with no save (Park, dorms) already take successfully.
        //
        // Safe to mutate: GetRoom returns a freshly deserialized LiteDB object and no
        // caller writes it back (verified), so this never persists. Self-correcting -
        // put the real .room files in Data/CDN/RoomBlobs and saves return untouched.
        // List overload. Room LISTINGS matter as much as the single-room GETs: the client
        // caches these and can join straight from a cached entry (rooms/visitedby/me is
        // requested moments before every join), so an unservable blob left in a listing
        // resurfaces the same failure by another route.
        //
        // Only ever call this on GET/serialize paths. The PUT/POST mutation endpoints
        // (SetRoomName, SetRoomData, ...) load-modify-save the same objects, so stripping
        // there would PERSIST the null into the DB and destroy the reference for good.
        private static List<RoomDBClasses.RoomRoot> StripUnservableSaves(List<RoomDBClasses.RoomRoot>? rooms)
            => WithCCU(Campus_live_rewrite.api.server.RoomBlobFilter.Strip(rooms));

        /// <summary>
        /// The viewer's account id, or 0 when the request is unauthenticated.
        ///
        /// Some room endpoints (bulk, hot, search) never called ValidateToken, so there is
        /// no `account` in scope there. Visibility still has to be decided per viewer, so
        /// read it from the token directly. 0 means "no one" - which sees only published
        /// rooms, the correct default for an anonymous caller.
        /// </summary>
        private ulong ViewerId()
        {
            try
            {
                var (acc, err) = AuthHelper.ValidateToken(HttpContext);
                return err == null && acc != null ? acc.Id : 0UL;
            }
            catch
            {
                return 0UL;
            }
        }

        // ---- Visibility -------------------------------------------------------
        //
        // Applied at every point a room is SERVED, not just in listings. Fetching a room
        // straight by id used to bypass every check: any player could read another
        // player's unpublished private room - name, subrooms, save data - simply by
        // asking for /Room_server/rooms/78.
        //
        // A room is visible when it is published, or when the viewer holds a role on it
        // (owner / co-owner / moderator / host). See RoomDB.CanPlayerSeeRoom.

        /// <summary>Returns the room, or null when this viewer is not allowed to see it.</summary>
        private static RoomDBClasses.RoomRoot? VisibleTo(RoomDBClasses.RoomRoot? room, ulong viewerId)
            => RoomDB.CanPlayerSeeRoom(room, viewerId) ? room : null;

        // A DIRECT lookup (rooms/{id}, rooms?id=, rooms/bulk) answers the record whatever its
        // accessibility, exactly like the reference (and rec.net): Private / Unlisted only keep a
        // room off the browse lists and search - CanPlayerEnterRoom still gates joining, and the
        // saves are stripped separately. Hiding it here (answering null / []) broke every player
        // who was INSIDE a private room or another player's dorm: their friend card, search
        // result and profile all resolve the room they're in through these routes, the client
        // reads the empty answer as NoSuchRoom, and the card / profile never rendered - "some
        // players' profiles won't load for anyone". Only excludePrivateRooms=True filters, and
        // it filters on listing, not on who is asking.
        private static RoomDBClasses.RoomRoot? DirectLookup(RoomDBClasses.RoomRoot? room, bool excludePrivate = false)
            => room == null ? null : (excludePrivate && !RoomDB.IsRoomListed(room)) ? null : room;

        /// <summary>Drops every room this viewer is not allowed to see.</summary>
        private static List<RoomDBClasses.RoomRoot> VisibleTo(List<RoomDBClasses.RoomRoot>? rooms, ulong viewerId)
            => (rooms ?? new List<RoomDBClasses.RoomRoot>())
               .Where(r => RoomDB.CanPlayerSeeRoom(r, viewerId))
               .ToList();

        private static RoomDBClasses.RoomRoot? StripUnservableSaves(RoomDBClasses.RoomRoot? room)
            => WithCCU(Campus_live_rewrite.api.server.RoomBlobFilter.Strip(room));

        // Fill the client's CCU key (live player count) on whatever this response is about to
        // return. One presence pass per response, not per room.
        private static RoomDBClasses.RoomRoot? WithCCU(RoomDBClasses.RoomRoot? room)
        {
            if (room == null) return null;
            try { room.CCU = HeartbeatDB.LivePlayerCountsByRoom().TryGetValue((long)room.RoomId, out var n) ? n : 0; }
            catch { }
            return room;
        }

        private static List<RoomDBClasses.RoomRoot> WithCCU(List<RoomDBClasses.RoomRoot>? rooms)
        {
            rooms ??= new List<RoomDBClasses.RoomRoot>();
            try
            {
                var counts = HeartbeatDB.LivePlayerCountsByRoom();
                foreach (var r in rooms)
                    if (r != null) r.CCU = counts.TryGetValue((long)r.RoomId, out var n) ? n : 0;
            }
            catch { }
            return rooms;
        }

        [HttpGet("rooms/{roomid}")]
        public ContentResult GetRoomById(ulong roomid)
        {
            var room = RoomDB.GetRoom(roomid);
            if (room == null)
            {
                return new ContentResult
                {
                    Content = "[]",
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }

            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(StripUnservableSaves(DirectLookup(room))),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpDelete("rooms/{roomid}")]
        public ContentResult DeleteRoomById(ulong roomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var room = RoomDB.GetRoom(roomid);
            if (room == null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        Success = false,
                        Value = (string?)null,
                        ErrorId = "Rooms.DoesntExist",
                        Error = "This room does not exist!"
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }

            if (room.CreatorAccountId != account.Id)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        Success = false,
                        Value = (string?)null,
                        ErrorId = "Rooms.PermissionDenied",
                        Error = "You are not the owner of this room!"
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }

            RoomDB.DeleteRoom(roomid);

            // This used to BAN the caller - Set_moderation_block(account.Id, ..., isBan: true,
            // duration: 1). account.Id is the room OWNER, i.e. whoever just deleted their own
            // room, so deleting a room banned you from the game. isBan sends websocket event 22,
            // which blacks the client out, logs it out and closes it. Duration is in SECONDS, so
            // the block cleared after one second and you could log straight back in - which is
            // exactly why it looked like "something/someone keeps closing my game" rather than
            // a ban.
            //
            // The intent was presumably to get the owner out of the room they just deleted. That
            // is a host kick, not a ban: isHostKick drops them to their dorm with no ban screen,
            // no logout and no moderation record. Same shape ChatCommands.HandleKick uses.
            PlayerDB.Set_moderation_block(
                    account.Id,
                    ReportCategory.Moderator,
                    duration: 1,
                    gameSessionId: -1,
                    isHostKick: true,
                    message: "The room you were in was deleted.",
                    playerIdReporter: null,
                    isBan: false,
                    bannedByPlayerId: 0
                );
            return new ContentResult()
            {
                Content = JsonConvert.SerializeObject(new
                {
                    success = true,
                    error = "",
                    value = (string?)null
                }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpPost("rooms/bulk")]
        public IActionResult Room_server_rooms_bulk_post()
        {
            var f = RoomModeration.Fields(Request);
            var ids = RoomModeration.ULongs(f, "id", "ids", "roomIds", "Ids");
            string? name = RoomModeration.Str(f, "name");
            bool excl = (RoomModeration.Str(f, "excludePrivateRooms") ?? "").Equals("true", StringComparison.OrdinalIgnoreCase);
            if (ids.Count <= 1) return Room_server_rooms_bulk(ids.Count == 1 ? ids[0] : 0, name, null, excl);
            ulong viewer = ViewerId();
            var rooms = new List<object>();
            foreach (var id in ids.Take(100))
            {
                var room = RoomDB.GetRoom(id);
                if (room == null) continue;
                if (DirectLookup(room, excl) == null) continue;
                rooms.Add(StripUnservableSaves(room));
            }
            return Content(JsonConvert.SerializeObject(rooms), "application/json");
        }

        [HttpGet("rooms/bulk")]
        public IActionResult Room_server_rooms_bulk([FromQuery(Name = "id")] ulong roomId, [FromQuery] string? name, [FromQuery] ulong? include, [FromQuery] bool? excludePrivateRooms)
        {
            RoomDBClasses.RoomRoot room = RoomDB.GetRoomByName(name);
            if (room == null)
            {
                RoomDBClasses.RoomRoot room2 = RoomDB.GetRoom(roomId);
                if (room2 == null)
                {
                    return Ok(ConfigCampus.Bracket);
                }
                // by-ID branch - this is the one the client uses (rooms/bulk?id=2) and it
                // was handing back CurrentSave unfiltered, which is how the DataBlob
                // kept reaching the client even after the room-load endpoints were fixed.
                return Content(DirectLookup(room2, excludePrivateRooms == true) == null ? "[]" : $"[{JsonConvert.SerializeObject(StripUnservableSaves(room2))}]", "application/json");
            }

            return Content(DirectLookup(room, excludePrivateRooms == true) == null ? "[]" : $"[{JsonConvert.SerializeObject(StripUnservableSaves(room))}]", "application/json");
        }

        // These three back the Create -> "My Rooms" list. createdby/me used to return a
        // hardcoded "[]" stub, and ownedby/me fell through to the ulong route below where
        // "me" bound to 0 - so the tab was always empty even with rooms in the DB.
        // contributedby/me did not exist at all and 404'd.
        [HttpGet("rooms/createdby/me")]
        public ContentResult roomscreatedbyme()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(StripUnservableSaves(RoomDB.GetRoomsByCreatorPaged(account.Id, 0, ConfigCampus.ProfileRoomsCap))),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // The profile's Rooms tab asks by PLAYER ID (createdby/{id}, contributedby/{id}), not "me";
        // only the /me spellings existed, so another player's rooms - and your own after a restart,
        // once the client stopped using the locally cached list - came back 404 and the tab was
        // empty while the showcase (which does take an id) still filled.
        [HttpGet("rooms/createdby/{playerId:long}")]
        public ContentResult RoomsCreatedBy(ulong playerId, int skip = 0, int take = 0)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            if (take <= 0) take = ConfigCampus.ProfileRoomsCap;
            var rooms = RoomDB.GetRoomsByCreatorPaged(playerId, skip, take);
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(StripUnservableSaves(VisibleTo(rooms, account.Id).Where(r => !r.IsDorm).ToList())),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpGet("rooms/contributedby/{playerId:long}")]
        public ContentResult RoomsContributedBy(ulong playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            return new ContentResult
            {
                // GetRoomsContributedTo now leads with the player's OWN rooms, so this is the
                // profile's whole room list. VisibleTo is what keeps another player's unpublished
                // rooms off it - a viewer with no role on a room sees it only once it is public.
                Content = JsonConvert.SerializeObject(StripUnservableSaves(
                    VisibleTo(RoomDB.GetRoomsContributedTo(playerId), account.Id)
                        .Where(r => !r.IsDorm).ToList())),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // MUST be declared before rooms/ownedby/{PlayerId}: a literal segment beats the
        // parameter route, otherwise "me" is parsed as a ulong and silently becomes 0.
        [HttpGet("rooms/ownedby/me")]
        public ContentResult RoomsOwnedByMe()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(StripUnservableSaves(RoomDB.GetRoomsByCreatorPaged(account.Id, 0, ConfigCampus.ProfileRoomsCap))),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpGet("rooms/contributedby/me")]
        public ContentResult RoomsContributedByMe()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(StripUnservableSaves(
                    RoomDB.GetRoomsContributedTo(account.Id).Where(r => !r.IsDorm).ToList())),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // What each role may do in ONE subroom - the Permissions tab of Room Settings. JSON array
        // body, each entry addressed by its (Permission, Role) pair: Override:true stores the
        // value, Override:false is the unchecked box and clears the pair back to the default.
        // The stored table is what GET /photon_access_token merges over its defaults for every
        // player standing in that subroom - so this IS "edit what the perms do", and it lives on
        // the subroom record, which is what a room save carries. (Reference: creator-only. Here
        // co-owners may too: "high enough permissions" - a co-owner already builds in the room.)
        [HttpPut("rooms/{roomId}/subrooms/{subRoomId}/permissions")]
        [HttpPost("rooms/{roomId}/subrooms/{subRoomId}/permissions")]
        public async Task<IActionResult> SetSubRoomPermissions(ulong roomId, ulong subRoomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;

            var room = RoomDB.GetRoom(roomId);
            if (room == null || RoomDB.GetSubRoom(roomId, subRoomId) == null) return StatusCode(404, "");
            if (!RoomDB.PlayerCanManageRoles(roomId, account.Id))
            {
                Console.WriteLine($"[room-perms] {account.Id} may not edit permissions on room {roomId} - refused");
                return StatusCode(403, "");
            }

            string raw;
            using (var reader = new StreamReader(Request.Body)) raw = await reader.ReadToEndAsync();
            var changes = Campus_live_rewrite.api.server.RoomPermissions.ParseBody(raw);
            if (changes == null)
            {
                Console.WriteLine($"[room-perms] {account.Id}: unreadable body on room {roomId}/{subRoomId}: {raw.Substring(0, Math.Min(200, raw.Length))}");
                return StatusCode(400, "");
            }

            var current = RoomDB.GetSubRoom(roomId, subRoomId)?.Permissions;
            var table = Campus_live_rewrite.api.server.RoomPermissions.Apply(current, changes);
            RoomDB.SetSubRoomPermissions(roomId, subRoomId, table);
            Console.WriteLine($"[room-perms] {account.Id} set {changes.Count} permission(s) on room {roomId} subroom {subRoomId}: " +
                              string.Join(", ", changes.Select(c => $"{c.Permission}@{c.Role}={(c.Override ? c.Value : "default")}")));

            // Instant: everyone standing in the room re-reads it (and re-pulls photon_access_token
            // with the new table) instead of waiting for their next spawn.
            foreach (var pid in Campus_live_rewrite.api.server.RoomPermissions.PlayersInRoom(roomId))
                Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate(pid, room);

            // The 2025 client's ChangeAndRefresh reads the answer through the enveloped room
            // helper - an empty body is "Response was empty" / "Failed to change subroom
            // permissions" in Player.log, even though the change was stored. (Reference: empty.)
            return RoomWriteEnvelope(roomId);
        }

        // The ROOM-level spelling (PUT rooms/{id}/permissions, 404'd): the same body, applied to
        // every subroom of the room, so a room with one subroom behaves exactly like the subroom
        // route and a multi-subroom room gets the change everywhere.
        [HttpPut("rooms/{roomId}/permissions")]
        [HttpPost("rooms/{roomId}/permissions")]
        public async Task<IActionResult> SetRoomPermissions(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room = RoomDB.GetRoom(roomId);
            if (room == null) return StatusCode(404, "");
            if (!RoomDB.PlayerCanManageRoles(roomId, account.Id)) return StatusCode(403, "");

            string raw;
            using (var reader = new StreamReader(Request.Body)) raw = await reader.ReadToEndAsync();
            var changes = Campus_live_rewrite.api.server.RoomPermissions.ParseBody(raw);
            if (changes == null) return StatusCode(400, "");

            RoomDB.AttachSubRooms(new[] { room });
            foreach (var sub in room.SubRooms ?? new List<SubRoom>())
            {
                var table = Campus_live_rewrite.api.server.RoomPermissions.Apply(sub.Permissions, changes);
                RoomDB.SetSubRoomPermissions(roomId, (ulong)sub.SubRoomId, table);
            }
            Console.WriteLine($"[room-perms] {account.Id} set {changes.Count} permission(s) on every subroom of room {roomId}");
            foreach (var pid in Campus_live_rewrite.api.server.RoomPermissions.PlayersInRoom(roomId))
                Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate(pid, room);
            return RoomWriteEnvelope(roomId);
        }

        [HttpGet("rooms/{roomId}/subrooms/{subRoomId}/permissions")]
        public IActionResult GetSubRoomPermissions(ulong roomId, ulong subRoomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var sub = RoomDB.GetSubRoom(roomId, subRoomId);
            if (sub == null) return StatusCode(404, "");
            return Ok(sub.Permissions ?? new List<Campus_live_rewrite.api.server.RoomPermissions.Entry>());
        }

        [HttpGet("photon_access_token")]
        public IActionResult photon_access_token()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var heartbeat = HeartbeatDB.GetPlayerHeartbeat(account.Id);

            // The table the client applies when it spawns: RoomPermissions.Defaults (reset and
            // delete-all now start at Moderator, not at everyone) with the overrides the room's
            // managers saved on the SUBROOM the caller is standing in merged over it, by
            // (Permission, Role) - see PUT rooms/{id}/subrooms/{sub}/permissions.
            var permissions = Campus_live_rewrite.api.server.RoomPermissions.Defaults(account.Id);
            var inst = heartbeat?.roomInstance;
            if (inst != null && inst.subRoomId > 0)
            {
                var sub = RoomDB.GetSubRoom((ulong)inst.roomId, (ulong)inst.subRoomId);
                permissions = Campus_live_rewrite.api.server.RoomPermissions.Merge(permissions, sub?.Permissions);
            }

            return Ok(new
            {
                RoomInstanceId = inst?.roomInstanceId,
                PhotonAccessToken = ClientSecurity.Createphotonacesstoken(account.Id),
                Permissions = permissions.ToArray()
            });
        }


        [HttpGet("rooms/hot")]
        public ContentResult HotRooms(string tag, int skip = 0, int take = 30)
        {
            var rooms = RoomDB.GetHotRooms();

            if (rooms == null || rooms.Count == 0)
            {
                return new ContentResult
                {
                    Content = JsonConvert.SerializeObject(new Resultslist<RoomDBClasses.RoomRoot>
                    {
                        Results = new List<RoomDBClasses.RoomRoot>(),
                        TotalResults = 0
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }

            IEnumerable<RoomDBClasses.RoomRoot> query = rooms;

            bool isRRO = false;

            if (!string.IsNullOrEmpty(tag))
            {
                string t = tag.ToLower();

                // --- RRO Filter ---
                if (t == "rro" || t == "recroomoriginal")
                {
                    isRRO = true;

                    query = query.Where(r =>
                        r.Tags != null &&
                        r.Tags.Any(x =>
                        {
                            string tt = x.Tag?.ToLower();
                            return tt == "rro" || tt == "recroomoriginal";
                        })
                    );
                }
                else if (t == "new")
                {
                    query = query.OrderByDescending(r => r.CreatedAt)
                                 .Take(30);
                }
            }
            else
            {
                // Default mode: EXCLUDE rro + base
                query = query.Where(r =>
                    r.Tags == null ||
                    !r.Tags.Any(x =>
                    {
                        string tt = x.Tag?.ToLower();
                        return tt == "base" || tt == "rro" || tt == "recroomoriginal";
                    })
                );
            }

            // Only public rooms when NOT requesting RRO
            if (!isRRO)
            {
                query = query.Where(r => r.Accessibility == RoomDBClasses.RoomAccessibility.Public);
            }

            // Order by popularity
            query = query.OrderByDescending(r => r.Stats?.VisitCount ?? 0)
                         .ThenByDescending(r => r.Stats?.CheerCount ?? 0);

            // Pagination
            int totalCount = query.Count();
            var paged = query.Skip(skip).Take(take).ToList();
            // Subrooms only for the page being returned (see RoomDB.GetHotRooms).
            RoomDB.AttachSubRooms(paged);
            int countTotal = rooms.Count;
            int countRRO = rooms.Count(r =>
                r?.Tags != null &&
                r.Tags.Any(t =>
                {
                    var x = t.Tag?.ToLower();
                    return x == "rro" || x == "recroomoriginal";
                })
            );

            Console.WriteLine($"HOT TOTAL ROOMS: {countTotal}");
            Console.WriteLine($"HOT RRO ROOMS: {countRRO}");
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(new Resultslist<RoomDBClasses.RoomRoot>
                {
                    Results = StripUnservableSaves(VisibleTo(paged, ViewerId())),
                    TotalResults = totalCount
                }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }





        [HttpGet("rooms/{roomid}/interactionby/me")]
        public IActionResult Room_server_room_interactionby_me(ulong roomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var interaction = PlayerDB.GetInteraction(account.Id, roomid);

            // ContentResult, not Ok(string): a raw string goes out as text/plain (see CommerceController).
            return Content(JsonConvert.SerializeObject(new
            {
                Cheered = interaction.Cheered,
                Favorited = interaction.Favorited,
                LastVisitedAt = DateTime.Now // could persist if you want
            }), "application/json");
        }

        [Route("rooms/{roomid}/interactionby/me/cheer")]
        public IActionResult Room_server_room_interactionby_me_cheer(ulong roomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            bool cheered = PlayerDB.ToggleCheer(account.Id, roomid);
            var favorited = PlayerDB.GetInteraction(account.Id, roomid).Favorited;

            return Content(JsonConvert.SerializeObject(new
            {
                Cheered = cheered,
                Favorited = favorited,
                LastVisitedAt = DateTime.Now
            }), "application/json");
        }

        [Route("rooms/{roomid}/interactionby/me/favorite")]
        public IActionResult Room_server_room_interactionby_me_favorite(ulong roomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            bool favorited = PlayerDB.ToggleFavorite(account.Id, roomid);
            var cheered = PlayerDB.GetInteraction(account.Id, roomid).Cheered;

            return Content(JsonConvert.SerializeObject(new
            {
                Cheered = cheered,
                Favorited = favorited,
                LastVisitedAt = DateTime.Now
            }), "application/json");
        }

        [HttpGet("rooms/ownedby/{PlayerId}")]
        public ContentResult RoomsOwnedBy(ulong PlayerId, int skip = 0, int take = 0)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            // Page at the DB level - only this page's rooms (and their subrooms) are loaded. An
            // account that owns thousands (e.g. @Importer) used to load EVERY room + a subroom query
            // each on every profile view, overloading the server.
            if (take <= 0) take = ConfigCampus.ProfileRoomsCap;
            var owned = RoomDB.GetRoomsByCreatorPaged(PlayerId, skip, take);

            // The dorm is personal space, served by /dormroom/me - never part of a rooms list.
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(StripUnservableSaves(VisibleTo(owned, account.Id).Where(r => !r.IsDorm).ToList())),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // Search suggestions for the search box - type-ahead. Ported from RecFlare.
        //
        // Returns a BARE ARRAY OF STRINGS (not rooms, not an envelope): room names and tags
        // drawn from the public, non-dorm rooms that /rooms/search searches, so every
        // suggestion finds something when submitted. A tag suggestion carries its '#' so it
        // searches by tag; a query starting with '#' suggests tags ONLY. Matches that START
        // with the query come first, then ones that merely contain it, alphabetical within
        // each. `take` caps the list (the client asks for 4). searchSessionId is ignored.
        //
        // This did not exist, so search-as-you-type got a 404 and no suggestions ever showed.
        [HttpGet("rooms/autocomplete_search")]
        public ContentResult RoomAutocompleteSearch(string? query = "", int take = 10, string? searchSessionId = null)
        {
            query = (query ?? "").Trim();
            bool tagsOnly = query.StartsWith("#");
            string q = query.TrimStart('#').ToLowerInvariant();

            var suggestions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            foreach (var room in RoomDB.GetAllRooms())
            {
                if (room == null || room.IsDorm) continue;
                if (!RoomDB.IsRoomListed(room)) continue;   // only rooms search can actually find

                if (!tagsOnly && !string.IsNullOrWhiteSpace(room.Name))
                    suggestions.Add(room.Name);

                if (room.Tags != null)
                    foreach (var t in room.Tags)
                        if (!string.IsNullOrWhiteSpace(t?.Tag))
                            suggestions.Add("#" + t.Tag);
            }

            // Rank: starts-with the query before merely-contains, alphabetical within each.
            // A tag's '#' is ignored when matching, so "#rr" and "rr" both hit the "rro" tag.
            static string Bare(string s) => s.TrimStart('#').ToLowerInvariant();
            var ordered = suggestions
                .Where(s => tagsOnly ? s.StartsWith("#") : true)
                .Where(s => q.Length == 0 || Bare(s).Contains(q))
                .OrderByDescending(s => q.Length > 0 && Bare(s).StartsWith(q))
                .ThenBy(s => s, StringComparer.OrdinalIgnoreCase)
                .Take(take <= 0 ? 10 : take)
                .ToList();

            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(ordered),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpGet("rooms/search")]
        public ContentResult RoomSearch(string query, int skip = 0, int take = 30)
        {
            var rooms = RoomDB.Search(query);

            if (rooms == null || rooms.Count == 0)
            {
                return new ContentResult
                {
                    Content = JsonConvert.SerializeObject(
                        new RoomDBClasses.Resultslist<RoomDBClasses.RoomRoot>
                        {
                            Results = new List<RoomDBClasses.RoomRoot>(),
                            TotalResults = 0
                        }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }

            int total = rooms.Count;
            var paged = rooms.Skip(skip).Take(take).ToList();

            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(
                    new RoomDBClasses.Resultslist<RoomDBClasses.RoomRoot>
                    {
                        Results = StripUnservableSaves(VisibleTo(paged, ViewerId())),
                        TotalResults = total
                    }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }


        [HttpGet("rooms/visitedby/me")]
        public ContentResult RoomsVisitedByMe(int skip = 0, int take = 20)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return new ContentResult()
            {
                Content = PlayerDB.GetRecentRooms(account.Id, skip, take),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // The "recent rooms" section on ANOTHER player's profile. Only /me existed, so opening
        // someone else's profile 404'd this section. Respects the target's recent-room-history
        // privacy setting exactly as Rec Room does: when they've hidden it, the viewer gets [].
        // Your own id always returns your history (privacy is about what OTHERS see).
        [HttpGet("rooms/visitedby/{playerid}")]
        public ContentResult RoomsVisitedByPlayer(ulong playerid, int skip = 0, int take = 20)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            if (playerid != account.Id)
            {
                var target = PlayerDB.GetFullAccount(playerid);
                bool visible = target?.player_Extra?.IsRecentRoomHistoryVisible ?? false;
                if (!visible)
                    return new ContentResult { Content = "[]", ContentType = "application/json", StatusCode = 200 };
            }

            return new ContentResult()
            {
                Content = PlayerDB.GetRecentRooms(playerid, skip, take),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // The room showcase on a player's profile. This used to be a hardcoded "[]"
        // stub, which is why the Profile tab rendered as one big empty panel even for
        // accounts that own rooms. The client wants a plain list of room ids: [1, 2, 3].
        //
        // Dorms and private rooms are deliberately excluded - a showcase is public, and
        // listing someone's private rooms to any viewer would leak them.
        // The showcase is the handful of rooms a player PICKS for the top of their profile
        // (PUT showcase, room ids). It used to list every room they own, which is what made
        // everything land in "Room Showcase" instead of the Rooms tab. No pick = empty, exactly
        // like the real service; the Rooms tab (createdby/{id}) is where all of them live.
        [HttpPut("showcase")]
        [HttpPost("showcase")]
        [HttpPut("showcase/me")]
        [HttpPost("showcase/me")]
        public ContentResult SetRoomShowcase()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            var ids = new List<ulong>();
            void Add(string? v) { if (!string.IsNullOrWhiteSpace(v)) foreach (var p in v.Split(',')) if (ulong.TryParse(p.Trim(), out var id) && id != 0 && !ids.Contains(id)) ids.Add(id); }
            try
            {
                if (Request.HasFormContentType)
                    foreach (var k in new[] { "roomIds", "roomId", "ids", "id", "RoomIds" }) foreach (var v in Request.Form[k]) Add(v);
                foreach (var k in new[] { "roomIds", "roomId", "ids", "id" }) foreach (var v in Request.Query[k]) Add(v);
                if (ids.Count == 0 && !Request.HasFormContentType)
                {
                    Request.EnableBuffering(); Request.Body.Position = 0;
                    using var reader = new StreamReader(Request.Body, leaveOpen: true);
                    string raw = reader.ReadToEndAsync().GetAwaiter().GetResult();
                    if (!string.IsNullOrWhiteSpace(raw))
                    {
                        var node = System.Text.Json.Nodes.JsonNode.Parse(raw);
                        if (node is System.Text.Json.Nodes.JsonArray ja) foreach (var n in ja) Add(n?.ToString());
                        else if (node is System.Text.Json.Nodes.JsonObject jo) foreach (var kv in jo) { if (kv.Value is System.Text.Json.Nodes.JsonArray a2) foreach (var n in a2) Add(n?.ToString()); else Add(kv.Value?.ToString()); }
                    }
                }
            }
            catch (Exception ex) { Console.WriteLine($"[showcase] {account.Id}: could not read body - {ex.Message}"); }
            // Only rooms the player actually created may be showcased.
            ids = ids.Where(id => RoomDB.GetRoom(id)?.CreatorAccountId == account.Id).Take(ConfigCampus.ShowcaseCap).ToList();
            SettingsDB.SetPlayerSetting("Campus.RoomShowcase", string.Join(",", ids), account.Id);
            Console.WriteLine($"[showcase] {account.Id} set showcase to [{string.Join(",", ids)}]");
            return new ContentResult { Content = JsonConvert.SerializeObject(ids), ContentType = "application/json", StatusCode = 200 };
        }

        [HttpGet("showcase/{playerid}")]
        public ContentResult RoomShowcaseForPlayer(ulong playerid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var picked = (SettingsDB.GetPlayerSettingValue("Campus.RoomShowcase", playerid) ?? "")
                .Split(',', StringSplitOptions.RemoveEmptyEntries)
                .Select(p => ulong.TryParse(p.Trim(), out var id) ? id : 0)
                .Where(id => id != 0)
                .ToList();
            var rooms = picked.Select(id => RoomDB.GetRoom(id)).Where(r => r != null && r!.CreatorAccountId == playerid).Select(r => r!).ToList();

            // NO FALLBACK. A showcase with nothing picked is EMPTY.
            //
            // This briefly fell back to "every room the player created", which did put the rooms
            // on the profile - but under the Room Showcase heading, all 33 of them, instead of in
            // the rooms list where the co-owned rooms (contributedby) correctly land. The rooms
            // list is fed by rooms/createdby/{id}, which is the route that was actually missing
            // (only the /me spelling existed, so a profile by id 404'd and the grid was empty).
            // That route is what makes an owner see their own rooms; this one stays a pick list.

            // Show what THIS VIEWER is allowed to see, not just public rooms.
            //
            // This used to be "Accessibility == Public", which hid almost everything: a
            // freshly created room defaults to PRIVATE (RoomAccessibility.Private = 0), so
            // players saw an empty portfolio even on their own profile. Now:
            //   - your own profile shows all your rooms, private included
            //   - someone else's shows their public/unlisted rooms, plus any private room
            //     you personally hold a role on (owner / co-owner / moderator / host)
            // Dorms are never listed - they are personal space, not portfolio pieces.
            var ids = rooms
                .Where(r => r != null
                         && !r.IsDorm
                         && RoomDB.CanPlayerSeeRoom(r, account.Id))
                .Select(r => r.RoomId)
                .Take(ConfigCampus.ShowcaseCap)
                .ToList();

            return new ContentResult()
            {
                Content = JsonConvert.SerializeObject(ids),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // Room role management (co-owner / moderator / host). These were ack/empty-array stubs, so
        // "invite as co-owner" did nothing and the roles list always showed empty. Now they persist.
        // Ban history for one account in one room. ENVELOPED {Value:{ActiveBan, PreviousBans}}
        // (wire-shapes: rooms-bans-history); "never banned" is a null ActiveBan and an empty list,
        // and nothing throws on either. Was a 404.
        [HttpGet("rooms/{roomId}/bans/history")]
        public IActionResult RoomBanHistory(ulong roomId, [FromQuery] long id)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;

            // A room ban is the Banned ROLE on the room plus a RoomBans record (RoomDB.BanFromRoom);
            // the record carries who / when / why / until, and closed ones are the history.
            var room = RoomDB.GetRoom(roomId);
            object? BanRow(RoomDBClasses.RoomBanDetails d) => new
            {
                Status = d.Status,                    // Active 0 / Elapsed 1 / Lifted 2
                UnbannedByAccountId = d.UnbannedByAccountId.HasValue ? (int?)d.UnbannedByAccountId.Value : null,
                BanEndTime = d.BanEndTime,
                Reason = d.Reason ?? "",
                AccountId = (int)d.AccountId,
                BannedByAccountId = d.BannedByAccountId != 0 ? (int?)d.BannedByAccountId : null,
                BanStartTime = d.BanStartTime
            };
            var current = room != null ? RoomDB.ActiveRoomBan(room, (ulong)id) : null;
            object? active = current != null ? BanRow(current) : null;
            var previous = (room?.RoomBans ?? new())
                .Where(b => b.AccountId == id && b.Status != 0)
                .OrderByDescending(b => b.BanStartTime)
                .Select(b => BanRow(b)!)
                .ToArray();
            return Ok(new
            {
                Value = new { ActiveBan = active, PreviousBans = previous },
                Success = true,
                Error = (string?)null,
                error_id = (string?)null
            });
        }

        // What every role / permission WRITE answers: the room-write envelope with the updated
        // room as its value, {success, error, value}. The 2025 client sends all of these through
        // the room facade's enveloped helper (OALMDGJKBJH.PJPLCMBOAFB<T>) and parses the answer
        // as an object - Player.log, inviting a co-owner: "Malformed Response: '[{"AccountId":1,
        // ...}]' ... expected:'{', actual:'['", then "Failed to invite account to role"; and on
        // the permissions PUT: "Response was empty" / "Failed to change subroom permissions".
        // The bare roles ARRAY is what GET /roles answers (rooms-roles-wire-shape) and only that.
        // The wire keys accept any casing, so this is the same lowercase envelope PUT /name uses.
        private ContentResult RoomWriteEnvelope(ulong roomId) => new ContentResult
        {
            Content = JsonConvert.SerializeObject(new { success = true, error = "", value = RoomDB.GetRoom(roomId) }),
            ContentType = "application/json",
            StatusCode = 200
        };

        [HttpGet("rooms/{roomId}/roles")]
        public IActionResult GetRoomRolesEndpoint(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            return Ok(RoomDB.GetRoomRoles(roomId));   // BARE array - the one roles route that is
        }

        // Remove a player's role outright (the roles panel's "remove"). Same gate as invite.
        [HttpDelete("rooms/{roomId}/roles/{playerId}")]
        public IActionResult RemoveRoomRole(ulong roomId, long playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            // Removing YOURSELF: decline a pending invite, or step down from a role you hold.
            if ((ulong)playerId == account.Id)
            {
                if (RoomDB.PendingRoleInvite(roomId, playerId) != RoomDBClasses.Role_data.None)
                    return ResolveRoleInvite(roomId, account.Id, accept: false);
                var mine = RoomDB.GetRoom(roomId);
                if (mine != null && mine.CreatorAccountId == account.Id) return StatusCode(403, "");
                RoomDB.SetRoomRole(roomId, playerId, RoomDBClasses.Role_data.None, (long)account.Id);
                Console.WriteLine($"[room-role] {account.Id} left their role on room {roomId}");
                return RoomWriteEnvelope(roomId);
            }
            if (!RoomDB.PlayerCanManageRoles(roomId, account.Id))
                return StatusCode(403, "");
            bool ok = RoomDB.SetRoomRole(roomId, playerId, RoomDBClasses.Role_data.None, (long)account.Id);
            Console.WriteLine($"[room-role] {account.Id} removed player {playerId}'s role on room {roomId} -> {ok}");
            return RoomWriteEnvelope(roomId);
        }

        [HttpPut("rooms/{roomId}/roles/{playerId}")]
        [HttpPost("rooms/{roomId}/roles/{playerId}")]
        [HttpPut("rooms/{roomId}/roles/{playerId}/invite")]
        [HttpPost("rooms/{roomId}/roles/{playerId}/invite")]
        public IActionResult InviteRoomRole(ulong roomId, long playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;

            // The INVITEE answering their own pending invite comes through the same route with
            // their own id: that is an accept, never a self-grant (nothing here lets a caller give
            // themselves a role - the grant is exactly the role a manager offered).
            if ((ulong)playerId == account.Id)
            {
                var pending = RoomDB.PendingRoleInvite(roomId, playerId);
                if (pending == RoomDBClasses.Role_data.None)
                {
                    // Already accepted (the notification tapped twice, or a retry after the first
                    // answer failed to parse): a no-op success, with the room. A player with no
                    // role and no invite is still refused - nothing here grants.
                    var held = RoomDB.PlayerRoleOn(RoomDB.GetRoom(roomId), account.Id) ?? RoomDBClasses.Role_data.None;
                    if (held != RoomDBClasses.Role_data.None && held != RoomDBClasses.Role_data.Banned)
                        return RoomWriteEnvelope(roomId);
                    Console.WriteLine($"[room-role] {account.Id} tried to set their OWN role on room {roomId} with no pending invite - refused");
                    return StatusCode(403, "");
                }
                return ResolveRoleInvite(roomId, account.Id, accept: true);
            }

            // Only the room's creator, a co-owner, or a dev/admin may offer roles.
            if (!RoomDB.PlayerCanManageRoles(roomId, account.Id))
                return StatusCode(403, "");

            // The client PUTs a small form body: role=<Role_data value> (30 CoOwner, 20 Moderator,
            // 10 Host, 0 None=remove). Fall back to query / invitedRole; default CoOwner if absent.
            string roleStr = Request.HasFormContentType ? Request.Form["role"].ToString() : "";
            if (string.IsNullOrWhiteSpace(roleStr)) roleStr = Request.Query["role"].ToString();
            if (string.IsNullOrWhiteSpace(roleStr) && Request.HasFormContentType) roleStr = Request.Form["invitedRole"].ToString();
            int roleVal = int.TryParse(roleStr, out var rv) ? rv : (int)RoomDBClasses.Role_data.CoOwner;
            var role = Enum.IsDefined(typeof(RoomDBClasses.Role_data), (byte)roleVal)
                ? (RoomDBClasses.Role_data)(byte)roleVal : RoomDBClasses.Role_data.CoOwner;

            // A creator can't be demoted through here, can't be invited to their own room, and
            // nobody can hand out Creator.
            var target_room = RoomDB.GetRoom(roomId);
            if (target_room != null && (ulong)playerId == target_room.CreatorAccountId)
            {
                Console.WriteLine($"[room-role] {account.Id} tried to change the creator's role on room {roomId} - refused");
                return StatusCode(403, "");
            }
            if (role == RoomDBClasses.Role_data.Creator) role = RoomDBClasses.Role_data.CoOwner;
            if (role == RoomDBClasses.Role_data.Banned) role = RoomDBClasses.Role_data.None;

            bool ok;
            if (role == RoomDBClasses.Role_data.None)
            {
                ok = RoomDB.SetRoomRole(roomId, playerId, role, (long)account.Id);
                Console.WriteLine($"[room-role] {account.Id} removed player {playerId}'s role on room {roomId} -> {ok}");
                if (ok) Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate((ulong)playerId, RoomDB.GetRoom(roomId));
                return RoomWriteEnvelope(roomId);
            }

            // Co-owner and contributor are OFFERED and wait for the invitee's Accept - they hand
            // over the room's contents. Moderator and host are GRANTED on the spot: they are
            // staffing roles, and an invite for them is what the owner reported as "adding a mod
            // makes them get an invite". The target's client is told immediately either way.
            if (role == RoomDBClasses.Role_data.Moderator || role == RoomDBClasses.Role_data.Host)
            {
                ok = RoomDB.SetRoomRole(roomId, playerId, role, (long)account.Id);
                Console.WriteLine($"[room-role] {account.Id} made player {playerId} {role} ({roleVal}) on room {roomId} -> {ok} (granted directly)");
                if (ok) Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate((ulong)playerId, RoomDB.GetRoom(roomId));
                return RoomWriteEnvelope(roomId);
            }

            ok = RoomDB.InviteRoomRole(roomId, playerId, role, (long)account.Id);
            Console.WriteLine($"[room-role] {account.Id} invited player {playerId} as {role} ({roleVal}) on room {roomId} -> {ok} (pending acceptance)");
            if (ok)
            {
                try
                {
                    var msg = PlayerDB.AddMessage((ulong)playerId, account.Id, WebsocketEvents.MessageType.RoomCoOwnerInvited, ((int)role).ToString(), roomId, null);
                    if (msg != null) Notifications.SendToPlayer((ulong)playerId, JsonConvert.SerializeObject(WebsocketEvents.CreateMessageResponse(msg)));
                }
                catch (Exception ex) { Console.WriteLine($"[room-role] invite notification failed: {ex.Message}"); }
            }

            // The client re-GETs /roles right after; return the updated list so it reflects immediately.
            return RoomWriteEnvelope(roomId);
        }

        private IActionResult ResolveRoleInvite(ulong roomId, ulong accountId, bool accept)
        {
            var pending = RoomDB.PendingRoleInvite(roomId, (long)accountId);
            if (pending == RoomDBClasses.Role_data.None) return StatusCode(404, "");
            bool ok = RoomDB.ResolveRoleInvite(roomId, (long)accountId, accept);
            Console.WriteLine($"[room-role] {accountId} {(accept ? "ACCEPTED" : "declined")} the {pending} invite on room {roomId} -> {ok}");
            if (ok && accept) Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate(accountId, RoomDB.GetRoom(roomId));
            if (ok && accept)
            {
                // RoomCoOwnerAdded (60) reads "You are now a Co-Owner of X" - it is addressed to the
                // player who GAINED the role, not to the room's owner. Sending it to the creator is
                // what made the owner receive "You are now a Co-Owner" of their own room.
                var room = RoomDB.GetRoom(roomId);
                if (room != null && room.CreatorAccountId != accountId)
                {
                    try
                    {
                        var msg = PlayerDB.AddMessage(accountId, room.CreatorAccountId, WebsocketEvents.MessageType.RoomCoOwnerAdded, ((int)pending).ToString(), roomId, null);
                        if (msg != null) Notifications.SendToPlayer(accountId, JsonConvert.SerializeObject(WebsocketEvents.CreateMessageResponse(msg)));
                    }
                    catch { }
                }
            }
            return RoomWriteEnvelope(roomId);
        }

        // The explicit accept / decline spellings, plus "myrole" (the reference lists GET
        // rooms/{id}/roles/myrole; a PUT there is the same accept).
        [HttpPut("rooms/{roomId}/roles/{playerId}/accept")]
        [HttpPost("rooms/{roomId}/roles/{playerId}/accept")]
        public IActionResult AcceptRoomRole(ulong roomId, long playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            if ((ulong)playerId != account.Id) return StatusCode(403, "");
            return ResolveRoleInvite(roomId, account.Id, accept: true);
        }

        [HttpPut("rooms/{roomId}/roles/{playerId}/decline")]
        [HttpPost("rooms/{roomId}/roles/{playerId}/decline")]
        [HttpDelete("rooms/{roomId}/roles/{playerId}/invite")]
        public IActionResult DeclineRoomRole(ulong roomId, long playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            if ((ulong)playerId == account.Id) return ResolveRoleInvite(roomId, account.Id, accept: false);
            // A manager withdrawing an offer they made.
            if (!RoomDB.PlayerCanManageRoles(roomId, account.Id)) return StatusCode(403, "");
            RoomDB.ResolveRoleInvite(roomId, playerId, accept: false);
            return RoomWriteEnvelope(roomId);
        }

        [HttpGet("rooms/{roomId}/roles/myrole")]
        public IActionResult MyRoomRole(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room = RoomDB.GetRoom(roomId);
            return Ok((int)(RoomDB.PlayerRoleOn(room, account.Id) ?? RoomDBClasses.Role_data.None));
        }

        [HttpPut("rooms/{roomId}/roles/myrole")]
        [HttpPost("rooms/{roomId}/roles/myrole")]
        public IActionResult SetMyRoomRole(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            return ResolveRoleInvite(roomId, account.Id, accept: true);
        }

        // Anything else under /roles: log the shape so an unknown client spelling names itself.
        [Route("rooms/{roomId}/roles/{**rest}")]
        public IActionResult UnhandledRoleRoute(ulong roomId, string rest)
        {
            string body = "";
            try { if (Request.HasFormContentType) body = string.Join("&", Request.Form.Select(kv => kv.Key + "=" + kv.Value)); } catch { }
            Console.WriteLine($"[room-role] UNHANDLED {Request.Method} rooms/{roomId}/roles/{rest}{Request.QueryString} body='{body}'");
            return StatusCode(404, "");
        }

        [HttpGet("rooms/base")]
        public ContentResult BaseRooms()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            List<RoomDBClasses.RoomRoot> room = RoomDB.Search("#base", isBase: true);
            return new ContentResult()
            {
                Content = JsonConvert.SerializeObject(StripUnservableSaves(VisibleTo(room, ViewerId()))),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpPost("rooms/{roomId}/clone")]
        public ContentResult CloneRoom(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string RoomName = HttpContext.Request.Form["name"];
            if (string.IsNullOrEmpty(RoomName))
            {
                return Utils.Error("You must enter a name for your room.");
            }
            var checkifroomexists = RoomDB.GetRoomByName(RoomName);
            if (checkifroomexists != null)
            {
                return Utils.Error("A room with that name already exists!");
            }
            bool CheckSwears = !string.IsNullOrEmpty(RoomName) && Sanitize.ContainsSwears(RoomName);
            if (CheckSwears)
            {
                return Utils.Error("Room name contains swear words!");
            }
            // Anyone could clone ANY room (unpublished drafts included) and end up owning a copy.
            // Only the room's own creator/co-owners, or anyone when the owner allowed cloning on a
            // room others can see.
            var source = RoomDB.GetRoom(roomId);
            if (source == null) return Utils.Error("This room does not exist!");
            bool mineToClone = source.CreatorAccountId == account.Id || RoomDB.IsCoOwner(source, account.Id) || PlayerDB.CheckDevFlag(account.Id);
            bool template = RoomDB.RoomHasTag(source, "base") || source.IsRRO;   // the "create a room" templates
            if (!mineToClone && !template && !(source.CloningAllowed && RoomDB.CanPlayerSeeRoom(source, account.Id)))
            {
                Console.WriteLine($"[rooms] {account.Id} tried to clone room {roomId} ({source.Name}) without permission - refused");
                return Utils.Error("This room can't be cloned.");
            }
            ulong? temp = RoomDB.CloneRoom(roomId, RoomName, account.Id);
            if (temp == null)
            {
                return Utils.Error("You can't clone this room!");
            }
            var NewRoom = RoomDB.GetRoom(temp.Value);
            if (NewRoom == null)
            {
                Console.WriteLine($"[Room_server_room_clone] get_room({temp.Value}) returned null");
            }
            Console.WriteLine($"[Room_server_room_clone] clone_room returned id: {temp}");

            return new ContentResult()
            {
                Content = JsonConvert.SerializeObject(new
                {
                    success = true,
                    error = "",
                    value = NewRoom
                }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // set room stuff

        [HttpPut("rooms/{roomId}/name")]
        public ContentResult SetRoomName(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string NewRoomName = HttpContext.Request.Form["name"].ToString();

            RoomDBClasses.RoomRoot? room_data = RoomDB.GetRoom(roomId);
            Uri.UnescapeDataString(NewRoomName);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }

            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            if (room_data.IsDorm == true)
            {
                return Utils.ErrorRoom("Rooms.Dorm", "You cannot edit your dorm room's name!");
            }

            if (NewRoomName.Contains(" "))
            {
                return Utils.ErrorRoom("Rooms.NoSpaces", "Your room name must not contain spaces!");
            }

            if (Regex.IsMatch(NewRoomName, @"[^\u0000-\u007F]"))
            {
                return Utils.ErrorRoom("Rooms.NoUnicodeCharacters", "Your room name contains Unicode characters!");
            }

            bool CheckSwears = !string.IsNullOrEmpty(NewRoomName) && Sanitize.ContainsSwears(NewRoomName);
            if (CheckSwears)
            {
                return Utils.ErrorRoom("Rooms.NoSwearWords", "Your room name contains swear words!");
            }

            RoomDBClasses.RoomRoot? temp = RoomDB.SetRoomName(roomId, NewRoomName);
            RoomDBClasses.RoomRoot? UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DuplicateName", "A room with the same name already exists!");
            }
        }

        [HttpPut("rooms/{roomId}/description")]
        public ContentResult SetRoomDescriptionAPI(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string NewDescription = HttpContext.Request.Form["description"].ToString();
            Uri.UnescapeDataString(NewDescription);

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomId);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            bool CheckSwears = !string.IsNullOrEmpty(NewDescription) && Sanitize.ContainsSwears(NewDescription);
            if (CheckSwears)
            {
                return Utils.ErrorRoom("Rooms.NoSwearWords", "Your room description contains swear words!");
            }

            RoomDBClasses.RoomRoot temp = RoomDB.SetRoomDescription(roomId, NewDescription);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpPut("rooms/{roomId}/accessibility")]
        public ContentResult SetRoomAccessibility(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string NewAccessibilityString = HttpContext.Request.Form["accessibility"].ToString();
            RoomDBClasses.RoomAccessibility accessibility = RoomDBClasses.RoomAccessibility.Private;
            if (int.TryParse(NewAccessibilityString, out int accessibilityValue) && Enum.IsDefined(typeof(RoomDBClasses.RoomAccessibility), accessibilityValue))
            {
                accessibility = (RoomDBClasses.RoomAccessibility)accessibilityValue;
            }
            else
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = false,
                        error = "",
                        value = (object?)null
                    }),
                    ContentType = "application/json",
                    StatusCode = 400
                };
            }
            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomId);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            RoomDBClasses.RoomRoot temp = RoomDB.SetRoomAccessibility(roomId, accessibility);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        // Transfer a room to a new owner (reference rooms PUT /rooms/{id}/creator): the new owner's
        // role entry becomes Creator (255), the old owner's becomes CoOwner (30), and
        // CreatorAccountId - the field every gate and "rooms I made" list reads - moves with it.
        // Owner only (a co-owner cannot give a room away), and a dorm can never be transferred.
        [HttpPut("rooms/{roomId}/creator")]
        [HttpPost("rooms/{roomId}/creator")]
        public ContentResult TransferRoom(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            var f = RoomModeration.Fields(Request);
            ulong target = RoomModeration.ULong(f, "accountId", "id", "playerId", "newOwnerId");
            var room = RoomDB.GetRoom(roomId);
            if (room == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            bool isOwner = room.CreatorAccountId == account.Id || PlayerDB.CheckDevFlag(account.Id);
            if (!isOwner) return Utils.ErrorRoom("Rooms.PermissionDenied", "Only the owner can transfer this room!");
            if (room.IsDorm) return Utils.ErrorRoom("Rooms.PermissionDenied", "A dorm cannot be transferred!");
            if (target == 0 || PlayerDB.GetAccountById(target) == null) return Utils.ErrorRoom("Rooms.InvalidAccount", "You must name a valid player!");
            if (target == room.CreatorAccountId) return Utils.ErrorRoom("Rooms.InvalidAccount", "That player already owns this room!");

            var stored = RoomDB.col.FindOne(x => x.RoomId == roomId);
            if (stored == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            ulong previous = stored.CreatorAccountId;
            stored.Roles ??= new List<RoomDBClasses.RoleClass>();
            stored.Roles.RemoveAll(x => (ulong)x.AccountId == target);
            stored.Roles.Add(new RoomDBClasses.RoleClass { AccountId = (long)target, Role = RoomDBClasses.Role_data.Creator, InvitedRole = 0, LastChangedByAccountId = (long)account.Id });
            var old = stored.Roles.FirstOrDefault(x => (ulong)x.AccountId == previous);
            if (old != null) { old.Role = RoomDBClasses.Role_data.CoOwner; old.InvitedRole = 0; old.LastChangedByAccountId = (long)account.Id; }
            else if (previous != 0) stored.Roles.Add(new RoomDBClasses.RoleClass { AccountId = (long)previous, Role = RoomDBClasses.Role_data.CoOwner, InvitedRole = 0, LastChangedByAccountId = (long)account.Id });
            stored.CreatorAccountId = target;
            RoomDB.col.Update(stored);
            Console.WriteLine($"[rooms] room {roomId} '{stored.Name}': ownership {previous} -> {target} (by {account.Id})");

            var updated = RoomDB.GetRoom(roomId);
            foreach (var pid in RoomPermissions.PlayersInRoom(roomId).Concat(new[] { previous, target }).Distinct())
                RoomPermissions.PushRoomUpdate(pid, updated);
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(new { success = true, error = "", value = updated }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // A subroom's own visibility (reference rooms PUT /rooms/{id}/subrooms/{sub}/accessibility):
        // the client sends the RoomAccessibility NAME (accessibility=Private); the ordinal works too.
        // Owner only. Answers the updated ROOM so the client re-renders its subroom list.
        [HttpPut("rooms/{roomId}/subrooms/{subRoomId}/accessibility")]
        [HttpPost("rooms/{roomId}/subrooms/{subRoomId}/accessibility")]
        public ContentResult SetSubroomAccessibility(ulong roomId, ulong subRoomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            var f = RoomModeration.Fields(Request);
            string raw = RoomModeration.Str(f, "accessibility", "Accessibility") ?? "";
            RoomDBClasses.RoomAccessibility acc;
            if (int.TryParse(raw, out var n) && Enum.IsDefined(typeof(RoomDBClasses.RoomAccessibility), n)) acc = (RoomDBClasses.RoomAccessibility)n;
            else if (!Enum.TryParse(raw, true, out acc)) return Utils.ErrorRoom("Rooms.InvalidArgument", "Unknown accessibility!");
            var room = RoomDB.GetRoom(roomId);
            if (room == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            if (room.CreatorAccountId != account.Id && !RoomDB.IsCoOwner(room, account.Id) && !PlayerDB.CheckDevFlag(account.Id))
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            var sub = room.SubRooms?.FirstOrDefault(s => s.SubRoomId == subRoomId);
            if (sub == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This subroom does not exist!");
            RoomDB.ModifySubroom(roomId, subRoomId, sub.Name ?? "", acc, sub.MaxPlayers);
            var updated = RoomDB.GetRoom(roomId);
            RoomPermissions.PushRoomUpdate(account.Id, updated);
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(new { success = true, error = "", value = updated }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpPut("rooms/{roomId}/image")]
        public ContentResult SetRoomImageName(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string NewImageName = HttpContext.Request.Form["imageName"].ToString();

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomId);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            RoomDBClasses.RoomRoot temp = RoomDB.SetRoomImageName(roomId, NewImageName);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpPost("rooms/{roomId}/subrooms/{subroomId}/data")]
        public async Task<ContentResult> SetRoomData(ulong roomId, ulong subroomId, [FromBody] RoomFileData request)
        {
            string authtoken = HttpContext.Request.Headers["Authorization"].ToString();

            if (string.IsNullOrEmpty(authtoken))
            {
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 401
                };
            }
            string playerdata = ClientSecurity.DecodeToken(authtoken);
            if (playerdata == null)
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 401
                };
            if (playerdata.Contains("error_token"))
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 401
                };
            player_info account = JsonConvert.DeserializeObject<player_info>(playerdata);

            string token = authtoken.ToString().Replace("Bearer ", "", StringComparison.OrdinalIgnoreCase);

            var handler = new JwtSecurityTokenHandler();
            var jwt = handler.ReadJwtToken(token);

            // "platform" is normally numeric, but int.Parse here threw an UNHANDLED
            // FormatException -> HTTP 500 on any token carrying a name ("Standalone").
            // A room save is the one request you never want to lose, so accept either
            // shape and fall back to All rather than dropping the save on the floor.
            string currentplatformstr = jwt.Payload.TryGetValue("platform", out var platObj)
                ? platObj?.ToString() ?? "" : "";
            Platforms platformparsed;
            if (int.TryParse(currentplatformstr, out int currentplatform))
                platformparsed = Enum.IsDefined(typeof(Platforms), currentplatform) ? (Platforms)currentplatform : Platforms.All;
            else if (!Enum.TryParse(currentplatformstr, ignoreCase: true, out platformparsed))
                platformparsed = Platforms.All;

            // The subroom blob (the actual build) and the ROOM-level blob are two
            // different uploads. Both lines used to read SubRoomData, so RoomData was
            // silently discarded and subroomFilename was dead code.
            string subroomFilename = request.SubRoomData?.Filename ?? "";
            string? roomLevelBlob  = request.RoomData?.Filename;

            string RoomDesc = request.Description ?? "";

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomId);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (!RoomDB.CanEditContent(room_data, account?.Id ?? 0))   // creator, co-owner, or an ACCEPTED contributor
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            // Pass the versions the client reported with this save. Without them every
            // save was recorded as 0/0/0 and the client treated the room as dirty
            // immediately, prompting to save on exit even when nothing had changed.
            // A save never changes the room's VISIBILITY (accessibility is the owner's setting).
            // What AutoPublish decides is whether this save goes LIVE now or is staged as an
            // unpublished save until the owner publishes it (publish_save) - published and
            // unpublished saves are kept apart, so visitors keep loading the published build.

            RoomDBClasses.RoomRoot room = RoomDB.SetRoomSubroomRoomFile(
                roomId,
                subroomId,
                subroomFilename,
                RoomDesc,
                account.Id,
                platformparsed,
                request.PersistenceVersion,
                request.OMVersion,
                request.UgcSubVersion,
                roomLevelBlob,
                request.AutoPublish,
                out var createdSave);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                // The client parses value as { room, subRoomDataSave } (see wire-shapes
                // subroom-data-save-endpoint). We used to hand back the bare room, so the
                // deserializer NRE'd on the missing pair, the promise rejected with the generic
                // "Failed to save room", and the room stayed dirty - every save after the first
                // one in an instance "failed" even though the blob had been stored.
                // subRoomDataSave is a camelCase projection with its OWN field set, not the
                // PascalCase CurrentSave embedded in the room.
                // The save just made - staged or published - not necessarily the live CurrentSave.
                var save = createdSave ?? RoomDB.GetSubRoom(roomId, subroomId)?.CurrentSave;
                object? subRoomDataSave = save == null ? null : new
                {
                    subRoomDataSaveId = (long)save.SubRoomDataSaveId,
                    subRoomId = (long)save.SubRoomId,
                    unityAssetId = save.UnityAssetId,
                    unityAsset = (string?)null,
                    unityAssetHash = (string?)null,
                    dataBlob = save.DataBlob ?? "",
                    dataBlobHash = request.SubRoomData?.Hash ?? "",
                    savedByAccountId = (long?)save.SavedByAccountId,
                    savedOnPlatform = (int)(save.SavedOnPlatform ?? Platforms.All),
                    savedOnDeviceClass = (int)(save.SavedOnDeviceClass ?? DeviceClasses.Screen),
                    description = save.Description,
                    createdAt = save.CreatedAt
                };
                Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate(account.Id, UpdatedRoom);
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = (string?)null,
                        value = new { room = UpdatedRoom, subRoomDataSave }
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpPut("rooms/{roomId}/cloning")]
        public ContentResult SetRoomCloning(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string? cloningAllowedStr = HttpContext.Request.Form["cloningAllowed"];
            if (!bool.TryParse(cloningAllowedStr, out bool cloningAllowed))
            {
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 400
                };
            }

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomId);
            if (room_data.IsDorm == true)
            {
                return Utils.ErrorRoom("Rooms.DormNotAllowed", "You cannot edit that in this dorm.");
            }
            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            RoomDBClasses.RoomRoot temp = RoomDB.SetRoomCloning(roomId, cloningAllowed);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpPut("rooms/{roomId}/restrictions")]
        [HttpPut("rooms/{roomId}/v2/restrictions")]      // the 2025 client's spelling (404'd)
        [HttpPost("rooms/{roomId}/v2/restrictions")]
        public ContentResult SetRoomRestrictions(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            bool ParseBool(string key, bool defaultValue = false)
            {
                string? str = HttpContext.Request.Form[key];
                return bool.TryParse(str, out bool result) ? result : defaultValue;
            }

            bool supportsScreens = ParseBool("supportsScreens");
            bool supportsWalkVR = ParseBool("supportsWalkVR");
            bool supportsTeleportVR = ParseBool("supportsTeleportVR");
            bool supportsJuniors = ParseBool("supportsJuniors");

            RoomDBClasses.RoomRoot? room_data = RoomDB.GetRoom(roomId);
            if (room_data?.IsDorm == true)
            {
                return Utils.ErrorRoom("Rooms.DormNotAllowed", "You cannot edit that in dorms.");
            }
            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            RoomDBClasses.RoomRoot? temp = RoomDB.SetRoomRestrictions(roomId, supportsScreens, supportsWalkVR, supportsTeleportVR, supportsJuniors);
            RoomDBClasses.RoomRoot? UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpPut("rooms/{roomId}/loadscreen")]
        public ContentResult SetRoomLoadingScreen(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string imageName = HttpContext.Request.Form["imageName"].ToString();
            string title = HttpContext.Request.Form["title"].ToString();
            string subtitle = HttpContext.Request.Form["subtitle"].ToString();

            RoomDBClasses.RoomRoot? room_data = RoomDB.GetRoom(roomId);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            if (!string.IsNullOrEmpty(title) && title.Length > 24)
            {
                return Utils.ErrorRoom("Room.LoadScreen.Title", "Title cannot exceed 24 characters!");
            }

            if (!string.IsNullOrEmpty(subtitle) && subtitle.Length > 150)
            {
                return Utils.ErrorRoom("Room.LoadScreen.Subtitle", "Subtitle cannot exceed 150 characters!");
            }

            RoomDBClasses.RoomRoot? temp = RoomDB.SetRoomLoadscreen(roomId, imageName, title, subtitle);
            RoomDBClasses.RoomRoot? UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpPut("rooms/{roomId}/warning")]
        public ContentResult SetRoomWarning(ulong roomId, [FromForm] WarningMaskType warningMask)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomId);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            RoomDBClasses.RoomRoot temp = RoomDB.SetRoomWarningMask(roomId, warningMask);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomId);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpPut("rooms/{roomId}/tags")]
        public IActionResult SetRoomTags(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var room = RoomDB.GetRoom(roomId);
            if (room == null)
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");

            if (!RoomDB.UserCanEditRoom(roomId, account.Id))
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");

            var restricted = new HashSet<string>
            {
                "rro",
                "recroomoriginal",
                "featured",
                "base"
            };

            List<string> Values(string name) => Request.HasFormContentType
                ? Request.Form[name].Select(t => Uri.UnescapeDataString(t ?? "").Trim().ToLowerInvariant()).Where(t => t.Length > 0).Distinct().ToList()
                : new List<string>();
            var tags = Values("tag");
            var autoTags = Values("autoTag");
            string? primaryGenre = Values("primaryGenreTag").FirstOrDefault();

            if (tags.Count == 0 && autoTags.Count == 0 && primaryGenre == null)
                return Utils.ErrorRoom("Rooms.InvalidTag", "No valid tags provided.");
            if (tags.Any(t => restricted.Contains(t)) || (primaryGenre != null && restricted.Contains(primaryGenre)))
                return Utils.ErrorRoom("Rooms.TagNotAllowed", "One or more tags are not allowed!");
            // Derived tags are a closed set: what the client's own toggles produce.
            var allowedAuto = new HashSet<string> { "limitsv2", "beta", "rooms2", "r2" };
            if (autoTags.Any(t => !allowedAuto.Contains(t)))
                return Utils.ErrorRoom("Rooms.TagNotAllowed", "One or more tags are not allowed!");

            // A lone `tag` toggles; anything more is the whole-state save (see RoomDB.ApplyRoomTagEdit).
            bool isToggle = tags.Count == 1 && autoTags.Count == 0 && primaryGenre == null;
            Console.WriteLine($"[rooms] {account.Id} tags on room {roomId}: {(isToggle ? "toggle " + tags[0] : $"set [{string.Join(",", tags)}] auto [{string.Join(",", autoTags)}] genre {primaryGenre ?? "-"}")}");
            var updatedRoom = RoomDB.ApplyRoomTagEdit(roomId, isToggle ? tags[0] : null, isToggle ? null : (tags.Count > 0 ? tags : null), autoTags, primaryGenre);
            if (updatedRoom == null)
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");

            return Ok(new
            {
                success = true,
                error = "",
                value = updatedRoom
            });
        }



        [HttpGet("rooms/favoritedby/me")]
        public ContentResult MyFavoritedRooms()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return new ContentResult()
            {
                // Was: JsonConvert.SerializeObject(...) wrapped around a method that
                // ALREADY returns serialized JSON, so the client received the string
                // "[]" (quoted) instead of the array []. Verified live - this endpoint
                // was returning "[]" and it is the source of the client's
                // `Malformed Response: '[]'` errors.
                Content = PlayerDB.GetFavoritedRooms(account.Id),
                ContentType = "application/json",
                StatusCode = 200
            };
        }


        // Don't advertise a save whose .room blob we cannot actually serve.
        //
        // Symptom this fixes: joining a room ALONE failed with no subroom data, but
        // joining a friend already inside worked. Creating an instance makes the client
        // load the room from its save - it requests /cdn/room/<DataBlob>, which 404s
        // when the file is absent from Data/CDN/RoomBlobs (the cdn.rec.net fallback in
        // CDNController is dead - those blobs are no longer public). Joining an existing
        // instance never fetches the blob; state replicates over Photon from whoever is
        // already there. That is exactly why the same room worked via a friend.
        //
        // Rooms with no save at all (Park, dorms) were unaffected - they just load their
        // default Unity scene. So make an unservable save look like no save and let the
        // room fall back to that same scene.
        //
        // Scope: only changes rooms that are ALREADY broken. If the blob is present the
        // save is returned exactly as before. Self-correcting - drop the real .room files
        // into Data/CDN/RoomBlobs and the saves come back with no code change.
        //
        // Trade-off: an affected room loads its base scene instead of its saved build.
        // Joinable-but-plain beats unjoinable, and it is reversible.
        private static List<object> FilterUnservableSaves(dynamic? results, ulong roomId, ulong subroomId)
        {
            var servable = new List<object>();
            int dropped = 0;

            if (results != null)
            {
                foreach (var s in results)
                {
                    string? blob = (string?)s?.DataBlob;
                    if (BlobHasContent(blob)) servable.Add(s!);
                    else dropped++;
                }
            }

            if (dropped > 0)
            {
                Console.WriteLine($"[rooms/{roomId}/subrooms/{subroomId}/saves] dropped {dropped} save(s) " +
                                  "whose .room blob is missing or empty in Data/CDN/RoomBlobs - room will load its " +
                                  "default scene instead of failing to load at all");
            }

            return servable;
        }

        [HttpGet("rooms/{roomId}/subrooms/{subroomId}/saves")] // SCUFFED CODE fix later
        public ContentResult GetRoomSaves(ulong roomId, ulong subroomId, int unityAssetTarget = 0, int unityAssetVersion = 1, int skip = 0, int take = 20)
        {


            var save = RoomDB.GetRoomSaves(roomId, subroomId, skip, take);

            if (save == null)
            {
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 404
                };
            }

            var servable = FilterUnservableSaves(save.Results, roomId, subroomId);

            return new ContentResult()
            {
                Content = JsonConvert.SerializeObject(new
                {
                    Results = servable,
                    TotalResults = servable.Count
                }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpGet("rooms/{roomId}/subrooms/{subroomId}/saves/no_unity_assets")] // SCUFFED CODE fix later
        public ContentResult GetRoomSaves2(ulong roomId, ulong subroomId, int unityAssetTarget = 0, int unityAssetVersion = 1, int skip = 0, int take = 20)
        {


            var save = RoomDB.GetRoomSaves(roomId, subroomId, skip, take);

            if (save == null)
            {
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 404
                };
            }

            var servable = FilterUnservableSaves(save.Results, roomId, subroomId);

            return new ContentResult()
            {
                Content = JsonConvert.SerializeObject(new
                {
                    Results = servable,
                    TotalResults = servable.Count
                }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }


        // GetRoomSaveById returns a boxed object whose concrete type varies, so read
        // DataBlob off its JSON form rather than guessing at properties vs fields -
        // an earlier reflection-based version silently matched nothing and let the
        // blob through.
        // Single source of truth for "can the client actually download this blob?".
        // NOTE: existence alone is not enough - see BlobHasContent for why.
        private static bool BlobHasContent(string? blob)
            => Campus_live_rewrite.api.server.RoomBlobFilter.BlobHasContent(blob);

        private static bool SaveBlobIsServable(object save)
        {
            string? blob;
            try
            {
                blob = Newtonsoft.Json.Linq.JObject
                    .FromObject(save)["DataBlob"]?.ToString();
            }
            catch
            {
                return true;   // unknown shape - never block on it
            }

            return BlobHasContent(blob);
        }

        [HttpGet("rooms/{roomId}/subrooms/{subroomId}/saves/{subRoomDataSaveId}")]
        public IActionResult GetRoomSave(ulong roomId, ulong subroomId, ulong subRoomDataSaveId, [FromQuery] int unityAssetTarget, [FromQuery] int unityAssetVersion)
        {
            var save = RoomDB.GetRoomSaveById(roomId, subroomId, subRoomDataSaveId, unityAssetTarget, unityAssetVersion);

            // Same rule as everywhere else: a save whose .room blob is not in
            // Data/CDN/RoomBlobs cannot be loaded, so report it as absent rather than
            // handing back a DataBlob that will 404 at /cdn/room/<blob>.
            if (save != null && !SaveBlobIsServable(save))
            {
                Console.WriteLine($"[rooms/{roomId}/subrooms/{subroomId}/saves/{subRoomDataSaveId}] " +
                                  "blob missing or empty in Data/CDN/RoomBlobs - reporting save as absent");
                save = null;
            }

            if (save == null)
            {
                return new ContentResult()
                {
                    Content = "",
                    ContentType = "application/json",
                    StatusCode = 404
                };
            }

            return Ok(save);
        }


        [HttpGet("rooms/carousel/rising")]
        public ContentResult RisingRooms()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return new ContentResult()
            {
                Content = "[]", // todo db
                ContentType = "application/json",
                StatusCode = 200
            };
        }



        [HttpGet("featuredrooms/current")]
        public ContentResult CurrentFeaturedRooms()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            /*
              Response:
              {
                  "FeaturedRoomGroupId": 1,
                  "name": "Featured Rooms",
                  "StartAt": "2025-12-01T11:01:00Z",
                  "EndAt": "9999-12-08T11:00:00Z",
                  "Rooms": [
                    {
                      "RoomId": 7243703403195289000,
                      "RoomName": "WinterAlmonds",
                      "ImageName": "96w7irfsiucisrei9fsmhipqn.jpg",
                      "IsRecRoomApproved": false,
                      "ExcludeFromLists": false,
                      "ExcludeFromSearch": false
                    }
                  ]
                }
            */

            // Build the ONE shared featured group from FeaturedRoomsStore (admin-curated, same
            // list the website reads). Skips ids whose room no longer exists. Returned as an ARRAY
            // of groups (what the client expects - the old placeholder was an empty array too).
            var featuredRooms = new List<object>();
            foreach (var rid in Campus_live_rewrite.api.server.FeaturedRoomsStore.GetIds())
            {
                var r = RoomDB.GetRoom(rid);
                if (r == null || r.IsDorm) continue;
                featuredRooms.Add(new
                {
                    RoomId = r.RoomId,
                    RoomName = r.Name ?? "",
                    ImageName = r.ImageName ?? "",   // client's DTO wants a string, never null
                    IsRecRoomApproved = r.IsRecRoomApproved,
                    ExcludeFromLists = false,
                    ExcludeFromSearch = false,
                });
            }

            // A SINGLE group object (FeaturedRoomGroupDto), NOT an array - that's what the client's
            // deserializer for this call expects (confirmed against the reference server). Wrapping
            // it in an array made the client fail to parse it, so the in-game Featured Room was blank.
            var group = new
            {
                FeaturedRoomGroupId = 1,
                name = "Featured Rooms",
                StartAt = "2025-01-01T00:00:00Z",
                EndAt = "9999-12-31T00:00:00Z",
                Rooms = featuredRooms,
            };

            return new ContentResult()
            {
                Content = JsonConvert.SerializeObject(group),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpPost("rooms/{roomid}/subrooms")]
        public ContentResult CreateSubroomForRoom(ulong roomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            string SubroomName = HttpContext.Request.Form["name"].ToString();
            Uri.UnescapeDataString(SubroomName);

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomid);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }
            if (room_data.IsDorm == true)
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You cannot create a subroom for your dorm room!");
            }

            bool CheckSwears = !string.IsNullOrEmpty(SubroomName) && Sanitize.ContainsSwears(SubroomName);
            if (CheckSwears)
            {
                return Utils.ErrorRoom("Rooms.NoSwearWords", "Your subroom name contains swear words!");
            }

            RoomDBClasses.RoomRoot temp = RoomDB.CreateSubroomForRoom(roomid, SubroomName);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomid);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [HttpDelete("rooms/{roomid}/subrooms/{subroomid}")]
        public ContentResult DeleteSubroom(ulong roomid, ulong subroomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomid);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            bool success = RoomDB.DeleteSubroom(roomid, subroomid);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomid);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        // POST rooms/{id}/subrooms/{sid}/clone - a copy of the subroom (fresh SubRoomId, same
        // scene / settings / saves) in the same room. Owner or co-owner. Answers the updated ROOM
        // in the envelope, like create/delete - the client re-renders its subroom list from value.
        [HttpPost("rooms/{roomid}/subrooms/{subroomid}/clone")]
        public ContentResult CloneSubroom(ulong roomid, ulong subroomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room_data = RoomDB.GetRoom(roomid);
            if (room_data == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            if (room_data.IsDorm == true) return Utils.ErrorRoom("Rooms.PermissionDenied", "You cannot clone a dorm subroom!");
            var cloned = RoomDB.CloneSubroom(roomid, subroomid);
            if (cloned == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This subroom does not exist!");
            Console.WriteLine($"[rooms] {account!.Id} cloned subroom {subroomid} of room {roomid} -> {cloned.SubRoomId}");
            var updated = RoomDB.GetRoom(roomid);
            Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate(account.Id, updated);
            return new ContentResult { Content = JsonConvert.SerializeObject(new { success = true, error = "", value = updated }), ContentType = "application/json", StatusCode = 200 };
        }

        // POST rooms/{id}/subrooms/{sid}/move - reorder a subroom in the room's list. The
        // position comes as index / newIndex / position (0-based) or direction (up/down). Shape
        // unpinned; every field is logged so it can be.
        [HttpPost("rooms/{roomid}/subrooms/{subroomid}/move")]
        [HttpPut("rooms/{roomid}/subrooms/{subroomid}/move")]
        public ContentResult MoveSubroom(ulong roomid, ulong subroomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room_data = RoomDB.GetRoom(roomid);
            if (room_data == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            var f = Campus_live_rewrite.api.server.RoomModeration.Fields(Request);
            Console.WriteLine($"[rooms] {account!.Id} move subroom {subroomid} of {roomid}: {Campus_live_rewrite.api.server.RoomModeration.Dump(f)}");
            string[] idxKeys = { "index", "newIndex", "position", "toIndex", "targetIndex" };
            long idx = idxKeys.Any(k => f.ContainsKey(k)) ? Campus_live_rewrite.api.server.RoomModeration.Long(f, idxKeys) : -1;
            string dir = (Campus_live_rewrite.api.server.RoomModeration.Str(f, "direction", "dir") ?? "").ToLowerInvariant();
            var subs = room_data.SubRooms ?? new List<RoomDBClasses.SubRoom>();
            int cur = subs.FindIndex(x => x.SubRoomId == subroomid);
            if (cur < 0) return Utils.ErrorRoom("Rooms.DoesntExist", "This subroom does not exist!");
            int to = idx >= 0 ? (int)Math.Min(idx, subs.Count - 1) : dir == "up" ? Math.Max(0, cur - 1) : dir == "down" ? Math.Min(subs.Count - 1, cur + 1) : cur;
            if (to != cur)
            {
                var item = subs[cur]; subs.RemoveAt(cur); subs.Insert(to, item);
                RoomDB.ReorderSubrooms(roomid, subs.Select(x => x.SubRoomId).ToList());
            }
            var updated = RoomDB.GetRoom(roomid);
            return new ContentResult { Content = JsonConvert.SerializeObject(new { success = true, error = "", value = updated }), ContentType = "application/json", StatusCode = 200 };
        }

        // POST rooms/{id}/subrooms/{sid}/publish_save - make the save named by the
        // subRoomDataSaveId form field the one players load (its CurrentSave). Saves here are
        // never staged, so this is the "restore an older save" half of the reference's route.
        // Owner-only, like the reference. Answers the updated ROOM in the envelope.
        [HttpPost("rooms/{roomid}/subrooms/{subroomid}/publish_save")]
        public ContentResult PublishSubroomSave(ulong roomid, ulong subroomid)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room_data = RoomDB.GetRoom(roomid);
            if (room_data == null) return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            var f = Campus_live_rewrite.api.server.RoomModeration.Fields(Request);
            long saveId = Campus_live_rewrite.api.server.RoomModeration.Long(f, "subRoomDataSaveId", "SubRoomDataSaveId", "saveId", "id");
            if (saveId <= 0) return Utils.ErrorRoom("Rooms.InvalidSave", "You must provide a valid save!");
            if (!RoomDB.PublishSubroomSave(roomid, subroomid, (ulong)saveId))
                return Utils.ErrorRoom("Rooms.DoesntExist", "That save does not exist!");
            Console.WriteLine($"[rooms] {account!.Id} published save {saveId} on subroom {subroomid} of room {roomid}");
            var updated = RoomDB.GetRoom(roomid);
            Campus_live_rewrite.api.server.RoomPermissions.PushRoomUpdate(account.Id, updated);
            return new ContentResult { Content = JsonConvert.SerializeObject(new { success = true, error = "", value = updated }), ContentType = "application/json", StatusCode = 200 };
        }

        [HttpPut("rooms/{roomid}/subrooms/{subroomid}/modify")]
        public ContentResult ModifySubroom(ulong roomid, ulong subroomid, [FromForm] string name, RoomDBClasses.RoomAccessibility accessibility, int maxPlayers = 32)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            RoomDBClasses.RoomRoot room_data = RoomDB.GetRoom(roomid);

            if (room_data == null)
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
            if (room_data.CreatorAccountId != account?.Id && !RoomDB.IsCoOwner(room_data, account?.Id ?? 0))
            {
                return Utils.ErrorRoom("Rooms.PermissionDenied", "You are not the owner of this room!");
            }

            bool success = RoomDB.ModifySubroom(roomid, subroomid, name, accessibility, maxPlayers);
            RoomDBClasses.RoomRoot UpdatedRoom = RoomDB.GetRoom(roomid);
            if (UpdatedRoom != null)
            {
                return new ContentResult()
                {
                    Content = JsonConvert.SerializeObject(new
                    {
                        success = true,
                        error = "",
                        value = UpdatedRoom
                    }),
                    ContentType = "application/json",
                    StatusCode = 200
                };
            }
            else
            {
                return Utils.ErrorRoom("Rooms.DoesntExist", "This room does not exist!");
            }
        }

        [Route("unity_assets/{guid}/{target}/{version}")]
        public IActionResult GetUnityAssets(string guid, int target, int version)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return Ok(new
            {
                UnityAssetId = guid,
                Target = target,
                Version = version,
                Filename = $"{guid}.assetbundle",
                Hash = (string?)null
            });
        }

        // Rooms 2.0 rooms resolve their pre-baked mesh assetbundles here. Rec Room generated those
        // bundles at publish time on its own backend, so we DON'T have them for imported (or most)
        // rooms - and returning 404 hard-fails the load with "Error downloading room assets (Code
        // 8715)". The client can BAKE geometry at runtime from the raw shape data in the .room blob
        // (GatherBakedPrimitiveDataJob / GatherBakedSplineDataJob), so the right answer for an id we
        // have no baked bundles for is a VALID, EMPTY result - never a 404. When we DO have a cached
        // BakedBulk/<id>_assets.json (base rooms), we return it.
        [Route("/Room_server/unity_assets/baked/bulk")]
        public async Task<IActionResult> GetUnityAssetsBakedBulk()
        {
            // The request carries one or more asset ids. Accept every shape the client might use:
            // repeated/comma form field(s), query, or a JSON body (array, {ids:[...]}, or {id:...}).
            var ids = new List<string>();
            void AddCsv(string? s) { if (!string.IsNullOrWhiteSpace(s)) ids.AddRange(s.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim())); }

            try
            {
                if (Request.HasFormContentType)
                {
                    foreach (var k in new[] { "id", "ids", "Id", "Ids", "assetId", "assetIds" })
                        foreach (var v in Request.Form[k]) AddCsv(v);
                }
            }
            catch { }
            foreach (var k in new[] { "id", "ids" })
                foreach (var v in Request.Query[k]) AddCsv(v);

            string rawBody = "";
            if (ids.Count == 0)
            {
                try
                {
                    Request.EnableBuffering();
                    Request.Body.Position = 0;
                    using var reader = new StreamReader(Request.Body, leaveOpen: true);
                    rawBody = await reader.ReadToEndAsync();
                    Request.Body.Position = 0;
                    if (!string.IsNullOrWhiteSpace(rawBody))
                    {
                        var node = JsonNode.Parse(rawBody);
                        if (node is JsonArray ja) foreach (var n in ja) { if (n != null) AddCsv(n.ToString()); }
                        else if (node is JsonObject jo)
                        {
                            foreach (var key in new[] { "ids", "id", "Ids", "Id", "assetIds", "assetId" })
                                if (jo[key] is JsonArray a2) foreach (var n in a2) { if (n != null) AddCsv(n.ToString()); }
                                else if (jo[key] != null) AddCsv(jo[key]!.ToString());
                        }
                        else if (node != null) AddCsv(node.ToString());
                    }
                }
                catch { }
            }

            ids = ids.Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
            Console.WriteLine($"[baked/bulk] method={Request.Method} ct={Request.ContentType} ids=[{string.Join(",", ids)}] rawBody={(rawBody.Length > 300 ? rawBody.Substring(0, 300) : rawBody)}");

            // Build one group per requested id: its cached baked bundles if we have them, else empty
            // (client runtime-bakes). If we couldn't parse any id, still return an empty array (200).
            string dir = Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "BakedBulk");
            var groups = new List<object>();
            foreach (var id in ids)
            {
                JsonArray? baked = null;
                try
                {
                    string path = Path.Combine(dir, $"{id}_assets.json");
                    if (System.IO.File.Exists(path)) baked = JsonNode.Parse(System.IO.File.ReadAllText(path)) as JsonArray;
                }
                catch { }
                groups.Add(new
                {
                    UnityAssetId = id,
                    CreatedByAccountId = 1,
                    BakedUnityAssets = (object?)baked ?? new JsonArray(),
                    SubAssets = new List<object>(),
                    SourceAssetId = (string?)null
                });
            }

            return Ok(groups);
        }

        [HttpGet("/Room_server/publishState/configs")]
        public IActionResult GetPublishStateConfigs()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            /*
             {
                  "value": {
                    "UpdateMaxCount": 3,
                    "UpdateRollingWindowInDays": 365,
                    "UpdateExpirationInDays": 30,
                    "UpdateCooldownInDays": 45
                  },
                  "success": true,
                  "error_id": null,
                  "error": null
                } 
             */

            return Ok(new
            {
                value = new
                {
                    UpdateMaxCount = 3,
                    UpdateRollingWindowInDays = 365,
                    UpdateExpirationInDays = 30,
                    UpdateCooldownInDays = 45
                },
                success = true,
                error_id = (string?)null,
                error = (string?)null
            });
        }

        [HttpGet("/Room_server/dormroom/me")]
        public IActionResult GetMyDormRoom()
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var FullAccount = PlayerDB.GetFullAccount(account.Id);

            return Ok(FullAccount.player_Extra.DormRoomID);
        }

        // Rooms like this one: the paged {Results, TotalResults} shape the room lists use, from
        // shared tags (then the hot list). Answered "[]" before - the client's "Malformed
        // Response: '[]'" and "Error refreshing rooms from source RoomSimilarity" every room load.
        [HttpGet("/Room_server/rooms/{roomId}/similar")]
        public ContentResult SimilarRooms(ulong roomId, int skip = 0, int take = 30)
        {
            var seed = RoomDB.GetRoom(roomId);
            var tags = new HashSet<string>((seed?.Tags ?? new()).Select(t => (t.Tag ?? "").ToLowerInvariant()).Where(t => t.Length > 0 && t != "rro" && t != "base" && t != "recroomoriginal"));
            var pool = RoomDB.GetHotRooms().Where(r => r.RoomId != roomId && !r.IsDorm && RoomDB.IsRoomListed(r) && !RoomDB.IsRecRoomOriginal(r)).ToList();
            var ranked = pool
                .Select(r => (room: r, shared: (r.Tags ?? new()).Count(t => tags.Contains((t.Tag ?? "").ToLowerInvariant()))))
                .OrderByDescending(x => x.shared)
                .ThenByDescending(x => x.room.Stats?.CheerCount ?? 0)
                .ThenByDescending(x => x.room.Stats?.VisitCount ?? 0)
                .Select(x => x.room)
                .ToList();
            var page = ranked.Skip(Math.Max(0, skip)).Take(Math.Clamp(take, 1, 100)).ToList();
            RoomDB.AttachSubRooms(page);
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(new RoomDBClasses.Resultslist<RoomDBClasses.RoomRoot>
                {
                    Results = StripUnservableSaves(VisibleTo(page, ViewerId())),
                    TotalResults = ranked.Count
                }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        // Room leaderboard slots (Room Settings -> Leaderboards). A configure / clear is
        // acknowledged; nothing stores slots yet. DELETE 405'd before.
        [HttpGet("/Room_server/rooms/{roomId}/leaderboards/{leaderboardId}")]
        public ContentResult RoomLeaderboard(ulong roomId, int leaderboardId) =>
            new ContentResult { Content = "[]", ContentType = "application/json", StatusCode = 200 };
        [HttpPost("/Room_server/rooms/{roomId}/leaderboards/{leaderboardId}")]
        [HttpPut("/Room_server/rooms/{roomId}/leaderboards/{leaderboardId}")]
        [HttpDelete("/Room_server/rooms/{roomId}/leaderboards/{leaderboardId}")]
        public IActionResult RoomLeaderboardWrite(ulong roomId, int leaderboardId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            if (!RoomDB.UserCanEditRoom(roomId, account.Id)) return StatusCode(403, "");
            Console.WriteLine($"[leaderboard] {Request.Method} room {roomId} slot {leaderboardId} by {account.Id}");
            return Ok(new { success = true, error = "", value = (object?)null });
        }

        // The room's XP settings write (Room Settings -> Experience) - echoes what GET answers.
        [HttpPost("/Room_server/rooms/{roomId}/experience")]
        [HttpPut("/Room_server/rooms/{roomId}/experience")]
        public IActionResult SetExperienceForRoom(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            return Ok(new { DailyLimit = 1000000, Enabled = false, RoomExperienceId = 0 });
        }

        [HttpGet("/Room_server/rooms/{roomId}/experience")]
        public IActionResult GetExperienceForRoom(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return Ok(new
            {
                DailyLimit = 1000000,
                Enabled = false,
                RoomExperienceId = 0
            });
        }

        [HttpGet("/Room_server/rooms/{roomId}/experience/player")]
        public IActionResult GetPlayerExperienceInRoom(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            return Ok(new
            {
                Enabled = false,
                Experience = (object?)null,
                ConcurrencyCode = (string?)null
            });
        }

        // Whether a player is banned from a room - read from the same bans the join gates refuse
        // on, so it answers what would actually happen. Was a constant false, which is why the
        // client offered "ban" on someone already banned and never showed "unban".
        [HttpGet("/Room_server/rooms/{roomId}/bans/{playerId}/isBanned")]
        public IActionResult GetIsBanned(ulong roomId, ulong playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var room = RoomDB.GetRoom(roomId);
            return Ok(new
            {
                success = true,
                error = (string?)null,
                error_id = (string?)null,
                value = room != null && RoomDB.PlayerIsBannedFrom(room, playerId)
            });
        }

        private ContentResult BanEnvelope(RoomDBClasses.RoomBanDetails? ban, ulong roomId, string error = "") => new ContentResult
        {
            Content = JsonConvert.SerializeObject(new
            {
                success = ban != null,
                error,
                value = ban == null ? null : new
                {
                    RoomId = (long)roomId,
                    BannedPlayerId = ban.AccountId,
                    BanMask = 0,
                    BannedByAccountId = ban.BannedByAccountId,
                    CreatedAt = ban.BanStartTime
                }
            }),
            ContentType = "application/json",
            StatusCode = 200
        };

        // The room's active bans (Room Settings -> Moderation), newest first. camelCase entries
        // (reference: RoomBanEntryDto). Was a constant empty list.
        [HttpGet("/Room_server/rooms/{roomId}/bans")]
        public IActionResult GetRoomBans(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room = RoomDB.GetRoom(roomId);
            if (room == null) return Ok(Array.Empty<object>());
            return Ok(RoomDB.ActiveRoomBans(room).Select(b => new
            {
                accountId = b.AccountId,
                bannedByAccountId = b.BannedByAccountId,
                banStartTime = b.BanStartTime
            }));
        }

        // Ban a player from the room (form: id, banMask, and optionally reason / duration in
        // seconds). The room's owners, its moderators, or staff. The banned player gets the
        // ModerationKick frame their client leaves on, is moved out of the instance, and the
        // matchmaker refuses them until the ban is lifted. Answers {success,error,value:ban}.
        [HttpPost("/Room_server/rooms/{roomId}/bans")]
        [HttpPut("/Room_server/rooms/{roomId}/bans")]
        public IActionResult BanFromRoom(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;

            var room = RoomDB.GetRoom(roomId);
            if (room == null) return BanEnvelope(null, roomId, "This room does not exist!");
            if (!RoomDB.CanModerateRoom(room, account.Id)) return StatusCode(403, "");

            var f = RoomModeration.Fields(Request);
            ulong target = RoomModeration.ULong(f, "id", "accountId", "playerId", "bannedPlayerId");
            if (target == 0) return BanEnvelope(null, roomId, "You must provide a valid player to ban!");
            if (target == account.Id) return BanEnvelope(null, roomId, "You cannot ban yourself!");
            if (room.CreatorAccountId == target || RoomDB.IsCoOwner(room, target))
                return BanEnvelope(null, roomId, "You cannot ban an owner of this room!");
            if (PlayerDB.CheckDevFlag(target) && !PlayerDB.CheckDevFlag(account.Id))
                return BanEnvelope(null, roomId, "You cannot ban a staff member!");

            long seconds = RoomModeration.Long(f, "duration", "durationSeconds", "banDuration");
            string reason = RoomModeration.Str(f, "reason", "message", "displayReason") ?? "";
            var ban = RoomDB.BanFromRoom(roomId, target, account.Id, reason, seconds > 0 ? TimeSpan.FromSeconds(seconds) : null);
            if (ban == null) return BanEnvelope(null, roomId, "Could not ban that player.");

            bool isHostKick = room.CreatorAccountId == account.Id || RoomDB.IsCoOwner(room, account.Id);
            // isBan stays FALSE on the kick frame: `IsBan: true` is what the client renders as a ban
            // from the whole GAME (reference rooms POST /bans). The room ban itself is the stored row
            // the matchmaker refuses on (BannedFromRoom, 55); the frame only makes them leave.
            RoomModeration.RemoveFromRoom(target, roomId, 0, $"You have been banned from {room.Name}.", account.Id, isBan: false, isHostKick: isHostKick);
            ModerationLogDB.Record("roomban", target, account.Id, roomId, 0, seconds, ReportCategory.Moderator, reason);
            return BanEnvelope(ban, roomId);
        }

        // Lift a room ban. Answers the closed ban in the same envelope. Lifting also clears any
        // kick block the player has on the room's instances, so "unban" always means "let them
        // back in".
        [HttpDelete("/Room_server/rooms/{roomId}/bans/{playerId:long}")]
        [HttpPost("/Room_server/rooms/{roomId}/bans/{playerId:long}/unban")]
        public IActionResult UnbanFromRoom(ulong roomId, ulong playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room = RoomDB.GetRoom(roomId);
            if (room == null) return BanEnvelope(null, roomId, "This room does not exist!");
            if (!RoomDB.CanModerateRoom(room, account.Id)) return StatusCode(403, "");
            int lifted = InstanceBlocks.Clear(playerId, (long)roomId);
            var ban = RoomDB.UnbanFromRoom(roomId, playerId, account.Id);
            if (ban == null && lifted == 0) return BanEnvelope(null, roomId, "This player is not banned from this room!");
            if (ban == null)
                ban = new RoomDBClasses.RoomBanDetails { AccountId = (long)playerId, BannedByAccountId = 0, BanStartTime = DateTime.UtcNow, Status = 2, UnbannedByAccountId = (long)account.Id, Reason = "" };
            ModerationLogDB.Record("roomunban", playerId, account.Id, roomId, 0, 0, ReportCategory.Moderator, "");
            return BanEnvelope(ban, roomId);
        }

        // The 2025 client's bulk forms of the two calls above: DELETE rooms/{id}/bans/bulk lifts
        // the bans on every id given (form / JSON / query: ids, accountIds, playerIds, id);
        // POST / PUT bans/bulk issues them. DELETE used to fall into the single-player route with
        // playerId = 0 and answer "This player is not banned from this room!" (Player.log:
        // LLCLDPPAGIJ) whatever was asked. Answers the ban envelope with a list as its value.
        [HttpDelete("/Room_server/rooms/{roomId}/bans/bulk")]
        [HttpPost("/Room_server/rooms/{roomId}/bans/bulk/unban")]
        public IActionResult UnbanBulk(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room = RoomDB.GetRoom(roomId);
            if (room == null) return BanEnvelope(null, roomId, "This room does not exist!");
            if (!RoomDB.CanModerateRoom(room, account.Id)) return StatusCode(403, "");
            var f = RoomModeration.Fields(Request);
            var ids = RoomModeration.ULongs(f, "ids", "accountIds", "playerIds", "bannedPlayerIds", "id", "accountId", "playerId");
            Console.WriteLine($"[roomban] bulk unban on room {roomId} by {account.Id}: {RoomModeration.Dump(f)}");
            if (ids.Count == 0) return BanEnvelope(null, roomId, "You must provide a valid player to unban!");
            var rows = new List<object>();
            foreach (var pid in ids)
            {
                int lifted = InstanceBlocks.Clear(pid, (long)roomId);
                var ban = RoomDB.UnbanFromRoom(roomId, pid, account.Id);
                if (ban == null && lifted == 0) continue;
                ModerationLogDB.Record("roomunban", pid, account.Id, roomId, 0, 0, ReportCategory.Moderator, "");
                rows.Add(new { RoomId = (long)roomId, BannedPlayerId = (long)pid, BanMask = 0, BannedByAccountId = ban?.BannedByAccountId ?? 0, CreatedAt = ban?.BanStartTime ?? DateTime.UtcNow });
            }
            if (rows.Count == 0) return BanEnvelope(null, roomId, "This player is not banned from this room!");
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(new { success = true, error = "", value = rows }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpPost("/Room_server/rooms/{roomId}/bans/bulk")]
        [HttpPut("/Room_server/rooms/{roomId}/bans/bulk")]
        public IActionResult BanBulk(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null) return error;
            var room = RoomDB.GetRoom(roomId);
            if (room == null) return BanEnvelope(null, roomId, "This room does not exist!");
            if (!RoomDB.CanModerateRoom(room, account.Id)) return StatusCode(403, "");
            var f = RoomModeration.Fields(Request);
            var ids = RoomModeration.ULongs(f, "ids", "accountIds", "playerIds", "bannedPlayerIds", "id", "accountId", "playerId");
            Console.WriteLine($"[roomban] bulk ban on room {roomId} by {account.Id}: {RoomModeration.Dump(f)}");
            if (ids.Count == 0) return BanEnvelope(null, roomId, "You must provide a valid player to ban!");
            long seconds = RoomModeration.Long(f, "duration", "durationSeconds", "banDuration");
            string reason = RoomModeration.Str(f, "reason", "message", "displayReason") ?? "";
            bool isHostKick = room.CreatorAccountId == account.Id || RoomDB.IsCoOwner(room, account.Id);
            var rows = new List<object>();
            foreach (var pid in ids)
            {
                if (pid == account.Id || room.CreatorAccountId == pid || RoomDB.IsCoOwner(room, pid)) continue;
                if (PlayerDB.CheckDevFlag(pid) && !PlayerDB.CheckDevFlag(account.Id)) continue;
                var ban = RoomDB.BanFromRoom(roomId, pid, account.Id, reason, seconds > 0 ? TimeSpan.FromSeconds(seconds) : null);
                if (ban == null) continue;
                RoomModeration.RemoveFromRoom(pid, roomId, 0, $"You have been banned from {room.Name}.", account.Id, isBan: false, isHostKick: isHostKick);
                ModerationLogDB.Record("roomban", pid, account.Id, roomId, 0, seconds, ReportCategory.Moderator, reason);
                rows.Add(new { RoomId = (long)roomId, BannedPlayerId = ban.AccountId, BanMask = 0, BannedByAccountId = ban.BannedByAccountId, CreatedAt = ban.BanStartTime });
            }
            if (rows.Count == 0) return BanEnvelope(null, roomId, "Could not ban that player.");
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(new { success = true, error = "", value = rows }),
                ContentType = "application/json",
                StatusCode = 200
            };
        }

        [HttpGet("/Room_server/rooms/{roomId}/playerdata/me")]
        public IActionResult GetMyPlayerData(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var data = PlayerDB.GetPlayerData(account.Id, roomId);
            // The client expects a JSON body from this endpoint — 404 makes it treat the whole
            // room-join as "failed to fetch player state" and bounce. Return an empty payload
            // when there's no stored state yet (fresh player, never visited this room).
            return Ok(new
            {
                Data = data ?? ""
            });
        }

        [HttpPut("/Room_server/rooms/{roomId}/playerdata/me")]
        public IActionResult SetMyPlayerData(ulong roomId, [FromForm] string data)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            bool success = PlayerDB.SetPlayerData(account.Id, roomId, data);
            if (!success)
            {
                return BadRequest();
            }
            
            Console.WriteLine("Was updating playerdata successful: " + success);

            return NoContent();
        }

        [HttpGet("/Room_server/rooms/{roomId}/boosts/{playerId}/count")]
        public IActionResult GetBoostCountForRoom(ulong roomId, ulong playerId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            
            return Ok("0");
        }

        [HttpGet("/Room_server/rooms/{roomId}/assets")]
        public IActionResult GetRoomAssets(ulong roomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;
            
            return Ok(new
            {
                success = true,
                error = (string?)null,
                error_id = (string?)null,
                value = Array.Empty<object>()
            });
        }

        // https://rooms.rec.net/rooms/1089513655118942017/snapshots/ade3aee2-e469-4445-728b-08de39979f5f/loadinfo?subRoomId=1384652020053214301
        [HttpGet("/Room_server/rooms/{roomId}/snapshots/{snapshotId}/loadinfo")]
        public IActionResult GetRoomAssets(ulong roomId, string snapshotId, [FromQuery] ulong subRoomId)
        {
            var (account, error) = AuthHelper.ValidateToken(HttpContext);
            if (error != null)
                return error;

            var room = RoomDB.GetRoom(roomId);
            if (room == null) return NotFound();
            var subRoom = room.SubRooms?.FirstOrDefault(sr => sr.SubRoomId == subRoomId);
            
            return Ok(new
            {
                success = true,
                error = (string?)null,
                error_id = (string?)null,
                value = new
                {
                    Assets = Array.Empty<object>(),
                    RoomId = roomId,
                    SnapshotId = snapshotId,
                    SubRoom = new
                    {
                        SubRoomDataSaveId = subRoom?.CurrentSave?.SubRoomDataSaveId
                    },
                    SubRoomId = subRoomId,
                    UgcSubVersion = room.UgcSubVersion,
                    UgcVersion = room.UgcVersion
                }
            });
        }
    }
}