private async Task HandleClientRequest(object clientRequestObj)
        {
            SocketAsyncEventArgs clientArgs = SocketArgsPool.Get();

            byte[] responseBuffer = BufferPool.Rent(NetworkPacket.TotalSize);
            Memory<byte> responseBufferMemory = new Memory<byte>(responseBuffer);

            ClientRequest clientRequest = (ClientRequest) clientRequestObj;

            NetworkPacket request = clientRequest.RequestPacket;
            EndPoint remoteEndPoint = clientRequest.ClientEndPoint;
            CancellationToken cancellationToken = clientRequest.CancellationToken;

            // TODO implement actual request handling, besides just an echo
            NetworkPacket response = request;

            NetworkPacket.Serialise(response, responseBufferMemory);

            TransmissionResult sendResult =
                await SocketAsyncOperations
                    .SendToAsync(clientArgs, connection, remoteEndPoint, SocketFlags.None, responseBufferMemory, cancellationToken)
                    .ConfigureAwait(false);

#if DEBUG
                    lock (typeof(Console))
                    {
                        Console.WriteLine($"[Server] Sent {sendResult.Count} bytes to {sendResult.RemoteEndPoint}");
                        Console.WriteLine($"[Server] >>>> {Encoding.UTF8.GetString(sendResult.Buffer.Span)}");
                    }
#endif

            BufferPool.Return(responseBuffer, true);

            SocketArgsPool.Return(clientArgs);
        }

        public override async Task RunAsync(CancellationToken cancellationToken = default)
        {
            EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
            using SocketAsyncEventArgs remoteArgs = GenerateConnectionArgs(remoteEndPoint);

            byte[] requestBuffer = new byte[NetworkPacket.TotalSize];
            Memory<byte> requestBufferMemory = new Memory<byte>(requestBuffer);

            while (!cancellationToken.IsCancellationRequested)
            {
                TransmissionResult receiveResult =
                    await SocketAsyncOperations
                        .ReceiveFromAsync(remoteArgs, connection, remoteEndPoint, SocketFlags.None, requestBufferMemory, cancellationToken)
                        .ConfigureAwait(false);

                EndPoint clientEndPoint = receiveResult.RemoteEndPoint;

#if DEBUG
                lock (typeof(Console))
                {
                    Console.WriteLine($"[Server] Received {receiveResult.Count} bytes from {receiveResult.RemoteEndPoint}");
                    Console.WriteLine($"[Server] <<<< {Encoding.UTF8.GetString(receiveResult.Buffer.Span)}");
                }
#endif

                NetworkPacket requestPacket = NetworkPacket.Deserialise(requestBufferMemory);

                ClientRequest request = new ClientRequest(in requestPacket, in clientEndPoint, in cancellationToken);

                await Task.Factory.StartNew(HandleClientRequest, request, cancellationToken);
            }
}