using Akka.Actor;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
using ZB.MOM.WW.OtOpcUa.Commons.Types;
using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
using ZB.MOM.WW.OtOpcUa.Runtime.OpcUa;
using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;
using static ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness.V3ArtifactSeeder;

namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Drivers;

/// <summary>
///     v3 Batch 4 (B4-WP3) — the driver <b>single-source fan-out</b> wired into
///     <see cref="DriverHostActor"/>. The driver publishes a value keyed by its wire-ref (== the tag's
///     <c>RawPath</c>); the host's <c>_nodeIdByDriverRef</c> map — rebuilt each apply from the composition's
///     <c>RawTags</c> ∪ <c>UnsReferenceVariables</c> — resolves <c>(DriverInstanceId, RawPath)</c> to the RAW
///     NodeId AND every referencing UNS NodeId, so <c>ForwardBatchToMux</c> lands ONE write on the raw node
///     (<see cref="AddressSpaceRealm.Raw"/>) plus every UNS node (<see cref="AddressSpaceRealm.Uns"/>) with
///     IDENTICAL value/quality/timestamp (no independent buffer ⇒ no drift). The raw value is still forwarded
///     to the dependency mux (VirtualTag inputs), keyed by the RawPath.
///     <para>
///         Driven over the BATCH ingress, because that is the only one a driver child has: since the
///         value-pipeline batching work <c>DriverInstanceActor.OnDataChangeForward</c> wraps even a single
///         data change in an <see cref="DriverInstanceActor.AttributeValueBatchPublished"/>, and the host
///         no longer receives the per-value message at all. These fan-out cases are therefore stated as
///         single-item bursts; what they pin is the ROUTING, while
///         <see cref="DriverHostActorBatchFanOutTests"/> pins the message counts of a multi-item burst.
///     </para>
///     <para>
///         Drives a real apply through <see cref="V3ArtifactSeeder"/>: the seeded artifact carries the v3
///         raw-tag chain (RawFolder → DriverInstance(RawFolderId) → Device → Tag) + an optional
///         UnsTagReference projecting each raw tag into an equipment. <c>DispatchDeployment</c> triggers the
///         <c>BeginDirectApply → HandleArtifactForApply → PushDesiredSubscriptionsFromParsed</c> pass that
///         builds the map; the sink and mux are
///         injected as <see cref="Akka.TestKit.TestProbe"/>s.
///     </para>
/// </summary>
public sealed class DriverHostActorLiveValueTests : RuntimeActorTestBase
{
    private static readonly NodeId TestNode = NodeId.Parse("driver-lv-test");
    private static readonly RevisionHash RevA = RevisionHash.Parse(new string('a', 64));
    private static readonly DateTime Ts = new(2026, 6, 13, 10, 0, 0, DateTimeKind.Utc);

    /// <summary>The single-item burst a driver child emits for one data change — every value ingress into
    /// the host is an AttributeValueBatchPublished, so the fan-out cases below state their input that
    /// way.</summary>
    private static DriverInstanceActor.AttributeValueBatchPublished Burst((string Ref, object Value) item) =>
        new("drv-1", new[] { new DriverInstanceActor.AttributeValueItem(item.Ref, item.Value, OpcUaStatus.Good, Ts) });

    /// <summary>A driver value published by RawPath fans to the RAW node AND the referencing UNS node, each
    /// carrying identical value/quality/timestamp — the fan-out drift guard.</summary>
    [Fact]
    public void Driver_value_fans_out_to_raw_and_uns_NodeIds_with_identical_value()
    {
        var db = NewInMemoryDbFactory();
        var deploymentId = SeedV3Deployment(db, RevA,
            rawTags: new[] { (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "speed", DataType: "Double", Writable: false) },
            unsRefs: new[] { (Area: "filling", Line: "line1", Equip: "station1", BackingTag: "speed", Effective: (string?)null) });

        var (actor, publish, mux) = SpawnHostAndApply(this, db, TestNode, deploymentId, RevA);

        // The driver publishes by its wire-ref RawPath, in the single-item burst DriverInstanceActor
        // emits for one data change.
        actor.Tell(Burst(("Plant/Modbus/dev1/speed", 42.0)));

        var byId = publish.ExpectMsg<OpcUaPublishActor.AttributeValueBatchUpdate>(PresenceBudget)
            .Items.ToDictionary(u => u.NodeId);

        byId.Keys.ShouldBe(new[] { "Plant/Modbus/dev1/speed", "filling/line1/station1/speed" }, ignoreOrder: true);
        // Realm travels with each update so the sink resolves the right namespace.
        byId["Plant/Modbus/dev1/speed"].Realm.ShouldBe(AddressSpaceRealm.Raw);
        byId["filling/line1/station1/speed"].Realm.ShouldBe(AddressSpaceRealm.Uns);
        // Fan-out drift guard: identical value + quality + timestamp on BOTH node states.
        foreach (var u in byId.Values)
        {
            u.Value.ShouldBe(42.0);
            u.StatusCode.ShouldBe(OpcUaStatus.Good);
            u.SourceTimestampUtc.ShouldBe(Ts);
        }

        // The raw publish still reaches the dependency mux (VirtualTag inputs), keyed by RawPath.
        mux.ExpectMsg<DriverInstanceActor.AttributeValueBatchPublished>(PresenceBudget)
            .Items.Single().FullReference.ShouldBe("Plant/Modbus/dev1/speed");
    }

