using System.Collections.Concurrent;
using Microsoft.Extensions.Logging.Abstractions;
using ZB.MOM.WW.ScadaBridge.Communication.Grpc;

namespace ZB.MOM.WW.ScadaBridge.Communication.Tests.Grpc;

/// <summary>
/// Regression tests: the factory's synchronous
/// <see cref="SiteStreamGrpcClientFactory.Dispose"/> must not block on the
/// async disposal path (sync-over-async). It must dispose each client through
/// the client's synchronous <see cref="SiteStreamGrpcClient.Dispose"/>.
/// </summary>
public class SiteStreamGrpcClientFactoryDisposeTests
{
    /// <summary>
    /// Test client that records whether it was disposed via the sync or async path.
    /// </summary>
    private sealed class TrackingClient : SiteStreamGrpcClient
    {
        /// <summary>Gets a value indicating whether the synchronous dispose path was called.</summary>
        public bool SyncDisposeCalled { get; private set; }
        /// <summary>Gets a value indicating whether the asynchronous dispose path was called.</summary>
        public bool AsyncDisposeCalled { get; private set; }

        /// <inheritdoc />
        public override void Dispose() => SyncDisposeCalled = true;

        /// <inheritdoc />
        public override ValueTask DisposeAsync()
        {
            AsyncDisposeCalled = true;
            return ValueTask.CompletedTask;
        }
    }

    /// <summary>
    /// Test factory that hands out <see cref="TrackingClient"/> instances while
    /// still exercising the base factory's real caching and disposal machinery.
    /// </summary>
    private sealed class TrackingFactory : SiteStreamGrpcClientFactory
    {
        private readonly ConcurrentBag<TrackingClient> _created = new();

        /// <summary>Initializes the factory with a null logger factory.</summary>
        public TrackingFactory() : base(NullLoggerFactory.Instance) { }

        /// <summary>Gets the clients this factory has created.</summary>
        public IReadOnlyCollection<TrackingClient> Created => _created.ToList();

        /// <inheritdoc />
        protected override SiteStreamGrpcClient CreateClient(string siteIdentifier, string grpcEndpoint)
        {
            var client = new TrackingClient();
            _created.Add(client);
            return client;
        }
    }

    /// <summary>Verifies that Dispose disposes clients synchronously and not via the async path.</summary>
    [Fact]
    public void Dispose_DisposesClientsSynchronously_NotViaAsyncPath()
    {
        var factory = new TrackingFactory();
        factory.GetOrCreate("site-a", "http://localhost:5100");
        factory.GetOrCreate("site-b", "http://localhost:5200");

        factory.Dispose();

        Assert.NotEmpty(factory.Created);
        Assert.All(factory.Created, c =>
        {
            Assert.True(c.SyncDisposeCalled, "client should be disposed via synchronous Dispose()");
            Assert.False(c.AsyncDisposeCalled, "synchronous Dispose() must not route through DisposeAsync()");
        });
    }

    /// <summary>
    /// Test client whose disposal always throws — stands in for a client whose
    /// <c>ReleaseResources</c> hit an <see cref="ObjectDisposedException"/> on a subscription
    /// token source.
    /// </summary>
    private sealed class ThrowingClient : SiteStreamGrpcClient
    {
        /// <inheritdoc />
        public override void Dispose() => throw new ObjectDisposedException(nameof(CancellationTokenSource));

        /// <inheritdoc />
        public override ValueTask DisposeAsync() =>
            throw new ObjectDisposedException(nameof(CancellationTokenSource));
    }

    /// <summary>Hands out one throwing client followed by tracking clients.</summary>
    private sealed class OneThrowingClientFactory : SiteStreamGrpcClientFactory
    {
        private readonly ConcurrentBag<TrackingClient> _created = new();
        private int _next;

        /// <summary>Initializes the factory with a null logger factory.</summary>
        public OneThrowingClientFactory() : base(NullLoggerFactory.Instance) { }

        /// <summary>Gets the clients this factory has created.</summary>
        public IReadOnlyCollection<TrackingClient> Created => _created.ToList();

