using Grpc.Core;
using MxGateway.Contracts.Proto.Galaxy;

namespace MxGateway.Client;

/// <summary>
/// gRPC implementation of IGalaxyRepositoryClientTransport.
/// </summary>
internal sealed class GrpcGalaxyRepositoryClientTransport(
    MxGatewayClientOptions options,
    GalaxyRepository.GalaxyRepositoryClient rawClient) : IGalaxyRepositoryClientTransport
{
    /// <summary>
    /// Gets the gateway client options.
    /// </summary>
    public MxGatewayClientOptions Options { get; } = options;

    /// <summary>
    /// Gets the underlying gRPC client.
    /// </summary>
    public GalaxyRepository.GalaxyRepositoryClient RawClient { get; } = rawClient;

    /// <inheritdoc />
    GalaxyRepository.GalaxyRepositoryClient? IGalaxyRepositoryClientTransport.RawClient => RawClient;

    /// <inheritdoc />
    public async Task<TestConnectionReply> TestConnectionAsync(
        TestConnectionRequest request,
        CallOptions callOptions)
    {
        try
        {
            return await RawClient.TestConnectionAsync(request, callOptions)
                .ResponseAsync
                .ConfigureAwait(false);
        }
        catch (RpcException exception)
        {
            throw RpcExceptionMapper.Map(exception, callOptions.CancellationToken);
        }
    }

    /// <inheritdoc />
    public async Task<GetLastDeployTimeReply> GetLastDeployTimeAsync(
        GetLastDeployTimeRequest request,
        CallOptions callOptions)
    {
        try
        {
            return await RawClient.GetLastDeployTimeAsync(request, callOptions)
                .ResponseAsync
                .ConfigureAwait(false);
        }
        catch (RpcException exception)
        {
            throw RpcExceptionMapper.Map(exception, callOptions.CancellationToken);
        }
    }

    /// <inheritdoc />
    public async Task<DiscoverHierarchyReply> DiscoverHierarchyAsync(
        DiscoverHierarchyRequest request,
        CallOptions callOptions)
    {
        try
        {
            return await RawClient.DiscoverHierarchyAsync(request, callOptions)
                .ResponseAsync
                .ConfigureAwait(false);
        }
        catch (RpcException exception)
        {
            throw RpcExceptionMapper.Map(exception, callOptions.CancellationToken);
        }
    }

    /// <inheritdoc />
    public async IAsyncEnumerable<DeployEvent> WatchDeployEventsAsync(
        WatchDeployEventsRequest request,
        CallOptions callOptions,
        [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        CancellationToken effectiveCancellationToken = cancellationToken.CanBeCanceled
            ? cancellationToken
            : callOptions.CancellationToken;

        using AsyncServerStreamingCall<DeployEvent> call = RawClient.WatchDeployEvents(request, callOptions);

        IAsyncStreamReader<DeployEvent> responseStream = call.ResponseStream;
        while (true)
        {
            DeployEvent? deployEvent;
            try
            {
                if (!await responseStream.MoveNext(effectiveCancellationToken).ConfigureAwait(false))
                {
                    break;
                }

                deployEvent = responseStream.Current;
            }
            catch (RpcException exception)
            {
                throw RpcExceptionMapper.Map(exception, effectiveCancellationToken);
            }

            yield return deployEvent;
        }
    }

    /// <inheritdoc />
    IAsyncEnumerable<DeployEvent> IGalaxyRepositoryClientTransport.WatchDeployEventsAsync(
        WatchDeployEventsRequest request,
        CallOptions callOptions)
    {
        return WatchDeployEventsAsync(request, callOptions);
    }
}