using Microsoft.Data.SqlClient;
using Shouldly;
using Xunit;

namespace ZB.MOM.WW.OtOpcUa.Configuration.Tests;

/// <summary>
///     Happy-path + representative error-path coverage per Task B.2 acceptance. Each test seeds its
///     own cluster + node + credential, creates a draft, exercises one proc, then cleans up at the
///     fixture level (the fixture drops the DB in Dispose).
/// </summary>
[Trait("Category", "StoredProcedures")]
[Collection(nameof(SchemaComplianceCollection))]
public sealed class StoredProceduresTests
{
    private readonly SchemaComplianceFixture _fixture;

    public StoredProceduresTests(SchemaComplianceFixture fixture) => _fixture = fixture;

    [Fact]
    public void Publish_then_GetCurrent_returns_the_published_generation()
    {
        using var conn = _fixture.OpenConnection();
        var (clusterId, nodeId, _, draftId) = SeedClusterWithDraft(conn, suffix: "pub1");

        Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
            ("c", clusterId), ("g", draftId));

        using var cmd = conn.CreateCommand();
        cmd.CommandText = "EXEC dbo.sp_GetCurrentGenerationForCluster @NodeId=@n, @ClusterId=@c";
        cmd.Parameters.AddWithValue("n", nodeId);
        cmd.Parameters.AddWithValue("c", clusterId);
        using var r = cmd.ExecuteReader();
        r.Read().ShouldBeTrue("proc should return exactly one row");
        r.GetInt64(0).ShouldBe(draftId);
        r.GetString(2).ShouldBe("Published");
    }

    [Fact]
    public void GetCurrent_rejects_caller_not_bound_to_node()
    {
        using var conn = _fixture.OpenConnection();
        var (clusterId, _, _, _) = SeedClusterWithDraft(conn, suffix: "unauth");

        var ex = Should.Throw<SqlException>(() =>
            Exec(conn, "EXEC dbo.sp_GetCurrentGenerationForCluster @NodeId=@n, @ClusterId=@c",
                ("n", "ghost-node"), ("c", clusterId)));
        ex.Message.ShouldContain("Unauthorized");
    }

    [Fact]
    public void Publish_second_draft_supersedes_first()
    {
        using var conn = _fixture.OpenConnection();
        var (clusterId, _, _, draft1) = SeedClusterWithDraft(conn, suffix: "sup");
        Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
            ("c", clusterId), ("g", draft1));

        var draft2 = CreateDraft(conn, clusterId);
        Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
            ("c", clusterId), ("g", draft2));

        var status1 = Scalar<string>(conn,
            "SELECT Status FROM dbo.ConfigGeneration WHERE GenerationId = @g", ("g", draft1));
        var status2 = Scalar<string>(conn,
            "SELECT Status FROM dbo.ConfigGeneration WHERE GenerationId = @g", ("g", draft2));
        status1.ShouldBe("Superseded");
        status2.ShouldBe("Published");
    }

    [Fact]
    public void Publish_rejects_non_draft_generation()
    {
        using var conn = _fixture.OpenConnection();
        var (clusterId, _, _, draftId) = SeedClusterWithDraft(conn, suffix: "twice");
        Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
            ("c", clusterId), ("g", draftId));

        var ex = Should.Throw<SqlException>(() =>
            Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
                ("c", clusterId), ("g", draftId)));
        ex.Message.ShouldContain("not in Draft");
    }

    [Fact]
    public void ValidateDraft_rejects_orphan_tag()
    {
        using var conn = _fixture.OpenConnection();
        var (clusterId, _, _, draftId) = SeedClusterWithDraft(conn, suffix: "orphan");
        Exec(conn, @"INSERT dbo.Tag (GenerationId, TagId, DriverInstanceId, Name, DataType, AccessLevel, WriteIdempotent, TagConfig)
                     VALUES (@g, 'tag-1', 'missing-driver', 'X', 'Int32', 'Read', 0, '{}')",
            ("g", draftId));

        var ex = Should.Throw<SqlException>(() =>
            Exec(conn, "EXEC dbo.sp_ValidateDraft @DraftGenerationId=@g", ("g", draftId)));
        ex.Message.ShouldContain("unresolved DriverInstanceId");
    }

    [Fact]
    public void Rollback_creates_new_published_generation_and_clones_rows()
    {
        using var conn = _fixture.OpenConnection();
        var (clusterId, _, _, draftId) = SeedClusterWithDraft(conn, suffix: "rb");
        SeedMinimalDriverRow(conn, draftId, clusterId, driverInstanceId: "drv-a");
        Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
            ("c", clusterId), ("g", draftId));

        Exec(conn, "EXEC dbo.sp_RollbackToGeneration @ClusterId=@c, @TargetGenerationId=@g, @Notes='test'",
            ("c", clusterId), ("g", draftId));

        var newlyPublishedCount = Scalar<int>(conn,
            @"SELECT COUNT(*) FROM dbo.ConfigGeneration
              WHERE ClusterId = @c AND Status = 'Published' AND GenerationId <> @g",
            ("c", clusterId), ("g", draftId));
        newlyPublishedCount.ShouldBe(1);

        var driverClonedCount = Scalar<int>(conn,
            @"SELECT COUNT(*) FROM dbo.DriverInstance di
              JOIN dbo.ConfigGeneration cg ON cg.GenerationId = di.GenerationId
              WHERE cg.ClusterId = @c AND cg.Status = 'Published' AND di.DriverInstanceId = 'drv-a'",
            ("c", clusterId));
        driverClonedCount.ShouldBe(1);
    }

    [Fact]
    public void ComputeDiff_returns_Added_for_driver_present_only_in_target()
    {
        using var conn = _fixture.OpenConnection();
        var (clusterId, _, _, draft1) = SeedClusterWithDraft(conn, suffix: "diff");
        Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
            ("c", clusterId), ("g", draft1));

        var draft2 = CreateDraft(conn, clusterId);
        SeedMinimalDriverRow(conn, draft2, clusterId, driverInstanceId: "drv-added");
        Exec(conn, "EXEC dbo.sp_PublishGeneration @ClusterId=@c, @DraftGenerationId=@g",
            ("c", clusterId), ("g", draft2));

        using var cmd = conn.CreateCommand();
        cmd.CommandText = "EXEC dbo.sp_ComputeGenerationDiff @FromGenerationId=@f, @ToGenerationId=@t";
        cmd.Parameters.AddWithValue("f", draft1);
        cmd.Parameters.AddWithValue("t", draft2);
        using var r = cmd.ExecuteReader();
        var diffs = new List<(string Table, string Id, string Kind)>();
        while (r.Read())
            diffs.Add((r.GetString(0), r.GetString(1), r.GetString(2)));

        diffs.ShouldContain(d => d.Table == "DriverInstance" && d.Id == "drv-added" && d.Kind == "Added");
    }

    [Fact]
    public void ReleaseReservation_requires_nonempty_reason()
    {
        using var conn = _fixture.OpenConnection();
        var ex = Should.Throw<SqlException>(() =>
            Exec(conn, "EXEC dbo.sp_ReleaseExternalIdReservation @Kind='ZTag', @Value='X', @ReleaseReason=''"));
        ex.Message.ShouldContain("ReleaseReason is required");
    }

    // ---- helpers ----

    /// <summary>Creates a cluster, one node, one credential bound to the current SUSER_SNAME(), and an empty Draft.</summary>
    private static (string ClusterId, string NodeId, string Credential, long DraftId)
        SeedClusterWithDraft(SqlConnection conn, string suffix)
    {
        var clusterId = $"cluster-{suffix}";
        var nodeId = $"node-{suffix}-a";

        // Every test uses the same SUSER_SNAME() ('sa' by default), and the credential unique index
        // is filtered on Enabled=1 across (Kind, Value) globally. To avoid collisions across tests
        // sharing one DB, we disable old credentials first.
        Exec(conn, "UPDATE dbo.ClusterNodeCredential SET Enabled = 0 WHERE Value = SUSER_SNAME();");

        Exec(conn,
            @"INSERT dbo.ServerCluster (ClusterId, Name, Enterprise, Site, RedundancyMode, NodeCount, Enabled, CreatedBy)
              VALUES (@c, @c, 'zb', @s, 'None', 1, 1, SUSER_SNAME());
              INSERT dbo.ClusterNode (NodeId, ClusterId, RedundancyRole, Host, OpcUaPort, DashboardPort, ApplicationUri, ServiceLevelBase, Enabled, CreatedBy)
              VALUES (@n, @c, 'Primary', 'localhost', 4840, 5001, CONCAT('urn:localhost:', @s), 200, 1, SUSER_SNAME());
              INSERT dbo.ClusterNodeCredential (NodeId, Kind, Value, Enabled, CreatedBy)
              VALUES (@n, 'SqlLogin', SUSER_SNAME(), 1, SUSER_SNAME());",
            ("c", clusterId), ("n", nodeId), ("s", suffix));

        var draftId = CreateDraft(conn, clusterId);
        return (clusterId, nodeId, "sa", draftId);
    }

    private static long CreateDraft(SqlConnection conn, string clusterId)
    {
        using var cmd = conn.CreateCommand();
        cmd.CommandText = @"
INSERT dbo.ConfigGeneration (ClusterId, Status, CreatedAt, CreatedBy)
VALUES (@c, 'Draft', SYSUTCDATETIME(), SUSER_SNAME());
SELECT CAST(SCOPE_IDENTITY() AS bigint);";
        cmd.Parameters.AddWithValue("c", clusterId);
        return (long)cmd.ExecuteScalar()!;
    }

    private static void SeedMinimalDriverRow(SqlConnection conn, long genId, string clusterId, string driverInstanceId)
    {
        Exec(conn,
            @"INSERT dbo.Namespace (GenerationId, NamespaceId, ClusterId, Kind, NamespaceUri, Enabled)
              VALUES (@g, @ns, @c, 'Equipment', 'urn:ns', 1);
              INSERT dbo.DriverInstance (GenerationId, DriverInstanceId, ClusterId, NamespaceId, Name, DriverType, Enabled, DriverConfig)
              VALUES (@g, @drv, @c, @ns, 'drv', 'ModbusTcp', 1, '{}');",
            ("g", genId), ("c", clusterId), ("ns", $"ns-{driverInstanceId}"), ("drv", driverInstanceId));
    }

    private static void Exec(SqlConnection conn, string sql, params (string Name, object Value)[] parameters)
    {
        using var cmd = conn.CreateCommand();
        cmd.CommandText = sql;
        foreach (var (name, value) in parameters) cmd.Parameters.AddWithValue(name, value);
        cmd.ExecuteNonQuery();
    }

    private static T Scalar<T>(SqlConnection conn, string sql, params (string Name, object Value)[] parameters)
    {
        using var cmd = conn.CreateCommand();
        cmd.CommandText = sql;
        foreach (var (name, value) in parameters) cmd.Parameters.AddWithValue(name, value);
        return (T)cmd.ExecuteScalar()!;
    }
}