namespace GeoSus.Server;

using System.Collections.Concurrent;
using System.Net;
using System.Net.WebSockets;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Logging;

/// <summary>
/// Admin Panel - Webová administrace serveru
/// 
/// Funkce:
/// - Přehled stavu serveru
/// - Real-time spectate mode pro lobby
/// - Konfigurace serveru za běhu
/// - Informace o hráčích
/// - WebSocket pro live updates
/// </summary>
public class AdminPanel
{
    private readonly ILogger<AdminPanel> _logger;
    private readonly ServerConfig _config;
    private readonly LobbyManager _lobbyManager;
    private readonly StatsDb _statsDb;
    
    // Bezpečnost
    private readonly string _adminPasswordHash;
    private readonly ConcurrentDictionary<string, AdminSession> _sessions = new();
    private readonly TimeSpan _sessionTimeout = TimeSpan.FromHours(8);
    
    // WebSocket connections pro spectate
    private readonly ConcurrentDictionary<string, SpectatorConnection> _spectators = new();
    
    public AdminPanel(
        ILogger<AdminPanel> logger,
        ServerConfig config,
        LobbyManager lobbyManager,
        StatsDb statsDb)
    {
        _logger = logger;
        _config = config;
        _lobbyManager = lobbyManager;
        _statsDb = statsDb;
        
        // Hash admin hesla (z env nebo default)
        var adminPassword = Environment.GetEnvironmentVariable("GEOSUS_ADMIN_PASSWORD") ?? "admin123";
        _adminPasswordHash = HashPassword(adminPassword);
        
        _logger.LogInformation("Admin Panel inicializován");
    }
    
    #region ═══════════════════════════════════════════════════════════════════
    //                         AUTENTIZACE
    // ════════════════════════════════════════════════════════════════════════
    #endregion
    
