using System;
using System.Collections.Generic;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

internal class Program
{
    static async Task Main(string[] args)
    {
        var listener = new HttpListener();

        listener.Prefixes.Add("http://localhost:7123/");
        listener.Start();

        while (true)
        {
            var context = await listener.GetContextAsync();
            if (context.Request.IsWebSocketRequest)
            {
                _ = Task.Run(() => ProcessWebSocketRequest(context));
            }
            else
            {
                context.Response.StatusCode = 400;
                context.Response.Close();
            }
        }
    }

    static async Task ProcessWebSocketRequest(HttpListenerContext context)
    {
        var websocketContext = await context.AcceptWebSocketAsync(null);
        var websocket = websocketContext.WebSocket;
        var buffer = new byte[256].AsMemory();

        while (websocket.State == WebSocketState.Open)
        {
            try
            {
                var result = await websocket.ReceiveAsync(buffer, CancellationToken.None);
                if (result.MessageType == WebSocketMessageType.Text)
                {
                    string message = Encoding.UTF8.GetString(buffer.Span.Slice(0, result.Count));
                    var jsonData = new Dictionary<string, object>();
                    jsonData.Add("type", "response");
                    jsonData.Add("body", message);
                    string serialized = JsonSerializer.Serialize(jsonData);

                    var responseBuffer = Encoding.UTF8.GetBytes(serialized);
                    await websocket.SendAsync(responseBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
                }
                else if (result.MessageType == WebSocketMessageType.Close)
                {
                    await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
                    break;
                }
            }
            catch (Exception ex)
            {
                //Console.WriteLine(ex.Message);
            }
        }
        websocket.Dispose();
    }

}

internal class Program
{
    private static Random s_random = new Random();
    static async Task Main(string[] args)
    {
        Task[] tasks = new Task[2000];
        for (int i = 0; i < tasks.Length;i++)
        {
            tasks[i] = Task.Run(Tick);
        }
        Console.Read();
    }

    static async Task Tick()
    {
        while(true)
        {

            var clientWebSocket = new ClientWebSocket();
            clientWebSocket.Options.SetRequestHeader("Accept-Encoding", "en");
            clientWebSocket.Options.SetRequestHeader("Pragma", "no-cache");
            clientWebSocket.Options.SetRequestHeader("User-Agent", "MyUserAgent");
            clientWebSocket.Options.KeepAliveInterval = TimeSpan.FromHours(20);
            clientWebSocket.Options.Cookies = new CookieContainer();

            await clientWebSocket.ConnectAsync(new Uri("ws://localhost:7123/"), CancellationToken.None);
            int i = 0;
            while (clientWebSocket.State == WebSocketState.Open && i++ < 4)
            {
                var jsondata = new Dictionary<string, object>();
                jsondata.Add("type", "request");
                byte[] rndBytes = new byte[16];
                s_random.NextBytes(rndBytes);
                jsondata.Add("body", new Guid(rndBytes).ToString());

                string serialized = JsonSerializer.Serialize(jsondata);
                await clientWebSocket.SendAsync(Encoding.UTF8.GetBytes(serialized), WebSocketMessageType.Text, true, CancellationToken.None);

                var rcvBuffer = new byte[256].AsMemory();
                var bytesReaded = await clientWebSocket.ReceiveAsync(rcvBuffer, CancellationToken.None);
                string message = Encoding.UTF8.GetString(rcvBuffer.Span.Slice(0, bytesReaded.Count));

                await Task.Delay(1000);
            }
            await clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
            clientWebSocket.Dispose();
        }
    }
}