using LiteDB;
using Microsoft.Extensions.FileProviders;
using Campus_live_rewrite;
using Campus_live_rewrite.api.dbs;
using Campus_live_rewrite.Controllers;
using Campus_live_rewrite.Commands;
using Campus_live_rewrite.api.server;
using System.Security.Principal;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using Campus_live_rewrite.api.server.Classes;
using Newtonsoft.Json;

internal class Program
{
    private static async Task Main(string[] args)
    {
        // If a DB restore was staged from the admin panel, apply it NOW — before anything opens
        // a LiteDB file (they open lazily on first use, and can't be overwritten while held open).
        BackupService.RestorePendingIfAny();

        var builder = WebApplication.CreateBuilder(args);

        builder.WebHost.ConfigureKestrel(serverOptions =>
        {
            serverOptions.AllowSynchronousIO = true;

            // ---- DoS / resource-exhaustion caps -------------------------------------------
            // Nothing bounded Kestrel before this, so a connection flood or a giant/slow body
            // could grow the process to max memory (the reported crash). These are hard ceilings
            // that never affect a normal client; they only stop abuse.
            //
            //  * Body size: an explicit per-request cap (== the historical 30 MB default, so real
            //    room/image uploads are unchanged) instead of relying on the implicit default.
            //  * Concurrent connections: bound how many sockets can be held open at once, so a
            //    flood of connections cannot balloon memory - excess connections are refused, the
            //    server stays up. Applies separately to normal and upgraded (WebSocket) sockets.
            //  * Header timeout: a client must finish sending request headers within 15s, which
            //    kills slowloris-style "trickle the headers forever" connection hoarding.
            //  * Keep-alive: reclaim idle connections after 60s instead of the 130s default.
            //  (MinRequestBodyDataRate is left at Kestrel's default - 240 B/s over a 5s grace -
            //   which already drops a client that trickles the BODY too slowly.)
            serverOptions.Limits.MaxRequestBodySize = ConfigCampus.MaxRequestBodyBytes;
            serverOptions.Limits.MaxConcurrentConnections = ConfigCampus.MaxConcurrentConnections;
            serverOptions.Limits.MaxConcurrentUpgradedConnections = ConfigCampus.MaxConcurrentUpgradedConnections;
            serverOptions.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(15);
            serverOptions.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(60);
        });

        builder.Services.AddHttpLogging(configureOptions => { });

        builder.Services
    .AddControllers()
    .AddJsonOptions(o =>
    {
        o.JsonSerializerOptions.PropertyNamingPolicy = null;
    });

        builder.Services.AddSignalR();

        builder.Services.AddSingleton<DiscordBot>();

        builder.Host.UseContentRoot(Directory.GetCurrentDirectory());

        builder.Services.Configure<ApiBehaviorOptions>(options =>
        {
            options.SuppressModelStateInvalidFilter = false;
        });

        var app = builder.Build();

        if (!Directory.Exists(Environment.CurrentDirectory + "/Data"))
        {
            Directory.CreateDirectory(Environment.CurrentDirectory + "/Data");
            Directory.CreateDirectory(Environment.CurrentDirectory + "/Data/APIS");
            Directory.CreateDirectory(Environment.CurrentDirectory + "/Data/DBs");
        }

        if (!Directory.Exists(Environment.CurrentDirectory + "/Web"))
        {
            Directory.CreateDirectory(Environment.CurrentDirectory + "/Web");
            Directory.CreateDirectory(Environment.CurrentDirectory + "/Web/Admin");
        }

        // FIRST in the pipeline: a banned IP gets 502 for the whole domain and never
        // touches logging, routing or any controller. Loopback is exempt so the operator
        // cannot lock themselves out of the admin panel over the SSH tunnel.
        app.UseMiddleware<BannedIpMiddleware>();

        // Per-IP flood + brute-force guard. Runs right after the ban check and BEFORE routing /
        // logging / controllers, so a flood is 429'd at the cheapest possible point and never
        // reaches LiteDB or the access log. General ceiling stops volumetric DoS; a tight ceiling
        // on /Auth/connect/token + /api/site/login stops credential brute-force and token farming.
        // Loopback exempt. Toggle with ConfigCampus.TrafficGuardEnabled.
        app.UseMiddleware<TrafficGuardMiddleware>();

        // Patch gate: refuse game requests from any IP that has not completed the patch handshake
        // (POST /api/patch/verify with the correct X-Campus-Patch header). A wrong/old/no patch
        // never validates, so it is blocked here. Toggle with PatchGateMiddleware.Enable; exempts
        // /api/patch/verify + /admin + browser assets + loopback.
        app.UseMiddleware<PatchGateMiddleware>();

        // Admin hardening: security headers + per-IP rate limit on /admin/* and /api/web/admin/*
        // (on top of the dev-token + admin-session auth). Runs after the gate so the login page is
        // still reachable to be throttled, and after the ban check so banned IPs never reach it.
        app.UseMiddleware<AdminProtectionMiddleware>();

        // Lightweight per-request access log for the admin "Log" tab (/admin/api/apilog).
        // Rewritten to an in-memory ring buffer + single shared file writer (see Log.cs), so it
        // no longer opens/closes the file per request or drops lines under concurrency. Now cheap
        // enough to run UNCONDITIONALLY - the admin log tool needs data whether or not the heavy
        // VerboseRequestLogging body-logging (Log2, below) is on. This only records one line per
        // request ("<time> <METHOD> <PATH> -> <status>"); it changes no response bytes.
        app.UseMiddleware<Log>(Path.Combine(Environment.CurrentDirectory, "Data", "APILog.txt"));

        // Registered unconditionally - it checks the flag itself and short-circuits,
        // so the flag can be read in one place and the pipeline shape stays constant.
        app.UseMiddleware<RequestResponseLoggingMiddleware>();

        //app.UseMiddleware<VpnBlockMiddleware>();

        app.Use(async (context, next) =>
        {
            var path = context.Request.Path.ToString();
            if (path.Contains("//"))
            {
                path = path.Replace("//", "/");
                context.Request.Path = path;
            }
            await next.Invoke();
        });

        // Security headers on the ADMIN panel only.
        //
        // The panel holds moderation controls, so harden its responses: no framing (anti-
        // clickjacking), no MIME sniffing, no referrer leak of admin URLs, and never cache an
        // authenticated admin page or its JSON. Scoped to /admin so game endpoints - which the
        // client caches aggressively - are untouched. Auth itself is already enforced per
        // request by AuthHelper.ValidateTokenDev (valid signed token AND a real dev flag);
        // these headers are defence-in-depth around that, not a replacement for it.
        app.Use(async (context, next) =>
        {
            if (context.Request.Path.StartsWithSegments("/admin"))
            {
                var h = context.Response.Headers;
                h["X-Frame-Options"] = "DENY";
                h["X-Content-Type-Options"] = "nosniff";
                h["Referrer-Policy"] = "no-referrer";
                h["Cache-Control"] = "no-store, no-cache, must-revalidate, private";
                h["Pragma"] = "no-cache";
                h["Content-Security-Policy"] = "frame-ancestors 'none'";
            }
            await next.Invoke();
        });

        app.UseWebSockets();

        app.UseAuthorization();

        app.UseMiddleware<IPAllowMiddleware>();

        // app.UseStatusCodePagesWithReExecute("/Web/404");

        var webSocketOptions = new WebSocketOptions
        {
            KeepAliveInterval = TimeSpan.FromMinutes(2)
        };

        app.UseWebSockets(webSocketOptions);

        app.UseStaticFiles(new StaticFileOptions
        {
            FileProvider = new PhysicalFileProvider(Path.Combine(builder.Environment.ContentRootPath, "Data", "Videos")),
            RequestPath = "/cdn/video",
            OnPrepareResponse = ctx =>
            {
                ctx.Context.Response.Headers.Remove("Accept-Ranges");
                var allowedContentTypes = new[] 
                {
                    "video/mp4", // some webm video break recroom video screen and show artifact
                    "video/mkv"
                };
                if (!allowedContentTypes.Contains(ctx.Context.Response.ContentType))
                {
                    ctx.Context.Response.StatusCode = StatusCodes.Status403Forbidden;
                    ctx.Context.Response.Body = Stream.Null;
                }
            }
        });

        app.UseStaticFiles(new StaticFileOptions
        {
            FileProvider = new PhysicalFileProvider(
         Path.Combine(builder.Environment.ContentRootPath, "Data", "CDN", "Configs")
     ),
            RequestPath = "/cdn/config",
            OnPrepareResponse = ctx =>
            {
                ctx.Context.Response.Headers.Remove("Accept-Ranges");
            },
            ServeUnknownFileTypes = true // optional if some files have unknown extensions
        });

        // Third logging layer - dumps full request/response headers per request.
        // Same gate; this is pure overhead during normal play.
        if (ConfigCampus.VerboseRequestLogging)
        {
            app.UseHttpLogging();
        }

        // Campus admin panel: the LoginV4.html / HomeV4.html templates reference
        // /admin-assets/Cutout.png, /admin-assets/Background.png, /admin-assets/AnimatedIcon.png
        // for the Campus branding (purple/orange gradient + tile pattern + Cutout hero).
        // Mount those files from ContentRoot/AdminPanel/Assets - PackageServer.ps1 ships that
        // folder into the deploy tarball alongside Data/ and Web/.
        {
            string adminAssets = Path.Combine(builder.Environment.ContentRootPath, "AdminPanel", "Assets");
            if (Directory.Exists(adminAssets))
            {
                app.UseStaticFiles(new StaticFileOptions
                {
                    FileProvider = new PhysicalFileProvider(Path.GetFullPath(adminAssets)),
                    RequestPath = "/admin-assets",
                });
                Console.WriteLine($"[admin] assets from {Path.GetFullPath(adminAssets)}");
            }
            else
            {
                Console.WriteLine($"[admin] WARN: AdminPanel/Assets not found at {adminAssets} - Campus branding won't load");
            }
        }

        // Campus public website, served straight off ContentRoot/Website - this is what used
        // to be the separate Flask process in Website/server.py. Only the web assets were
        // copied across: server.py / build.py / requirements.txt / StartFlask*.bat stayed
        // behind on purpose, because mounting the Flask project folder at the web root would
        // publish its source (and any token.json sitting next to it) as downloadable files.
        //
        // NO UseDefaultFiles here. It would serve index.html for "/" from inside this
        // middleware, before routing runs, and "/" MUST reach WebController.NsRoot or the
        // game client cannot connect. NsRoot serves index.html itself for browsers.
        {
            string siteRoot = Path.Combine(builder.Environment.ContentRootPath, "Website");
            if (Directory.Exists(siteRoot))
            {
                app.UseStaticFiles(new StaticFileOptions
                {
                    FileProvider = new PhysicalFileProvider(Path.GetFullPath(siteRoot)),
                    RequestPath = "",     // mount at root: /app.js, /style.css, /assets/...
                    OnPrepareResponse = ctx =>
                    {
                        // Pages must not be cached (they change with every deploy); the
                        // fingerprinted css/js/images can be.
                        ctx.Context.Response.Headers["Cache-Control"] =
                            ctx.File.Name.EndsWith(".html", StringComparison.OrdinalIgnoreCase)
                                ? "no-cache"
                                : "public, max-age=3600";
                    }
                });
                Console.WriteLine($"[site] serving website from {Path.GetFullPath(siteRoot)}");
            }
            else
            {
                Console.WriteLine($"[site] WARN: {siteRoot} not found - the landing page will 404");
            }
        }

        app.MapControllers();

        //PlayerDB.EnsureDormsDontBeStupid(log: true);

        //RoomDB.d(51, 138, "f94c6b386d2b45a0a582f688022aba0c.room");

        //PlayerDB.ImportPlayers(Environment.CurrentDirectory + "/Data/exported_players.json");
        //await RoomDB.ImportRooms(Environment.CurrentDirectory + "/Data/yay.json");
        // Once everything is checked for prod release, uncomment this and import the players and rooms.
        /*
        await Task.Run(() =>
        {
            try
            {
                Webhook.Send(
                1,
                "prod",
                "Server Info",
                "Campus Live server just went online!",
                5898927
                );

            }
            catch (Exception ex)
            {
                Console.WriteLine($"{ex.Message}");
            }
        });
        */
        // PlayerDB.SetIsInfluencer(282, true);
        // PlayerDB.SetCreatorCode(282, "idk");
        // RoomDB.FixDuplicateDorms();
        // PlayerDB.EnsureDormsForAllPlayers();
        // PlayerDB.SetPlayerDev(Campus_live_rewrite.api.server.Classes.db_class.DevFlag.none, 3);
        // PlayerDB.ClearRecentRoomsForAllPlayers();
        // Start Discord bot in background — never let a bot fault take the web server down.
        _ = Task.Run(async () =>
        {
            try
            {
                Console.WriteLine("[DiscordBot] Starting...");
                await StartBotAsync(app.Services);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[DiscordBot] CRASHED: {ex}");
            }
        });
        // Only start the interactive command console when stdin is attached to a terminal.
        // Under systemd, stdin is /dev/null → ReadLine() returns null immediately and the loop
        // busy-spins, flooding the journal and starving other threads.
        if (!Console.IsInputRedirected)
        {
            new Thread(new ThreadStart(debug_run)).Start();
        }
        else
        {
            Console.WriteLine("[Startup] stdin is redirected — skipping CommandConsole (headless mode).");
        }
        
        PlayerDB.Setup();
        HeartbeatDB.Setup();
        RoomDB.Setup();
        RoomDB.RenameAllDormsToOwners();

        // Load the in-game token kill-switch epoch (admin "Expire all game tokens") so a revoke
        // survives restarts. See ClientSecurity / ConfigCampus.GameTokenValidFrom.
        Campus_live_rewrite.api.server.ClientSecurity.LoadGameTokenRevocation();

        // Index the UGC custom-avatar-item catalog (Data/APIS/items/UGC.json) into memory once, so
        // the customAvatarItems endpoints don't re-parse ~87MB per request. See CustomItemsCache.
        Campus_live_rewrite.api.server.CustomItemsCache.Load();

        // Bulk UGC import on boot: any avatar packs staged in Data/AvatarImportStaging/ (rsync'd
        // there - the no-browser path for a large library) are imported once, then the pack folder
        // is moved to _imported/ so a restart doesn't re-scan it. Assets are copied into AvatarBlobs
        // /Images and each item registered into the dev locker. See AvatarItemImporter.
        try
        {
            string staging = Path.Combine(Environment.CurrentDirectory, "Data", "AvatarImportStaging");
            if (Directory.Exists(staging))
            {
                string done = Path.Combine(staging, "_imported");
                foreach (var pack in Directory.EnumerateDirectories(staging))
                {
                    if (Path.GetFileName(pack).Equals("_imported", StringComparison.OrdinalIgnoreCase)) continue;
                    if (!Campus_live_rewrite.api.server.AvatarItemImporter.LooksLikeAvatarPack(pack)) continue;
                    var ar = Campus_live_rewrite.api.server.AvatarItemImporter.ImportDir(pack);
                    Console.WriteLine($"[avatar-staging] {Path.GetFileName(pack)}: {ar.Items} items, {ar.BundlesHosted} bundles, {ar.ThumbsHosted} images, {ar.MissingAssets.Count} missing");
                    try { Directory.CreateDirectory(done); Directory.Move(pack, Path.Combine(done, Path.GetFileName(pack) + "_" + DateTime.UtcNow.ToString("yyyyMMddHHmmss"))); } catch (Exception mv) { Console.WriteLine($"[avatar-staging] move-aside failed for {Path.GetFileName(pack)}: {mv.Message}"); }
                }
            }
        }
        catch (Exception stx) { Console.WriteLine($"[avatar-staging] scan failed: {stx.Message}"); }

        // Bulk ROOM import on boot from Data/RoomImportStaging/ (the no-browser path for big batches -
        // scp/rsync/sftp the files there, no fragile multi-GB browser upload). Handles, per entry:
        //   * a room-export FOLDER (RoomDetails.json + .binpb blobs) -> ImportRoomExport
        //   * a FOLDER of loose .room blobs                          -> wrap each loadable one
        //   * a .zip                    -> extract, then room-export OR loose-.room pack
        //   * a loose .room file        -> wrap it
        // Processed entries move to _imported/. See RoomDB.ImportRoomExport / RoomDB.WrapLooseRoom.
        try
        {
            string rstaging = Path.Combine(Environment.CurrentDirectory, "Data", "RoomImportStaging");
            if (Directory.Exists(rstaging))
            {
                ulong importerId = Campus_live_rewrite.api.dbs.PlayerDB.GetAccountIdByUsernameCI("Importer");
                ulong? owner = importerId == 0 ? (ulong?)null : importerId;
                string done = Path.Combine(rstaging, "_imported");

                async Task ProcessRoomDir(string dir, string label)
                {
                    if (Campus_live_rewrite.api.dbs.RoomDB.LooksLikeRoomExport(dir))
                    {
                        var rr = await Campus_live_rewrite.api.dbs.RoomDB.ImportRoomExport(dir, owner);
                        Console.WriteLine($"[room-staging] {label}: room-export -> {rr.Rooms} room(s) [{string.Join(", ", rr.Names.Take(8))}], {rr.Blobs} blob(s), {rr.Errors.Count} error(s)");
                        foreach (var e in rr.Errors.Take(10)) Console.WriteLine($"[room-staging]   ! {e}");
                    }
                    else
                    {
                        var roomFiles = Directory.EnumerateFiles(dir, "*.room", SearchOption.AllDirectories).ToList();
                        int made = 0, tooNew = 0, other = 0;
                        foreach (var rf in roomFiles)
                        {
                            var (st, id, ver, nm, _) = Campus_live_rewrite.api.dbs.RoomDB.WrapLooseRoom(rf, importerId);
                            if (st == Campus_live_rewrite.api.dbs.RoomDB.LooseWrapStatus.Created) made++;
                            else if (st == Campus_live_rewrite.api.dbs.RoomDB.LooseWrapStatus.TooNew) tooNew++;
                            else other++;
                        }
                        Console.WriteLine($"[room-staging] {label}: {roomFiles.Count} loose .room -> {made} room(s) created, {tooNew} too-new, {other} skipped");
                    }
                }

                // Loose .room files sitting directly in staging.
                foreach (var rf in Directory.EnumerateFiles(rstaging, "*.room", SearchOption.TopDirectoryOnly))
                {
                    var (st, id, ver, nm, err) = Campus_live_rewrite.api.dbs.RoomDB.WrapLooseRoom(rf, importerId);
                    Console.WriteLine($"[room-staging] {Path.GetFileName(rf)}: {st}" + (st == Campus_live_rewrite.api.dbs.RoomDB.LooseWrapStatus.Created ? $" '{nm}' (id {id}, v{ver})" : st == Campus_live_rewrite.api.dbs.RoomDB.LooseWrapStatus.TooNew ? $" (v{ver})" : ""));
                    try { Directory.CreateDirectory(done); Directory.Move(rf, Path.Combine(done, Path.GetFileName(rf))); } catch { }
                }

                // .zip files in staging: extract then process.
                foreach (var zip in Directory.EnumerateFiles(rstaging, "*.zip", SearchOption.TopDirectoryOnly))
                {
                    string ex = Path.Combine(rstaging, Path.GetFileNameWithoutExtension(zip) + "_x" + DateTime.UtcNow.ToString("HHmmss"));
                    try
                    {
                        Directory.CreateDirectory(ex);
                        System.IO.Compression.ZipFile.ExtractToDirectory(zip, ex, overwriteFiles: true);
                        await ProcessRoomDir(ex, Path.GetFileName(zip));
                        try { Directory.CreateDirectory(done); Directory.Move(zip, Path.Combine(done, Path.GetFileName(zip))); } catch { }
                        try { Directory.Delete(ex, true); } catch { }
                    }
                    catch (Exception zx) { Console.WriteLine($"[room-staging] {Path.GetFileName(zip)}: extract/import failed: {zx.Message}"); }
                }

                // Folders (room-export or loose-.room packs).
                foreach (var pack in Directory.EnumerateDirectories(rstaging))
                {
                    if (Path.GetFileName(pack).Equals("_imported", StringComparison.OrdinalIgnoreCase)) continue;
                    if (Path.GetFileName(pack).Contains("_x", StringComparison.Ordinal) && !Directory.EnumerateFileSystemEntries(pack).Any()) continue;
                    await ProcessRoomDir(pack, Path.GetFileName(pack));
                    try { Directory.CreateDirectory(done); Directory.Move(pack, Path.Combine(done, Path.GetFileName(pack) + "_" + DateTime.UtcNow.ToString("yyyyMMddHHmmss"))); } catch (Exception mv) { Console.WriteLine($"[room-staging] move-aside failed for {Path.GetFileName(pack)}: {mv.Message}"); }
                }
            }
        }
        catch (Exception rex) { Console.WriteLine($"[room-staging] scan failed: {rex.Message}"); }

        // Downgrade already-imported rooms' declared build version to the client's level, so rooms
        // imported before this fix stop failing the client's "older version of Rec Room" gate.
        try
        {
            ulong impId = Campus_live_rewrite.api.dbs.PlayerDB.GetAccountIdByUsernameCI("Importer");
            int clamped = Campus_live_rewrite.api.dbs.RoomDB.ClampImportedRoomsToClient(impId);
            if (clamped > 0) Console.WriteLine($"[room-version] downgraded {clamped} imported room(s) to the client build version");
            int purged = Campus_live_rewrite.api.dbs.RoomDB.RemoveTooNewLooseRooms(impId);
            if (purged > 0) Console.WriteLine($"[room-version] removed {purged} too-new loose-blob room(s) that would freeze the client");
        }
        catch (Exception cvx) { Console.WriteLine($"[room-version] clamp failed: {cvx.Message}"); }

        // End-of-game / quest reward pools (Data/APIS/quest-rewards.json) - keyed by mode + gift
        // context, rolled into a gift box on POST /api/gamerewards/v1/request. See QuestRewards.
        Campus_live_rewrite.api.server.QuestRewards.Load();

        // Weekly-challenge definition (Data/APIS/weekly-challenge.json) served by /api/challenge/v2.
        Campus_live_rewrite.api.server.WeeklyChallenge.Load();

        // ---- LiteDB write-ahead log handling ---------------------------------------------
        // Every LiteDatabase here is a static that is never disposed, so LiteDB's checkpoint
        // (which merges <name>-log.db back into <name>.db) never ran. Data accumulated in the
        // WAL indefinitely - and because install.sh preserves Data/DBs/* across deploys, that
        // WAL was carried into every subsequent build, which is why deploying a known-good
        // server changed nothing. Verified fix: the boot report caught Settings.db at 8KB with
        // a 7.7MB log, and after checkpointing the data files hold the data and the logs are 0.
        DbMaintenance.ReportWalState();

        // Merge the write-ahead logs into the data files every 5 minutes, not just at
        // shutdown. Without this, a hard kill leaves every write since boot recoverable
        // only by replaying the log.
        DbMaintenance.StartAutoCheckpoint(5);

        // Snapshot every LiteDB store 3x/day into Data/Backups, keep 3 days (admin "Database" tab).
        BackupService.Start();

        // Creator earnings: pay the sales whose Sunday has come (EarningsDB).
        Campus_live_rewrite.api.dbs.EarningsDB.Start();

        // The Coach is Level 99 and nobody else can be (Progress.PLAYER_MAX_LEVEL).
        try
        {
            ulong coach = Campus_live_rewrite.api.dbs.PlayerDB.GetAccountIdByUsernameCI(Campus_live_rewrite.api.server.ConfigCampus.Level99Username);
            if (coach != 0)
            {
                var cur = Campus_live_rewrite.api.server.Classes.Progress.GetPlayerLevel(coach);
                if (cur.Level != Campus_live_rewrite.api.server.Classes.Progress.MAX_LEVEL)
                {
                    Campus_live_rewrite.api.dbs.PlayerDB.SetProgression(coach, 0, Campus_live_rewrite.api.server.Classes.Progress.MAX_LEVEL);
                    Console.WriteLine($"[progression] {Campus_live_rewrite.api.server.ConfigCampus.Level99Username} ({coach}) set to Level {Campus_live_rewrite.api.server.Classes.Progress.MAX_LEVEL}");
                }
            }
        }
        catch (Exception ex) { Console.WriteLine($"[progression] level-99 seed skipped: {ex.Message}"); }

        app.Lifetime.ApplicationStopping.Register(() =>
        {
            Console.WriteLine("[Startup] shutting down - checkpointing LiteDB stores ...");
            DbMaintenance.StopAutoCheckpoint();
            BackupService.Stop();
            DbMaintenance.CheckpointAll();
        });

        // ---- Admin seed --------------------------------------------------------------------
        // Idempotent. On every start, make sure there's a Kyle account with dev_Flag=dev and
        // the operator password so the admin panel is always reachable, even after a fresh
        // deploy that ships with an empty Players.db. If the account already exists we DON'T
        // clobber it - operator may have changed the password from the panel.
        try
        {
            var col = Campus_live_rewrite.api.dbs.PlayerDB.PlayerDBFile
                        .GetCollection<Campus_live_rewrite.api.server.Classes.db_class.player_data>("players");
            var existing = col.FindOne(x => x.player != null && x.player.Username == "Kyle");
            if (existing == null)
            {
                // Seed via CreateAccount - random name + starter reputation - then rename to Kyle.
                if (Campus_live_rewrite.api.dbs.PlayerDB.CreateAccount(
                        Campus_live_rewrite.api.server.Classes.db_class.Platforms.All,
                        0UL, "", 0UL, out var seeded))
                {
                    var fresh = col.FindOne(x => x.playerid == seeded.accountId);
                    if (fresh != null && fresh.player != null)
                    {
                        fresh.player.Username = "Kyle";
                        fresh.player.DisplayName = "Kyle";
                        fresh.password = Campus_live_rewrite.api.server.ClientSecurity.HashPassword("VanessaPlease16#");
                        fresh.dev_Flag = Campus_live_rewrite.api.server.Classes.db_class.DevFlag.dev;
                        col.Update(fresh);
                        Console.WriteLine($"[admin-seed] created Kyle (id={fresh.playerid}) with dev flag - login: Kyle / VanessaPlease16#");
                    }
                }
                else
                {
                    Console.WriteLine("[admin-seed] CreateAccount returned false, Kyle NOT seeded");
                }
            }
            else
            {
                bool changed = false;
                if (string.IsNullOrEmpty(existing.password))
                {
                    existing.password = Campus_live_rewrite.api.server.ClientSecurity.HashPassword("VanessaPlease16#");
                    changed = true;
                }
                if ((existing.dev_Flag & Campus_live_rewrite.api.server.Classes.db_class.DevFlag.dev) !=
                     Campus_live_rewrite.api.server.Classes.db_class.DevFlag.dev)
                {
                    existing.dev_Flag |= Campus_live_rewrite.api.server.Classes.db_class.DevFlag.dev;
                    changed = true;
                }
                // Stamp Kyle's owner Discord + Steam IDs.
                existing.player_Extra ??= new Campus_live_rewrite.api.server.Classes.db_class.player_extra();
                if (existing.player_Extra.DiscordId != 1450391092984807445UL)
                {
                    existing.player_Extra.DiscordId = 1450391092984807445UL;
                    changed = true;
                }
                existing.platform = Campus_live_rewrite.api.server.Classes.db_class.Platforms.Steam;
                existing.player.PlatformIds ??= new List<Campus_live_rewrite.api.server.Classes.db_class.mPlatformID>();
                var steamEntry = existing.player.PlatformIds.FirstOrDefault(p => p != null && p.Platform == Campus_live_rewrite.api.server.Classes.db_class.Platforms.Steam);
                if (steamEntry == null)
                {
                    existing.player.PlatformIds.Add(new Campus_live_rewrite.api.server.Classes.db_class.mPlatformID
                    {
                        Platform = Campus_live_rewrite.api.server.Classes.db_class.Platforms.Steam,
                        PlatformId = 76561199059115358UL
                    });
                    changed = true;
                }
                else if (steamEntry.PlatformId != 76561199059115358UL)
                {
                    steamEntry.PlatformId = 76561199059115358UL;
                    changed = true;
                }
                if (changed) { col.Update(existing); Console.WriteLine($"[admin-seed] refreshed Kyle (id={existing.playerid}) - dev flag / discord / steam stamped"); }
                else         { Console.WriteLine($"[admin-seed] Kyle (id={existing.playerid}) already fine - no changes"); }

                // Force skip-orientation flags on Kyle so first login on this build doesn't
                // loop through the broken SocialOrientation load path.
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("TUTORIAL_COMPLETE_MASK",              "4294967295", existing.playerid);
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasFinished", "true",       existing.playerid);
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasChosenUsername",  "true", existing.playerid);
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasCreatedPassword", "true", existing.playerid);
            }
        }
        catch (Exception seedEx)
        {
            Console.WriteLine($"[admin-seed] FAILED: {seedEx.Message}");
        }

        // ---- @Importer seed ----------------------------------------------------------------
        // A second owner-controlled account that HOLDS the imported rooms. It shares Kyle's Steam
        // id and is account-lock exempt (ConfigCampus.LockExemptUsernames), so it can be signed
        // into from the same Steam/device as Kyle (log in with username "Importer"). Idempotent.
        try
        {
            var col = Campus_live_rewrite.api.dbs.PlayerDB.PlayerDBFile
                        .GetCollection<Campus_live_rewrite.api.server.Classes.db_class.player_data>("players");
            var imp = col.FindOne(x => x.player != null && x.player.Username == "Importer");
            if (imp == null &&
                Campus_live_rewrite.api.dbs.PlayerDB.CreateAccount(
                    Campus_live_rewrite.api.server.Classes.db_class.Platforms.All, 0UL, "", 0UL, out var impSeeded))
            {
                imp = col.FindOne(x => x.playerid == impSeeded.accountId);
            }
            if (imp != null && imp.player != null)
            {
                bool changed = false;
                if (imp.player.Username != "Importer") { imp.player.Username = "Importer"; imp.player.DisplayName = "Importer"; changed = true; }
                if (string.IsNullOrEmpty(imp.password)) { imp.password = Campus_live_rewrite.api.server.ClientSecurity.HashPassword("ImporterPlease16#"); changed = true; }
                imp.platform = Campus_live_rewrite.api.server.Classes.db_class.Platforms.Steam;
                imp.player.PlatformIds ??= new List<Campus_live_rewrite.api.server.Classes.db_class.mPlatformID>();
                var s = imp.player.PlatformIds.FirstOrDefault(p => p != null && p.Platform == Campus_live_rewrite.api.server.Classes.db_class.Platforms.Steam);
                if (s == null) { imp.player.PlatformIds.Add(new Campus_live_rewrite.api.server.Classes.db_class.mPlatformID { Platform = Campus_live_rewrite.api.server.Classes.db_class.Platforms.Steam, PlatformId = 76561199059115358UL }); changed = true; }
                else if (s.PlatformId != 76561199059115358UL) { s.PlatformId = 76561199059115358UL; changed = true; }
                if (changed) col.Update(imp);
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("TUTORIAL_COMPLETE_MASK",              "4294967295", imp.playerid);
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasFinished",         "true", imp.playerid);
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasChosenUsername",   "true", imp.playerid);
                Campus_live_rewrite.api.dbs.SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasCreatedPassword",  "true", imp.playerid);
                Console.WriteLine($"[admin-seed] Importer ready (id={imp.playerid}) - login: Importer / ImporterPlease16#");
            }
        }
        catch (Exception impEx) { Console.WriteLine($"[admin-seed] Importer seed FAILED: {impEx.Message}"); }

        // Mirror each Rooms 2.0 room's Accessibility onto its primary subroom's, so existing
        // published rooms appear per their real visibility (they set it on the subroom, but
        // Search/hot read the room-level field).
        try { Campus_live_rewrite.api.dbs.RoomDB.FixPlayerRoomFlags(); }
        catch (Exception _fEx) { Console.WriteLine("[rooms] player-room flag fix skipped: " + _fEx.Message); }
        try
        {
            int _synced = Campus_live_rewrite.api.dbs.RoomDB.SyncAllRoomAccessibility();
            if (_synced > 0) Console.WriteLine($"[rooms] synced room-level accessibility from subrooms for {_synced} room(s)");
        }
        catch (Exception _rEx) { Console.WriteLine("[rooms] accessibility sync skipped: " + _rEx.Message); }
        try
        {
            int _pres = Campus_live_rewrite.api.dbs.HeartbeatDB.FixOutOfRangePresence();
            if (_pres > 0) Console.WriteLine($"[presence] repaired {_pres} presence row(s) with out-of-range values");
        }
        catch (Exception _pEx) { Console.WriteLine("[presence] repair skipped: " + _pEx.Message); }
        // Room kicks were stored as permanent room bans ("Kicked by X"); those are lifted once.
        try
        {
            int _kicks = Campus_live_rewrite.api.dbs.RoomDB.LiftKickBans();
            Campus_live_rewrite.api.server.BundleHashes.WarmUp();   // item definitions carry the hash of the bundle we actually serve
            if (_kicks > 0) Console.WriteLine($"[rooms] lifted {_kicks} room ban(s) that were really kicks");
        }
        catch (Exception _kEx) { Console.WriteLine("[rooms] kick-ban lift skipped: " + _kEx.Message); }

        // Resolve the account-lock exemptions (Coach/Kyle -> their current account ids) now that
        // the admin-seed has run, so the owner's test accounts can share one Steam/device.
        // LiteDB 5's BsonMapper builds an entity's member map lazily and registers the map
        // BEFORE filling it; two requests hitting a not-yet-mapped type at once made the second
        // see an empty map and throw "Member X not found on BsonMapper for type Y" (seen on
        // ImageMetadataDB+Cheer, ClubDB+Club, ClubDB+ClubMember - random 500s on first use).
        // Build every mapper here, single-threaded, before Kestrel accepts a request.
        try
        {
            int warmed = 0;
            foreach (var t in typeof(Program).Assembly.GetTypes())
            {
                if (!t.IsClass || t.IsAbstract || t.IsGenericTypeDefinition || t.IsNested && !t.IsNestedPublic && !t.IsNestedPrivate) continue;
                // The global-namespace stores (ClubDB, ImageMetadataDB, InventionDB, InventionStore...)
                // were skipped here, which is exactly where the race kept firing.
                if (t.Namespace != null && !(t.Namespace.StartsWith("Campus_live_rewrite.api.dbs") || t.Namespace.StartsWith("Campus_live_rewrite.api.server"))) continue;
                if (t.Name.EndsWith("Controller") || t.Name.EndsWith("Middleware")) continue;
                if (t.GetConstructor(Type.EmptyTypes) == null) continue;
                try { LiteDB.BsonMapper.Global.ToDocument(t, Activator.CreateInstance(t)!); warmed++; } catch { }
            }
            Console.WriteLine($"[litedb] pre-built {warmed} entity mappers");
        }
        catch (Exception ex) { Console.WriteLine($"[litedb] mapper warm-up failed: {ex.Message}"); }

        // Nobody runs Orientation (ConfigCampus.SkipOrientation). Existing accounts that were
        // parked mid-flow - tutorial mask 0, AccountCreation.* false - are settled here, once, so
        // they stop being dropped back into it on login.
        if (Campus_live_rewrite.api.server.ConfigCampus.SkipOrientation)
        {
            try
            {
                int _skipped = Campus_live_rewrite.api.dbs.SettingsDB.SkipOrientationForAllPlayers();
                if (_skipped > 0) Console.WriteLine($"[orientation] marked complete for {_skipped} existing account(s)");
            }
            catch (Exception _oEx) { Console.WriteLine("[orientation] backfill skipped: " + _oEx.Message); }
        }

        try { Campus_live_rewrite.api.server.UploadGuard.LoadPenalties(); }
        catch (Exception ex) { Console.WriteLine($"[upload-guard] load failed: {ex.Message}"); }
        if (Campus_live_rewrite.api.server.ConfigCampus.UploadSweepOnStartup)
        {
            // A minute after boot so it never competes with startup; quarantines, never deletes.
            _ = Task.Run(async () =>
            {
                await Task.Delay(TimeSpan.FromSeconds(60));
                try { Campus_live_rewrite.api.server.UploadGuard.SweepStorage(dryRun: Campus_live_rewrite.api.server.ConfigCampus.UploadSweepDryRun); }
                catch (Exception ex) { Console.WriteLine($"[upload-guard] sweep failed: {ex.Message}"); }
            });
        }
        try { Campus_live_rewrite.api.server.AccountLock.ResolveExemptions(); }
        catch (Exception _lEx) { Console.WriteLine("[account-lock] exemption resolve skipped: " + _lEx.Message); }


        app.Run();
        //await botTask;
    }
    public static async Task StartBotAsync(IServiceProvider services)
    {
        var bot = services.GetRequiredService<DiscordBot>();
        await bot.RunAsync();
    }

    public static void debug_run()
    {
        new CommandConsole();
    }
}