Meum/Meum.Client/ServerConnection.cs

using System.Net;
using System.Net.Quic;
using System.Runtime.InteropServices;
using DTLib.Logging;
using Meum.Core.Messages;

namespace Meum.Client;

public class ServerConnection : IAsyncDisposable
{
    private readonly QuicConnection _quicConnection;
    private readonly QuicStreamWrapper _systemStream;
    private readonly ILogger _logger;

    public DnsEndPoint ServerEndPoint { get; }
    
    
    private ServerConnection(QuicConnection quicConnection, 
        DnsEndPoint serverEndPoint, 
        QuicStreamWrapper systemStream, 
        ILogger logger)
    {
        ServerEndPoint = serverEndPoint;
        _quicConnection = quicConnection;
        _systemStream = systemStream;
        _logger = logger;
    }

    public static async Task<ServerConnection> OpenAsync(QuicConnection quicConnection,
        DnsEndPoint serverEndPoint,
        ILogger logger,
        CancellationToken ct)
    {
        var systemStream = await quicConnection.OpenStreamAsync(QuicStreamType.Bidirectional, ct);
        var serverConnection = new ServerConnection(quicConnection, serverEndPoint, systemStream, logger);
        await systemStream.SendPingReceivePong();
        return serverConnection;
    }

    public async Task Register()
    {
        await _systemStream.WriteStructAsync(new DataMessageHeader(
            MessageTypeCode.RegistrationRequest,
            Marshal.SizeOf<RegistrationRequest>()));
        var registrationRequest = new RegistrationRequest();
        await _systemStream.WriteStructAsync(registrationRequest);

        var responseHeader = await _systemStream.ReadDataMessageHeaderAsync();
        if(responseHeader.type_code != MessageTypeCode.RegistrationResponse)
            throw new Exception($"Invalid response header type: {responseHeader.type_code}");
        
    }

    public async Task Authorize()
    {
        
    }
    
    public override int GetHashCode()
    {
        return _quicConnection.RemoteEndPoint.GetHashCode();
    }

    public async ValueTask DisposeAsync()
    {
        await _quicConnection.DisposeAsync();
    }
}