ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests/Actors/InstanceActorIntegrationTests.cs

using Akka.Actor;
using Akka.TestKit.Xunit2;
using Microsoft.Extensions.Logging.Abstractions;
using ZB.MOM.WW.ScadaBridge.Commons.Messages.DebugView;
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Instance;
using ZB.MOM.WW.ScadaBridge.Commons.Messages.ScriptExecution;
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Streaming;
using ZB.MOM.WW.ScadaBridge.Commons.Types.Flattening;
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Actors;
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Persistence;
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Scripts;
using ZB.MOM.WW.ScadaBridge.TestSupport;
using System.Text.Json;

namespace ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Actors;

/// <summary>
/// Integration tests for InstanceActor with child Script/Alarm actors (WP-15, WP-16, WP-24, WP-25).
/// </summary>
public class InstanceActorIntegrationTests : TestKit, IDisposable
{
    private readonly SiteStorageService _storage;
    private readonly ScriptCompilationService _compilationService;
    private readonly SharedScriptLibrary _sharedScriptLibrary;
    private readonly SiteRuntimeOptions _options;
    private readonly TestLocalDb _localDb;

    public InstanceActorIntegrationTests()
    {
        _localDb = TestLocalDb.CreateTemp("instance-int-test");
        _storage = new SiteStorageService(
            _localDb.Db,
            NullLogger<SiteStorageService>.Instance);
        _storage.InitializeAsync().GetAwaiter().GetResult();
        _compilationService = new ScriptCompilationService(
            NullLogger<ScriptCompilationService>.Instance);
        _sharedScriptLibrary = new SharedScriptLibrary(
            _compilationService, NullLogger<SharedScriptLibrary>.Instance);
        _options = new SiteRuntimeOptions
        {
            MaxScriptCallDepth = 10,
            ScriptExecutionTimeoutSeconds = 30
        };

    }

    void IDisposable.Dispose()
    {
        // TestKit teardown first, so no in-flight actor can reach a disposed ILocalDb;
        // then dispose the database before deleting — the master connection anchors the WAL.
        Shutdown();
        var path = _localDb.Path;
        _localDb.Dispose();
        TestLocalDb.DeleteFiles(path);
    }

