// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
namespace Microsoft.AspNetCore.SignalR.Internal;
 
internal sealed class UserProxy<THub> : IClientProxy where THub : Hub
{
    private readonly string _userId;
    private readonly HubLifetimeManager<THub> _lifetimeManager;
 
    public UserProxy(HubLifetimeManager<THub> lifetimeManager, string userId)
    {
        ArgumentNullException.ThrowIfNull(userId);
 
        _lifetimeManager = lifetimeManager;
        _userId = userId;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendUserAsync(_userId, method, args, cancellationToken);
    }
}
 
internal sealed class MultipleUserProxy<THub> : IClientProxy where THub : Hub
{
    private readonly IReadOnlyList<string> _userIds;
    private readonly HubLifetimeManager<THub> _lifetimeManager;
 
    public MultipleUserProxy(HubLifetimeManager<THub> lifetimeManager, IReadOnlyList<string> userIds)
    {
        _lifetimeManager = lifetimeManager;
        _userIds = userIds;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendUsersAsync(_userIds, method, args, cancellationToken);
    }
}
 
internal sealed class GroupProxy<THub> : IClientProxy where THub : Hub
{
    private readonly string _groupName;
    private readonly HubLifetimeManager<THub> _lifetimeManager;
 
    public GroupProxy(HubLifetimeManager<THub> lifetimeManager, string groupName)
    {
        ArgumentNullException.ThrowIfNull(groupName);
 
        _lifetimeManager = lifetimeManager;
        _groupName = groupName;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendGroupAsync(_groupName, method, args, cancellationToken);
    }
}
 
internal sealed class MultipleGroupProxy<THub> : IClientProxy where THub : Hub
{
    private readonly HubLifetimeManager<THub> _lifetimeManager;
    private readonly IReadOnlyList<string> _groupNames;
 
    public MultipleGroupProxy(HubLifetimeManager<THub> lifetimeManager, IReadOnlyList<string> groupNames)
    {
        _lifetimeManager = lifetimeManager;
        _groupNames = groupNames;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendGroupsAsync(_groupNames, method, args, cancellationToken);
    }
}
 
internal sealed class GroupExceptProxy<THub> : IClientProxy where THub : Hub
{
    private readonly string _groupName;
    private readonly HubLifetimeManager<THub> _lifetimeManager;
    private readonly IReadOnlyList<string> _excludedConnectionIds;
 
    public GroupExceptProxy(HubLifetimeManager<THub> lifetimeManager, string groupName, IReadOnlyList<string> excludedConnectionIds)
    {
        ArgumentNullException.ThrowIfNull(groupName);
 
        _lifetimeManager = lifetimeManager;
        _groupName = groupName;
        _excludedConnectionIds = excludedConnectionIds;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendGroupExceptAsync(_groupName, method, args, _excludedConnectionIds, cancellationToken);
    }
}
 
internal sealed class AllClientProxy<THub> : IClientProxy where THub : Hub
{
    private readonly HubLifetimeManager<THub> _lifetimeManager;
 
    public AllClientProxy(HubLifetimeManager<THub> lifetimeManager)
    {
        _lifetimeManager = lifetimeManager;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendAllAsync(method, args, cancellationToken);
    }
}
 
internal sealed class AllClientsExceptProxy<THub> : IClientProxy where THub : Hub
{
    private readonly HubLifetimeManager<THub> _lifetimeManager;
    private readonly IReadOnlyList<string> _excludedConnectionIds;
 
    public AllClientsExceptProxy(HubLifetimeManager<THub> lifetimeManager, IReadOnlyList<string> excludedConnectionIds)
    {
        _lifetimeManager = lifetimeManager;
        _excludedConnectionIds = excludedConnectionIds;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendAllExceptAsync(method, args, _excludedConnectionIds, cancellationToken);
    }
}
 
internal sealed class MultipleClientProxy<THub> : IClientProxy where THub : Hub
{
    private readonly HubLifetimeManager<THub> _lifetimeManager;
    private readonly IReadOnlyList<string> _connectionIds;
 
    public MultipleClientProxy(HubLifetimeManager<THub> lifetimeManager, IReadOnlyList<string> connectionIds)
    {
        _lifetimeManager = lifetimeManager;
        _connectionIds = connectionIds;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendConnectionsAsync(_connectionIds, method, args, cancellationToken);
    }
}
 
internal sealed class SingleClientProxy<THub> : ISingleClientProxy where THub : Hub
{
    private readonly string _connectionId;
    private readonly HubLifetimeManager<THub> _lifetimeManager;
 
    public SingleClientProxy(HubLifetimeManager<THub> lifetimeManager, string connectionId)
    {
        _lifetimeManager = lifetimeManager;
        ArgumentNullException.ThrowIfNull(connectionId);
        _connectionId = connectionId;
    }
 
    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.SendConnectionAsync(_connectionId, method, args, cancellationToken);
    }
 
    public Task<T> InvokeCoreAsync<T>(string method, object?[] args, CancellationToken cancellationToken = default)
    {
        return _lifetimeManager.InvokeConnectionAsync<T>(_connectionId, method, args ?? Array.Empty<object?>(), cancellationToken);
    }
}