using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Text.Json;
using System.Threading.Tasks;
using System.Threading.RateLimiting;
using Mocha2023.Classes;
using Mocha2023.Classes.DBs;
using Mocha2023.Classes.DBs.DBClasses;
using Mocha2023.Controllers;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.RateLimiting;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using static Mocha2023.Classes.DBs.DBClasses.PlayerDBClasses;
using JsonSerializer = System.Text.Json.JsonSerializer;

// Modified by @mechanicalize on Discord.
// Original codebase by @nito9999.
// Repository: https://github.com/nito9999/Mocha-2023
// Target client: Rec Room 20230406.
// Licensed under the MIT License.

namespace Mocha2023
{

    public sealed class DualTextWriter : TextWriter
    {
        private readonly TextWriter _console;
        private readonly StreamWriter _file;
        private readonly object _sync = new();

        public DualTextWriter(TextWriter console, StreamWriter file)
        {
            _console = console;
            _file = file;
        }

        public override Encoding Encoding => _console.Encoding;

        public override void Write(char value)
        {
            lock (_sync)
            {
                _console.Write(value);
                _file.Write(value);
            }
        }

        public override void Write(string? value)
        {
            lock (_sync)
            {
                _console.Write(value);
                _file.Write(value);
                _file.Flush();
            }
        }

        public override void WriteLine(string? value)
        {
            lock (_sync)
            {
                _console.WriteLine(value);
                _file.WriteLine($"[{DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC] {value}");
                _file.Flush();
            }
        }
    }

    internal static class ServerLog
    {
        private static readonly object Sync = new();

        public static void Info(string message) => Write("INFO", message, ConsoleColor.Cyan);
        public static void Success(string message) => Write("OK", message, ConsoleColor.Green);
        public static void Warning(string message) => Write("WARN", message, ConsoleColor.Yellow);
        public static void Error(string message) => Write("ERROR", message, ConsoleColor.Red);

        public static void Http(
            int statusCode,
            string method,
            string path,
            long elapsedMilliseconds,
            Exception? exception = null)
        {
            ConsoleColor color = statusCode switch
            {
                >= 500 => ConsoleColor.Red,
                >= 400 => ConsoleColor.Yellow,
                >= 300 => ConsoleColor.Cyan,
                >= 200 => ConsoleColor.Green,
                _ => ConsoleColor.Gray
            };

            string suffix = exception == null
                ? string.Empty
                : $" | {exception.GetType().Name}: {exception.Message}";

            WriteRaw(
                $"[{statusCode}] {method,-7} {path} ({elapsedMilliseconds} ms){suffix}",
                color
            );
        }

        private static void Write(string tag, string message, ConsoleColor color)
        {
            WriteRaw($"[{tag}] {message}", color);
        }

        private static void WriteRaw(string message, ConsoleColor color)
        {
            lock (Sync)
            {
                ConsoleColor previousColor = Console.ForegroundColor;

                try
                {
                    Console.ForegroundColor = color;
                    Console.WriteLine(message);
                }
                finally
                {
                    Console.ForegroundColor = previousColor;
                }
            }
        }
    }

    public class Program
    {
        private static readonly string ServerUrl =
            Environment.GetEnvironmentVariable("MOCHA_SERVER_URL") ??
            "https://localhost:443";
        private static readonly string SERVERSTATWEB = LoadLocalSetting("SERVERSTATWEB");

        internal static string LoadLocalSetting(string settingName)
        {
            string? environmentValue = Environment.GetEnvironmentVariable(settingName);
            if (!string.IsNullOrWhiteSpace(environmentValue))
            {
                return environmentValue.Trim();
            }

            string envPath = Path.Combine(Directory.GetCurrentDirectory(), ".env");
            if (!File.Exists(envPath))
            {
                return string.Empty;
            }

            foreach (string line in File.ReadLines(envPath))
            {
                string trimmedLine = line.Trim();
                if (trimmedLine.Length == 0 || trimmedLine.StartsWith('#'))
                {
                    continue;
                }

                int separatorIndex = trimmedLine.IndexOf('=');
                if (separatorIndex <= 0)
                {
                    continue;
                }

                string key = trimmedLine[..separatorIndex].Trim();
                if (string.Equals(key, settingName, StringComparison.OrdinalIgnoreCase))
                {
                    return trimmedLine[(separatorIndex + 1)..].Trim().Trim('"', '\'');
                }
            }

            return string.Empty;
        }

        private static readonly HttpClient ServerStatusHttpClient = new()
        {
            Timeout = TimeSpan.FromSeconds(8)
        };

        private static DateTimeOffset _serverStartedAt;
        private static int _serverIsOnline;
        private static int _offlineWebhookSent;

        public static string dataDir = Path.Combine(
            Directory.GetCurrentDirectory(),
            "Data"
        );

        // Set from builder.Environment.WebRootPath in Main - the framework's
        // own resolved wwwroot path, not a guess based on CWD/BaseDirectory
        // (which RecNetController.Serve() used to do and got wrong on the
        // container).
        public static string wwwRootDir = string.Empty;

        private static readonly string[] RequiredDirectories =
        {
            "DBs",
            "Images",
            Path.Combine("Images", "PlayerImages"),
            Path.Combine("Images", "CustomPFPS"),
            Path.Combine("Images", "PolaroidImages"),
            Path.Combine("Images", "RemoteLoadingScreens"),
            Path.Combine("Images", "EventImages"),
            Path.Combine("Images", "CommunityBoardUploads"),
            "CommunityBoardUploads",
            Path.Combine("CDN", "video"),
            Path.Combine("CDN", "DataBlobs"),
            Path.Combine("CDN", "InventionBlobs"),
            Path.Combine("CDN", "RoomBlobs"),
            "Imports",
            "Debug"
        };

        private sealed class ConsoleInputGuard
        {
            private readonly TextWriter _promptWriter;
            private readonly TextWriter _logWriter;

            public ConsoleInputGuard(
                TextWriter promptWriter,
                TextWriter logWriter)
            {
                _promptWriter = promptWriter;
                _logWriter = logWriter;
            }

            public string ReadLine()
            {
                _promptWriter.Write("> ");

                string line = Console.ReadLine()?.Trim() ?? string.Empty;

                if (!string.IsNullOrWhiteSpace(line))
                {
                    _logWriter.WriteLine($"[CMD] {line}");
                }

                return line;
            }
        }

        public static async Task Main(string[] args)
        {
            TextWriter originalConsole = Console.Out;
            string logFilePath = InitializeFileLogging(originalConsole);
            var consoleInput = new ConsoleInputGuard(originalConsole, Console.Out);

            ServerLog.Info($"Debug log: {logFilePath}");

            EnsureDataDirectories();

            WebApplication? app = null;
            bool serverStarted = false;
            string shutdownReason = "Server stopped normally";

            try
            {
                WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
                wwwRootDir = builder.Environment.WebRootPath;
                ConfigureFrameworkLogging(builder);
                ConfigureServices(builder);

                app = builder.Build();

                NotiController.Initialize(
                    app.Services.GetRequiredService<IHubContext<NotificationHub>>());

                await ImportBaseRoomsAsync();
                int orphanedDormsRemoved = RoomDB.RemoveOrphanedPlayerDorms();
                ServerLog.Info($"Orphaned player dorms removed: {orphanedDormsRemoved}");
                int dormsCreated = RoomDB.EnsurePlayerDormsForAllPlayers();
                ServerLog.Info($"Player dorm ownership: created={dormsCreated}");
                EnforceRRPlusForExistingPlayers();
                int socialAccountsUpdated = PlayerDB.EnsureSocialDefaultsForAllPlayers();
                ServerLog.Info($"Social defaults: updated={socialAccountsUpdated}");
                int tokenAccountsUpdated = PlayerDB.EnsureInitialTokensForAllPlayers();
                ServerLog.Info(
                    $"Initial token grant: updated={tokenAccountsUpdated}, " +
                    $"amount={PlayerDB.InitialTokenBalance}");
                int alpacaOwnershipsRemoved =
                    PlayerDB.ResetAlpacaShirtOwnershipForExistingPlayers();
                ServerLog.Info(
                    $"Alpaca Shirt ownership reset: removed={alpacaOwnershipsRemoved}");
                ConfigureRequestPipeline(app);

                app.Urls.Add(ServerUrl);
                await app.StartAsync();

                serverStarted = true;
                _serverStartedAt = DateTimeOffset.UtcNow;
                Volatile.Write(ref _serverIsOnline, 1);
                RegisterShutdownWebhookHandlers();

                ServerLog.Success($"Server listening on {ServerUrl}");
                ServerLog.Info("Type 'help' to view console commands.");

                Mocha2023.Cloudflare.StartCloudflared();

                await SendServerOnlineWebhookAsync();
                await RunConsoleLoopAsync(app, consoleInput);
            }
            catch (Exception ex)
            {
                shutdownReason = $"Unexpected shutdown: {ex.GetType().Name}";
                ServerLog.Error($"Fatal server error: {ex.GetType().Name}: {ex.Message}");
                throw;
            }
            finally
            {
                if (serverStarted)
                {
                    await SendServerOfflineWebhookOnceAsync(shutdownReason);
                }

                if (app != null)
                {
                    await app.DisposeAsync();
                }
            }
        }

