using System.Buffers.Binary;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport.Cip;
using ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport.Tests.Fakes;
namespace ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport.Tests.Cip;

/// <summary>Serializes every test class that asserts on <see cref="CipConnection"/>'s process-wide
/// diagnostic counters, so no parallel test can move them mid-assertion.</summary>
[CollectionDefinition(Name, DisableParallelization = true)]
public sealed class CipConnectionStatics
{
    public const string Name = "CipConnection statics";
}

/// <summary><see cref="CipConnection"/> against <see cref="FakeCipTarget"/>. Wire I/O is real loopback;
/// the throttle, deadlines and keep-alive run on <see cref="ManualTimeProvider"/>.</summary>
[Collection(CipConnectionStatics.Name)]
public sealed class CipConnectionTests
{
    private static readonly TimeSpan Guard = TimeSpan.FromSeconds(10);
    private static readonly byte[] ReadTag = [0x4C, 0x02, 0x91, 0x03, 0x54, 0x61, 0x67, 0x00, 0x01, 0x00];
    private static CancellationToken TestCt => TestContext.Current.CancellationToken;

    private static CipConnection Create(FakeCipTarget target, ConnectionOptions o, ManualTimeProvider time, string path = "1,0") =>
        new(new DeviceKey("127.0.0.1", target.Port, path, "ControlLogix"), o,
            new ForwardOpenThrottle(o.MinForwardOpenInterval, time), time);

    private static ConnectionOptions Options(CipRouting routing = CipRouting.Connected, int size = 4002, double timeoutSeconds = 2) =>
        new() { Routing = routing, ConnectionSize = size, Timeout = TimeSpan.FromSeconds(timeoutSeconds) };

    private static ushort RegularOTParams(byte[] fo) => BinaryPrimitives.ReadUInt16LittleEndian(fo.AsSpan(32));

    // ---- options ---------------------------------------------------------------------------------

    [Fact]
    public void Defaults_match_the_press_safety_values()
    {
        var o = new ConnectionOptions();
        o.MinForwardOpenInterval.ShouldBe(TimeSpan.FromSeconds(1));
        o.RpiMicros.ShouldBe(2_000_000u);
        o.TimeoutMultiplier.ShouldBe((byte)1);
        o.ConnectionExpiry.ShouldBe(TimeSpan.FromSeconds(16));
        o.KeepAliveInterval.ShouldBe(TimeSpan.FromSeconds(8));
        o.VendorId.ShouldBe((ushort)0x1337);
        new ConnectionOptions().OriginatorSerial.ShouldBe(o.OriginatorSerial);   // per process, not per instance
    }

    public static TheoryData<TimeSpan> UnusableTimeouts => new() { Timeout.InfiniteTimeSpan, TimeSpan.Zero, TimeSpan.FromSeconds(-1) };

    [Theory]
    [MemberData(nameof(UnusableTimeouts))]
    public void Options_reject_a_non_finite_or_non_positive_timeout(TimeSpan timeout) =>
        Should.Throw<ArgumentOutOfRangeException>(() => new ConnectionOptions { Timeout = timeout });

    [Fact]
    public void Options_reject_a_forward_open_interval_below_one_second() =>
        Should.Throw<ArgumentOutOfRangeException>(() => new ConnectionOptions { MinForwardOpenInterval = TimeSpan.FromMilliseconds(999) });

    // ---- Large Forward Open fallback -------------------------------------------------------------

    [Fact]
    public async Task Large_open_service_not_supported_falls_back_to_regular_open_once()
    {
        await using var target = new FakeCipTarget();
        target.ForwardOpenReply = fo => fo[0] == 0x5B ? FakeCipTarget.Refuse(0x08)(fo) : FakeCipTarget.Accept(fo);
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);
        var before = Volatile.Read(ref CipConnection.ForwardOpenCount);

        await conn.SendAsync(ReadTag, TestCt);

