using ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;

namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip.Tests;

/// <summary>
///     Gitea #611 item 1 — ALMA (<c>ALARM_ANALOG</c>) projection. Driven through fake tag runtimes only:
///     ab_server has no alarm instructions, and Z35162 has no ALMA/ALMD, so there is no wire-level gate.
///     Status members are declared BOOL, as on a real controller, so every member is read through its own runtime
///     (the production read path) rather than the whole-UDT offset fast path.
/// </summary>
[Trait("Category", "Unit")]
public sealed class AbCipAlmaProjectionTests
{
    private const string Device = "ab://10.0.0.5/1,0";
    private const string Tag = "HighPress";

    private static readonly string[] Bits =
    [
        "HHInAlarm", "HInAlarm", "LInAlarm", "LLInAlarm", "ROCPosInAlarm",
        "HHAcked", "HAcked", "LAcked", "LLAcked", "ROCPosAcked", "OperAckAll",
    ];
    private static readonly string[] Sevs = ["HHSeverity", "HSeverity", "LSeverity", "LLSeverity", "ROCPosSeverity"];

    private static AbCipTagDefinition AlmaTag(string name = Tag) => new(
        name, Device, name, AbCipDataType.Structure,
        Members: [.. Bits.Select(n => new AbCipStructureMember(n, AbCipDataType.Bool)),
                  .. Sevs.Select(n => new AbCipStructureMember(n, AbCipDataType.DInt))]);

    private static AbCipTagDefinition AlmdTag(string name) => new(
        name, Device, name, AbCipDataType.Structure,
        Members: [new AbCipStructureMember("InAlarm", AbCipDataType.Bool), new AbCipStructureMember("Acked", AbCipDataType.Bool),
                  new AbCipStructureMember("Severity", AbCipDataType.DInt)]);

    private static AbCipDriverOptions Options(params AbCipTagDefinition[] tags) => new()
    {
        Devices = [new AbCipDeviceOptions(Device)],
        RawTags = AbCipRawTags.From(tags),
        EnableAlarmProjection = true,
        AlarmPollInterval = TimeSpan.FromMilliseconds(20),
    };

    private sealed record Rig(AbCipDriver Drv, FakeAbCipTagFactory Factory, List<AlarmEventArgs> Events, IAlarmSubscriptionHandle Handle)
    {
        public void Set(string member, object v, string tag = Tag) => Factory.Tags[$"{tag}.{member}"].Value = v;
        public FakeAbCipTag Probe => Factory.Tags[$"{Tag}.HHInAlarm"];
        public async Task StopAsync()
        {
            await Drv.UnsubscribeAlarmsAsync(Handle, CancellationToken.None);
            await Drv.ShutdownAsync(CancellationToken.None);
        }
    }

    /// <summary>Starts a quiet ALMA (severities set, nothing in alarm, nothing acked) and applies <paramref name="seed"/>.</summary>
    private static async Task<Rig> StartAsync(Action<Rig>? seed = null)
    {
        var factory = new FakeAbCipTagFactory();
        var drv = new AbCipDriver(Options(AlmaTag()), "drv-1", factory);
        await drv.InitializeAsync("{}", CancellationToken.None);
        var events = new List<AlarmEventArgs>();
        drv.OnAlarmEvent += (_, e) => { lock (events) events.Add(e); };
        var handle = await drv.SubscribeAlarmsAsync([Tag], CancellationToken.None);
        var rig = new Rig(drv, factory, events, handle);
        await WaitFor(() => Bits.Take(10).Concat(Sevs).All(m => factory.Tags.ContainsKey($"{Tag}.{m}")));
        foreach (var b in Bits.Take(10)) rig.Set(b, false);
        rig.Set("HHSeverity", 900); rig.Set("HSeverity", 600); rig.Set("LSeverity", 300);
        rig.Set("LLSeverity", 800); rig.Set("ROCPosSeverity", 400);
        seed?.Invoke(rig);
        return rig;
    }

    private static async Task WaitFor(Func<bool> cond)
    {
        var deadline = DateTime.UtcNow.AddSeconds(5);
        while (DateTime.UtcNow < deadline) { if (cond()) return; await Task.Delay(5); }
        throw new TimeoutException("condition never met");
    }

    private static async Task<AlarmEventArgs> Next(Rig r, Func<AlarmEventArgs, bool> match)
    {
        await WaitFor(() => { lock (r.Events) return r.Events.Any(match); });
        lock (r.Events) return r.Events.First(match);
    }