    private static string HashPassword(string password)
    {
        using var sha256 = SHA256.Create();
        var bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(password + "GeoSus_Salt_2026"));
        return Convert.ToBase64String(bytes);
    }
    
    private string? ValidateSession(HttpListenerRequest request)
    {
        var cookie = request.Cookies["geosus_admin_session"];
        if (cookie == null) return null;
        
        if (_sessions.TryGetValue(cookie.Value, out var session))
        {
            if (DateTime.UtcNow - session.LastActivity < _sessionTimeout)
            {
                session.LastActivity = DateTime.UtcNow;
                return cookie.Value;
            }
            _sessions.TryRemove(cookie.Value, out _);
        }
        return null;
    }
    
    private string CreateSession()
    {
        var sessionId = Convert.ToBase64String(RandomNumberGenerator.GetBytes(32));
        _sessions[sessionId] = new AdminSession { LastActivity = DateTime.UtcNow };
        return sessionId;
    }
    
    #region ═══════════════════════════════════════════════════════════════════
    //                         HTTP HANDLING
    // ════════════════════════════════════════════════════════════════════════
    #endregion
    
    public async Task HandleRequestAsync(HttpListenerContext context)
    {
        var request = context.Request;
        var response = context.Response;
        var path = request.Url?.AbsolutePath ?? "/";
        
        try
        {
            // Login endpoint - vždy přístupný
            if (path == "/admin/login" && request.HttpMethod == "POST")
            {
                await HandleLoginAsync(request, response);
                return;
            }
            
            // Statické soubory pro login stránku - bez autentizace
            if (path == "/admin" || path == "/admin/")
            {
                await ServeStaticFileAsync(response, "admin.html", "text/html");
                return;
            }
            
            // CSS a JS musí být dostupné bez autentizace (pro login stránku)
            if (path == "/admin/app.js")
            {
                await ServeStaticFileAsync(response, "admin.js", "application/javascript");
                return;
            }
            
            if (path == "/admin/style.css")
            {
                await ServeStaticFileAsync(response, "admin.css", "text/css");
                return;
            }
            
            // Všechno ostatní vyžaduje autentizaci
            var sessionId = ValidateSession(request);
            if (sessionId == null)
            {
                response.StatusCode = 401;
                await WriteJsonAsync(response, new { error = "Unauthorized", redirect = "/admin" });
                return;
            }
            
            // WebSocket pro spectate
            if (path.StartsWith("/admin/ws/spectate/") && request.IsWebSocketRequest)
            {
                var lobbyId = path["/admin/ws/spectate/".Length..];
                await HandleSpectateWebSocketAsync(context, lobbyId, sessionId);
                return;
            }
            
            // WebSocket pro server stats
            if (path == "/admin/ws/stats" && request.IsWebSocketRequest)
            {
                await HandleStatsWebSocketAsync(context, sessionId);
                return;
            }
            
            // REST API endpointy
            switch (path)
            {
                case "/admin/api/status":
                    await HandleStatusAsync(response);
                    break;
                    
                case "/admin/api/lobbies":
                    await HandleLobbiesAsync(response);
                    break;
                    
                case "/admin/api/config":
                    if (request.HttpMethod == "GET")
                        await HandleGetConfigAsync(response);
                    else if (request.HttpMethod == "POST")
                        await HandleSetConfigAsync(request, response);
                    break;
                    
                case "/admin/api/players":
                    await HandlePlayersAsync(request, response);
                    break;
                    
                case "/admin/api/kick":
                    await HandleKickAsync(request, response);
                    break;
                    
                case "/admin/api/broadcast":
                    await HandleBroadcastAsync(request, response);
                    break;
                    
                case "/admin/api/logout":
                    _sessions.TryRemove(sessionId, out _);
                    response.SetCookie(new Cookie("geosus_admin_session", "", "/admin") { Expired = true });
                    await WriteJsonAsync(response, new { success = true });
                    break;
                    
                default:
                    response.StatusCode = 404;
                    await WriteJsonAsync(response, new { error = "Not found" });
                    break;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Admin panel error: {Path}", path);
            
            // Don't try to write response for WebSocket requests (already submitted)
            if (!request.IsWebSocketRequest)
            {
                try
                {
                    response.StatusCode = 500;
                    await WriteJsonAsync(response, new { error = ex.Message });
                }
                catch { /* Response may already be sent */ }
            }
        }
    }
    
    #region ═══════════════════════════════════════════════════════════════════
    //                         LOGIN
    // ════════════════════════════════════════════════════════════════════════
    #endregion
    
    private async Task HandleLoginAsync(HttpListenerRequest request, HttpListenerResponse response)
    {
        using var reader = new StreamReader(request.InputStream);
        var body = await reader.ReadToEndAsync();
        var data = JsonSerializer.Deserialize<JsonElement>(body);
        
        var password = data.GetProperty("password").GetString() ?? "";
        var hash = HashPassword(password);
        
        if (hash == _adminPasswordHash)
        {
            var sessionId = CreateSession();
            response.SetCookie(new Cookie("geosus_admin_session", sessionId, "/admin")
            {
                HttpOnly = true,
                Expires = DateTime.Now.Add(_sessionTimeout)
            });
            
            _logger.LogInformation("Admin login successful from {IP}", request.RemoteEndPoint);
            await WriteJsonAsync(response, new { success = true });
        }
        else
        {
            _logger.LogWarning("Admin login failed from {IP}", request.RemoteEndPoint);
            response.StatusCode = 401;
            await WriteJsonAsync(response, new { error = "Invalid password" });
        }
    }
    
    #region ═══════════════════════════════════════════════════════════════════
    //                         API ENDPOINTS
    // ════════════════════════════════════════════════════════════════════════
    #endregion
    
    private async Task HandleStatusAsync(HttpListenerResponse response)
    {
        var uptime = DateTime.UtcNow - Program.StartTime;
        var status = new
        {
            status = "online",
            version = "1.0.0",
            uptime = new
            {
                days = uptime.Days,
                hours = uptime.Hours,
                minutes = uptime.Minutes,
                seconds = uptime.Seconds,
                totalSeconds = (long)uptime.TotalSeconds
            },
            lobbies = new
            {
                active = _lobbyManager.LobbyCount,
                players = _lobbyManager.TotalPlayerCount
            },
            memory = new
            {
                usedMb = GC.GetTotalMemory(false) / 1024 / 1024,
                gcCollections = new
                {
                    gen0 = GC.CollectionCount(0),
                    gen1 = GC.CollectionCount(1),
                    gen2 = GC.CollectionCount(2)
                }
            },
            sessions = _sessions.Count,
            spectators = _spectators.Count
        };
        
        await WriteJsonAsync(response, status);
    }
    
    private async Task HandleLobbiesAsync(HttpListenerResponse response)
    {
        var lobbies = _lobbyManager.GetAllLobbies().Select(l => new
        {
            id = l.LobbyId,
            joinCode = l.JoinCode,
            phase = l.Phase.ToString(),
            players = l.GetPlayers().Select(p => new
            {
                id = p.PlayerId,
                name = p.DisplayName,
                state = p.State.ToString(),
                role = p.Role.ToString(),
                position = new { lat = p.Position.Lat, lng = p.Position.Lon },
                isHost = p.IsHost
            }),
            playerCount = l.PlayerCount,
            settings = new
            {
                impostorCount = l.Settings.ImpostorCount,
                taskCount = l.Settings.TaskCount,
                center = new { lat = l.Settings.PlayAreaCenter.Lat, lng = l.Settings.PlayAreaCenter.Lon },
                radius = l.Settings.PlayAreaRadius
            },
            createdAt = l.CreatedAt,
            activeSabotage = l.ActiveSabotage?.Type.ToString()
        });
        
        await WriteJsonAsync(response, new { lobbies });
    }
    
    private async Task HandleGetConfigAsync(HttpListenerResponse response)
    {
        // Vrátíme pouze bezpečné konfigurace (ne hesla apod.)
        var config = new
        {
            tcpPort = _config.TcpPort,
            httpPort = _config.HttpPort,
            maxPlayersPerLobby = _config.MaxPlayersPerLobby,
            killDistanceM = _config.KillDistanceM,
            killCooldownMs = _config.KillCooldownMs,
            discussionPhaseMs = _config.DiscussionPhaseMs,
            votingPhaseMs = _config.VotingPhaseMs,
            taskStartDistanceM = _config.TaskStartDistanceM,
            sabotageCooldownMs = _config.SabotageCooldownMs,
            criticalMeltdownDeadlineMs = _config.CriticalMeltdownDeadlineMs,
            maxSpeedMps = _config.MaxSpeedMps,
            teleportThresholdMeters = _config.TeleportThresholdMeters
        };
        
        await WriteJsonAsync(response, config);
    }
    
    private async Task HandleSetConfigAsync(HttpListenerRequest request, HttpListenerResponse response)
    {
        using var reader = new StreamReader(request.InputStream);
        var body = await reader.ReadToEndAsync();
        var data = JsonSerializer.Deserialize<JsonElement>(body);
        
        // Aplikuj změny
        if (data.TryGetProperty("killDistanceM", out var kd)) _config.KillDistanceM = kd.GetDouble();
        if (data.TryGetProperty("killCooldownMs", out var kc)) _config.KillCooldownMs = kc.GetInt32();
        if (data.TryGetProperty("discussionPhaseMs", out var dp)) _config.DiscussionPhaseMs = dp.GetInt32();
        if (data.TryGetProperty("votingPhaseMs", out var vp)) _config.VotingPhaseMs = vp.GetInt32();
        if (data.TryGetProperty("maxSpeedMps", out var ms)) _config.MaxSpeedMps = ms.GetDouble();
        
        _logger.LogInformation("Config updated via admin panel");
        
        await WriteJsonAsync(response, new { success = true });
    }
    
    private async Task HandlePlayersAsync(HttpListenerRequest request, HttpListenerResponse response)
    {
        var query = request.QueryString;
        var search = query["search"] ?? "";
        
        var allPlayers = _lobbyManager.GetAllLobbies()
            .SelectMany(l => l.GetPlayers().Select(p => new
            {
                playerId = p.PlayerId,
                displayName = p.DisplayName,
                lobbyId = l.LobbyId,
                joinCode = l.JoinCode,
                state = p.State.ToString(),
                role = p.Role.ToString(),
                position = new { lat = p.Position.Lat, lng = p.Position.Lon },
                isHost = p.IsHost,
                cheatScore = p.CheatScore
            }))
            .Where(p => string.IsNullOrEmpty(search) || 
                        p.displayName.Contains(search, StringComparison.OrdinalIgnoreCase) ||
                        p.playerId.Contains(search, StringComparison.OrdinalIgnoreCase))
            .ToList();
        
        await WriteJsonAsync(response, new { players = allPlayers, total = allPlayers.Count });
    }
    
    private async Task HandleKickAsync(HttpListenerRequest request, HttpListenerResponse response)
    {
        using var reader = new StreamReader(request.InputStream);
        var body = await reader.ReadToEndAsync();
        var data = JsonSerializer.Deserialize<JsonElement>(body);
        
        var playerId = data.GetProperty("playerId").GetString();
        var reason = data.TryGetProperty("reason", out var r) ? r.GetString() : "Kicked by admin";
        
        // Najdi hráče a kickni ho
        foreach (var lobby in _lobbyManager.GetAllLobbies())
        {
            if (lobby.TryKickPlayer(playerId!, reason!))
            {
                _logger.LogInformation("Player {PlayerId} kicked by admin: {Reason}", playerId, reason);
                await WriteJsonAsync(response, new { success = true });
                return;
            }
        }
        
        response.StatusCode = 404;
        await WriteJsonAsync(response, new { error = "Player not found" });
    }
    
    private async Task HandleBroadcastAsync(HttpListenerRequest request, HttpListenerResponse response)
    {
        using var reader = new StreamReader(request.InputStream);
        var body = await reader.ReadToEndAsync();
        var data = JsonSerializer.Deserialize<JsonElement>(body);
        
        var message = data.GetProperty("message").GetString();
        var lobbyId = data.TryGetProperty("lobbyId", out var l) ? l.GetString() : null;
        
        if (string.IsNullOrEmpty(lobbyId))
        {
            // Broadcast všem
            foreach (var lobby in _lobbyManager.GetAllLobbies())
            {
                lobby.BroadcastSystemMessage(message!);
            }
        }
        else
        {
            // Broadcast do konkrétní lobby
            var lobby = _lobbyManager.GetLobby(lobbyId);
            lobby?.BroadcastSystemMessage(message!);
        }
        
        _logger.LogInformation("Admin broadcast: {Message}", message);
        await WriteJsonAsync(response, new { success = true });
    }
    
    #region ═══════════════════════════════════════════════════════════════════
    //                         WEBSOCKET - SPECTATE
    // ════════════════════════════════════════════════════════════════════════
    #endregion
    
    private async Task HandleSpectateWebSocketAsync(HttpListenerContext context, string lobbyId, string sessionId)
    {
        var wsContext = await context.AcceptWebSocketAsync(null);
        var ws = wsContext.WebSocket;
        var spectatorId = Guid.NewGuid().ToString("N")[..8];
        
        var lobby = _lobbyManager.GetLobby(lobbyId);
        if (lobby == null)
        {
            try
            {
                await ws.CloseAsync(WebSocketCloseStatus.InvalidPayloadData, "Lobby not found", CancellationToken.None);
            }
            catch (WebSocketException) { /* Client already disconnected */ }
            return;
        }
        
        var connection = new SpectatorConnection
        {
            WebSocket = ws,
            LobbyId = lobbyId,
            SessionId = sessionId
        };
        
        _spectators[spectatorId] = connection;
        _logger.LogInformation("Spectator {Id} connected to lobby {LobbyId}", spectatorId, lobbyId);
        
        try
        {
            // Pošli initial state
            await SendLobbyStateAsync(ws, lobby);
            
            var buffer = new byte[4096];
            var updateInterval = TimeSpan.FromMilliseconds(200);
            var cts = new CancellationTokenSource();
            var receivedMessage = new TaskCompletionSource<(bool closed, string? message)>();
            
            // Spustíme receive task separátně
            var receiveTask = Task.Run(async () =>
            {
                try
                {
                    while (ws.State == WebSocketState.Open && !cts.Token.IsCancellationRequested)
                    {
                        var result = await ws.ReceiveAsync(new ArraySegment<byte>(buffer), cts.Token);
                        if (result.MessageType == WebSocketMessageType.Close)
                        {
                            return true; // closed
                        }
                        
                        if (result.Count > 0)
                        {
                            var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                            await HandleSpectatorMessageAsync(ws, lobby!, message);
                        }
                    }
                }
                catch (OperationCanceledException) { }
                catch (WebSocketException) { }
                return ws.State != WebSocketState.Open;
            });
            
            // Hlavní smyčka posílá state
            while (ws.State == WebSocketState.Open && !receiveTask.IsCompleted)
            {
                lobby = _lobbyManager.GetLobby(lobbyId);
                if (lobby != null)
                {
                    await SendLobbyStateAsync(ws, lobby);
                }
                else
                {
                    break;
                }
                
                try
                {
                    await Task.WhenAny(receiveTask, Task.Delay(updateInterval, cts.Token));
                }
                catch (OperationCanceledException) { break; }
            }
            
            cts.Cancel();
            
            // Gracefully close if still open
            if (ws.State == WebSocketState.Open)
            {
                try
                {
                    await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, lobby == null ? "Lobby closed" : "Closing", CancellationToken.None);
                }
                catch (WebSocketException) { /* Already closed by client */ }
            }
        }
        catch (WebSocketException)
        {
            // Client disconnected - this is normal
        }
        catch (Exception ex)
        {
            _logger.LogDebug(ex, "Spectate WebSocket error");
        }
        finally
        {
            _spectators.TryRemove(spectatorId, out _);
            _logger.LogInformation("Spectator {Id} disconnected", spectatorId);
        }
    }
    
    private async Task SendLobbyStateAsync(WebSocket ws, LobbyActor lobby)
    {
        var state = new
        {
            type = "state",
            lobby = new
            {
                id = lobby.LobbyId,
                joinCode = lobby.JoinCode,
                phase = lobby.Phase.ToString(),
                phaseEndTime = lobby.PhaseEndTime?.ToString("o"),
                
                players = lobby.GetPlayers().Select(p => new
                {
                    id = p.PlayerId,
                    name = p.DisplayName,
                    state = p.State.ToString(),
                    role = p.Role.ToString(),
                    lat = p.Position.Lat,
                    lng = p.Position.Lon,
                    isHost = p.IsHost,
                    cheatScore = p.CheatScore,
                    killCooldownEnd = p.KillCooldownEnd?.ToString("o"),
                    votedFor = p.VotedFor
                }),
                
                tasks = lobby.GetTasks().Select(t => new
                {
                    id = t.TaskId,
                    name = t.Name,
                    lat = t.Location.Lat,
                    lng = t.Location.Lon,
                    completedBy = t.CompletedBy.ToList()
                }),
                
                bodies = lobby.GetBodies().Select(b => new
                {
                    victimId = b.VictimId,
                    lat = b.Position.Lat,
                    lng = b.Position.Lon,
                    reportedAt = b.ReportedAt?.ToString("o")
                }),
                
                sabotage = lobby.ActiveSabotage != null ? new
                {
                    type = lobby.ActiveSabotage.Type.ToString(),
                    deadline = lobby.ActiveSabotage.Deadline?.ToString("o"),
                    repairStations = lobby.ActiveSabotage.RepairStations.Select(rs => new
                    {
                        id = rs.StationId,
                        lat = rs.Location.Lat,
                        lng = rs.Location.Lon,
                        isRepaired = rs.IsRepaired
                    })
                } : null,
                
                votes = lobby.Phase == GamePhase.Voting ? lobby.GetVotes() : null,
                
                settings = new
                {
                    center = new { lat = lobby.Settings.PlayAreaCenter.Lat, lng = lobby.Settings.PlayAreaCenter.Lon },
                    radius = lobby.Settings.PlayAreaRadius,
                    impostorCount = lobby.Settings.ImpostorCount,
                    taskCount = lobby.Settings.TaskCount
                },
                
                mapData = lobby.MapData // Overpass data pro vykreslení mapy
            },
            timestamp = DateTime.UtcNow.ToString("o")
        };
        
        var json = JsonSerializer.Serialize(state, JsonOptions.Default);
        var bytes = Encoding.UTF8.GetBytes(json);
        
        if (ws.State == WebSocketState.Open)
        {
            await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, CancellationToken.None);
        }
    }
    
    private async Task HandleSpectatorMessageAsync(WebSocket ws, LobbyActor lobby, string message)
    {
        try
        {
            var data = JsonSerializer.Deserialize<JsonElement>(message);
            var type = data.GetProperty("type").GetString();
            
            switch (type)
            {
                case "ping":
                    await SendJsonAsync(ws, new { type = "pong" });
                    break;
                    
                case "getPlayerHistory":
                    var playerId = data.GetProperty("playerId").GetString();
                    var stats = _statsDb.GetPlayerStats(playerId!);
                    await SendJsonAsync(ws, new { type = "playerHistory", stats });
                    break;
            }
        }
        catch { }
    }
    
    #region ═══════════════════════════════════════════════════════════════════
    //                         WEBSOCKET - SERVER STATS
    // ════════════════════════════════════════════════════════════════════════
    #endregion
    
    private async Task HandleStatsWebSocketAsync(HttpListenerContext context, string sessionId)
    {
        var wsContext = await context.AcceptWebSocketAsync(null);
        var ws = wsContext.WebSocket;
        
        try
        {
            var buffer = new byte[1024];
            var updateInterval = TimeSpan.FromSeconds(1);
            var cts = new CancellationTokenSource();
            
            // Spustíme receive task separátně - bude běžet celou dobu
            var receiveTask = Task.Run(async () =>
            {
                try
                {
                    while (ws.State == WebSocketState.Open && !cts.Token.IsCancellationRequested)
                    {
                        var result = await ws.ReceiveAsync(new ArraySegment<byte>(buffer), cts.Token);
                        if (result.MessageType == WebSocketMessageType.Close)
                        {
                            return;
                        }
                    }
                }
                catch (OperationCanceledException) { }
                catch (WebSocketException) { }
            });
            
            // Hlavní smyčka posílá stats
            while (ws.State == WebSocketState.Open && !receiveTask.IsCompleted)
            {
                var uptime = DateTime.UtcNow - Program.StartTime;
                var stats = new
                {
                    type = "stats",
                    uptime = (long)uptime.TotalSeconds,
                    lobbies = _lobbyManager.LobbyCount,
                    players = _lobbyManager.TotalPlayerCount,
                    memoryMb = GC.GetTotalMemory(false) / 1024 / 1024,
                    spectators = _spectators.Count,
                    timestamp = DateTime.UtcNow.ToString("o")
                };
                
                await SendJsonAsync(ws, stats);
                
                // Čekáme na interval nebo ukončení receive tasku
                var delayTask = Task.Delay(updateInterval, cts.Token);
                try
                {
                    await Task.WhenAny(receiveTask, delayTask);
                }
                catch (OperationCanceledException) { break; }
            }
            
            cts.Cancel();
            
            if (ws.State == WebSocketState.Open)
            {
                try
                {
                    await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
                }
                catch (WebSocketException) { /* Already closed */ }
            }
        }
        catch (WebSocketException) { }
        catch (Exception ex)
        {
            _logger.LogDebug(ex, "Stats WebSocket error");
        }
    }
    
    #region ═══════════════════════════════════════════════════════════════════
    //                         HELPERS
    // ════════════════════════════════════════════════════════════════════════
    #endregion
    
    private static async Task WriteJsonAsync(HttpListenerResponse response, object data)
    {
        response.ContentType = "application/json";
        var json = JsonSerializer.Serialize(data, JsonOptions.Default);
        var bytes = Encoding.UTF8.GetBytes(json);
        response.ContentLength64 = bytes.Length;
        await response.OutputStream.WriteAsync(bytes);
    }
    
    private static async Task SendJsonAsync(WebSocket ws, object data)
    {
        var json = JsonSerializer.Serialize(data, JsonOptions.Default);
        var bytes = Encoding.UTF8.GetBytes(json);
        if (ws.State == WebSocketState.Open)
        {
            await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, CancellationToken.None);
        }
    }
    
    private async Task ServeStaticFileAsync(HttpListenerResponse response, string filename, string contentType)
    {
        var content = GetEmbeddedResource(filename);
        if (content == null)
        {
            response.StatusCode = 404;
            return;
        }
        
        response.ContentType = contentType + "; charset=utf-8";
        var bytes = Encoding.UTF8.GetBytes(content);
        response.ContentLength64 = bytes.Length;
        await response.OutputStream.WriteAsync(bytes);
    }
    
    private string? GetEmbeddedResource(string filename)
    {
        // Embedded resources z AdminResources třídy
        return filename switch
        {
            "admin.html" => AdminResources.Html,
            "admin.css" => AdminResources.Css,
            "admin.js" => AdminResources.JavaScript,
            _ => null
        };
    }
}

public class AdminSession
{
    public DateTime LastActivity { get; set; }
}

public class SpectatorConnection
{
    public required WebSocket WebSocket { get; set; }
    public required string LobbyId { get; set; }
    public required string SessionId { get; set; }
}