using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Web;

// ============================================================
// Queue Ticket System — Pure C# Console Application with SSE
// No ASP.NET, No Kestrel, No Framework
// Just a TcpListener, raw HTTP, and Server-Sent Events.
// ============================================================

class Program
{
    // --- Configuration ---
    static int Port = 8080;

    // --- Departments ---
    static Dictionary<int, string> Departments = new Dictionary<int, string>
    {
        { 1, "General Inquiries" },
        { 2, "Payments" },
        { 3, "License Services" },
        { 4, "Account & Register" }
    };

    // --- Ticket counters per department ---
    // Department 1 starts at 1000, Department 2 at 2000, etc.
    static Dictionary<int, int> NextTicketNumber = new Dictionary<int, int>
    {
        { 1, 1000 },
        { 2, 2000 },
        { 3, 3000 },
        { 4, 4000 }
    };

    // --- Queue: tickets waiting to be called, per department ---
    static Dictionary<int, Queue<int>> WaitingQueues = new Dictionary<int, Queue<int>>
    {
        { 1, new Queue<int>() },
        { 2, new Queue<int>() },
        { 3, new Queue<int>() },
        { 4, new Queue<int>() }
    };

    // --- Call history ---
    static List<QueueCall> CallHistory = new List<QueueCall>();

    // --- SSE clients ---
    static List<SseClient> DisplayClients = new List<SseClient>();
    static int SseEventId = 0;

    // --- Lock for thread safety ---
    static object Lock = new object();

    static void Main(string[] args)
    {
        TcpListener listener = new TcpListener(IPAddress.Any, Port);
        listener.Start();

        Console.WriteLine($"Queue Ticket System started on port {Port}");
        Console.WriteLine($"Display:  http://localhost:{Port}/display");
        Console.WriteLine($"Terminal: http://localhost:{Port}/terminal");
        Console.WriteLine($"Operator: http://localhost:{Port}/operator");
        Console.WriteLine();

        while (true)
        {
            TcpClient client = listener.AcceptTcpClient();
            Thread thread = new Thread(() => HandleClient(client));
            thread.IsBackground = true;
            thread.Start();
        }
    }

    // ============================================================
    // Layer 1: HTTP — Read request, route, write response
    // ============================================================

