// Server
using System.Buffers;
using System.Net;
using System.Net.Quic;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

namespace Server;

internal class Server
{
    private static async Task Main(string[] args)
    {
        TaskScheduler.UnobservedTaskException += (sender, e) =>
        {
            if (e.Exception is AggregateException ex)
            {
                foreach (Exception exception in ex.InnerExceptions)
                {
                    Console.WriteLine(exception);
                }
            }
        };

        var serverConnectionOptions = new QuicServerConnectionOptions()
        {
            DefaultStreamErrorCode = 0x0A,
            DefaultCloseErrorCode = 0x0B,
            IdleTimeout = TimeSpan.FromSeconds(60),
            ServerAuthenticationOptions = new SslServerAuthenticationOptions
            {
                ApplicationProtocols = new List<SslApplicationProtocol> { SslApplicationProtocol.Http3 },
                ServerCertificate = X509CertificateLoader.LoadPkcs12FromFile(@"server.pfx", "test"),
            }
        };

        var quicListenerOptions = new QuicListenerOptions
        {
            ListenEndPoint = new IPEndPoint(IPAddress.Any, 23456),
            ApplicationProtocols = new List<SslApplicationProtocol> { SslApplicationProtocol.Http3 },
            ConnectionOptionsCallback = (_, _, _) => ValueTask.FromResult(serverConnectionOptions),
        };

        await using QuicListener listener = await QuicListener.ListenAsync(quicListenerOptions);

        int clientId = 0;
        while (true)
        {
            QuicConnection connection = await listener.AcceptConnectionAsync();
            //Console.WriteLine($"connection = {connection.RemoteEndPoint} | {connection.NegotiatedApplicationProtocol}");
            _ = StartReceive(++clientId, connection);
        }
    }

    private static async Task StartReceive(int clientId, QuicConnection client)
    {
        byte[] receiveBuffer = ArrayPool<byte>.Shared.Rent(4096);

        try
        {
            await using var stream = await client.AcceptInboundStreamAsync().ConfigureAwait(false);

            while (true)
            {
                int receivedBytesCount = await stream.ReadAsync(receiveBuffer).ConfigureAwait(false);

                //Console.WriteLine($"Received Count = {receivedBytesCount}, Data = {Encoding.UTF8.GetString(receiveBuffer)}");

                // Echo for test
                await stream.WriteAsync(receiveBuffer, 0, receivedBytesCount).ConfigureAwait(false);
            }
        }
        catch (Exception ex)
        {
            //Console.WriteLine($"ID {clientId} : {ex}");
        }
        finally
        {
            Console.WriteLine($"ID {clientId} | Disconnected.");

            // I know calling DisposeAsync in this part is the correct code,
            // but I'm wondering if it's the intended behavior
            // to throw an UnobservedTaskException because I missed calling DisposeAsync.
            await client.CloseAsync(0x0B).ConfigureAwait(false);

            ArrayPool<byte>.Shared.Return(receiveBuffer);
        }
    }
}

// Client

using System.Net.Quic;
using System.Net.Security;
using System.Net;
using System.Buffers;
using System.Text;

namespace Client;

internal class Client
{
    private static async Task Main(string[] args)
    {
        TaskScheduler.UnobservedTaskException += (sender, e) =>
        {
            Console.WriteLine(e);
        };

        await Task.Delay(1000);

        var clientConnectionOptions = new QuicClientConnectionOptions()
        {
            RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, 23456),

            DefaultStreamErrorCode = 0x0A,
            DefaultCloseErrorCode = 0x0B,

            MaxInboundUnidirectionalStreams = 0,
            MaxInboundBidirectionalStreams = 1,

            ClientAuthenticationOptions = new SslClientAuthenticationOptions
            {
                ApplicationProtocols = new List<SslApplicationProtocol> { SslApplicationProtocol.Http3 },
                RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => true,
            }
        };

        for (int i = 0; i < 1000; ++i)
        {
            _ = ClientLoop(clientConnectionOptions);
            await Task.Delay(5);
        }

        await Task.Delay(Timeout.Infinite);
    }

    private static async Task ClientLoop(QuicClientConnectionOptions options)
    {
        QuicConnection connection = await QuicConnection.ConnectAsync(options);
        Console.WriteLine($"Connected {connection.LocalEndPoint} --> {connection.RemoteEndPoint}");

        byte[] receiveBuffer = ArrayPool<byte>.Shared.Rent(1024);
        int number = 0;
        using var stream = await connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional);
        while (true)
        {
            byte[] helloWorldToBytes = Encoding.UTF8.GetBytes($"Hello, World! ({number++})");

            if (Random.Shared.Next() % 10 == 0)
            {
                await connection.CloseAsync(0x0B);
                return;
            }

            await stream.WriteAsync(helloWorldToBytes, 0, helloWorldToBytes.Length);
            await stream.ReadExactlyAsync(receiveBuffer, 0, helloWorldToBytes.Length);
            string receivedString = Encoding.UTF8.GetString(receiveBuffer);

            Console.WriteLine(receivedString);

            await Task.Delay(10);
        }
    }
}