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.Core.Abstractions;
using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;

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

/// <summary>
///     Covers WS-4b: <see cref="DriverInstanceActor"/> subscribes a driver's native
///     <see cref="IAlarmSource.OnAlarmEvent"/> (when the driver is an <see cref="IAlarmSource"/>)
///     and forwards every transition to its parent as
///     <see cref="DriverInstanceActor.AttributeAlarmPublished"/> — mirroring the OnDataChange →
///     <see cref="DriverInstanceActor.AttributeValuePublished"/> forward. The driver fires
///     <c>OnAlarmEvent</c> on its OWN thread; the actor marshals it onto the actor thread via Self.
/// </summary>
public sealed class DriverInstanceActorNativeAlarmTests : RuntimeActorTestBase
{
    /// <summary>
    ///     Driving an <see cref="IAlarmSource"/> driver to Connected then raising a native alarm forwards
    ///     it to the parent as <see cref="DriverInstanceActor.AttributeAlarmPublished"/> carrying the
    ///     driver-instance id + the original <see cref="AlarmEventArgs"/> (SourceNodeId preserved).
    /// </summary>
    [Fact]
    public async Task Native_alarm_is_forwarded_to_parent_as_AttributeAlarmPublished()
    {
        var driver = new AlarmSourceStubDriver();
        var parent = CreateTestProbe();
        var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver));

        actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
        AwaitCondition(() => driver.InitializeCount > 0, TimeSpan.FromSeconds(2));
        // The alarm handler is attached after Become(Connected); wait for it to be wired before raising.
        AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(2));
        // Also establish a data-change subscription so the OnDataChange path is wired (the alarm attach is
        // independent of Subscribe — this proves both event paths coexist on one driver).
        await actor.Ask<DriverInstanceActor.SubscriptionEstablished>(
            new DriverInstanceActor.Subscribe(new[] { "tag-z" }, TimeSpan.FromMilliseconds(100)),
            TimeSpan.FromSeconds(3));

        driver.RaiseAlarm(new AlarmEventArgs(
            new StubAlarmHandle(),
            SourceNodeId: "src-node-7",
            ConditionId: "cond-1",
            AlarmType: "AnalogLimitAlarm.HiHi",
            Message: "level too high",
            Severity: AlarmSeverity.High,
            SourceTimestampUtc: DateTime.UtcNow,
            Kind: AlarmTransitionKind.Raise));

        var published = parent.ExpectMsg<DriverInstanceActor.AttributeAlarmPublished>(TimeSpan.FromSeconds(2));
        published.DriverInstanceId.ShouldBe(driver.DriverInstanceId);
        published.Args.SourceNodeId.ShouldBe("src-node-7");
        published.Args.ConditionId.ShouldBe("cond-1");
        published.Args.Kind.ShouldBe(AlarmTransitionKind.Raise);

        // The same driver's OnDataChange still flows independently — alarm + value events coexist.
        driver.FireDataChange("tag-z", value: 9.0, statusCode: 0u);
        parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(2))
            .FullReference.ShouldBe("tag-z");
    }

    /// <summary>
    ///     A driver that is NOT an <see cref="IAlarmSource"/> (only <see cref="ISubscribable"/>) connects
    ///     and serves data changes normally — <c>AttachAlarmSource</c> is a safe no-op (no crash) and no
    ///     <see cref="DriverInstanceActor.AttributeAlarmPublished"/> is ever produced.
    /// </summary>
    [Fact]
    public async Task Non_alarm_source_driver_serves_data_changes_and_never_publishes_alarms()
    {
        var driver = new SubscribableOnlyStubDriver();
        var parent = CreateTestProbe();
        var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver));

        actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
        AwaitCondition(() => driver.InitializeCount > 0, TimeSpan.FromSeconds(2));

        await actor.Ask<DriverInstanceActor.SubscriptionEstablished>(
            new DriverInstanceActor.Subscribe(new[] { "tag-a" }, TimeSpan.FromMilliseconds(100)),
            TimeSpan.FromSeconds(3));

        driver.FireDataChange("tag-a", value: 1.5, statusCode: 0u);

        // Data-change forwarding still works (no crash on AttachAlarmSource for a non-IAlarmSource driver).
        var dc = parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(2));
        dc.FullReference.ShouldBe("tag-a");
        // An AttributeAlarmPublished can never be produced for a non-IAlarmSource driver.
        parent.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
    }

    /// <summary>
    ///     A native alarm transition that races in while the actor is in <c>Reconnecting</c> is silently
    ///     dropped (debug log only) — it NEVER reaches the parent as
    ///     <see cref="DriverInstanceActor.AttributeAlarmPublished"/> and does NOT dead-letter. The feed
    ///     re-delivers active alarms once the actor re-enters <c>Connected</c>, so dropping here is safe.
    ///     (<see cref="DriverInstanceActor"/> line ~345: the <c>Reconnecting</c> state's
    ///     <c>Receive&lt;NativeAlarmRaised&gt;</c> logs a debug message and discards.)
    ///
    ///     <para>
    ///         To reproduce the race deterministically: a <c>ForceReconnect</c> is enqueued first, then
    ///         the driver fires an alarm while its <c>OnAlarmEvent</c> handler is still attached (the actor
    ///         hasn't yet processed <c>ForceReconnect</c>). The handler's <c>self.Tell(NativeAlarmRaised)</c>
    ///         lands second in the mailbox. The actor then processes <c>ForceReconnect</c> → Reconnecting
    ///         (detaches handler), then processes the queued <c>NativeAlarmRaised</c> in Reconnecting
    ///         → drops it. The default 10 s reconnect interval ensures no retry fires during the check.
    ///     </para>
    /// </summary>
    [Fact]
    public void Native_alarm_during_reconnect_is_dropped_not_forwarded()
    {
        // Long reconnect interval (default 10 s) so the retry doesn't fire during the assertion window.
        var driver = new AlarmSourceStubDriver();
        var parent = CreateTestProbe();
        var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver));

        // Drive to Connected; confirm the alarm handler is attached.
        actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
        AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(2));

        // Enqueue ForceReconnect FIRST — the actor hasn't processed it yet, so the handler is
        // still wired. The test thread then immediately fires the alarm on the driver; the handler's
        // self.Tell(NativeAlarmRaised) lands SECOND in the mailbox.
        actor.Tell(new DriverInstanceActor.ForceReconnect());
        driver.RaiseAlarm(new AlarmEventArgs(
            new StubAlarmHandle(),
            SourceNodeId: "src-node-reconnect",
            ConditionId: "cond-reconnect",
            AlarmType: "T",
            Message: "during-reconnect raise",
            Severity: AlarmSeverity.High,
            SourceTimestampUtc: DateTime.UtcNow,
            Kind: AlarmTransitionKind.Raise));

        // The actor processes: (1) ForceReconnect → Reconnecting (handler detached);
        //                      (2) NativeAlarmRaised → dropped (debug log, no forward).
        // The parent must NOT receive AttributeAlarmPublished from that alarm.
        // Wait generously — the default reconnect interval of 10 s means no retry fires here.
        parent.ExpectNoMsg(TimeSpan.FromMilliseconds(500));

        // The actor must still be alive — Watch + no Terminated (not crashed or dead-lettered).
        Watch(actor);
        parent.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
    }

    /// <summary>
    ///     After a full reconnect cycle (Connected → Reconnecting → Connected), a single raised alarm still
    ///     yields EXACTLY ONE <see cref="DriverInstanceActor.AttributeAlarmPublished"/> — the
    ///     <c>_alarmEventHandler is not null</c> guard in <c>AttachAlarmSource</c> plus the detach on the
    ///     Connected → Reconnecting transition prevent a double-attach (which would publish twice).
    /// </summary>
    [Fact]
    public void Reconnect_does_not_double_attach_alarm_handler()
    {
        var driver = new AlarmSourceStubDriver();
        var parent = CreateTestProbe();
        var actor = parent.ChildActorOf(DriverInstanceActor.Props(driver, reconnectInterval: TimeSpan.FromMilliseconds(50)));

        actor.Tell(new DriverInstanceActor.InitializeRequested("{}"));
        AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(2));

        // Force Connected → Reconnecting (detaches) → Connected (re-attaches). InitializeCount climbs on
        // the retry; the alarm handler count must settle back to exactly one (no leaked extra handler).
        var initBefore = driver.InitializeCount;
        actor.Tell(new DriverInstanceActor.DisconnectObserved("backend blip"));
        AwaitCondition(() => driver.InitializeCount > initBefore, TimeSpan.FromSeconds(3));
        AwaitCondition(() => driver.AlarmSubscriberCount == 1, TimeSpan.FromSeconds(3));

        driver.RaiseAlarm(new AlarmEventArgs(
            new StubAlarmHandle(),
            SourceNodeId: "src-node-1",
            ConditionId: "cond-x",
            AlarmType: "T",
            Message: "m",
            Severity: AlarmSeverity.Low,
            SourceTimestampUtc: DateTime.UtcNow,
            Kind: AlarmTransitionKind.Raise));

        // Exactly one forward — a double-attach would surface as a second AttributeAlarmPublished.
        parent.ExpectMsg<DriverInstanceActor.AttributeAlarmPublished>(TimeSpan.FromSeconds(2))
            .Args.SourceNodeId.ShouldBe("src-node-1");
        parent.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
    }

    // --- stub drivers ----------------------------------------------------------------------------

    private class StubDriver : IDriver
    {
        /// <summary>Gets the number of times initialization was called.</summary>
        public int InitializeCount;

        /// <summary>Gets the driver instance ID.</summary>
        public string DriverInstanceId => "alarm-stub-driver-1";
        /// <summary>Gets the driver type.</summary>
        public string DriverType => "Stub";

        /// <summary>Initializes the driver.</summary>
        public Task InitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
        {
            Interlocked.Increment(ref InitializeCount);
            return Task.CompletedTask;
        }

        /// <summary>Reinitializes the driver.</summary>
        public Task ReinitializeAsync(string driverConfigJson, CancellationToken cancellationToken) =>
            Task.CompletedTask;

        /// <summary>Shuts down the driver.</summary>
        public Task ShutdownAsync(CancellationToken cancellationToken) => Task.CompletedTask;
        /// <summary>Gets the health status of the driver.</summary>
        public DriverHealth GetHealth() => new(DriverState.Healthy, DateTime.UtcNow, null);
        /// <summary>Gets the memory footprint of the driver.</summary>
        public long GetMemoryFootprint() => 0;
        /// <summary>Flushes optional caches in the driver.</summary>
        public Task FlushOptionalCachesAsync(CancellationToken cancellationToken) => Task.CompletedTask;
    }

    /// <summary>A driver that implements <see cref="ISubscribable"/> + <see cref="IAlarmSource"/> and lets the
    /// test raise <see cref="IAlarmSource.OnAlarmEvent"/> on demand (the driver fires it on its own thread in
    /// production; here the test thread stands in for that).</summary>
    private sealed class AlarmSourceStubDriver : StubDriver, ISubscribable, IAlarmSource
    {
        private readonly StubHandle _subHandle = new();

        /// <summary>Occurs when data changes.</summary>
        public event EventHandler<DataChangeEventArgs>? OnDataChange;
        /// <summary>Server-pushed alarm transition.</summary>
        public event EventHandler<AlarmEventArgs>? OnAlarmEvent;

        /// <summary>Number of live subscribers on <see cref="OnAlarmEvent"/> — proves attach/detach.</summary>
        public int AlarmSubscriberCount => OnAlarmEvent?.GetInvocationList().Length ?? 0;

        /// <summary>Subscribes to the specified full references.</summary>
        public Task<ISubscriptionHandle> SubscribeAsync(
            IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken) =>
            Task.FromResult<ISubscriptionHandle>(_subHandle);

        /// <summary>Unsubscribes from the specified subscription handle.</summary>
        public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken) =>
            Task.CompletedTask;

        /// <summary>Subscribes to alarm events for the specified node set.</summary>
        public Task<IAlarmSubscriptionHandle> SubscribeAlarmsAsync(
            IReadOnlyList<string> sourceNodeIds, CancellationToken cancellationToken) =>
            Task.FromResult<IAlarmSubscriptionHandle>(new StubAlarmHandle());

        /// <summary>Cancels an alarm subscription.</summary>
        public Task UnsubscribeAlarmsAsync(IAlarmSubscriptionHandle handle, CancellationToken cancellationToken) =>
            Task.CompletedTask;

        /// <summary>Acknowledges a batch of alarms.</summary>
        public Task AcknowledgeAsync(
            IReadOnlyList<AlarmAcknowledgeRequest> acknowledgements, CancellationToken cancellationToken) =>
            Task.CompletedTask;

        /// <summary>Fires <see cref="OnAlarmEvent"/> — stands in for the driver's native feed.</summary>
        public void RaiseAlarm(AlarmEventArgs args) => OnAlarmEvent?.Invoke(this, args);

        /// <summary>Fires a data change event (keeps OnDataChange exercised; the actor wires both events).</summary>
        public void FireDataChange(string fullRef, object? value, uint statusCode)
        {
            var snapshot = new DataValueSnapshot(value, statusCode, DateTime.UtcNow, DateTime.UtcNow);
            OnDataChange?.Invoke(this, new DataChangeEventArgs(_subHandle, fullRef, snapshot));
        }

        private sealed class StubHandle : ISubscriptionHandle
        {
            /// <summary>Gets the diagnostic ID of the subscription.</summary>
            public string DiagnosticId => "stub-sub";
        }
    }

    /// <summary>A driver that is <see cref="ISubscribable"/> but NOT <see cref="IAlarmSource"/> — proves
    /// <c>AttachAlarmSource</c> is a no-op (no crash) and no alarm forward ever happens.</summary>
    private sealed class SubscribableOnlyStubDriver : StubDriver, ISubscribable
    {
        private readonly StubHandle _subHandle = new();

        /// <summary>Occurs when data changes.</summary>
        public event EventHandler<DataChangeEventArgs>? OnDataChange;

        /// <summary>Subscribes to the specified full references.</summary>
        public Task<ISubscriptionHandle> SubscribeAsync(
            IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken) =>
            Task.FromResult<ISubscriptionHandle>(_subHandle);

        /// <summary>Unsubscribes from the specified subscription handle.</summary>
        public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken) =>
            Task.CompletedTask;

        /// <summary>Fires a data change event with the specified parameters.</summary>
        public void FireDataChange(string fullRef, object? value, uint statusCode)
        {
            var snapshot = new DataValueSnapshot(value, statusCode, DateTime.UtcNow, DateTime.UtcNow);
            OnDataChange?.Invoke(this, new DataChangeEventArgs(_subHandle, fullRef, snapshot));
        }

        private sealed class StubHandle : ISubscriptionHandle
        {
            /// <summary>Gets the diagnostic ID of the subscription.</summary>
            public string DiagnosticId => "stub-sub";
        }
    }

    /// <summary>Minimal <see cref="IAlarmSubscriptionHandle"/> for building <see cref="AlarmEventArgs"/>.</summary>
    private sealed class StubAlarmHandle : IAlarmSubscriptionHandle
    {
        /// <summary>Gets the diagnostic ID of the alarm subscription.</summary>
        public string DiagnosticId => "stub-alarm-sub";
    }
}