    static void HandleClient(TcpClient client)
    {
        try
        {
            NetworkStream stream = client.GetStream();
            stream.ReadTimeout = 5000;

            // Wait briefly for data to arrive
            if (!stream.DataAvailable)
            {
                // Give the client a moment to send data
                System.Threading.Thread.Sleep(500);
                if (!stream.DataAvailable) return; // nothing came, abandon
            }

            // --- Read headers byte-by-byte until \r\n\r\n ---
            StringBuilder headerBuilder = new StringBuilder();
            int prev3 = 0, prev2 = 0, prev1 = 0, current = 0;

            while (true)
            {
                int b = stream.ReadByte();
                if (b == -1) return;

                headerBuilder.Append((char)b);

                prev3 = prev2;
                prev2 = prev1;
                prev1 = current;
                current = b;

                if (prev3 == '\r' && prev2 == '\n' && prev1 == '\r' && current == '\n')
                    break;
            }

            string headerSection = headerBuilder.ToString();

            // --- Parse Content-Length ---
            int contentLength = 0;
            string[] headerLines = headerSection.Split(new[] { "\r\n" }, StringSplitOptions.None);

            foreach (string line in headerLines)
            {
                if (line.StartsWith("Content-Length:", StringComparison.OrdinalIgnoreCase))
                {
                    string val = line.Substring("Content-Length:".Length).Trim();
                    int.TryParse(val, out contentLength);
                    break;
                }
            }

            // --- Read body ---
            string body = "";
            if (contentLength > 0)
            {
                byte[] bodyBuffer = new byte[contentLength];
                int totalRead = 0;
                while (totalRead < contentLength)
                {
                    int read = stream.Read(bodyBuffer, totalRead, contentLength - totalRead);
                    if (read == 0) break;
                    totalRead += read;
                }
                body = Encoding.UTF8.GetString(bodyBuffer, 0, totalRead);
            }

            // --- Parse request ---
            HttpRequest request = ParseHttpRequest(headerSection, body);
            Console.WriteLine($"{request.Method} {request.Path}");

            // --- Route ---
            string path = request.Path;

            // SSE endpoints — these hold the connection open
            if (path == "/sse-display")
            {
                HandleSseDisplay(client, stream);
                return; // don't close — SSE keeps the connection alive
            }

            // Normal HTTP endpoints
            string responseHtml;
            int statusCode = 200;

            switch (path)
            {
                case "/":
                case "/display":
                    responseHtml = PageDisplay();
                    break;
                case "/terminal":
                    responseHtml = PageTerminal(request);
                    break;
                case "/operator":
                    responseHtml = PageOperator(request);
                    break;
                default:
                    responseHtml = PageNotFound();
                    statusCode = 404;
                    break;
            }

            // --- Send HTTP response ---
            string statusText = statusCode == 200 ? "OK" : "Not Found";
            string httpResponse =
                $"HTTP/1.1 {statusCode} {statusText}\r\n" +
                "Content-Type: text/html; charset=utf-8\r\n" +
                $"Content-Length: {Encoding.UTF8.GetByteCount(responseHtml)}\r\n" +
                "Connection: close\r\n" +
                "\r\n" +
                responseHtml;

            byte[] responseBytes = Encoding.UTF8.GetBytes(httpResponse);
            stream.Write(responseBytes, 0, responseBytes.Length);
            stream.Flush();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
        finally
        {
            try { client.Close(); } catch { }
        }
    }

    // ============================================================
    // SSE — Server-Sent Events
    // ============================================================

    static void HandleSseDisplay(TcpClient client, NetworkStream stream)
    {
        try
        {
            // Send SSE headers — the response that never ends
            string headers =
                "HTTP/1.1 200 OK\r\n" +
                "Content-Type: text/event-stream\r\n" +
                "Cache-Control: no-cache\r\n" +
                "Connection: keep-alive\r\n" +
                "\r\n";

            byte[] headerBytes = Encoding.UTF8.GetBytes(headers);
            stream.Write(headerBytes, 0, headerBytes.Length);
            stream.Flush();

            // Send the current state immediately so the display is not blank
            string currentHtml = RenderDisplayBoard();
            string initEvent = $"id: {SseEventId}\nevent: display\ndata: {EncodeSSE(currentHtml)}\n\n";
            byte[] initBytes = Encoding.UTF8.GetBytes(initEvent);
            stream.Write(initBytes, 0, initBytes.Length);
            stream.Flush();

            // Register this client
            SseClient sseClient = new SseClient
            {
                Client = client,
                Stream = stream
            };

            lock (Lock)
            {
                DisplayClients.Add(sseClient);
            }

            Console.WriteLine("SSE display client connected. Total: " + DisplayClients.Count);

            // Keep the connection alive — wait until it dies
            // We detect this by periodically sending a comment (heartbeat)
            while (true)
            {
                Thread.Sleep(15000);

                try
                {
                    // SSE comment — keeps the connection alive through proxies
                    byte[] heartbeat = Encoding.UTF8.GetBytes(": heartbeat\n\n");
                    stream.Write(heartbeat, 0, heartbeat.Length);
                    stream.Flush();
                }
                catch
                {
                    break; // client disconnected
                }
            }
        }
        catch { }
        finally
        {
            // Remove from SSE client list
            lock (Lock)
            {
                DisplayClients.RemoveAll(c => c.Client == client);
            }
            try { client.Close(); } catch { }
            Console.WriteLine("SSE display client disconnected. Total: " + DisplayClients.Count);
        }
    }

    static void BroadcastDisplay()
    {
        string html = RenderDisplayBoard();

        int eventId;
        List<SseClient> clients;

        lock (Lock)
        {
            SseEventId++;
            eventId = SseEventId;
            clients = new List<SseClient>(DisplayClients);
        }

        string eventData = $"id: {eventId}\nevent: display\ndata: {EncodeSSE(html)}\n\n";
        byte[] eventBytes = Encoding.UTF8.GetBytes(eventData);

        List<SseClient> deadClients = new List<SseClient>();

        foreach (var c in clients)
        {
            try
            {
                c.Stream.Write(eventBytes, 0, eventBytes.Length);
                c.Stream.Flush();
            }
            catch
            {
                deadClients.Add(c);
            }
        }

        // Clean up dead connections
        if (deadClients.Count > 0)
        {
            lock (Lock)
            {
                foreach (var dead in deadClients)
                {
                    DisplayClients.Remove(dead);
                    try { dead.Client.Close(); } catch { }
                }
            }
        }
    }

    // SSE data field cannot contain newlines — encode as single line
    static string EncodeSSE(string html)
    {
        // Replace newlines so the entire HTML fits in one SSE data line
        // The browser will decode this back
        return html.Replace("\n", "&#10;").Replace("\r", "");
    }

    // ============================================================
    // Render: Display Board HTML (sent via SSE)
    // ============================================================

    static string RenderDisplayBoard()
    {
        lock (Lock)
        {
            // The most recent call is the "Now Serving" — shown large on the left
            // The next few recent calls are shown on the right panel

            QueueCall latest = CallHistory.Count > 0
                ? CallHistory[CallHistory.Count - 1]
                : null;

            // Get the last few calls for the history panel (excluding the latest)
            List<QueueCall> recent = new List<QueueCall>();
            for (int i = CallHistory.Count - 2; i >= 0 && recent.Count < 5; i--)
            {
                recent.Add(CallHistory[i]);
            }

            string mainPanel;
            if (latest != null)
            {
                mainPanel = $@"
                    <div class='now-ticket'>{latest.TicketNumber}</div>
                    <div class='now-counter'>Counter {latest.CounterNumber}</div>
                    <div class='now-dept'>{HtmlEncode(GetDeptName(latest.DepartmentId))}</div>";
            }
            else
            {
                mainPanel = @"
                    <div class='now-ticket'>----</div>
                    <div class='now-counter'>Waiting</div>";
            }

            StringBuilder historyHtml = new StringBuilder();
            foreach (var call in recent)
            {
                historyHtml.Append($@"
                    <div class='history-item'>
                        <span class='history-ticket'>{call.TicketNumber}</span>
                        <span class='history-counter'>Counter {call.CounterNumber}</span>
                    </div>");
            }

            return $@"
                <div class='main-panel'>
                    <div class='now-label'>Now Serving</div>
                    {mainPanel}
                </div>
                <div class='sub-panel'>
                    <div class='history-label'>Recent</div>
                    {historyHtml}
                </div>";
        }
    }

    // ============================================================
    // Queue Engine
    // ============================================================

    static int RegisterTicket(int departmentId)
    {
        lock (Lock)
        {
            if (!NextTicketNumber.ContainsKey(departmentId))
                return -1;

            NextTicketNumber[departmentId]++;
            int ticket = NextTicketNumber[departmentId];
            WaitingQueues[departmentId].Enqueue(ticket);
            return ticket;
        }
    }

    static int CallNextNumber(int counterNumber, int departmentId)
    {
        lock (Lock)
        {
            if (!WaitingQueues.ContainsKey(departmentId))
                return -1;

            if (WaitingQueues[departmentId].Count == 0)
                return -1;

            int ticket = WaitingQueues[departmentId].Dequeue();

            CallHistory.Add(new QueueCall
            {
                TicketNumber = ticket,
                DepartmentId = departmentId,
                CounterNumber = counterNumber,
                CalledAt = DateTime.Now
            });

            return ticket;
        }
    }

    static int CallSpecificNumber(int counterNumber, int departmentId, int ticketNumber)
    {
        lock (Lock)
        {
            if (!WaitingQueues.ContainsKey(departmentId))
                return -1;

            // Remove from queue if present
            var queue = WaitingQueues[departmentId];
            var remaining = new Queue<int>();
            bool found = false;

            while (queue.Count > 0)
            {
                int t = queue.Dequeue();
                if (t == ticketNumber && !found)
                {
                    found = true; // skip — we're pulling this one out
                }
                else
                {
                    remaining.Enqueue(t);
                }
            }

            // Rebuild the queue without the called ticket
            WaitingQueues[departmentId] = remaining;

            if (!found)
                return -1;

            CallHistory.Add(new QueueCall
            {
                TicketNumber = ticketNumber,
                DepartmentId = departmentId,
                CounterNumber = counterNumber,
                CalledAt = DateTime.Now
            });

            return ticketNumber;
        }
    }

    // --- Placeholders for future implementation ---

    static class TicketEngine
    {
        public static int Register(int departmentId)
        {
            return RegisterTicket(departmentId);
        }
    }

    static class KioskEngine
    {
        public static void PrintTicket(int ticketNumber)
        {
            // Placeholder: physical ticket printer integration
            Console.WriteLine($"  [Printer] Ticket #{ticketNumber}");
        }
    }

    static class AudioAnnouncer
    {
        public static void Announce(int ticketNumber, int counterNumber)
        {
            // Placeholder: text-to-speech / audio file playback
            Console.WriteLine($"  [Audio] Now serving #{ticketNumber} at Counter {counterNumber}");
        }
    }

    // ============================================================
    // Layer 2: Pages
    // ============================================================

    // --- Display Page (the TV screen) ---
    static string PageDisplay()
    {
        return $@"<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8' />
    <title>Queue Display</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        body {{
            font-family: 'Segoe UI', Arial, sans-serif;
            background: #1a1a2e;
            color: #fff;
            overflow: hidden;
        }}
        .container {{
            display: flex;
            width: 100vw;
            height: 100vh;
        }}
        .main-panel {{
            flex: 1;
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
            background: #16213e;
            border-right: 3px solid #0f3460;
        }}
        .now-label {{
            font-size: 3vw;
            color: #a8b2d1;
            text-transform: uppercase;
            letter-spacing: 0.3em;
            margin-bottom: 1vh;
        }}
        .now-ticket {{
            font-size: 12vw;
            font-weight: bold;
            color: #e94560;
            line-height: 1;
        }}
        .now-counter {{
            font-size: 3vw;
            color: #a8b2d1;
            margin-top: 1vh;
        }}
        .now-dept {{
            font-size: 2vw;
            color: #6c7a96;
            margin-top: 1vh;
        }}
        .sub-panel {{
            width: 35%;
            display: flex;
            flex-direction: column;
            padding: 3vh 2vw;
            background: #1a1a2e;
        }}
        .history-label {{
            font-size: 2vw;
            color: #a8b2d1;
            text-transform: uppercase;
            letter-spacing: 0.2em;
            margin-bottom: 2vh;
            padding-bottom: 1vh;
            border-bottom: 2px solid #0f3460;
        }}
        .history-item {{
            display: flex;
            justify-content: space-between;
            align-items: center;
            padding: 2vh 1vw;
            margin-bottom: 1vh;
            background: #16213e;
            border-radius: 8px;
            border-left: 4px solid #0f3460;
        }}
        .history-ticket {{
            font-size: 3vw;
            font-weight: bold;
            color: #e2e8f0;
        }}
        .history-counter {{
            font-size: 1.8vw;
            color: #a8b2d1;
        }}
        .status {{
            position: fixed;
            bottom: 1vh;
            right: 1vw;
            font-size: 1.2vw;
            color: #4a5568;
        }}
        .status.connected {{ color: #48bb78; }}
        .status.disconnected {{ color: #e94560; }}
    </style>
</head>
<body>
    <div id='container' class='container'>
        <div class='main-panel'>
            <div class='now-label'>Now Serving</div>
            <div class='now-ticket'>----</div>
            <div class='now-counter'>Waiting</div>
        </div>
        <div class='sub-panel'>
            <div class='history-label'>Recent</div>
        </div>
    </div>
    <div id='status' class='status'>Connecting...</div>

    <script>
        function connectSSE() {{
            var source = new EventSource('/sse-display');
            var status = document.getElementById('status');

            source.addEventListener('display', function(e) {{
                document.getElementById('container').innerHTML = e.data;
            }});

            source.onopen = function() {{
                status.textContent = 'Connected';
                status.className = 'status connected';
            }};

            source.onerror = function() {{
                status.textContent = 'Reconnecting...';
                status.className = 'status disconnected';
            }};
        }}

        connectSSE();
    </script>
</body>
</html>";
    }

    // --- Terminal Page (the kiosk where visitors take a number) ---
    static string PageTerminal(HttpRequest request)
    {
        string message = "";

        if (request.Method == "POST")
        {
            string action = request.GetForm("action");

            if (action == "take-number")
            {
                int deptId = request.GetFormInt("department-id");
                if (Departments.ContainsKey(deptId))
                {
                    int ticket = TicketEngine.Register(deptId);
                    KioskEngine.PrintTicket(ticket);
                    message = $@"
                        <div class='ticket-result'>
                            <div class='ticket-label'>Your Number</div>
                            <div class='ticket-number'>{ticket}</div>
                            <div class='ticket-dept'>{HtmlEncode(Departments[deptId])}</div>
                            <div class='ticket-msg'>Please wait for your number to be called.</div>
                        </div>";
                }
            }
        }

        // Build department buttons
        StringBuilder deptButtons = new StringBuilder();
        foreach (var dept in Departments)
        {
            int waiting;
            lock (Lock)
            {
                waiting = WaitingQueues[dept.Key].Count;
            }

            deptButtons.Append($@"
                <form method='post' action='/terminal'>
                    <input type='hidden' name='action' value='take-number' />
                    <input type='hidden' name='department-id' value='{dept.Key}' />
                    <button type='submit' class='dept-btn'>
                        <span class='dept-name'>{HtmlEncode(dept.Value)}</span>
                        <span class='dept-waiting'>{waiting} waiting</span>
                    </button>
                </form>");
        }

        return $@"<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8' />
    <meta name='viewport' content='width=device-width, initial-scale=1' />
    <title>Take a Number</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        body {{
            font-family: 'Segoe UI', Arial, sans-serif;
            background: #f0f4f8;
            padding: 20px;
        }}
        h1 {{
            text-align: center;
            color: #2d3748;
            margin-bottom: 10px;
            font-size: 28px;
        }}
        .subtitle {{
            text-align: center;
            color: #718096;
            margin-bottom: 30px;
        }}
        .dept-btn {{
            display: block;
            width: 100%;
            max-width: 400px;
            margin: 10px auto;
            padding: 20px;
            font-size: 18px;
            background: #4a90d9;
            color: #fff;
            border: none;
            border-radius: 12px;
            cursor: pointer;
            text-align: left;
        }}
        .dept-btn:hover {{ background: #357abd; }}
        .dept-btn:active {{ background: #2a5f9e; }}
        .dept-name {{ display: block; font-weight: bold; font-size: 20px; }}
        .dept-waiting {{ display: block; font-size: 14px; opacity: 0.8; margin-top: 4px; }}
        form {{ margin: 0; }}
        .ticket-result {{
            max-width: 400px;
            margin: 0 auto 30px auto;
            padding: 30px;
            background: #fff;
            border-radius: 16px;
            text-align: center;
            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
            border: 2px dashed #4a90d9;
        }}
        .ticket-label {{ font-size: 16px; color: #718096; text-transform: uppercase; letter-spacing: 0.1em; }}
        .ticket-number {{ font-size: 64px; font-weight: bold; color: #e94560; margin: 10px 0; }}
        .ticket-dept {{ font-size: 18px; color: #4a5568; }}
        .ticket-msg {{ font-size: 14px; color: #a0aec0; margin-top: 15px; }}
        .home-link {{ display: block; text-align: center; margin-top: 30px; color: #4a90d9; }}
    </style>
</head>
<body>
    <h1>Queue Ticket</h1>
    <p class='subtitle'>Select a service to take a number</p>
    {message}
    {deptButtons}
    <a class='home-link' href='/display' target='_blank'>View Display Board</a>
</body>
</html>";
    }

    // --- Operator Page (the counter staff) ---
    static string PageOperator(HttpRequest request)
    {
        string message = "";
        string counterNumber = request.GetForm("counter-number");
        string departmentId = request.GetForm("department-id");
        bool isSetup = string.IsNullOrEmpty(counterNumber) || counterNumber == "0";

        if (request.Method == "POST")
        {
            string action = request.GetForm("action");

            if (action == "call-next")
            {
                int counter = request.GetFormInt("counter-number");
                int deptId = request.GetFormInt("department-id");
                int ticket = CallNextNumber(counter, deptId);

                if (ticket > 0)
                {
                    AudioAnnouncer.Announce(ticket, counter);
                    BroadcastDisplay();
                    message = $"<div class='msg success'>Called #{ticket} to Counter {counter}</div>";
                }
                else
                {
                    message = "<div class='msg empty'>No tickets waiting in queue.</div>";
                }

                // Stay in operator mode
                counterNumber = counter.ToString();
                departmentId = deptId.ToString();
                isSetup = false;
            }
            else if (action == "call-specific")
            {
                int counter = request.GetFormInt("counter-number");
                int deptId = request.GetFormInt("department-id");
                int specificTicket = request.GetFormInt("ticket-number");
                int ticket = CallSpecificNumber(counter, deptId, specificTicket);

                if (ticket > 0)
                {
                    AudioAnnouncer.Announce(ticket, counter);
                    BroadcastDisplay();
                    message = $"<div class='msg success'>Called #{ticket} to Counter {counter}</div>";
                }
                else
                {
                    message = $"<div class='msg empty'>Ticket #{specificTicket} not found in queue.</div>";
                }

                counterNumber = counter.ToString();
                departmentId = deptId.ToString();
                isSetup = false;
            }
            else if (action == "setup")
            {
                // Transition from setup to operator mode
                counterNumber = request.GetForm("counter-number");
                departmentId = request.GetForm("department-id");
                isSetup = false;
            }
        }

        if (isSetup)
        {
            return PageOperatorSetup();
        }

        // --- Operator mode: show call buttons ---
        int deptIdInt = 0;
        int.TryParse(departmentId, out deptIdInt);
        string deptName = GetDeptName(deptIdInt);

        int waitingCount;
        string waitingList;
        lock (Lock)
        {
            var queue = WaitingQueues.ContainsKey(deptIdInt)
                ? WaitingQueues[deptIdInt]
                : new Queue<int>();
            waitingCount = queue.Count;
            waitingList = string.Join(", ", queue);
        }

        return $@"<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8' />
    <meta name='viewport' content='width=device-width, initial-scale=1' />
    <title>Operator — Counter {HtmlEncode(counterNumber)}</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        body {{
            font-family: 'Segoe UI', Arial, sans-serif;
            background: #f0f4f8;
            padding: 20px;
            max-width: 500px;
            margin: 0 auto;
        }}
        h1 {{ color: #2d3748; margin-bottom: 5px; }}
        .counter-info {{ color: #718096; margin-bottom: 20px; font-size: 14px; }}
        .msg {{
            padding: 15px;
            border-radius: 8px;
            margin-bottom: 20px;
            font-size: 16px;
            font-weight: bold;
        }}
        .msg.success {{ background: #c6f6d5; color: #22543d; }}
        .msg.empty {{ background: #fed7d7; color: #742a2a; }}
        .call-btn {{
            display: block;
            width: 100%;
            padding: 20px;
            font-size: 20px;
            font-weight: bold;
            background: #48bb78;
            color: #fff;
            border: none;
            border-radius: 12px;
            cursor: pointer;
            margin-bottom: 15px;
        }}
        .call-btn:hover {{ background: #38a169; }}
        .call-btn:active {{ background: #2f855a; }}
        .specific-section {{
            background: #fff;
            padding: 20px;
            border-radius: 12px;
            margin-bottom: 20px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.06);
        }}
        .specific-section label {{ font-weight: bold; color: #4a5568; }}
        .specific-section input[type=number] {{
            width: 100%;
            padding: 12px;
            font-size: 18px;
            border: 2px solid #e2e8f0;
            border-radius: 8px;
            margin: 10px 0;
        }}
        .specific-btn {{
            display: block;
            width: 100%;
            padding: 14px;
            font-size: 16px;
            background: #4a90d9;
            color: #fff;
            border: none;
            border-radius: 8px;
            cursor: pointer;
        }}
        .specific-btn:hover {{ background: #357abd; }}
        .waiting-info {{
            background: #fff;
            padding: 15px;
            border-radius: 12px;
            margin-bottom: 20px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.06);
        }}
        .waiting-info strong {{ color: #2d3748; }}
        .waiting-list {{ color: #718096; font-size: 14px; margin-top: 5px; word-break: break-all; }}
        .reset-link {{ display: block; text-align: center; margin-top: 20px; color: #a0aec0; font-size: 14px; }}
    </style>
</head>
<body>
    <h1>Counter {HtmlEncode(counterNumber)}</h1>
    <div class='counter-info'>{HtmlEncode(deptName)}</div>

    {message}

    <div class='waiting-info'>
        <strong>Waiting: {waitingCount}</strong>
        <div class='waiting-list'>{(waitingCount > 0 ? waitingList : "—")}</div>
    </div>

    <form method='post' action='/operator'>
        <input type='hidden' name='action' value='call-next' />
        <input type='hidden' name='counter-number' value='{HtmlEncode(counterNumber)}' />
        <input type='hidden' name='department-id' value='{HtmlEncode(departmentId)}' />
        <button type='submit' class='call-btn'>Call Next Number</button>
    </form>

    <div class='specific-section'>
        <form method='post' action='/operator'>
            <input type='hidden' name='action' value='call-specific' />
            <input type='hidden' name='counter-number' value='{HtmlEncode(counterNumber)}' />
            <input type='hidden' name='department-id' value='{HtmlEncode(departmentId)}' />
            <label>Call Specific Number:</label>
            <input type='number' name='ticket-number' placeholder='Enter ticket number' />
            <button type='submit' class='specific-btn'>Call This Number</button>
        </form>
    </div>

    <a class='reset-link' href='/operator'>Change Counter</a>
</body>
</html>";
    }

    // --- Operator Setup Page ---
    static string PageOperatorSetup()
    {
        StringBuilder deptOptions = new StringBuilder();
        foreach (var dept in Departments)
        {
            deptOptions.Append($"<option value='{dept.Key}'>{HtmlEncode(dept.Value)}</option>");
        }

        return $@"<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8' />
    <meta name='viewport' content='width=device-width, initial-scale=1' />
    <title>Operator Setup</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        body {{
            font-family: 'Segoe UI', Arial, sans-serif;
            background: #f0f4f8;
            display: flex;
            align-items: center;
            justify-content: center;
            min-height: 100vh;
        }}
        .setup-box {{
            background: #fff;
            padding: 40px;
            border-radius: 16px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
            width: 100%;
            max-width: 400px;
        }}
        h1 {{ color: #2d3748; margin-bottom: 25px; text-align: center; }}
        label {{ display: block; font-weight: bold; color: #4a5568; margin-bottom: 6px; margin-top: 15px; }}
        input[type=number], select {{
            width: 100%;
            padding: 12px;
            font-size: 18px;
            border: 2px solid #e2e8f0;
            border-radius: 8px;
        }}
        .setup-btn {{
            display: block;
            width: 100%;
            padding: 16px;
            font-size: 18px;
            font-weight: bold;
            background: #4a90d9;
            color: #fff;
            border: none;
            border-radius: 12px;
            cursor: pointer;
            margin-top: 25px;
        }}
        .setup-btn:hover {{ background: #357abd; }}
    </style>
</head>
<body>
    <div class='setup-box'>
        <h1>Operator Setup</h1>
        <form method='post' action='/operator'>
            <input type='hidden' name='action' value='setup' />
            <label>Counter Number:</label>
            <input type='number' name='counter-number' min='1' max='99' value='1' required />
            <label>Department:</label>
            <select name='department-id'>
                {deptOptions}
            </select>
            <button type='submit' class='setup-btn'>Start</button>
        </form>
    </div>
</body>
</html>";
    }

    // --- 404 Page ---
    static string PageNotFound()
    {
        return @"<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8' />
    <title>Not Found</title>
    <style>
        body { font-family: Arial, sans-serif; text-align: center; padding: 60px; background: #f0f4f8; }
        h1 { color: #e94560; }
        a { color: #4a90d9; }
    </style>
</head>
<body>
    <h1>404 — Page Not Found</h1>
    <p><a href='/display'>Display</a> | <a href='/terminal'>Terminal</a> | <a href='/operator'>Operator</a></p>
</body>
</html>";
    }

    // ============================================================
    // HTTP Parser (same as previous article)
    // ============================================================

    static HttpRequest ParseHttpRequest(string headerSection, string body)
    {
        HttpRequest request = new HttpRequest();

        string[] lines = headerSection.Split(new[] { "\r\n" }, StringSplitOptions.None);
        string[] requestLine = lines[0].Split(' ');

        request.Method = requestLine[0].ToUpper();
        request.Path = requestLine.Length > 1 ? requestLine[1] : "/";

        for (int i = 1; i < lines.Length; i++)
        {
            int colon = lines[i].IndexOf(':');
            if (colon > 0)
            {
                string key = lines[i].Substring(0, colon).Trim();
                string value = lines[i].Substring(colon + 1).Trim();
                request.Headers[key] = value;
            }
        }

        int qIndex = request.Path.IndexOf('?');
        if (qIndex >= 0)
        {
            string queryString = request.Path.Substring(qIndex + 1);
            request.Path = request.Path.Substring(0, qIndex);
            ParseFormData(queryString, request.Query);
        }

        if (request.Method == "POST" && body.Length > 0)
        {
            ParseFormData(body, request.Form);
        }

        request.Path = request.Path.ToLower().Trim().TrimEnd('/');
        if (request.Path == "") request.Path = "/";

        return request;
    }

    static void ParseFormData(string data, Dictionary<string, string> target)
    {
        string[] pairs = data.Split('&');
        foreach (string pair in pairs)
        {
            string[] kv = pair.Split(new[] { '=' }, 2);
            string key = HttpUtility.UrlDecode(kv[0]);
            string value = kv.Length > 1 ? HttpUtility.UrlDecode(kv[1]) : "";
            target[key] = value;
        }
    }

    // ============================================================
    // Utility
    // ============================================================

    static string GetDeptName(int deptId)
    {
        return Departments.ContainsKey(deptId) ? Departments[deptId] : "Unknown";
    }

    static string HtmlEncode(string text)
    {
        if (string.IsNullOrEmpty(text)) return "";
        return text.Replace("&", "&amp;")
                   .Replace("<", "&lt;")
                   .Replace(">", "&gt;")
                   .Replace("\"", "&quot;")
                   .Replace("'", "&#39;");
    }
}

// ============================================================
// Models
// ============================================================

class QueueCall
{
    public int TicketNumber { get; set; }
    public int DepartmentId { get; set; }
    public int CounterNumber { get; set; }
    public DateTime CalledAt { get; set; }
}

class SseClient
{
    public TcpClient Client { get; set; }
    public NetworkStream Stream { get; set; }
}

class HttpRequest
{
    public string Method { get; set; } = "GET";
    public string Path { get; set; } = "/";
    public Dictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
    public Dictionary<string, string> Query { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
    public Dictionary<string, string> Form { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

    public string GetForm(string key)
    {
        return Form.ContainsKey(key) ? Form[key] : "";
    }

    public int GetFormInt(string key)
    {
        string val = GetForm(key);
        int result;
        int.TryParse(val, out result);
        return result;
    }

    public string GetQuery(string key)
    {
        return Query.ContainsKey(key) ? Query[key] : "";
    }
}