    /// <summary>Processed-count wait: six more polls of the shared member runtime.</summary>
    private static async Task Settled(Rig r)
    {
        var target = r.Probe.ReadCount + 6;
        await WaitFor(() => r.Probe.ReadCount >= target);
    }

    private static List<AlarmEventArgs> Snapshot(Rig r) { lock (r.Events) return [.. r.Events]; }

    /// <summary>Detector: ALMA by per-limit bits and no plain Acked; ALMD-shaped / plain UDTs are not ALMA.</summary>
    [Fact]
    public void Detector_Flags_Alma_And_Not_Almd_Or_User_Udts()
    {
        AbCipAlarmDetector.IsAlma(AlmaTag()).ShouldBeTrue();
        AbCipAlarmDetector.IsAlma(AlmdTag("A")).ShouldBeFalse();
        AbCipAlarmDetector.IsAlmd(AlmdTag("A")).ShouldBeTrue();
        // A user UDT that is ALMD-shaped but happens to name an "HInAlarm" stays ALMD.
        var hybrid = new AbCipTagDefinition("U", Device, "U", AbCipDataType.Structure, Members:
            [new AbCipStructureMember("InAlarm", AbCipDataType.Bool), new AbCipStructureMember("Acked", AbCipDataType.Bool),
             new AbCipStructureMember("HInAlarm", AbCipDataType.Bool)]);
        AbCipAlarmDetector.IsAlma(hybrid).ShouldBeFalse();
        AbCipAlarmDetector.IsAlma(new AbCipTagDefinition("D", Device, "D", AbCipDataType.DInt)).ShouldBeFalse();
        // An ALMA authored WITHOUT members cannot be told apart from an ALMD: it falls to the ALMD path.
        AbCipAlarmDetector.IsAlma(new AbCipTagDefinition("N", Device, "N", AbCipDataType.Structure)).ShouldBeFalse();
    }

    /// <summary>A limit entering alarm raises one ALMA condition keyed on the RawPath, naming the limit, with the limit's severity.</summary>
    [Fact]
    public async Task A_limit_in_alarm_raises_with_the_limits_name_and_severity()
    {
        var r = await StartAsync();
        await Settled(r);
        r.Set("HInAlarm", true);
        var e = await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        await r.StopAsync();
        e.ConditionId.ShouldBe(Tag);
        e.SourceNodeId.ShouldBe(Tag);
        e.AlarmType.ShouldBe("ALMA");
        e.Message.ShouldBe($"ALMA {Tag} H alarm");
        e.OpcUaSeverity.ShouldBe(600);
        e.Severity.ShouldBe(AlarmSeverity.High);
    }

    /// <summary>With several limits active the most severe one names the condition and sets its severity.</summary>
    [Fact]
    public async Task The_most_severe_active_limit_wins()
    {
        var r = await StartAsync(x => { x.Set("LInAlarm", true); x.Set("HHInAlarm", true); x.Set("ROCPosInAlarm", true); });
        var e = await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        await r.StopAsync();
        e.Message.ShouldBe($"ALMA {Tag} HH alarm");
        e.OpcUaSeverity.ShouldBe(900);
    }

    /// <summary>ROC limits are named with their sign.</summary>
    [Fact]
    public async Task A_rate_of_change_limit_is_named_with_its_sign()
    {
        var r = await StartAsync(x => x.Set("ROCPosInAlarm", true));
        var e = await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        await r.StopAsync();
        e.Message.ShouldBe($"ALMA {Tag} ROC+ alarm");
    }