        var fos = target.ForwardOpenRequests;
        fos.Count.ShouldBe(2);
        fos[0][0].ShouldBe((byte)0x5B);
        fos[1][0].ShouldBe((byte)0x54);
        RegularOTParams(fos[1]).ShouldBe((ushort)(0x4200 | 504));
        conn.MaxRequestBytes.ShouldBe(502);
        (Volatile.Read(ref CipConnection.ForwardOpenCount) - before).ShouldBe(2);
        target.ConnectedRequests.ShouldBe(1);
    }

    [Fact]
    public async Task Large_open_bad_size_falls_back_to_regular_open_once()
    {
        await using var target = new FakeCipTarget();
        target.ForwardOpenReply = fo => fo[0] == 0x5B ? FakeCipTarget.Refuse(0x01, 0x0109)(fo) : FakeCipTarget.Accept(fo);
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);

        await conn.SendAsync(ReadTag, TestCt);

        target.ForwardOpenRequests.Select(f => f[0]).ShouldBe(new byte[] { 0x5B, 0x54 });
        RegularOTParams(target.ForwardOpenRequests[1]).ShouldBe((ushort)(0x4200 | 504));
    }

    [Fact]
    public async Task A_refused_fallback_is_not_retried_again()
    {
        await using var target = new FakeCipTarget { ForwardOpenReply = FakeCipTarget.Refuse(0x08) };
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);

        await Should.ThrowAsync<AbTransportException>(() => conn.SendAsync(ReadTag, TestCt));

        target.ForwardOpens.ShouldBe(2);   // Large, then exactly one regular
    }

    [Fact]
    public async Task Connection_in_use_does_not_fall_back()
    {
        await using var target = new FakeCipTarget { ForwardOpenReply = FakeCipTarget.Refuse(0x01, 0x0100) };
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);

        var ex = await Should.ThrowAsync<AbTransportException>(() => conn.SendAsync(ReadTag, TestCt));

        ex.Message.ShouldContain("Forward Open refused");
        target.ForwardOpens.ShouldBe(1);
        target.ConnectedRequests.ShouldBe(0);
    }

    [Fact]
    public async Task A_small_connection_size_uses_a_regular_open()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(size: 504), time);

        await conn.SendAsync(ReadTag, TestCt);

        target.ForwardOpenRequests.Single()[0].ShouldBe((byte)0x54);
        conn.MaxRequestBytes.ShouldBe(502);
    }

    // ---- routing (B3) ----------------------------------------------------------------------------

    [Fact]
    public async Task Direct_routing_sends_bare_cip_even_with_a_path()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(CipRouting.Direct), time, path: "1,0");

        var reply = await conn.SendAsync(ReadTag, TestCt);

        CipReply.Parse(reply).GeneralStatus.ShouldBe((byte)0);
        target.DirectCips.Single().ShouldBe(ReadTag);
        target.ForwardOpens.ShouldBe(0);
        target.UnconnectedSends.ShouldBe(0);
        target.ConnectedRequests.ShouldBe(0);
        conn.MaxRequestBytes.ShouldBe(504);
    }

    [Fact]
    public async Task UnconnectedSend_routing_wraps_in_0x52()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(CipRouting.UnconnectedSend), time, path: "1,0");

        await conn.SendAsync(ReadTag, TestCt);

        target.UnconnectedEmbedded.Single().ShouldBe(ReadTag);
        var raw = FakeEipServer.RequestCip(target.Server.Received.Last(f => FakeEipServer.Command(f) == 0x006F));
        raw.ShouldBe(ConnectionManagerServices.UnconnectedSend(ReadTag, new byte[] { 0x01, 0x00 }));
        target.ForwardOpens.ShouldBe(0);
        target.DirectRequests.ShouldBe(0);
        conn.MaxRequestBytes.ShouldBe(504 - (12 + 2));
    }

    [Fact]
    public async Task Connected_routing_never_sends_bare()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);

        for (var i = 0; i < 3; i++) await conn.SendAsync(ReadTag, TestCt);

        target.ConnectedCips.Count.ShouldBe(3);
        target.ConnectedCips.ShouldAllBe(c => c.SequenceEqual(ReadTag));
        target.ForwardOpens.ShouldBe(1);
        target.DirectRequests.ShouldBe(0);
        target.UnconnectedSends.ShouldBe(0);
        conn.MaxRequestBytes.ShouldBe(4000);
    }

    [Fact]
    public async Task Connected_routing_with_an_empty_route_opens_straight_to_the_message_router()
    {
        // R9-1: Micro800 is Connected with an empty route; libplctag's Forward Open path is just 20 02 24 01.
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(size: 504), time, path: "");

        await conn.SendAsync(ReadTag, TestCt);

        var fo = target.ForwardOpenRequests.Single();
        fo[^6..].ShouldBe(new byte[] { 0xA3, 0x02, 0x20, 0x02, 0x24, 0x01 });
        target.ConnectedRequests.ShouldBe(1);
    }

    // ---- reconnect -------------------------------------------------------------------------------

    [Fact]
    public async Task Caller_cancellation_does_not_reconnect()
    {
        await using var target = new FakeCipTarget();
        var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
        var held = 0;
        target.ConnectedHandler = async cip =>
        {
            if (Interlocked.Increment(ref held) == 1) await release.Task;
            return [(byte)(cip[0] | 0x80), 0, 0, 0];
        };
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);
        var before = Volatile.Read(ref CipConnection.ForwardOpenCount);

        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestCt);
        var pending = conn.SendAsync(ReadTag, cts.Token);
        await FakeCipTarget.Until(() => target.ConnectedRequests == 1, Guard, "the connected request");
        await cts.CancelAsync();
        await Should.ThrowAsync<OperationCanceledException>(() => pending);
        release.SetResult();

        await conn.SendAsync(ReadTag, TestCt);

        (Volatile.Read(ref CipConnection.ForwardOpenCount) - before).ShouldBe(1);
        target.ForwardOpens.ShouldBe(1);
        target.Server.Connections.ShouldBe(1);
        target.ConnectedRequests.ShouldBe(2);
    }

    [Fact]
    public async Task Timeout_reconnects_through_the_throttle()
    {
        await using var target = new FakeCipTarget();
        var answer = 1;
        target.ConnectedHandler = cip => Task.FromResult<byte[]?>(
            Volatile.Read(ref answer) == 1 ? [(byte)(cip[0] | 0x80), 0, 0, 0] : null);
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(timeoutSeconds: 0.3), time);

        await conn.SendAsync(ReadTag, TestCt);                         // first Forward Open, at fake t0
        Volatile.Write(ref answer, 0);
        var timedOut = await Should.ThrowAsync<AbTransportException>(() => conn.SendAsync(ReadTag, TestCt));
        timedOut.Status.ShouldBe(AbStatus.Timeout);                    // the failing call keeps its own error
        target.ForwardOpens.ShouldBe(1);

        Volatile.Write(ref answer, 1);
        var reconnect = conn.SendAsync(ReadTag, TestCt);
        await time.WaitForTimerDueAtAsync(time.Start + TimeSpan.FromSeconds(1), Guard);   // parked in the throttle
        target.ForwardOpens.ShouldBe(1);
        reconnect.IsCompleted.ShouldBeFalse();

        time.Advance(TimeSpan.FromSeconds(1));
        await reconnect.WaitAsync(Guard, TestCt);

        target.ForwardOpens.ShouldBe(2);
        target.Server.Connections.ShouldBe(2);
        // A fresh connection serial per attempt, so the target never sees a duplicate of the stale connection.
        var serials = target.ForwardOpenRequests.Select(f => BinaryPrimitives.ReadUInt16LittleEndian(f.AsSpan(16))).ToArray();
        serials[1].ShouldNotBe(serials[0]);
    }

    [Fact]
    public async Task A_stalled_open_is_bounded_by_the_deadline()
    {
        // R9-3: no caller token at all, and the target never answers the Forward Open.
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(timeoutSeconds: 30), time);
        target.Server.Stall = true;

        var send = conn.SendAsync(ReadTag, CancellationToken.None);
        await FakeCipTarget.Until(() => target.ForwardOpens == 0 && target.Server.Received.Count >= 2, Guard, "the Forward Open frame");
        var openBudget = TimeSpan.FromSeconds(1) + 4 * TimeSpan.FromSeconds(30);
        await time.WaitForTimerDueAtAsync(time.Start + openBudget, Guard);
        time.Advance(openBudget);

        var ex = await Should.ThrowAsync<AbTransportException>(() => send.WaitAsync(Guard, TestCt));
        ex.Status.ShouldBe(AbStatus.Timeout);
    }

    // ---- keep-alive ------------------------------------------------------------------------------

    [Fact]
    public async Task Idle_connection_sends_one_keepalive_per_interval()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);
        var before = Volatile.Read(ref CipConnection.RequestsSent);
        await conn.SendAsync(ReadTag, TestCt);

        time.Advance(TimeSpan.FromSeconds(8));
        conn.KeepAlivesSent.ShouldBe(1);
        await FakeCipTarget.Until(() => target.ConnectedRequests == 2, Guard, "the keep-alive");
        target.ConnectedCips[1].ShouldBe(CipConnection.KeepAliveRequest);
        await time.WaitForTimerDueAtAsync(time.Start + TimeSpan.FromSeconds(16), Guard);   // re-armed

        time.Advance(TimeSpan.FromSeconds(7));
        conn.KeepAlivesSent.ShouldBe(1);                     // exactly one per idle interval

        time.Advance(TimeSpan.FromSeconds(1));
        conn.KeepAlivesSent.ShouldBe(2);
        await FakeCipTarget.Until(() => target.ConnectedRequests == 3, Guard, "the second keep-alive");
        (Volatile.Read(ref CipConnection.RequestsSent) - before).ShouldBe(3);   // keep-alives count
        target.ForwardOpens.ShouldBe(1);
    }

    [Fact]
    public async Task Traffic_suppresses_keepalive()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);
        await conn.SendAsync(ReadTag, TestCt);

        for (var i = 0; i < 4; i++)
        {
            time.Advance(TimeSpan.FromSeconds(5));
            await conn.SendAsync(ReadTag, TestCt);
        }

        conn.KeepAlivesSent.ShouldBe(0);
        target.ConnectedCips.ShouldAllBe(c => c.SequenceEqual(ReadTag));
        target.ConnectedRequests.ShouldBe(5);
    }

    [Fact]
    public async Task No_keepalive_is_sent_when_the_connection_was_never_opened()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        await using var conn = Create(target, Options(), time);

        time.Advance(TimeSpan.FromSeconds(30));

        conn.KeepAlivesSent.ShouldBe(0);
        target.ForwardOpens.ShouldBe(0);
        target.Server.Connections.ShouldBe(0);
    }

    // ---- disposal --------------------------------------------------------------------------------

    [Fact]
    public async Task Send_after_dispose_throws_Abort()
    {
        await using var target = new FakeCipTarget();
        var time = new ManualTimeProvider();
        var conn = Create(target, Options(), time);
        await conn.SendAsync(ReadTag, TestCt);

        await conn.DisposeAsync();

        var ex = await Should.ThrowAsync<AbTransportException>(() => conn.SendAsync(ReadTag, TestCt));
        ex.Status.ShouldBe(AbStatus.Abort);
        target.ForwardCloses.ShouldBe(1);
        await conn.DisposeAsync();   // idempotent
    }

    [Fact]
    public async Task Callers_queued_behind_an_open_get_Abort_when_disposed()
    {
        await using var target = new FakeCipTarget { ForwardOpenReply = FakeCipTarget.Refuse(0x01, 0x0113) };
        var time = new ManualTimeProvider();
        var conn = Create(target, Options(), time);
        await Should.ThrowAsync<AbTransportException>(() => conn.SendAsync(ReadTag, TestCt));   // attempt 1, t0

        var parked = conn.SendAsync(ReadTag, TestCt);                                            // waits in the throttle
        await time.WaitForTimerDueAtAsync(time.Start + TimeSpan.FromSeconds(1), Guard);
        var queued = Enumerable.Range(0, 5).Select(_ => conn.SendAsync(ReadTag, TestCt)).ToArray();
        var dispose = conn.DisposeAsync().AsTask();
        time.Advance(TimeSpan.FromSeconds(1));

        (await Should.ThrowAsync<AbTransportException>(() => parked.WaitAsync(Guard, TestCt))).Status.ShouldBe(AbStatus.Abort);
        foreach (var q in queued)
            (await Should.ThrowAsync<AbTransportException>(() => q.WaitAsync(Guard, TestCt))).Status.ShouldBe(AbStatus.Abort);
        await dispose.WaitAsync(Guard, TestCt);
        target.ForwardOpens.ShouldBe(1);   // nothing is opened once disposal has begun
    }
}