        /// <inheritdoc />
        protected override SiteStreamGrpcClient CreateClient(string siteIdentifier, string grpcEndpoint)
        {
            if (Interlocked.Increment(ref _next) == 1)
            {
                return new ThrowingClient();
            }

            var client = new TrackingClient();
            _created.Add(client);
            return client;
        }
    }

    /// <summary>Verifies that DisposeAsync still disposes every other client when one client throws.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task DisposeAsync_OneClientThrowing_StillDisposesEveryOtherClient()
    {
        // The disposal loop used to abort on the first throwing client, leaving every LATER
        // client — and its gRPC channel — undisposed for the life of the process.
        var factory = new OneThrowingClientFactory();
        factory.GetOrCreate("site-a", "http://localhost:5100"); // throwing
        factory.GetOrCreate("site-b", "http://localhost:5200");
        factory.GetOrCreate("site-c", "http://localhost:5300");

        await factory.DisposeAsync();

        Assert.Equal(2, factory.Created.Count);
        Assert.All(factory.Created, c =>
            Assert.True(c.AsyncDisposeCalled, "a throwing client must not strand its peers undisposed"));
    }

    /// <summary>Verifies that Dispose still disposes every other client when one client throws.</summary>
    [Fact]
    public void Dispose_OneClientThrowing_StillDisposesEveryOtherClient()
    {
        var factory = new OneThrowingClientFactory();
        factory.GetOrCreate("site-a", "http://localhost:5100"); // throwing
        factory.GetOrCreate("site-b", "http://localhost:5200");
        factory.GetOrCreate("site-c", "http://localhost:5300");

        factory.Dispose();

        Assert.Equal(2, factory.Created.Count);
        Assert.All(factory.Created, c =>
            Assert.True(c.SyncDisposeCalled, "a throwing client must not strand its peers undisposed"));
    }

    /// <summary>Verifies that Dispose does not deadlock under a single-threaded synchronization context.</summary>
    [Fact]
    public void Dispose_DoesNotDeadlock_UnderSingleThreadedSynchronizationContext()
    {
        // A strict single-threaded SynchronizationContext: continuations posted to
        // it are only pumped by the worker loop. Sync-over-async (blocking the only
        // thread on an async continuation that needs that same thread) deadlocks here.
        using var ctx = new SingleThreadSyncContext();
        Exception? captured = null;
        var done = new ManualResetEventSlim();

        ctx.Post(_ =>
        {
            try
            {
                var factory = new SiteStreamGrpcClientFactory(NullLoggerFactory.Instance);
                factory.GetOrCreate("site-a", "http://localhost:5100");
                factory.Dispose();
            }
            catch (Exception ex)
            {
                captured = ex;
            }
            finally
            {
                done.Set();
            }
        }, null);

        Assert.True(done.Wait(TimeSpan.FromSeconds(5)),
            "factory.Dispose() did not complete — likely a sync-over-async deadlock");
        Assert.Null(captured);
    }

    /// <summary>Minimal single-threaded synchronization context for the deadlock test.</summary>
    private sealed class SingleThreadSyncContext : SynchronizationContext, IDisposable
    {
        private readonly BlockingCollection<(SendOrPostCallback cb, object? state)> _queue = new();
        private readonly Thread _thread;

        /// <summary>Initializes the synchronization context.</summary>
        public SingleThreadSyncContext()
        {
            _thread = new Thread(Run) { IsBackground = true };
            _thread.Start();
        }

        private void Run()
        {
            SetSynchronizationContext(this);
            foreach (var (cb, state) in _queue.GetConsumingEnumerable())
                cb(state);
        }

        /// <inheritdoc />
        public override void Post(SendOrPostCallback d, object? state) => _queue.Add((d, state));

        /// <summary>Releases the resources held by this instance.</summary>
        public void Dispose()
        {
            _queue.CompleteAdding();
            _thread.Join(TimeSpan.FromSeconds(2));
        }
    }
}