        private static bool HasServerStatusWebhook()
        {
            return !string.IsNullOrWhiteSpace(SERVERSTATWEB) &&
                   !SERVERSTATWEB.Contains(
                       "PASTE_DISCORD_WEBHOOK_HERE",
                       StringComparison.OrdinalIgnoreCase);
        }

        private static void RegisterShutdownWebhookHandlers()
        {
            Console.CancelKeyPress += (_, _) =>
            {
                try
                {
                    SendServerOfflineWebhookOnceAsync("Server stopped with Ctrl+C")
                        .GetAwaiter()
                        .GetResult();
                }
                catch
                {

                }
            };

            AppDomain.CurrentDomain.ProcessExit += (_, _) =>
            {
                try
                {
                    SendServerOfflineWebhookOnceAsync("Server process exited")
                        .GetAwaiter()
                        .GetResult();
                }
                catch
                {

                }
            };
        }

        private static async Task SendServerOnlineWebhookAsync()
        {
            var fields = new object[]
            {
                new
                {
                    name = "Status",
                    value = "🟢 Online",
                    inline = true
                },
                new
                {
                    name = "Build",
                    value = "Rec Room 2023.04.06",
                    inline = true
                },
                new
                {
                    name = "Server",
                    value = $"`{ServerUrl}`",
                    inline = false
                }
            };

            await SendServerStatusWebhookAsync(
                title: "☕ Mocha is freshly brewed!",
                description:
                    "The Mocha 2023 server is online and ready for players. " +
                    "The café is officially open!",
                color: 0xA66A3F,
                fields: fields,
                footerText: "Mocha • Freshly brewed for Rec Room 2023"
            );
        }

        private static async Task SendServerOfflineWebhookOnceAsync(string reason)
        {
            if (Volatile.Read(ref _serverIsOnline) == 0 ||
                Interlocked.Exchange(ref _offlineWebhookSent, 1) != 0)
            {
                return;
            }

            TimeSpan uptime = _serverStartedAt == default
                ? TimeSpan.Zero
                : DateTimeOffset.UtcNow - _serverStartedAt;

            var fields = new object[]
            {
                new
                {
                    name = "Status",
                    value = "🔴 Offline",
                    inline = true
                },
                new
                {
                    name = "Uptime",
                    value = FormatUptime(uptime),
                    inline = true
                },
                new
                {
                    name = "Reason",
                    value = reason,
                    inline = false
                }
            };

            await SendServerStatusWebhookAsync(
                title: "🫘 Mocha has gone cold",
                description:
                    "The Mocha 2023 server is offline. " +
                    "The café is closed for now.",
                color: 0x4E342E,
                fields: fields,
                footerText: "Mocha • Coffee break in progress"
            );

            Volatile.Write(ref _serverIsOnline, 0);
        }

        private static async Task SendServerStatusWebhookAsync(
            string title,
            string description,
            int color,
            object[] fields,
            string footerText)
        {
            if (!HasServerStatusWebhook())
            {
                ServerLog.Warning(
                    "SERVERSTATWEB is not configured; status webhook skipped.");
                return;
            }

            var payload = new
            {
                username = "Mocha Server Status",
                embeds = new[]
                {
                    new
                    {
                        title,
                        description,
                        color,
                        fields,
                        footer = new
                        {
                            text = footerText
                        },
                        timestamp = DateTimeOffset.UtcNow.ToString("O")
                    }
                }
            };

            try
            {
                string json = JsonSerializer.Serialize(payload);
                using var content = new StringContent(
                    json,
                    Encoding.UTF8,
                    "application/json");

                using HttpResponseMessage response =
                    await ServerStatusHttpClient.PostAsync(SERVERSTATWEB, content);

                if (response.IsSuccessStatusCode)
                {
                    ServerLog.Success("Discord server-status webhook sent.");
                    return;
                }

                string responseBody = await response.Content.ReadAsStringAsync();
                ServerLog.Warning(
                    $"Discord status webhook returned " +
                    $"{(int)response.StatusCode}: {responseBody}");
            }
            catch (Exception ex)
            {

                ServerLog.Warning(
                    $"Discord status webhook failed: " +
                    $"{ex.GetType().Name}: {ex.Message}");
            }
        }

        private static string FormatUptime(TimeSpan uptime)
        {
            if (uptime.TotalDays >= 1)
            {
                return $"{(int)uptime.TotalDays}d {uptime.Hours}h " +
                       $"{uptime.Minutes}m {uptime.Seconds}s";
            }

            if (uptime.TotalHours >= 1)
            {
                return $"{(int)uptime.TotalHours}h " +
                       $"{uptime.Minutes}m {uptime.Seconds}s";
            }

            return $"{uptime.Minutes}m {uptime.Seconds}s";
        }

        private static string InitializeFileLogging(TextWriter originalConsole)
        {
            string debugDirectory = Path.Combine(dataDir, "Debug");
            Directory.CreateDirectory(debugDirectory);

            string logFilePath = Path.Combine(
                debugDirectory,
                $"console_{DateTime.UtcNow:yyyyMMdd_HHmmss}.log"
            );

            var fileWriter = new StreamWriter(logFilePath, append: true)
            {
                AutoFlush = true
            };

            Console.SetOut(new DualTextWriter(originalConsole, fileWriter));
            return logFilePath;
        }

        private static void EnsureDataDirectories()
        {
            Directory.CreateDirectory(dataDir);

            foreach (string relativePath in RequiredDirectories)
            {
                Directory.CreateDirectory(Path.Combine(dataDir, relativePath));
            }
        }

        private static void ConfigureFrameworkLogging(
            WebApplicationBuilder builder)
        {

            builder.Logging.ClearProviders();
            builder.Logging.AddConsole();
            builder.Logging.SetMinimumLevel(LogLevel.Warning);
            builder.Logging.AddFilter("Microsoft", LogLevel.Warning);
            builder.Logging.AddFilter("Microsoft.Hosting.Lifetime", LogLevel.None);
        }