    /// <summary>A raw tag with NO UNS reference fans to ONLY its raw NodeId (Raw realm).</summary>
    [Fact]
    public void Unreferenced_raw_tag_fans_to_raw_node_only()
    {
        var db = NewInMemoryDbFactory();
        var deploymentId = SeedV3Deployment(db, RevA,
            rawTags: new[] { (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "speed", DataType: "Double", Writable: false) },
            unsRefs: Array.Empty<(string, string, string, string, string?)>());

        var (actor, publish, _) = SpawnHostAndApply(this, db, TestNode, deploymentId, RevA);

        actor.Tell(Burst(("Plant/Modbus/dev1/speed", 5.0)));

        var only = publish.ExpectMsg<OpcUaPublishActor.AttributeValueBatchUpdate>(PresenceBudget)
            .Items.ShouldHaveSingleItem();
        only.NodeId.ShouldBe("Plant/Modbus/dev1/speed");
        only.Realm.ShouldBe(AddressSpaceRealm.Raw);
        publish.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
    }

    /// <summary>A raw tag referenced by TWO equipments fans to the raw node PLUS both UNS nodes (3 updates,
    /// identical value) — the 1:N fan-out.</summary>
    [Fact]
    public void Raw_tag_referenced_by_two_equipments_fans_to_raw_plus_both_uns()
    {
        var db = NewInMemoryDbFactory();
        var deploymentId = SeedV3Deployment(db, RevA,
            rawTags: new[] { (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "speed", DataType: "Double", Writable: false) },
            unsRefs: new[]
            {
                (Area: "filling", Line: "line1", Equip: "station1", BackingTag: "speed", Effective: (string?)null),
                (Area: "filling", Line: "line1", Equip: "station2", BackingTag: "speed", Effective: (string?)null),
            });

        var (actor, publish, _) = SpawnHostAndApply(this, db, TestNode, deploymentId, RevA);

        actor.Tell(Burst(("Plant/Modbus/dev1/speed", 7.0)));

        // 3-wide fan-out inside ONE batch message — the batch path's own 1:N coverage.
        var updates = publish.ExpectMsg<OpcUaPublishActor.AttributeValueBatchUpdate>(PresenceBudget).Items;
        updates.Count.ShouldBe(3);
        updates.Select(u => u.NodeId).ShouldBe(new[]
        {
            "Plant/Modbus/dev1/speed",
            "filling/line1/station1/speed",
            "filling/line1/station2/speed",
        }, ignoreOrder: true);
        updates.ShouldAllBe(u => (double)u.Value! == 7.0);
    }

    /// <summary>A value for a ref not in the composition is NOT pushed to the OPC UA sink (no matching
    /// NodeId), but is still forwarded to the dependency mux.</summary>
    [Fact]
    public void Unmatched_ref_is_dropped_from_sink_but_still_forwarded_to_mux()
    {
        var db = NewInMemoryDbFactory();
        var deploymentId = SeedV3Deployment(db, RevA,
            rawTags: new[] { (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "speed", DataType: "Double", Writable: false) },
            unsRefs: Array.Empty<(string, string, string, string, string?)>());

        var (actor, publish, mux) = SpawnHostAndApply(this, db, TestNode, deploymentId, RevA);

        actor.Tell(Burst(("Plant/Modbus/dev1/nope", 99.0)));

        publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
        mux.ExpectMsg<DriverInstanceActor.AttributeValueBatchPublished>(PresenceBudget)
            .Items.Single().FullReference.ShouldBe("Plant/Modbus/dev1/nope");
    }

