using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Commons.Interfaces;
using ZB.MOM.WW.OtOpcUa.Commons.Messages.Admin;
using ZB.MOM.WW.OtOpcUa.Configuration;
using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
using ZB.MOM.WW.OtOpcUa.Configuration.Validation;
using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;

namespace ZB.MOM.WW.OtOpcUa.Host.IntegrationTests;

/// <summary>
/// End-to-end deploy of a UNS folder hierarchy through the <b>real</b> <c>ConfigComposer</c>: seed a
/// 1-area / 1-line / 1-equipment UNS plus a v3 raw-tag chain (RawFolder → DriverInstance → Device →
/// Tag), <c>StartDeployment</c>, then assert the deployment's persisted artifact decodes (via
/// <see cref="DeploymentArtifact.ParseComposition"/>).
/// <para>
/// <b>v3 DARK address space (Batch 1):</b> the composer + artifact deliberately emit an EMPTY
/// equipment-tag plan set — raw-tag variable nodes are lit up in Batch 4's dual-namespace UNS↔Raw
/// fan-out. So the live assertion here is the DARK contract: the Area/Line/Equipment folder nodes
/// decode with their friendly UNS names, and <c>EquipmentTags</c> is empty EVEN THOUGH a raw tag was
/// seeded. The full equipment-signal materialization (raw tag → EquipmentTag with FullName) is
/// preserved as a Batch-4-pending Skipped test below (the plan explicitly says keep it, don't delete).
/// </para>
/// <para>
/// The OPC UA address-space browse is exercised separately against a real SDK node manager in
/// <c>AddressSpaceApplierHierarchyTests</c>, because the in-process <see cref="TwoNodeClusterHarness"/>
/// binds the no-op address-space sink.
/// </para>
/// </summary>
public sealed class EquipmentNamespaceMaterializationTests
{
    private const string Batch4Pending =
        "v3 dark address space: equipment-tag variable plans (raw tag → EquipmentTag with FullName) do " +
        "not materialize until Batch 4 (dual-namespace UNS↔Raw fan-out). The composer + artifact emit an " +
        "empty equipment-tag plan set this batch; re-enable this full-materialization assertion (re-authored " +
        "against the UnsTagReference fan-out) when Batch 4 lights the raw/UNS variable nodes.";

    private static CancellationToken Ct => TestContext.Current.CancellationToken;

    // Equipment.EquipmentId must equal DraftValidator.DeriveEquipmentId(EquipmentUuid) — the
    // 'EquipmentIdNotDerived' rule (EquipmentId = 'EQ-' + first 12 hex of the UUID). A fixed UUID
    // keeps the derived id stable for the assertions below.
    private static readonly Guid EquipmentUuid = Guid.Parse("11111111-1111-1111-1111-111111111111");
    private static readonly string EquipmentId = DraftValidator.DeriveEquipmentId(EquipmentUuid); // EQ-111111111111

    /// <summary>Verifies a deployed UNS hierarchy carries its Area/Line/Equipment folder nodes into the
    /// composed artifact with their friendly UNS names, and — the v3 Batch-1 DARK contract — that the
    /// equipment-tag plan set is EMPTY even though a raw tag was seeded (raw-tag variables are Batch 4).</summary>
    [Fact]
    public async Task Deploying_a_uns_hierarchy_carries_folder_nodes_and_leaves_equipment_tags_dark()
    {
        await using var harness = await TwoNodeClusterHarness.StartAsync();

        // Seed the parent ServerCluster + ClusterNode rows the SQL FKs require (the c1 config below
        // FKs to ServerCluster; on the in-memory provider this is unnecessary — FKs aren't enforced).
        await harness.SeedDefaultClusterAsync("c1");
        await SeedUnsHierarchyAsync(harness);

        await using var scope = harness.NodeA.Services.CreateAsyncScope();
        var client = scope.ServiceProvider.GetRequiredService<IAdminOperationsClient>();

        var result = await client.StartDeploymentAsync(createdBy: "alice@test", Ct);
        result.Outcome.ShouldBe(StartDeploymentOutcome.Accepted, $"Deploy not accepted: {result.Message}");
        var deploymentId = result.DeploymentId!.Value.Value;

        // The artifact is composed + persisted at dispatch time; assert on it without waiting for
        // Seal (sealing depends on driver-node acks, orthogonal to composition correctness).
        var artifact = Array.Empty<byte>();
        await WaitForAsync(async () =>
        {
            await using var db = await CreateDbAsync(harness);
            var d = await db.Deployments.AsNoTracking()
                .FirstOrDefaultAsync(x => x.DeploymentId == deploymentId, Ct);
            if (d is { ArtifactBlob.Length: > 0 })
            {
                artifact = d.ArtifactBlob;
                return true;
            }
            return false;
        }, TimeSpan.FromSeconds(15));

        var composition = DeploymentArtifact.ParseComposition(artifact);

        // The UNS folder hierarchy decodes with its friendly UNS names (browse names), not MachineCodes.
        composition.EquipmentNodes.ShouldContain(e => e.EquipmentId == EquipmentId && e.DisplayName == "station-1");
        composition.UnsAreas.ShouldContain(a => a.UnsAreaId == "nw-area-filling" && a.DisplayName == "filling");
        composition.UnsLines.ShouldContain(l => l.UnsLineId == "nw-line-1" && l.DisplayName == "line-1");

        // v3 DARK contract: no equipment-tag variable plans materialize this batch — even though a raw
        // tag ("Speed" / FullName 40001) was seeded under the device. Batch 4 lights these via the UNS↔Raw fan-out.
        composition.EquipmentTags.ShouldBeEmpty();
    }