        private static void ConfigureServices(WebApplicationBuilder builder)
        {
            builder.WebHost.ConfigureKestrel(options =>
            {
                options.AddServerHeader = false;
                options.Limits.MaxRequestBodySize = 4 * 1024 * 1024;
                options.Limits.MaxRequestHeadersTotalSize = 32 * 1024;
                options.Limits.MaxRequestHeaderCount = 100;
                options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(15);
                options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
            });

            builder.Services
                .AddControllers()
                .AddJsonOptions(options =>
                {
                    options.JsonSerializerOptions.PropertyNamingPolicy = null;
                    options.JsonSerializerOptions.MaxDepth = 64;
                });

            builder.Services.AddAuthorization();

            builder.Services
                .AddSignalR(options =>
                {
                    options.KeepAliveInterval = TimeSpan.FromSeconds(15);
                    options.ClientTimeoutInterval = TimeSpan.FromSeconds(45);
                    options.MaximumReceiveMessageSize = 1024 * 1024;
                    options.EnableDetailedErrors = false;
                })
                .AddJsonProtocol(options =>
                {
                    options.PayloadSerializerOptions.PropertyNamingPolicy = null;
                    options.PayloadSerializerOptions.PropertyNameCaseInsensitive = true;
                });

            builder.Services.AddRateLimiter(options =>
            {
                options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
                options.OnRejected = async (context, cancellationToken) =>
                {
                    if (!context.HttpContext.Response.HasStarted)
                    {
                        context.HttpContext.Response.ContentType = "application/json";
                        await context.HttpContext.Response.WriteAsJsonAsync(
                            new { error = "Too many requests. Try again shortly." },
                            cancellationToken);
                    }
                };

                options.GlobalLimiter =
                    PartitionedRateLimiter.Create<HttpContext, string>(context =>
                    {
                        string clientKey = GetRateLimitClientKey(context);
                        PathString path = context.Request.Path;

                        if (IsAuthenticationAttempt(path))
                        {
                            return RateLimitPartition.GetFixedWindowLimiter(
                                $"auth:{clientKey}",
                                _ => new FixedWindowRateLimiterOptions
                                {
                                    PermitLimit = 30,
                                    Window = TimeSpan.FromMinutes(1),
                                    QueueLimit = 0,
                                    AutoReplenishment = true
                                });
                        }

                        if (path.StartsWithSegments(
                                "/reports",
                                StringComparison.OrdinalIgnoreCase))
                        {
                            return RateLimitPartition.GetFixedWindowLimiter(
                                $"crash:{clientKey}",
                                _ => new FixedWindowRateLimiterOptions
                                {
                                    PermitLimit = 6,
                                    Window = TimeSpan.FromMinutes(10),
                                    QueueLimit = 0,
                                    AutoReplenishment = true
                                });
                        }

                        if (IsLargeUpload(context.Request))
                        {
                            return RateLimitPartition.GetFixedWindowLimiter(
                                $"upload:{clientKey}",
                                _ => new FixedWindowRateLimiterOptions
                                {
                                    PermitLimit = 60,
                                    Window = TimeSpan.FromMinutes(10),
                                    QueueLimit = 0,
                                    AutoReplenishment = true
                                });
                        }

                        return RateLimitPartition.GetNoLimiter($"normal:{clientKey}");
                    });
            });
        }