    // ---- #481 (Layer 4): comms loss reaches the dependency mux ------------------------------------
    //
    // #478 gave a scripted condition the worst quality of its inputs, but only for inputs whose driver
    // PUBLISHES a Bad data change. A poll driver whose device goes unreachable publishes nothing — it
    // raises ConnectivityChanged(false) and goes silent — so the engine held its last Good value and
    // went on evaluating it. These pin the synthetic Bad that closes that hole.

    /// <summary>Comms loss pushes a Bad for every value ref the driver owns — not one, and not the
    /// alarm-bearing ones (those take the Part 9 quality path instead) — as ONE batch envelope rather than
    /// one Tell per ref.</summary>
    [Fact]
    public void Driver_comms_loss_pushes_BadNoCommunication_into_the_mux_for_every_ref_it_owns()
    {
        var db = NewInMemoryDbFactory();
        var deploymentId = SeedV3Deployment(db, RevA,
            rawTags: new[]
            {
                (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "speed", DataType: "Double", Writable: false),
                (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "temp", DataType: "Double", Writable: false),
            },
            unsRefs: Array.Empty<(string, string, string, string, string?)>());

        var (actor, _, mux) = SpawnHostAndApply(this, db, TestNode, deploymentId, RevA);

        actor.Tell(new DriverInstanceActor.ConnectivityChanged("drv-1", Connected: false));

        // ONE envelope for the whole driver: a driver owning 5k tags cost 5k Tells before this was batched.
        var fan = mux.ExpectMsg<DriverInstanceActor.AttributeValueBatchPublished>(PresenceBudget);
        fan.DriverInstanceId.ShouldBe("drv-1");
        var pushes = fan.Items;

        pushes.Select(p => p.FullReference).ShouldBe(
            new[] { "Plant/Modbus/dev1/speed", "Plant/Modbus/dev1/temp" }, ignoreOrder: true);

        foreach (var p in pushes)
        {
            // BadNoCommunication, not the bare Bad: #519's reasoning applies here too — the sub-code
            // names the actual cause and reaches a client through the scripted condition's quality.
            p.StatusCode.ShouldBe(OpcUaStatus.BadNoCommunication);
            // Null rather than the last-known value: the honest statement is "no current value". The
            // engine's AreInputsReady gate holds the predicate on any Bad, so no script sees the null.
            p.Value.ShouldBeNull();
        }

        mux.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
    }

    /// <summary>Reconnect pushes NOTHING — and this is the falsifying control for the test above, since
    /// both drive the same handler over the same populated map and only one may produce traffic.</summary>
    [Fact]
    public void Driver_reconnect_pushes_nothing_into_the_mux()
    {
        // Publishing Good here would assert a value quality the host has not observed. Recovery instead
        // rides the driver's own republish: the Connected -> Reconnecting edge calls DetachSubscription,
        // so the reconnect builds a FRESH subscription whose PollGroupEngine initial push runs with
        // forceRaise: true and re-publishes every tag with its real quality. Without that detach the poll
        // engine would compare against retained LastValues, see an unchanged value, raise nothing, and
        // strand these refs Bad forever — the value-dedup trap from the v3 Batch 4 virtual-tag reassert.
        var db = NewInMemoryDbFactory();
        var deploymentId = SeedV3Deployment(db, RevA,
            rawTags: new[] { (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "speed", DataType: "Double", Writable: false) },
            unsRefs: Array.Empty<(string, string, string, string, string?)>());

        var (actor, _, mux) = SpawnHostAndApply(this, db, TestNode, deploymentId, RevA);

        actor.Tell(new DriverInstanceActor.ConnectivityChanged("drv-1", Connected: true));

        mux.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
    }

    /// <summary>Comms loss for a driver this host knows nothing about pushes nothing — the fan-out is
    /// scoped by DriverInstanceId, so one dead device cannot Bad-out another driver's tags.</summary>
    [Fact]
    public void Comms_loss_for_another_driver_pushes_nothing_into_the_mux()
    {
        var db = NewInMemoryDbFactory();
        var deploymentId = SeedV3Deployment(db, RevA,
            rawTags: new[] { (Driver: "drv-1", DriverName: "Modbus", Device: "dev1", Tag: "speed", DataType: "Double", Writable: false) },
            unsRefs: Array.Empty<(string, string, string, string, string?)>());

        var (actor, _, mux) = SpawnHostAndApply(this, db, TestNode, deploymentId, RevA);

        actor.Tell(new DriverInstanceActor.ConnectivityChanged("drv-OTHER", Connected: false));

        mux.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
    }

}