    /// <summary>All limits returning to normal clears the one condition.</summary>
    [Fact]
    public async Task All_limits_clearing_fires_one_clear()
    {
        var r = await StartAsync(x => x.Set("LLInAlarm", true));
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        r.Set("LLInAlarm", false);
        var e = await Next(r, x => x.Kind == AlarmTransitionKind.Clear);
        await Settled(r);
        await r.StopAsync();
        e.ConditionId.ShouldBe(Tag);
        Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.Clear).ShouldBe(1);
    }

    /// <summary>A newly entered (unacked) limit while active is a Retrigger, not a second Raise.</summary>
    [Fact]
    public async Task A_newly_entered_limit_while_active_retriggers()
    {
        var r = await StartAsync(x => x.Set("HInAlarm", true));
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        r.Set("HHInAlarm", true);
        var e = await Next(r, x => x.Kind == AlarmTransitionKind.Retrigger);
        await Settled(r);
        await r.StopAsync();
        e.Message.ShouldBe($"ALMA {Tag} HH alarm");
        e.OpcUaSeverity.ShouldBe(900);
        Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.Raise).ShouldBe(1);
    }

    /// <summary>L1 — a limit entering ALREADY acked (AckRequired false) is atomic ActiveAcknowledged, never Retrigger+Acknowledge.</summary>
    [Fact]
    public async Task A_new_limit_entering_already_acked_is_active_acknowledged_not_retrigger_then_ack()
    {
        var r = await StartAsync(x => { x.Set("HInAlarm", true);
            foreach (var a in new[] { "HHAcked", "HAcked", "LAcked", "LLAcked", "ROCPosAcked" }) x.Set(a, true); });
        await Next(r, x => x.Kind == AlarmTransitionKind.ActiveAcknowledged);
        r.Set("HHInAlarm", true); // AckRequired=false: HHAcked is already true
        await WaitFor(() => Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.ActiveAcknowledged) >= 2);
        await Settled(r);
        await r.StopAsync();
        var evs = Snapshot(r);
        evs.Any(x => x.Kind is AlarmTransitionKind.Retrigger or AlarmTransitionKind.Acknowledge).ShouldBeFalse();
    }

    /// <summary>M1 — a limit dropping out while another stays active moves the text/severity as a no-row state update.</summary>
    [Fact]
    public async Task A_limit_dropping_out_is_a_restatement_state_update()
    {
        var r = await StartAsync(x => { x.Set("HInAlarm", true); x.Set("HHInAlarm", true); });
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        r.Set("HHInAlarm", false);
        var e = await Next(r, x => x.Kind == AlarmTransitionKind.Unspecified);
        await Settled(r);
        await r.StopAsync();
        e.IsRestatement.ShouldBeTrue("the host must write no alerts row for it");
        e.Message.ShouldBe($"ALMA {Tag} H alarm");
        e.OpcUaSeverity.ShouldBe(600);
        Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.Unspecified).ShouldBe(1);
    }

    /// <summary>M1 — a non-governing limit flickering (ROC under HH) changes neither text nor severity: no event at all.</summary>
    [Fact]
    public async Task A_non_governing_limit_flicker_emits_nothing()
    {
        var r = await StartAsync(x => { x.Set("HHInAlarm", true); x.Set("ROCPosInAlarm", true); });
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        r.Set("ROCPosInAlarm", false);
        await Settled(r);
        await r.StopAsync();
        Snapshot(r).Count.ShouldBe(1);
    }

    /// <summary>The PLC acknowledging every declared limit surfaces as one Acknowledge.</summary>
    [Fact]
    public async Task The_plc_acknowledging_the_limits_fires_acknowledge()
    {
        var r = await StartAsync(x => x.Set("HInAlarm", true));
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        r.Set("HAcked", true); r.Set("HHAcked", true); r.Set("LAcked", true); r.Set("LLAcked", true); r.Set("ROCPosAcked", true);
        await Next(r, x => x.Kind == AlarmTransitionKind.Acknowledge);
        await Settled(r);
        await r.StopAsync();
        Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.Acknowledge).ShouldBe(1);
    }

    /// <summary>
    ///     M2 — H acked; HH enters unacked then returns to normal still unacked (HHAcked stays false). The surviving,
    ///     acked H must NOT turn into a device "Acknowledged" for an HH excursion nobody acknowledged.
    /// </summary>
    [Fact]
    public async Task An_unacked_excursion_that_returns_to_normal_is_not_reported_as_acknowledged()
    {
        var r = await StartAsync(x => { x.Set("HInAlarm", true); x.Set("HAcked", true); });
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise); // other limits' Acked bits are false ⇒ still unacked
        r.Set("LAcked", true); r.Set("LLAcked", true); r.Set("ROCPosAcked", true); r.Set("HHAcked", true);
        await Next(r, x => x.Kind == AlarmTransitionKind.Acknowledge);
        r.Set("HHAcked", false);                // HH occurrence (unacked)…
        r.Set("HHInAlarm", true);
        await Next(r, x => x.Kind == AlarmTransitionKind.Retrigger);
        r.Set("HHInAlarm", false);              // …returns to normal, still unacked
        await Settled(r);
        await r.StopAsync();
        Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.Acknowledge).ShouldBe(1,
            "only the genuine PLC ack — the unacked HH excursion must keep the condition unacknowledged");
    }

    /// <summary>F3 — fully acked, then a declared *Acked goes false with the SAME limits active (a limit that left and re-entered
    /// between polls): the PLC says unacknowledged, so it is told as a Retrigger.</summary>
    [Fact]
    public async Task An_ack_falling_with_an_unchanged_active_set_retriggers()
    {
        var r = await StartAsync(x =>
        {
            x.Set("HInAlarm", true);
            foreach (var a in new[] { "HHAcked", "HAcked", "LAcked", "LLAcked", "ROCPosAcked" }) x.Set(a, true);
        });
        await Next(r, x => x.Kind == AlarmTransitionKind.ActiveAcknowledged);
        r.Set("HAcked", false);
        var e = await Next(r, x => x.Kind == AlarmTransitionKind.Retrigger);
        await Settled(r);
        await r.StopAsync();
        e.Message.ShouldBe($"ALMA {Tag} H alarm");
        Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.Retrigger).ShouldBe(1);
    }

    /// <summary>An alarm already active AND acked when first seen is told atomically, never Raise-then-Acknowledge.</summary>
    [Fact]
    public async Task An_already_acked_active_alarm_is_active_acknowledged()
    {
        var r = await StartAsync(x =>
        {
            x.Set("LInAlarm", true);
            foreach (var a in new[] { "HHAcked", "HAcked", "LAcked", "LLAcked", "ROCPosAcked" }) x.Set(a, true);
        });
        var e = await Next(r, x => x.Kind != AlarmTransitionKind.Unspecified);
        await Settled(r);
        await r.StopAsync();
        e.Kind.ShouldBe(AlarmTransitionKind.ActiveAcknowledged);
        Snapshot(r).Count.ShouldBe(1);
    }

    /// <summary>A re-subscribe must not re-raise a still-active ALMA (it would un-acknowledge it).</summary>
    [Fact]
    public async Task A_resubscribe_does_not_re_raise_a_still_active_alma()
    {
        var r = await StartAsync(x => x.Set("HInAlarm", true));
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        var sub2 = await r.Drv.SubscribeAlarmsAsync([Tag], CancellationToken.None);
        await Settled(r);
        await r.Drv.UnsubscribeAlarmsAsync(sub2, CancellationToken.None);
        await r.StopAsync();
        Snapshot(r).Count(x => x.Kind == AlarmTransitionKind.Raise).ShouldBe(1);
    }

    /// <summary>A Bad limit read judges nothing that tick: no event, and no false Clear for an active alarm.</summary>
    [Fact]
    public async Task A_bad_read_does_not_clear_an_active_alarm()
    {
        var r = await StartAsync(x => x.Set("HInAlarm", true));
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        // A non-zero libplctag status ⇒ Bad on every member read; the driver evicts the handle and re-creates it, so
        // every re-created runtime must fail too (a fresh fake would read as "all clear").
        var recreations = 0;
        r.Factory.Customise = p => { Interlocked.Increment(ref recreations); return new FakeAbCipTag(p) { Status = (int)AbStatus.NotFound }; };
        foreach (var t in r.Factory.Tags.Values.ToList()) t.Status = (int)AbStatus.NotFound;
        await WaitFor(() => Volatile.Read(ref recreations) >= 6);
        await r.StopAsync();
        Snapshot(r).Any(x => x.Kind == AlarmTransitionKind.Clear).ShouldBeFalse();
    }

    /// <summary>L2 — a Bad <c>*Acked</c> read is "unknown", not "un-acked": it must neither un-ack nor re-ack.</summary>
    [Fact]
    public async Task A_bad_acked_read_is_carried_not_stored_as_unacked()
    {
        var r = await StartAsync(x =>
        {
            x.Set("HInAlarm", true);
            foreach (var a in new[] { "HHAcked", "HAcked", "LAcked", "LLAcked", "ROCPosAcked" }) x.Set(a, true);
        });
        await Next(r, x => x.Kind == AlarmTransitionKind.ActiveAcknowledged);
        // Transient Bad *Acked reads: the evicted runtime is re-created failing, tick after tick.
        var bad = 0;
        r.Factory.Customise = p =>
        {
            if (!p.TagName.EndsWith("HAcked", StringComparison.Ordinal)) return null!;
            Interlocked.Increment(ref bad);
            return new FakeAbCipTag(p) { Status = (int)AbStatus.NotFound };
        };
        r.Factory.Tags[$"{Tag}.HAcked"].Status = (int)AbStatus.NotFound;
        await WaitFor(() => Volatile.Read(ref bad) >= 4);
        // The link recovers and HAcked reads true again.
        r.Factory.Customise = p => new FakeAbCipTag(p) { Value = true };
        await WaitFor(() => r.Factory.Tags[$"{Tag}.HAcked"].Status == 0 && r.Factory.Tags[$"{Tag}.HAcked"].Value is true);
        await Settled(r);
        await r.StopAsync();
        var evs = Snapshot(r);
        evs.Any(x => x.Kind is AlarmTransitionKind.Acknowledge or AlarmTransitionKind.Retrigger or AlarmTransitionKind.Raise).ShouldBeFalse(
            "a transient Bad *Acked read must not produce a second ack/raise");
    }

    /// <summary>L2 — a Bad severity read must not change the told message/severity.</summary>
    [Fact]
    public async Task A_bad_severity_read_changes_nothing()
    {
        var r = await StartAsync(x => { x.Set("HInAlarm", true); x.Set("HHInAlarm", true); });
        await Next(r, x => x.Kind == AlarmTransitionKind.Raise);
        r.Factory.Customise = p => new FakeAbCipTag(p) { Status = (int)AbStatus.NotFound };
        r.Factory.Tags[$"{Tag}.HHSeverity"].Status = (int)AbStatus.NotFound;
        await Task.Delay(150);
        await Settled(r);
        await r.StopAsync();
        Snapshot(r).Count.ShouldBe(1, "no Retrigger/update from a Bad severity read");
    }

    /// <summary>A client acknowledge writes the ALMA's OperAckAll input — never the ALMD-only <c>Acked</c> member.</summary>
    [Fact]
    public async Task Acknowledge_writes_OperAckAll_not_Acked()
    {
        var r = await StartAsync();
        await r.Drv.AcknowledgeAsync([new AlarmAcknowledgeRequest(Tag, Tag, null)], CancellationToken.None);
        await r.StopAsync();
        r.Factory.Tags.ShouldContainKey($"{Tag}.OperAckAll");
        r.Factory.Tags[$"{Tag}.OperAckAll"].WriteCount.ShouldBe(1);
        r.Factory.Tags.ShouldNotContainKey($"{Tag}.Acked");
    }

    /// <summary>L4 — one subscription mixing an ALMD and an ALMA: the cursor arithmetic keeps each node's reads apart.</summary>
    [Fact]
    public async Task A_mixed_almd_and_alma_subscription_projects_each_correctly()
    {
        var factory = new FakeAbCipTagFactory();
        var drv = new AbCipDriver(Options(AlmdTag("Motor"), AlmaTag(), AlmdTag("Pump")), "drv-1", factory);
        await drv.InitializeAsync("{}", CancellationToken.None);
        var events = new List<AlarmEventArgs>();
        drv.OnAlarmEvent += (_, e) => { lock (events) events.Add(e); };
        var handle = await drv.SubscribeAlarmsAsync(["Motor", Tag, "Pump"], CancellationToken.None);
        await WaitFor(() => factory.Tags.ContainsKey($"{Tag}.HHSeverity") && factory.Tags.ContainsKey("Pump.Severity")
            && factory.Tags.ContainsKey("Motor.Severity") && factory.Tags.ContainsKey($"{Tag}.HAcked"));
        factory.Tags["Motor.Severity"].Value = 300;
        factory.Tags["Pump.Severity"].Value = 700;
        factory.Tags[$"{Tag}.HSeverity"].Value = 600;
        factory.Tags["Pump.InAlarm"].Value = true;
        factory.Tags[$"{Tag}.HInAlarm"].Value = true;

        await WaitFor(() => { lock (events) return events.Count >= 2; });
        await Task.Delay(100);
        await drv.UnsubscribeAlarmsAsync(handle, CancellationToken.None);
        await drv.ShutdownAsync(CancellationToken.None);
        List<AlarmEventArgs> evs; lock (events) evs = [.. events];
        evs.Count.ShouldBe(2);
        var pump = evs.Single(e => e.ConditionId == "Pump");
        pump.AlarmType.ShouldBe("ALMD"); pump.Severity.ShouldBe(AlarmSeverity.High);
        var alma = evs.Single(e => e.ConditionId == Tag);
        alma.AlarmType.ShouldBe("ALMA"); alma.OpcUaSeverity.ShouldBe(600);
    }
}