        private static bool IsAuthenticationAttempt(PathString path)
        {
            return path.StartsWithSegments(
                       "/auth/connect/token",
                       StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWithSegments(
                       "/auth/cachedlogin",
                       StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWithSegments(
                       "/recnet/api/auth/login",
                       StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWithSegments(
                       "/recnet/api/auth/register",
                       StringComparison.OrdinalIgnoreCase);
        }

        private static bool IsLargeUpload(HttpRequest request)
        {
            if (request.Method is not ("POST" or "PUT" or "PATCH"))
                return false;

            PathString path = request.Path;
            return request.ContentLength > 1024 * 1024 ||
                   path.StartsWithSegments(
                       "/api/images/v4/uploadsaved",
                       StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWithSegments(
                       "/recnet/api/account/profile-image",
                       StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWithSegments(
                       "/recnet/api/account/banner-image",
                       StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWithSegments(
                       "/recnet/api/admin/events/image",
                       StringComparison.OrdinalIgnoreCase) ||
                   path.StartsWithSegments(
                       "/recnet/api/admin/community-board/media",
                       StringComparison.OrdinalIgnoreCase);
        }

        private static string GetRateLimitClientKey(HttpContext context)
        {
            IPAddress? remoteAddress = context.Connection.RemoteIpAddress;
            if (remoteAddress != null &&
                IPAddress.IsLoopback(remoteAddress) &&
                context.Request.Headers.TryGetValue(
                    "CF-Connecting-IP",
                    out var forwardedValues) &&
                IPAddress.TryParse(
                    forwardedValues.FirstOrDefault(),
                    out IPAddress? forwardedAddress))
            {
                remoteAddress = forwardedAddress;
            }

            return remoteAddress?.MapToIPv6().ToString() ?? "unknown";
        }

        private static async Task ImportBaseRoomsAsync()
        {
            string importPath = Path.Combine(
                dataDir,
                "Imports",
                "ImportRooms.json"
            );

            if (!File.Exists(importPath))
            {
                return;
            }

            if (RoomDB.Rooms.Count() == 0)
            {
                ServerLog.Info("Importing rooms from ImportRooms.json...");
                await RoomDB.ImportRooms(importPath);
                ServerLog.Success("Room import complete.");
                return;
            }

            int repaired = await RoomDB.EnsureCanonicalBaseRooms(importPath);
            ServerLog.Info($"Base room reconciliation: changed={repaired}");
        }

        private static void EnforceRRPlusForExistingPlayers()
        {
            int settingsUpdated = PlayerDB.ForceRRPlusForAllPlayers();
            int rolesAdded = ForceRRPlusRoleForAllPlayers();

            ServerLog.Info(
                $"RR+ enforcement: settings={settingsUpdated}, " +
                $"roles={rolesAdded}, players={PlayerDB.Players.Count()}"
            );
        }

        private static void ConfigureRequestPipeline(WebApplication app)
        {
            app.UseWebSockets();

            app.UseWhen(
                context => context.Request.Path.StartsWithSegments(
                    "/recnet",
                    StringComparison.OrdinalIgnoreCase),
                recNetApp => recNetApp.Use(async (context, next) =>
                {
                    context.Response.OnStarting(() =>
                    {
                        context.Response.Headers["X-Content-Type-Options"] = "nosniff";
                        context.Response.Headers["X-Frame-Options"] = "DENY";
                        context.Response.Headers["Cross-Origin-Opener-Policy"] =
                            "same-origin";
                        context.Response.Headers["Cross-Origin-Resource-Policy"] =
                            "same-origin";
                        context.Response.Headers["Referrer-Policy"] = "no-referrer";
                        context.Response.Headers["Permissions-Policy"] =
                            "camera=(), microphone=(), geolocation=()";
                        context.Response.Headers["Content-Security-Policy"] =
                            "default-src 'self'; " +
                            "script-src 'self' https://static.cloudflareinsights.com; " +
                            "style-src 'self' 'unsafe-inline' https://cdnjs.cloudflare.com https://fonts.googleapis.com; " +
                            "font-src 'self' https://cdnjs.cloudflare.com https://fonts.gstatic.com; " +
                            "img-src 'self' data: blob:; " +
                            "connect-src 'self' ws: wss: https://cloudflareinsights.com; " +
                            "object-src 'none'; base-uri 'self'; " +
                            "form-action 'self'; frame-ancestors 'none'";

                        if (context.Request.Path.StartsWithSegments(
                                "/recnet/api",
                                StringComparison.OrdinalIgnoreCase))
                        {
                            context.Response.Headers.CacheControl =
                                "no-store, no-cache, must-revalidate";
                            context.Response.Headers.Pragma = "no-cache";
                        }

                        return Task.CompletedTask;
                    });

                    await next();
                }));

            app.Use(async (context, next) =>
            {
                Stopwatch stopwatch = Stopwatch.StartNew();
                Exception? exception = null;
                long inboundBytes =
                    DeveloperTelemetry.EstimateInboundBytes(context.Request);
                DeveloperTelemetry.RecordInboundBytes(inboundBytes);

                Stream originalResponseBody = context.Response.Body;
                var countedResponseBody = new CountingResponseStream(
                    originalResponseBody,
                    bytes => DeveloperTelemetry.RecordOutboundBytes(bytes));
                context.Response.Body = countedResponseBody;

                try
                {
                    await next();
                }
                catch (Exception ex)
                {
                    exception = ex;

                    if (!context.Response.HasStarted)
                    {
                        context.Response.Clear();
                        context.Response.StatusCode =
                            StatusCodes.Status500InternalServerError;
                        context.Response.ContentType = "application/json";

                        await context.Response.WriteAsJsonAsync(new
                        {
                            error = "Internal server error"
                        });
                    }
                }
                finally
                {
                    stopwatch.Stop();
                    context.Response.Body = originalResponseBody;

                    string requestPath =
                        $"{context.Request.PathBase}{context.Request.Path}";
                    DeveloperTelemetry.RecordRequest(
                        context.Response.StatusCode,
                        context.Request.Method,
                        requestPath,
                        stopwatch.ElapsedMilliseconds,
                        inboundBytes,
                        countedResponseBody.BytesWritten);

                    bool isSuccessfulRelationshipPoll =
                        context.Response.StatusCode >= StatusCodes.Status200OK &&
                        context.Response.StatusCode < StatusCodes.Status300MultipleChoices &&
                        context.Request.Path.Equals(
                            "/api/relationships/v2/get",
                            StringComparison.OrdinalIgnoreCase);

                    if (!isSuccessfulRelationshipPoll)
                    {

                        string path = $"{context.Request.PathBase}" +
                                      $"{context.Request.Path}";

                        ServerLog.Http(
                            context.Response.StatusCode,
                            context.Request.Method,
                            path,
                            stopwatch.ElapsedMilliseconds,
                            exception
                        );
                    }
                }
            });

            app.UseDefaultFiles();
            app.UseStaticFiles();
            app.UseRouting();
            app.UseRateLimiter();
            app.UseAuthorization();
            app.MapHub<NotificationHub>("/noti/hub/v1");
            app.MapControllers();

        }

        private static async Task RunConsoleLoopAsync(
            WebApplication app,
            ConsoleInputGuard consoleInput)
        {
            while (true)
            {
                string line = consoleInput.ReadLine();

                if (string.IsNullOrWhiteSpace(line))
                {
                    continue;
                }

                string[] commandParts = line.Split(' ', 2);
                string command = commandParts[0].Trim().ToLowerInvariant();
                string arguments = commandParts.Length == 2
                    ? commandParts[1].Trim()
                    : string.Empty;

                TryLogAdminCommand(
                    command,
                    command == "set-password" ? "(redacted)" : arguments
                );

                try
                {
                    bool keepRunning = await ExecuteCommandAsync(command, arguments);

                    if (!keepRunning)
                    {
                        break;
                    }
                }
                catch (Exception ex)
                {
                    ServerLog.Error(
                        $"Command '{command}' failed: " +
                        $"{ex.GetType().Name}: {ex.Message}"
                    );

                    TryLogAdminError(command, arguments, ex);
                }
            }

            ServerLog.Info("Stopping server...");
            await app.StopAsync();
            ServerLog.Success("Server stopped.");
        }

        private static async Task<bool> ExecuteCommandAsync(
            string command,
            string arguments)
        {
            switch (command)
            {
                case "help":
                    PrintHelp();
                    break;

                case "give-rrplus":
                    HandleGiveRRPlus(arguments);
                    break;

                case "force-rrplus-all":
                    HandleForceRRPlusAll();
                    break;

                case "give-influencer":
                    HandleGiveInfluencer(arguments);
                    break;

                case "grant-role":
                case "grant-roles":
                    HandleGrantRoles(arguments);
                    break;

                case "set-bio":
                    HandleSetBio(arguments);
                    break;

                case "reset-usernamechanges":
                    HandleResetUsernameChanges(arguments);
                    break;

                case "set-pfp":
                    HandleSetProfileImage(arguments);
                    break;

                case "set-banner":
                    HandleSetBannerImage(arguments);
                    break;

                case "add-roomrole":
                    HandleAddRoomRole(arguments);
                    break;

                case "set-username":
                    HandleSetUsername(arguments);
                    break;

                case "set-display":
                    HandleSetDisplayName(arguments);
                    break;

                case "import-room-dump":
                    {
                        if (string.IsNullOrWhiteSpace(arguments))
                        {
                            Console.WriteLine("Usage: import-room-dump <extracted-folder> [creatorAccountId]");
                            break;
                        }

                        string path = arguments.Trim().Trim('"');
                        long creatorId = 1;

                        int finalSpace = path.LastIndexOf(' ');
                        if (finalSpace > 0 &&
                            long.TryParse(path[(finalSpace + 1)..], out long parsedCreatorId))
                        {
                            creatorId = parsedCreatorId;
                            path = path[..finalSpace].Trim().Trim('"');
                        }

                        ShowdownImporter.Import(path, creatorId, replaceExisting: true);
                        break;
                    }

                case "change-level":
                    HandleChangeLevel(arguments);
                    break;

                case "change-xp":
                    HandleChangeXp(arguments, add: false);
                    break;

                case "add-xp":
                    HandleChangeXp(arguments, add: true);
                    break;

                case "set-balance":
                    HandleBalance(arguments, add: false);
                    break;

                case "add-balance":
                    HandleBalance(arguments, add: true);
                    break;

                case "set-junior":
                    HandleSetJunior(arguments);
                    break;

                case "set-rep":
                    HandleSetReputation(arguments);
                    break;

                case "reset-password":
                    HandleResetPassword(arguments);
                    break;

                case "set-password":
                    HandleSetPassword(arguments);
                    break;

                case "ban-player":
                    HandleBanPlayer(arguments);
                    break;

                case "unban-player":
                    HandleUnbanPlayer(arguments);
                    break;

                case "set-room-state":
                    HandleSetRoomState(arguments);
                    break;

                case "set-room-access":
                    HandleSetRoomAccess(arguments);
                    break;

                case "clear-visits":
                    HandleClearPlayerData(arguments, PlayerDataToClear.Visits);
                    break;

                case "clear-favorites":
                    HandleClearPlayerData(arguments, PlayerDataToClear.Favorites);
                    break;

                case "clear-cheers":
                    HandleClearPlayerData(arguments, PlayerDataToClear.Cheers);
                    break;

                case "reset-profile":
                    HandleResetProfile(arguments);
                    break;

                case "create-account":
                    HandleCreateAccount(arguments);
                    break;

                case "change-accid":
                    HandleChangeAccountId(arguments);
                    break;

                case "maintenance":
                    await HandleMaintenanceAsync(arguments);
                    break;

                case "exit":
                case "quit":
                    return false;

                default:
                    ServerLog.Warning(
                        $"Unknown command '{command}'. Type 'help'."
                    );
                    break;
            }

            return true;
        }

        private static void PrintHelp()
        {
            Console.WriteLine();
            Console.WriteLine("=== Mocha2023 Admin Commands ===");
            Console.WriteLine("help");
            Console.WriteLine("give-rrplus <playerId>");
            Console.WriteLine("force-rrplus-all");
            Console.WriteLine("give-influencer <playerId1> [playerId2...]");
            Console.WriteLine("grant-role <playerIds> <role1> [role2...]");
            Console.WriteLine("set-bio <playerId> <text>");
            Console.WriteLine("reset-usernamechanges <playerId> [amount]");
            Console.WriteLine("set-pfp <playerId> <filename-or-path>");
            Console.WriteLine("set-banner <playerId> <filename-or-path>");
            Console.WriteLine("set-username <playerId> <name>");
            Console.WriteLine("set-display <playerId> <name>");
            Console.WriteLine("change-level <playerId> <level>");
            Console.WriteLine("change-xp <playerId> <xp>");
            Console.WriteLine("add-xp <playerId> <xp>");
            Console.WriteLine("set-balance <playerId> <amount>");
            Console.WriteLine("add-balance <playerId> <amount>");
            Console.WriteLine("set-junior <playerId> <true|false>");
            Console.WriteLine("set-rep <playerId> <value>");
            Console.WriteLine("reset-password <playerId>");
            Console.WriteLine("set-password <playerId> <password>");
            Console.WriteLine("ban-player <playerId> [hours]");
            Console.WriteLine("unban-player <playerId>");
            Console.WriteLine("set-room-state <roomId> <state>");
            Console.WriteLine("import-room-dump <folder> [creatorId] - Imports a legacy Rec Room dump");
            Console.WriteLine("set-room-access <roomId> <private|public|unlisted>");
            Console.WriteLine("clear-visits <playerId>");
            Console.WriteLine("clear-favorites <playerId>");
            Console.WriteLine("clear-cheers <playerId>");
            Console.WriteLine("add-roomrole <playerId> <roomId> <Host|Moderator|CoOwner|TemporaryCoOwner|Creator>");
            Console.WriteLine("reset-profile <playerId>");
            Console.WriteLine("create-account <username> <accountId> <true|false> <platform> <platformId>");
            Console.WriteLine("change-accid <currentAccountId> <newAccountId>");
            Console.WriteLine("maintenance <minutes>");
            Console.WriteLine("exit");
            Console.WriteLine();
        }

        private static void HandleGiveRRPlus(string arguments)
        {
            if (!TryParsePositiveLong(arguments, out long playerId))
            {
                Usage("give-rrplus <playerId>");
                return;
            }

            if (!ForceRRPlusForPlayer(playerId))
            {
                ServerLog.Error($"Player {playerId} was not found or updated.");
                return;
            }

            ServerLog.Success($"RR+ granted to player {playerId}.");
        }

        private static void HandleForceRRPlusAll()
        {
            int settingsUpdated = PlayerDB.ForceRRPlusForAllPlayers();
            int rolesAdded = ForceRRPlusRoleForAllPlayers();

            ServerLog.Success(
                $"RR+ enforced: settings={settingsUpdated}, " +
                $"roles={rolesAdded}, players={PlayerDB.Players.Count()}"
            );
        }

        private static void HandleGiveInfluencer(string arguments)
        {
            long[] playerIds = arguments
                .Split(
                    new[] { ',', ' ' },
                    StringSplitOptions.RemoveEmptyEntries |
                    StringSplitOptions.TrimEntries
                )
                .Select(value => long.TryParse(value, out long id) ? id : -1)
                .Where(id => id > 0)
                .Distinct()
                .ToArray();

            if (playerIds.Length == 0)
            {
                Usage("give-influencer <playerId1> [playerId2...]");
                return;
            }

            foreach (long playerId in playerIds)
            {
                FullPlayer? player = PlayerDB.Players.FindById(playerId);

                if (player == null)
                {
                    ServerLog.Warning($"Player {playerId} was not found.");
                    continue;
                }

                player.PlayerRoles ??= new List<PlayerRoles>();

                if (player.PlayerRoles.Contains(PlayerRoles.Influencer))
                {
                    ServerLog.Info($"Player {playerId} is already verified.");
                    continue;
                }

                player.PlayerRoles.Add(PlayerRoles.Influencer);

                if (PlayerDB.Players.Update(player))
                {
                    ServerLog.Success($"Influencer granted to player {playerId}.");
                }
                else
                {
                    ServerLog.Error($"Failed to update player {playerId}.");
                }
            }
        }

        private static void HandleGrantRoles(string arguments)
        {
            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                string.IsNullOrWhiteSpace(values[0]) ||
                string.IsNullOrWhiteSpace(values[1]))
            {
                Usage("grant-role <playerIds> <role1> [role2...]");
                return;
            }

            GrantRoles(values[0], values[1]);
        }

        private static void HandleAddRoomRole(string arguments)
        {
            string[] values = arguments.Split(
                ' ',
                3,
                StringSplitOptions.RemoveEmptyEntries |
                StringSplitOptions.TrimEntries);

            if (values.Length != 3)
            {
                Usage(
                    "add-roomrole <playerId> <roomId> " +
                    "<Host|Moderator|CoOwner|TemporaryCoOwner|Creator>");
                return;
            }

            if (!TryParsePositiveLong(values[0], out long playerId))
            {
                ServerLog.Warning(
                    $"Invalid player ID '{values[0]}'.");
                return;
            }

            if (!TryParsePositiveLong(values[1], out long roomId))
            {
                ServerLog.Warning(
                    $"Invalid room ID '{values[1]}'.");
                return;
            }

            if (!Enum.TryParse(
                    values[2],
                    ignoreCase: true,
                    out RoomDBClasses.Role role) ||
                !Enum.IsDefined(typeof(RoomDBClasses.Role), role) ||
                role is RoomDBClasses.Role.None or RoomDBClasses.Role.Banned)
            {
                ServerLog.Warning(
                    $"Invalid room role '{values[2]}'. Valid roles: " +
                    "Host, Moderator, CoOwner, TemporaryCoOwner, Creator.");
                return;
            }

            var player = PlayerDB.Players.FindById(playerId);

            if (player == null)
            {
                ServerLog.Warning(
                    $"Player {playerId} was not found.");
                return;
            }

            RoomDBClasses.Room? room =
                RoomDB.Rooms.FindById(roomId);

            if (room == null)
            {
                ServerLog.Warning(
                    $"Room {roomId} was not found.");
                return;
            }

            room.Roles ??= new List<RoomDBClasses.Roles>();

            RoomDBClasses.Roles? existingRole =
                room.Roles.FirstOrDefault(entry =>
                    entry.AccountId == playerId);

            if (existingRole == null)
            {
                room.Roles.Add(new RoomDBClasses.Roles
                {
                    AccountId = playerId,
                    Role = role,
                    InvitedRole = RoomDBClasses.Role.None
                });
            }
            else
            {
                existingRole.Role = role;
                existingRole.InvitedRole =
                    RoomDBClasses.Role.None;
            }

            room.UgcVersion =
                Math.Max(1, room.UgcVersion + 1);

            if (!RoomDB.Rooms.Update(room))
            {
                ServerLog.Error(
                    $"Failed to give player {playerId} the {role} role " +
                    $"in room {roomId}.");
                return;
            }

            ServerLog.Success(
                $"Player {playerId} is now {role} in " +
                $"room {roomId} ({room.Name}).");
        }

        private static void HandleSetBio(string arguments)
        {
            if (!TrySplitPlayerAndValue(
                    arguments,
                    "set-bio <playerId> <text>",
                    out long playerId,
                    out string bio))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            player.Player!.Bio = bio;
            SavePlayer(player, $"Bio updated for player {playerId}.", notifyProfile: true);
        }

        private static void HandleResetUsernameChanges(string arguments)
        {
            string[] values = arguments.Split(
                ' ',
                StringSplitOptions.RemoveEmptyEntries |
                StringSplitOptions.TrimEntries
            );

            if (values.Length is < 1 or > 2 ||
                !TryParsePositiveLong(values[0], out long playerId))
            {
                Usage("reset-usernamechanges <playerId> [amount]");
                return;
            }

            int amount = 3;

            if (values.Length == 2 &&
                (!int.TryParse(values[1], out amount) || amount < 0))
            {
                Usage("reset-usernamechanges <playerId> [amount]");
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            player.Player!.AvailableUsernameChanges = amount;
            SavePlayer(
                player,
                $"Username changes for player {playerId} set to {amount}."
            );
        }

        private static void HandleSetProfileImage(string arguments)
        {
            if (!TrySplitPlayerAndValue(
                    arguments,
                    "set-pfp <playerId> <filename-or-path>",
                    out long playerId,
                    out string sourceInput))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            string? sourcePath = ResolveProfileImageSourcePath(sourceInput);

            if (sourcePath == null)
            {
                ServerLog.Error($"Image file not found: {sourceInput}");
                return;
            }

            string copiedPath = CopyProfileImageToCustomPfps(sourcePath);
            player.Player!.ProfileImage = copiedPath;
            SavePlayer(player, $"Profile image set to {copiedPath}.", notifyProfile: true);
        }

        private static void HandleSetBannerImage(string arguments)
        {
            if (!TrySplitPlayerAndValue(
                    arguments,
                    "set-banner <playerId> <filename-or-path>",
                    out long playerId,
                    out string sourceInput))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
                return;

            string? sourcePath = ResolveProfileImageSourcePath(sourceInput);
            if (sourcePath == null)
            {
                ServerLog.Error($"Image file not found: {sourceInput}");
                return;
            }

            string copiedPath = CopyProfileImageToCustomPfps(sourcePath);
            player.Player!.BannerImage = copiedPath;
            SavePlayer(player, $"Banner image for player {playerId} set to {copiedPath}.", notifyProfile: true);
        }

        private static void HandleSetUsername(string arguments)
        {
            if (!TrySplitPlayerAndValue(
                    arguments,
                    "set-username <playerId> <name>",
                    out long playerId,
                    out string username))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            player.Player!.Username = username;
            SavePlayer(player, $"Username for player {playerId} set to '{username}'.", notifyProfile: true);
        }

        private static void HandleSetDisplayName(string arguments)
        {
            if (!TrySplitPlayerAndValue(
                    arguments,
                    "set-display <playerId> <name>",
                    out long playerId,
                    out string displayName))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            player.Player!.DisplayName = displayName;
            SavePlayer(
                player,
                $"Display name for player {playerId} set to '{displayName}'.",
                notifyProfile: true
            );
        }

        private static void HandleChangeLevel(string arguments)
        {
            if (!TryParsePlayerAndInt(
                    arguments,
                    "change-level <playerId> <level>",
                    out long playerId,
                    out int level))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            PlayerProgressionDTO? progression = PlayerDB.SetProgression(
                playerId,
                level,
                player.Player!.XP);

            if (progression == null)
            {
                ServerLog.Error(
                    $"Failed to update level for player {playerId}.");
                return;
            }

            ServerLog.Success(
                $"Level for player {playerId} set to {progression.Level}.");
        }

        private static void HandleChangeXp(string arguments, bool add)
        {
            string usage = add
                ? "add-xp <playerId> <xp>"
                : "change-xp <playerId> <xp>";

            if (!TryParsePlayerAndInt(
                    arguments,
                    usage,
                    out long playerId,
                    out int xp))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            int updatedXp = add
                ? Math.Max(0, player.Player!.XP + xp)
                : Math.Max(0, xp);

            PlayerProgressionDTO? progression = PlayerDB.SetProgression(
                playerId,
                player.Player!.Level,
                updatedXp);

            if (progression == null)
            {
                ServerLog.Error(
                    $"Failed to update XP for player {playerId}.");
                return;
            }

            ServerLog.Success(
                $"XP for player {playerId} is now {progression.XP}.");
        }

        private static void HandleBalance(string arguments, bool add)
        {
            string usage = add
                ? "add-balance <playerId> <amount>"
                : "set-balance <playerId> <amount>";

            if (!TryParsePlayerAndInt(
                    arguments,
                    usage,
                    out long playerId,
                    out int amount))
            {
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            player.Player!.PlayerExtra ??= new PlayerExtra();
            player.Player.PlayerExtra.Currencies ??= new List<PlayerCurrency>();

            PlayerCurrency? currency = player.Player.PlayerExtra.Currencies
                .FirstOrDefault(item =>
                    item.CurrencyType == CurrencyType.RecCenterTokens);

            if (currency == null)
            {
                currency = new PlayerCurrency
                {
                    CurrencyType = CurrencyType.RecCenterTokens,
                    BalanceType = BalanceType.NonPurchasedDefault,
                    Balance = Math.Max(0, amount)
                };

                player.Player.PlayerExtra.Currencies.Add(currency);
            }
            else
            {
                currency.Balance = add
                    ? Math.Max(0, currency.Balance + amount)
                    : Math.Max(0, amount);
            }

            SavePlayer(
                player,
                $"Token balance for player {playerId} is now {currency.Balance}."
            );
        }

        private static void HandleSetJunior(string arguments)
        {
            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                !TryParsePositiveLong(values[0], out long playerId) ||
                !bool.TryParse(values[1], out bool isJunior))
            {
                Usage("set-junior <playerId> <true|false>");
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            player.Player!.IsJunior = isJunior;
            SavePlayer(
                player,
                $"Junior status for player {playerId} set to {isJunior}."
            );
        }

        private static void HandleSetReputation(string arguments)
        {
            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                !TryParsePositiveLong(values[0], out long playerId) ||
                !double.TryParse(values[1], out double reputation))
            {
                Usage("set-rep <playerId> <value>");
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            player.Player!.Reputation ??= new Reputation();
            player.Player.Reputation.Noteriety = reputation;
            SavePlayer(
                player,
                $"Reputation for player {playerId} set to {reputation}."
            );
        }

        private static void HandleResetPassword(string arguments)
        {
            if (!TryParsePositiveLong(arguments, out long playerId))
            {
                Usage("reset-password <playerId>");
                return;
            }

            FullPlayer? player = PlayerDB.Players.FindById(playerId);

            if (player == null)
            {
                ServerLog.Warning($"Player {playerId} was not found.");
                return;
            }

            player.Password = null;
            SavePlayer(player, $"Password cleared for player {playerId}.");
        }

        private static void HandleSetPassword(string arguments)
        {
            if (!TrySplitPlayerAndValue(
                    arguments,
                    "set-password <playerId> <password>",
                    out long playerId,
                    out string password))
            {
                return;
            }

            if (password.Length < 4 ||
                password.Length > PasswordSecurity.MaxPasswordLength)
            {
                ServerLog.Warning("Password must be 4-256 characters.");
                return;
            }

            FullPlayer? player = PlayerDB.Players.FindById(playerId);
            if (player == null)
            {
                ServerLog.Warning($"Player {playerId} was not found.");
                return;
            }

            player.Password = PasswordSecurity.Hash(password);
            SavePlayer(player, $"Password set for player {playerId}.");
        }

        private static void HandleBanPlayer(string arguments)
        {
            string[] values = arguments.Split(
                ' ',
                StringSplitOptions.RemoveEmptyEntries |
                StringSplitOptions.TrimEntries
            );

            if (values.Length is < 1 or > 2 ||
                !TryParsePositiveLong(values[0], out long playerId))
            {
                Usage("ban-player <playerId> [hours]");
                return;
            }

            int durationHours = 24;

            if (values.Length == 2 &&
                (!int.TryParse(values[1], out durationHours) ||
                 durationHours < 1))
            {
                Usage("ban-player <playerId> [hours]");
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }
            if (durationHours > int.MaxValue / 3600)
            {
                ServerLog.Warning("Ban duration exceeds the 32-bit duration limit.");
                return;
            }

            PlayerDB.BanPlayer(
                playerId,
                durationHours * 3600,
                "Banned via console command"
            );
            ServerLog.Success($"Player {playerId} banned from gameplay for {durationHours} hour(s).");
        }

        private static void HandleUnbanPlayer(string arguments)
        {
            if (!TryParsePositiveLong(arguments, out long playerId))
            {
                Usage("unban-player <playerId>");
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            PlayerDB.UnbanPlayer(playerId);
            ServerLog.Success($"Player {playerId} unbanned from gameplay.");
        }

        private static void HandleSetRoomState(string arguments)
        {
            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                !TryParsePositiveLong(values[0], out long roomId) ||
                !Enum.TryParse(
                    values[1],
                    ignoreCase: true,
                    out RoomDBClasses.RoomState state))
            {
                Usage("set-room-state <roomId> <state>");
                return;
            }

            RoomDBClasses.Room? room = RoomDB.Rooms.FindById(roomId);

            if (room == null)
            {
                ServerLog.Warning($"Room {roomId} was not found.");
                return;
            }

            room.State = state;

            if (RoomDB.Rooms.Update(room))
            {
                ServerLog.Success($"Room {roomId} state set to {state}.");
            }
            else
            {
                ServerLog.Error($"Failed to update room {roomId}.");
            }
        }

        private static void HandleSetRoomAccess(string arguments)
        {
            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                !TryParsePositiveLong(values[0], out long roomId) ||
                !Enum.TryParse(
                    values[1],
                    ignoreCase: true,
                    out RoomDBClasses.RoomAccessibility accessibility))
            {
                Usage("set-room-access <roomId> <private|public|unlisted>");
                return;
            }

            RoomDBClasses.Room? room = RoomDB.Rooms.FindById(roomId);

            if (room == null)
            {
                ServerLog.Warning($"Room {roomId} was not found.");
                return;
            }

            room.Accessibility = accessibility;

            if (RoomDB.Rooms.Update(room))
            {
                ServerLog.Success(
                    $"Room {roomId} access set to {accessibility}."
                );
            }
            else
            {
                ServerLog.Error($"Failed to update room {roomId}.");
            }
        }

        private enum PlayerDataToClear
        {
            Visits,
            Favorites,
            Cheers
        }

        private static void HandleClearPlayerData(
            string arguments,
            PlayerDataToClear dataToClear)
        {
            if (!TryParsePositiveLong(arguments, out long playerId))
            {
                Usage(dataToClear switch
                {
                    PlayerDataToClear.Visits => "clear-visits <playerId>",
                    PlayerDataToClear.Favorites => "clear-favorites <playerId>",
                    _ => "clear-cheers <playerId>"
                });

                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

            switch (dataToClear)
            {
                case PlayerDataToClear.Visits:
                    player.Player!.VisitedRooms ??= new List<long>();
                    player.Player.VisitedRooms.Clear();
                    player.Player.PlayerExtra ??= new PlayerExtra();
                    player.Player.PlayerExtra.RoomVisits ??= new List<RoomVisit>();
                    player.Player.PlayerExtra.RoomVisits.Clear();
                    break;

                case PlayerDataToClear.Favorites:
                    player.Player!.FavoritedRooms ??= new List<long>();
                    player.Player.FavoritedRooms.Clear();
                    break;

                case PlayerDataToClear.Cheers:
                    player.Player!.CheeredRooms ??= new List<long>();
                    player.Player.CheeredRooms.Clear();
                    player.Player.ReceivedCheers ??=
                        new List<PlayerCheerRecord>();
                    player.Player.ReceivedCheers.Clear();
                    player.Player.Reputation ??= new Reputation();
                    player.Player.Reputation.IsCheerful = false;
                    player.Player.Reputation.SelectedCheer =
                        CheerCategory.General;
                    player.Player.Reputation.CheerGeneral = 0;
                    player.Player.Reputation.CheerHelpful = 0;
                    player.Player.Reputation.CheerSportsman = 0;
                    player.Player.Reputation.CheerGreatHost = 0;
                    player.Player.Reputation.CheerCreative = 0;
                    NotificationDB.DeletePlayerCheerMessages(playerId);
                    break;
            }

            SavePlayer(
                player,
                $"Cleared {dataToClear.ToString().ToLowerInvariant()} " +
                $"for player {playerId}."
            );
        }

        private static void HandleResetProfile(string arguments)
        {
            if (!TryParsePositiveLong(arguments, out long playerId))
            {
                Usage("reset-profile <playerId>");
                return;
            }

            if (!TryGetPlayerWithData(playerId, out FullPlayer player))
            {
                return;
            }

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

            player.Player.Bio = string.Empty;
            player.Player.ProfileImage = "DefaultPFP.png";
            player.Player.BannerImage = null;
            player.Player.DisplayName = player.Player.Username;
            player.Player.PlayerExtra.Avatar = new Avatar();
            player.Player.PlayerExtra.AvatarItems.Clear();
            player.Player.PlayerExtra.SavedAvatars.Clear();

            SavePlayer(player, $"Profile reset for player {playerId}.", notifyProfile: true);
        }

        private static void HandleCreateAccount(string arguments)
        {
            string[] values = arguments.Split(' ', 5);

            if (values.Length != 5 ||
                string.IsNullOrWhiteSpace(values[0]) ||
                !TryParsePositiveLong(values[1], out long accountId) ||
                !bool.TryParse(values[2], out bool isJunior) ||
                !Enum.TryParse(
                    values[3],
                    ignoreCase: true,
                    out Platforms platform) ||
                !ulong.TryParse(values[4], out ulong platformId))
            {
                Usage(
                    "create-account <username> <accountId> " +
                    "<true|false> <platform> <platformId>"
                );
                return;
            }

            if (PlayerDB.Players.FindById(accountId) != null)
            {
                ServerLog.Error($"Account {accountId} already exists.");
                return;
            }

            FullPlayer created = PlayerDB.CreateAccount(
                platform,
                platformId,
                isJunior,
                accountId
            );

            created.Player ??= new Player();
            created.Player.Username = values[0].Trim();
            created.Player.DisplayName = values[0].Trim();
            created.Player.PlayerExtra ??= new PlayerExtra();
            created.Player.PlayerExtra.Settings ??= new List<Setting>();

            SavePlayer(
                created,
                $"Created account {accountId} as '{created.Player.Username}'."
            );
        }

        private static void HandleChangeAccountId(string arguments)
        {
            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                !TryParsePositiveLong(values[0], out long currentAccountId) ||
                !TryParsePositiveLong(values[1], out long newAccountId))
            {
                Usage("change-accid <currentAccountId> <newAccountId>");
                return;
            }

            if (currentAccountId == newAccountId)
            {
                ServerLog.Warning("The current and new account IDs are equal.");
                return;
            }

            if (PlayerDB.ChangeAccountId(currentAccountId, newAccountId))
            {
                ServerLog.Success(
                    $"Account ID changed from {currentAccountId} " +
                    $"to {newAccountId}."
                );
            }
            else
            {
                ServerLog.Error(
                    $"Could not change account ID {currentAccountId} " +
                    $"to {newAccountId}."
                );
            }
        }

        public static async Task SetMaintenanceCountdownAsync(int minutes)
        {
            if (minutes is < 0 or > 10_080)
                throw new ArgumentOutOfRangeException(
                    nameof(minutes),
                    "Maintenance must be between 0 and 10,080 minutes.");

            string configPath = Path.Combine(dataDir, "APIS", "ConfigV2.json");

            if (!File.Exists(configPath))
                throw new FileNotFoundException(
                    $"ConfigV2.json was not found at '{configPath}'.",
                    configPath);

            string json = File.ReadAllText(configPath);
            Dictionary<string, object?>? config =
                JsonSerializer.Deserialize<Dictionary<string, object?>>(json);

            if (config == null)
                throw new InvalidDataException("ConfigV2.json could not be parsed.");

            config.Remove("ServerMaintainence");
            config["ServerMaintenance"] = new
            {
                StartsInMinutes = minutes
            };

            File.WriteAllText(
                configPath,
                JsonSerializer.Serialize(
                    config,
                    new JsonSerializerOptions { WriteIndented = true }
                )
            );

            await NotiController.BroadcastServerMaintenanceAsync(minutes);
        }

        private static async Task HandleMaintenanceAsync(string arguments)
        {
            if (!int.TryParse(arguments, out int minutes) || minutes < 0)
            {
                Usage("maintenance <minutes>");
                return;
            }

            try
            {
                await SetMaintenanceCountdownAsync(minutes);
            }
            catch (Exception ex) when (ex is ArgumentOutOfRangeException or
                FileNotFoundException or InvalidDataException or JsonException or IOException)
            {
                ServerLog.Error(ex.Message);
                return;
            }

            ServerLog.Success(
                $"Maintenance countdown set to {minutes} minute(s)."
            );
        }

        private static bool TrySplitPlayerAndValue(
            string arguments,
            string usage,
            out long playerId,
            out string value)
        {
            playerId = 0;
            value = string.Empty;

            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                !TryParsePositiveLong(values[0], out playerId) ||
                string.IsNullOrWhiteSpace(values[1]))
            {
                Usage(usage);
                return false;
            }

            value = values[1].Trim();
            return true;
        }

        private static bool TryParsePlayerAndInt(
            string arguments,
            string usage,
            out long playerId,
            out int value)
        {
            playerId = 0;
            value = 0;

            string[] values = arguments.Split(' ', 2);

            if (values.Length != 2 ||
                !TryParsePositiveLong(values[0], out playerId) ||
                !int.TryParse(values[1], out value))
            {
                Usage(usage);
                return false;
            }

            return true;
        }

        private static bool TryParsePositiveLong(
            string value,
            out long result)
        {
            return long.TryParse(value.Trim(), out result) && result > 0;
        }

        private static bool TryGetPlayerWithData(
            long playerId,
            out FullPlayer player)
        {
            FullPlayer? found = PlayerDB.Players.FindById(playerId);

            if (found?.Player == null)
            {
                ServerLog.Warning($"Player {playerId} was not found.");
                player = null!;
                return false;
            }

            player = found;
            return true;
        }

        private static void SavePlayer(
            FullPlayer player,
            string successMessage,
            bool notifyProfile = false)
        {
            if (PlayerDB.Players.Update(player))
            {
                ServerLog.Success(successMessage);
                if (notifyProfile)
                    _ = NotiController.NotifyPlayerProfileUpdatedAsync(player.PlayerId);
            }
            else
            {
                ServerLog.Error($"Failed to save player {player.PlayerId}.");
            }
        }

        private static void Usage(string usage)
        {
            ServerLog.Warning($"Usage: {usage}");
        }

        private static void TryLogAdminCommand(
            string command,
            string arguments)
        {
            try
            {
                DiscordLogger.Log(
                    "🛠️ **Admin Command Executed**\n" +
                    $"**Command:** `{command}`\n" +
                    $"**Args:** `{(string.IsNullOrWhiteSpace(arguments) ? "(none)" : arguments)}`"
                );
            }
            catch (Exception ex)
            {
                ServerLog.Warning(
                    $"Discord command log failed: {ex.Message}"
                );
            }
        }

        private static void TryLogAdminError(
            string command,
            string arguments,
            Exception exception)
        {
            try
            {
                DiscordLogger.Log(
                    "❌ **Admin Command Error**\n" +
                    $"**Command:** `{command}`\n" +
                    $"**Args:** `{(string.IsNullOrWhiteSpace(arguments) ? "(none)" : arguments)}`\n" +
                    $"**Error:** `{exception.GetType().Name}: {exception.Message}`"
                );
            }
            catch
            {

            }
        }

        private static string? ResolveProfileImageSourcePath(string inputPath)
        {
            if (string.IsNullOrWhiteSpace(inputPath))
            {
                return null;
            }

            if (Path.IsPathRooted(inputPath) && File.Exists(inputPath))
            {
                return Path.GetFullPath(inputPath);
            }

            string[] candidatePaths =
            {
                inputPath,
                Path.Combine(Environment.CurrentDirectory, inputPath),
                Path.Combine(dataDir, inputPath),
                Path.Combine(dataDir, "Images", inputPath),
                Path.Combine(dataDir, "Images", "PlayerImages", inputPath),
                Path.Combine(dataDir, "Images", "CustomPFPS", inputPath)
            };

            return candidatePaths
                .Select(Path.GetFullPath)
                .FirstOrDefault(File.Exists);
        }

        private static string CopyProfileImageToCustomPfps(string sourcePath)
        {
            string extension = Path.GetExtension(sourcePath);

            if (string.IsNullOrWhiteSpace(extension))
            {
                extension = ".png";
            }

            string targetFolder = Path.Combine(
                dataDir,
                "Images",
                "CustomPFPS"
            );

            Directory.CreateDirectory(targetFolder);

            string assetName = $"{Guid.NewGuid():D}{extension}";
            string targetPath = Path.Combine(targetFolder, assetName);

            File.Copy(sourcePath, targetPath, overwrite: true);

            return Path.Combine("CustomPFPS", assetName)
                .Replace('\\', '/');
        }

        private static bool ForceRRPlusForPlayer(long playerId)
        {
            if (playerId <= 0 || !PlayerDB.SetRRPlus(playerId, true))
            {
                return false;
            }

            FullPlayer? player = PlayerDB.Players.FindById(playerId);

            if (player == null)
            {
                return false;
            }

            player.PlayerRoles ??= new List<PlayerRoles>();

            if (player.PlayerRoles.Contains(PlayerRoles.RRPlus))
            {
                return true;
            }

            player.PlayerRoles.Add(PlayerRoles.RRPlus);
            return PlayerDB.Players.Update(player);
        }

        private static int ForceRRPlusRoleForAllPlayers()
        {
            int rolesAdded = 0;

            foreach (FullPlayer player in PlayerDB.Players.FindAll())
            {
                player.PlayerRoles ??= new List<PlayerRoles>();

                if (player.PlayerRoles.Contains(PlayerRoles.RRPlus))
                {
                    continue;
                }

                player.PlayerRoles.Add(PlayerRoles.RRPlus);

                if (PlayerDB.Players.Update(player))
                {
                    rolesAdded++;
                }
            }

            return rolesAdded;
        }

        private static void GrantRoles(
            string playerIdsText,
            string rolesText)
        {
            List<long> playerIds = ParsePlayerIds(playerIdsText);

            if (playerIds.Count == 0)
            {
                ServerLog.Warning("No valid player IDs were supplied.");
                return;
            }

            string[] roleNames = rolesText.Split(
                ' ',
                StringSplitOptions.RemoveEmptyEntries |
                StringSplitOptions.TrimEntries
            );

            if (roleNames.Length == 0)
            {
                ServerLog.Warning("No roles were supplied.");
                return;
            }

            foreach (long playerId in playerIds)
            {
                FullPlayer? player = PlayerDB.Players.FindById(playerId);

                if (player == null)
                {
                    ServerLog.Warning($"Player {playerId} was not found.");
                    continue;
                }

                player.PlayerRoles ??= new List<PlayerRoles>();
                var addedRoles = new List<PlayerRoles>();

                foreach (string roleName in roleNames)
                {
                    if (!RoleUtils.TryParseRole(roleName, out PlayerRoles role))
                    {
                        ServerLog.Warning(
                            $"Unknown role '{roleName}' for player {playerId}."
                        );
                        continue;
                    }

                    if (player.PlayerRoles.Contains(role))
                    {
                        continue;
                    }

                    player.PlayerRoles.Add(role);
                    addedRoles.Add(role);
                }

                if (addedRoles.Contains(PlayerRoles.Developer))
                {
                    PlayerDB.GrantDeveloperCheerAccess(
                        player,
                        selectDeveloperBadge: true);
                }

                if (addedRoles.Count == 0)
                {
                    ServerLog.Info(
                        $"Player {playerId} already has the requested roles."
                    );
                    continue;
                }

                if (PlayerDB.Players.Update(player))
                {
                    ServerLog.Success(
                        $"Added {string.Join(", ", addedRoles)} " +
                        $"to player {playerId}."
                    );
                }
                else
                {
                    ServerLog.Error($"Failed to update player {playerId}.");
                }
            }
        }

        private static List<long> ParsePlayerIds(string playerIdsText)
        {
            return playerIdsText
                .Split(
                    new[] { ',', ' ' },
                    StringSplitOptions.RemoveEmptyEntries |
                    StringSplitOptions.TrimEntries
                )
                .Select(value => long.TryParse(value, out long id) ? id : -1)
                .Where(id => id > 0)
                .Distinct()
                .ToList();
        }
    }
}