using Akka.Actor;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Commons.Messages.Redundancy;
using ZB.MOM.WW.OtOpcUa.Commons.Types;
using ZB.MOM.WW.OtOpcUa.Runtime.Health;
using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;

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

/// <summary>
/// Tests for <see cref="PeerProbeSupervisor"/>: it maintains exactly one peer-OPC-UA-probe child
/// per OTHER, non-Detached driver node named in the latest <see cref="RedundancyStateChanged"/>
/// snapshot, spawning/stopping children as the topology changes.
/// </summary>
public sealed class PeerProbeSupervisorTests : RuntimeActorTestBase
{
    private static readonly NodeId Local = NodeId.Parse("local:4053");
    private static readonly NodeId Peer = NodeId.Parse("peer:4053");
    private static readonly NodeId Adm = NodeId.Parse("adm:4053");

    /// <summary>No-op child actor stub so we can count children without real TCP probes.</summary>
    private sealed class NoopActor : ReceiveActor { }

    private static Props NoopProps() => Akka.Actor.Props.Create(() => new NoopActor());

    private static NodeRedundancyState State(NodeId id, RedundancyRole role) =>
        new(id, role, IsClusterLeader: false, IsRoleLeaderForDriver: false, DateTime.UtcNow);

    private static RedundancyStateChanged Snapshot(params NodeRedundancyState[] nodes) =>
        new(nodes, CorrelationId.NewId());

    /// <summary>Verifies one child is spawned per non-self, non-Detached peer — self and Detached
    /// nodes are excluded.</summary>
    [Fact]
    public void Spawns_one_child_per_non_self_non_detached_peer()
    {
        var sup = ActorOfAsTestActorRef<PeerProbeSupervisor>(
            PeerProbeSupervisor.PropsForTests(Local, _ => NoopProps()));

        sup.Tell(Snapshot(
            State(Local, RedundancyRole.Primary),
            State(Peer, RedundancyRole.Secondary),
            State(Adm, RedundancyRole.Detached)));

        AwaitAssert(() => sup.UnderlyingActor.ChildCount.ShouldBe(1),
            duration: TimeSpan.FromMilliseconds(500));
    }

    /// <summary>Verifies the child for a departed peer is stopped when the next snapshot omits it.</summary>
    [Fact]
    public void Stops_child_for_departed_peer()
    {
        var sup = ActorOfAsTestActorRef<PeerProbeSupervisor>(
            PeerProbeSupervisor.PropsForTests(Local, _ => NoopProps()));

        sup.Tell(Snapshot(
            State(Local, RedundancyRole.Primary),
            State(Peer, RedundancyRole.Secondary)));
        AwaitAssert(() => sup.UnderlyingActor.ChildCount.ShouldBe(1),
            duration: TimeSpan.FromMilliseconds(500));

        sup.Tell(Snapshot(State(Local, RedundancyRole.Primary)));
        AwaitAssert(() => sup.UnderlyingActor.ChildCount.ShouldBe(0),
            duration: TimeSpan.FromMilliseconds(500));
    }

    /// <summary>Verifies a single-node snapshot (just the local node) spawns no children.</summary>
    [Fact]
    public void Single_node_snapshot_spawns_no_children()
    {
        var sup = ActorOfAsTestActorRef<PeerProbeSupervisor>(
            PeerProbeSupervisor.PropsForTests(Local, _ => NoopProps()));

        sup.Tell(Snapshot(State(Local, RedundancyRole.Primary)));

        AwaitAssert(() => sup.UnderlyingActor.ChildCount.ShouldBe(0),
            duration: TimeSpan.FromMilliseconds(500));
    }

    /// <summary>Verifies a previously-removed peer is respawned when it re-appears, without an
    /// "actor name not unique" collision on the sanitized child name.</summary>
    [Fact]
    public void Re_adding_a_previously_removed_peer_respawns_it()
    {
        var sup = ActorOfAsTestActorRef<PeerProbeSupervisor>(
            PeerProbeSupervisor.PropsForTests(Local, _ => NoopProps()));

        sup.Tell(Snapshot(
            State(Local, RedundancyRole.Primary),
            State(Peer, RedundancyRole.Secondary)));
        AwaitAssert(() => sup.UnderlyingActor.ChildCount.ShouldBe(1),
            duration: TimeSpan.FromMilliseconds(500));

        sup.Tell(Snapshot(State(Local, RedundancyRole.Primary)));
        AwaitAssert(() => sup.UnderlyingActor.ChildCount.ShouldBe(0),
            duration: TimeSpan.FromMilliseconds(500));

        sup.Tell(Snapshot(
            State(Local, RedundancyRole.Primary),
            State(Peer, RedundancyRole.Secondary)));
        AwaitAssert(() => sup.UnderlyingActor.ChildCount.ShouldBe(1),
            duration: TimeSpan.FromMilliseconds(500));
    }
}