    /// <summary>BATCH-4-PENDING: the full equipment-signal materialization — the seeded raw tag decodes
    /// (via the real ConfigComposer → ParseComposition) into an EquipmentTag carrying its FullName. Dark
    /// until Batch 4's UNS↔Raw fan-out; preserved (not deleted) so re-enabling is a one-line change once
    /// the equipment-tag plan set is lit up.</summary>
    [Fact(Skip = Batch4Pending)]
    public async Task Deploying_an_equipment_namespace_carries_the_signal_into_the_artifact()
    {
        await using var harness = await TwoNodeClusterHarness.StartAsync();
        await harness.SeedDefaultClusterAsync("c1");
        await SeedUnsHierarchyAsync(harness);

        await using var scope = harness.NodeA.Services.CreateAsyncScope();
        var client = scope.ServiceProvider.GetRequiredService<IAdminOperationsClient>();

        var result = await client.StartDeploymentAsync(createdBy: "alice@test", Ct);
        result.Outcome.ShouldBe(StartDeploymentOutcome.Accepted, $"Deploy not accepted: {result.Message}");
        var deploymentId = result.DeploymentId!.Value.Value;

        var artifact = Array.Empty<byte>();
        await WaitForAsync(async () =>
        {
            await using var db = await CreateDbAsync(harness);
            var d = await db.Deployments.AsNoTracking()
                .FirstOrDefaultAsync(x => x.DeploymentId == deploymentId, Ct);
            if (d is { ArtifactBlob.Length: > 0 })
            {
                artifact = d.ArtifactBlob;
                return true;
            }
            return false;
        }, TimeSpan.FromSeconds(15));

        var composition = DeploymentArtifact.ParseComposition(artifact);

        // Batch 4: the raw tag surfaces as an EquipmentTag with FullName pulled from TagConfig.
        var tag = composition.EquipmentTags.ShouldHaveSingleItem();
        tag.TagId.ShouldBe("tag-speed");
        tag.EquipmentId.ShouldBe(EquipmentId);
        tag.Name.ShouldBe("Speed");
        tag.DataType.ShouldBe("Float");
        tag.FullName.ShouldBe("40001");
    }

    private static async Task SeedUnsHierarchyAsync(TwoNodeClusterHarness harness)
    {
        await using var db = await CreateDbAsync(harness);

        // v3 raw-tag chain: RawFolder → DriverInstance(RawFolderId) → Device(DriverInstanceId) →
        // Tag(DeviceId). The Namespace entity is deleted; equipment no longer binds a driver/device.
        db.RawFolders.Add(new RawFolder { RawFolderId = "raw-plant", ClusterId = "c1", Name = "Plant" });
        // Disabled so the driver-role nodes don't spawn a live Modbus driver (no endpoint to reach);
        // the composition still carries the instance (ParseComposition does not filter on Enabled).
        db.DriverInstances.Add(new DriverInstance
        {
            DriverInstanceId = "drv-modbus", ClusterId = "c1", RawFolderId = "raw-plant",
            Name = "Modbus", DriverType = "Modbus", DriverConfig = "{}", Enabled = false,
        });
        db.Devices.Add(new Device
        {
            DeviceId = "dev-1", DriverInstanceId = "drv-modbus",
            Name = "dev-1", DeviceConfig = "{}",
        });
        db.UnsAreas.Add(new UnsArea { UnsAreaId = "nw-area-filling", ClusterId = "c1", Name = "filling" });
        db.UnsLines.Add(new UnsLine { UnsLineId = "nw-line-1", UnsAreaId = "nw-area-filling", Name = "line-1" });
        db.Equipment.Add(new Equipment
        {
            EquipmentId = EquipmentId, EquipmentUuid = EquipmentUuid,
            UnsLineId = "nw-line-1", Name = "station-1", MachineCode = "STATION_001",
        });
        db.Tags.Add(new Tag
        {
            TagId = "tag-speed", DeviceId = "dev-1",
            Name = "Speed", DataType = "Float", AccessLevel = TagAccessLevel.Read,
            TagConfig = "{\"FullName\":\"40001\"}",
        });

        await db.SaveChangesAsync(Ct);
    }

    private static async Task<OtOpcUaConfigDbContext> CreateDbAsync(TwoNodeClusterHarness harness)
    {
        var factory = harness.NodeA.Services.GetRequiredService<IDbContextFactory<OtOpcUaConfigDbContext>>();
        return await factory.CreateDbContextAsync();
    }

    private static async Task WaitForAsync(Func<Task<bool>> condition, TimeSpan timeout)
    {
        var deadline = DateTime.UtcNow + timeout;
        while (DateTime.UtcNow < deadline)
        {
            if (await condition()) return;
            await Task.Delay(200);
        }
        throw new TimeoutException($"Condition not met within {timeout}");
    }
}
