namespace System.Net.Quic;

// Existing class.
public abstract partial class QuicConnectionOptions
{
    // New callback, raised when MAX_STREAMS frame arrives, reports new capacity for stream limits.
    // First invocation with the initial values might happen during QuicConnection.ConnectAsync or QuicListener.AcceptConnectionAsync, before the QuicConnection object is handed out.
    public QuicConnectionStreamCapacityAvailableCallback? StreamCapacityAvailableCallback { get; set; }
}
// Callback definition:
// The arguments represent additional counts of released stream limits.
// The initial values will be reported by the first invocation of the callback.
public delegate void QuicConnectionStreamCapacityAvailableCallback(QuicConnection connection, QuicConnectionStreamCapacityAvailableArgs args);
// Callback arguments:
public readonly struct QuicConnectionStreamCapacityAvailableArgs
{
    public readonly int BidirectionalStreamsCountIncrement { get; init; }
    public readonly int UnidirectionalStreamsCountIncrement { get; init; }
}

// Method that creates Http3Connection. 
// Shows the slight disadvantage of passing callback in the options class together with not having public QuicConnection ctor.
// As a result, H/3 connection cannot take QuicConnection in a constructor argument and must be instantiated upfront, and only after ConnectAsync finishes, tied with QuicConnection.

Http3Connection h3Connection = new Http3Connection();
// The first invocation of h3Connection.StreamCapacityAvailableCallback will likely happen during QuicConnection.ConnectAsync before it returns the QuicConnection instance.
QuicConnection quicConnection = await QuicConnection.ConnectAsync(new QuicClientConnectionOptions()
{
    // Other options ...
    StreamCapacityAvailableCallback = h3Connection.StreamCapacityAvailableCallback
}, cancellationToken).ConfigureAwait(false);
h3Connection.InitQuicConnection(quicConnection);


internal class Http3Connection
{
    private int _availableRequestStreamsCount;

    // Using the available stream count to see whether we can process the request on the current HTTP/3 connection.
    public bool TryReserveStream()
    {
        lock (SyncObj)
        {
            if (_availableRequestStreamsCount == 0)
            {
                return false;
            }
            --_availableRequestStreamsCount;
            return true;
        }
    }

    // In case the TryReserveStream returns false, we remove the HTTP/3 connection from the pool of usable connections and wait for StreamCapacityAvailableCallback event to put it back.
    public Task WaitForAvailableStreamsAsync()
    {
        lock (SyncObj)
        {
            if (_availableRequestStreamsCount > 0)
            {
                return Task.FromResult(true);
            }

            _availableStreamsWaiter = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
            return _availableStreamsWaiter.Task;
        }
    }

    // Callback from the QUIC will increment the available stream count and unblock a waiter if there's one.
    public void StreamCapacityAvailableCallback(QuicConnection sender, QuicConnectionStreamCapacityAvailableArgs args)
    {
        lock (SyncObj)
        {
            _availableRequestStreamsCount += args.BidirectionalStreamsCountIncrement;
            _availableStreamsWaiter?.SetResult();
            _availableStreamsWaiter = null;
        }
    }
}

public delegate void QuicConnectionStreamCapacityAvailableCallback(QuicConnection connection,  int bidirectionalStreamsCountIncrement,  int unidirectionalStreamsCountIncrement);

// Existing class.
public abstract partial class QuicConnectionOptions
{
    // New event, raised when MAX_STREAMS frame arrives, reports new capacity for stream limits.
    public event System.Net.Quic.QuicConnectionStreamCapacityAvailableEventHandler? StreamCapacityAvailable { add { } remove { } }
}
// Arguments for StreamCapacityAvailable event.
public partial class QuicConnectionStreamCapacityAvailableEventArgs : System.EventArgs
{
    internal QuicConnectionStreamCapacityAvailableEventArgs() { }
    // The additional count of released stream limit. Corresponds to new_value(AvailableBidirectionalStreamsCount) - old_value(AvailableBidirectionalStreamsCount).
    public int BidirectionalStreamsCountIncrement { get { throw null; } }
    // The additional count of released stream limit. Corresponds to new_value(AvailableUnidirectionalStreamsCount) - old_value(AvailableUnidirectionalStreamsCount).
    public int UnidirectionalStreamsCountIncrement { get { throw null; } }
}
// Event delegate definition.
public delegate void QuicConnectionStreamCapacityAvailableEventHandler(object? sender, System.Net.Quic.QuicConnectionStreamCapacityAvailableEventArgs e);

public sealed partial class QuicConnection : System.IAsyncDisposable
{
    public Task<int> BidirectionalStreamsCapacityAvailable { get; }
    public Task<int> UnidirectionalStreamsCapacityAvailable { get; }
}