    private IActorRef CreateInstanceWithScripts(
        string instanceName,
        IReadOnlyList<ResolvedScript>? scripts = null,
        IReadOnlyList<ResolvedAlarm>? alarms = null)
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = instanceName,
            Attributes =
            [
                new ResolvedAttribute { CanonicalName = "Temperature", Value = "98.6", DataType = "Double" },
                new ResolvedAttribute { CanonicalName = "Status", Value = "Running", DataType = "String" }
            ],
            Scripts = scripts ?? [],
            Alarms = alarms ?? []
        };

        return ActorOf(Props.Create(() => new InstanceActor(
            instanceName,
            JsonSerializer.Serialize(config),
            _storage,
            _compilationService,
            _sharedScriptLibrary,
            null, // no stream manager
            _options,
            NullLogger<InstanceActor>.Instance)));
    }

    [Fact]
    public void InstanceActor_CreatesScriptActors_FromConfig()
    {
        var scripts = new[]
        {
            new ResolvedScript
            {
                CanonicalName = "GetValue",
                Code = "42"
            }
        };

        var actor = CreateInstanceWithScripts("Pump1", scripts);

        // Verify script actor is reachable via CallScript
        actor.Tell(new ScriptCallRequest("GetValue", null, 0, "corr-1"));
        var result = ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
        Assert.True(result.Success);
        Assert.Equal(42, result.ReturnValue);
    }

    [Fact]
    public void InstanceActor_ScriptCallRequest_UnknownScript_ReturnsError()
    {
        var actor = CreateInstanceWithScripts("Pump1");

        actor.Tell(new ScriptCallRequest("NonExistent", null, 0, "corr-2"));
        var result = ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(5));
        Assert.False(result.Success);
        Assert.Contains("not found", result.ErrorMessage);
    }

    [Fact]
    public void InstanceActor_WP24_StateMutationsSerializedThroughMailbox()
    {
        // WP-24: Instance Actor processes messages sequentially.
        // Verify that rapid attribute changes don't corrupt state.
        var actor = CreateInstanceWithScripts("Pump1");

        // Send many rapid set commands
        for (int i = 0; i < 50; i++)
        {
            actor.Tell(new SetStaticAttributeCommand(
                $"corr-{i}", "Pump1", "Temperature", $"{i}", DateTimeOffset.UtcNow));
        }

        // Each static write replies with a SetStaticAttributeResponse; drain all
        // 50 — the FIFO mailbox guarantees they are processed in order.
        for (int i = 0; i < 50; i++)
        {
            ExpectMsg<SetStaticAttributeResponse>(TimeSpan.FromSeconds(5));
        }

        // The last value should be the final one
        actor.Tell(new GetAttributeRequest(
            "corr-final", "Pump1", "Temperature", DateTimeOffset.UtcNow));
        var response = ExpectMsg<GetAttributeResponse>(TimeSpan.FromSeconds(5));
        Assert.True(response.Found);
        Assert.Equal("49", response.Value?.ToString());
    }

    [Fact]
    public void InstanceActor_WP25_DebugViewSubscribe_ReturnsSnapshot()
    {
        var actor = CreateInstanceWithScripts("Pump1");

        // Wait for initialization
        Thread.Sleep(500);

        actor.Tell(new SubscribeDebugViewRequest("Pump1", "debug-1"));
        var snapshot = ExpectMsg<DebugViewSnapshot>(TimeSpan.FromSeconds(5));

        Assert.Equal("Pump1", snapshot.InstanceUniqueName);
        Assert.True(snapshot.AttributeValues.Count >= 2); // Temperature + Status
        Assert.True(snapshot.SnapshotTimestamp > DateTimeOffset.MinValue);
    }

    [Fact]
    public void InstanceActor_WP25_DebugViewSubscribe_NoLongerForwardsEventsViaClusterClient()
    {
        // Events now flow via gRPC (SiteStreamManager → StreamRelayActor → gRPC),
        // not via ClusterClient. Subscribing returns a snapshot but ongoing events
        // are NOT forwarded to the subscriber actor.
        var actor = CreateInstanceWithScripts("Pump1");

        // Subscribe to debug view — should still get snapshot
        actor.Tell(new SubscribeDebugViewRequest("Pump1", "debug-2"));
        ExpectMsg<DebugViewSnapshot>(TimeSpan.FromSeconds(5));

        // Change an attribute
        actor.Tell(new AttributeValueChanged(
            "Pump1", "Temperature", "Temperature", "200", "Good", DateTimeOffset.UtcNow));

        // Should NOT receive change notification (old ClusterClient path removed)
        ExpectNoMsg(TimeSpan.FromSeconds(1));
    }

    [Fact]
    public void InstanceActor_WP25_DebugViewUnsubscribe_StopsNotifications()
    {
        var actor = CreateInstanceWithScripts("Pump1");

        // Subscribe
        actor.Tell(new SubscribeDebugViewRequest("Pump1", "debug-3"));
        ExpectMsg<DebugViewSnapshot>(TimeSpan.FromSeconds(5));

        // Unsubscribe
        actor.Tell(new UnsubscribeDebugViewRequest("Pump1", "debug-3"));

        // Change attribute
        actor.Tell(new AttributeValueChanged(
            "Pump1", "Temperature", "Temperature", "300", "Good", DateTimeOffset.UtcNow));

        // Should NOT receive change notification
        ExpectNoMsg(TimeSpan.FromSeconds(1));
    }

    [Fact]
    public void InstanceActor_CreatesAlarmActors_FromConfig()
    {
        var alarms = new[]
        {
            new ResolvedAlarm
            {
                CanonicalName = "HighTemp",
                TriggerType = "RangeViolation",
                TriggerConfiguration = "{\"attributeName\":\"Temperature\",\"min\":0,\"max\":100}",
                PriorityLevel = 1
            }
        };

        var actor = CreateInstanceWithScripts("Pump1", alarms: alarms);

        // Wait for initialization
        Thread.Sleep(500);

        // Verify alarm actor was created by checking the debug snapshot includes the alarm
        actor.Tell(new DebugSnapshotRequest("Pump1", "snap-alarm"));
        var snapshot = ExpectMsg<DebugViewSnapshot>(TimeSpan.FromSeconds(5));

        Assert.Single(snapshot.AlarmStates);
        Assert.Equal("HighTemp", snapshot.AlarmStates[0].AlarmName);
    }
}