/**
 * EdgeId Tests
 * Sprint: SPRINT_9100_0001_0003 (Content-Addressed EdgeId)
 * Tasks: EDGEID-9100-015 through EDGEID-9100-019
 */

using Xunit;

using StellaOps.TestKit;
namespace StellaOps.Resolver.Tests;

public class EdgeIdTests
{
    [Trait("Category", TestCategories.Unit)]
        [Fact]
    public void EdgeId_ComputedDeterministically()
    {
        // EDGEID-9100-015: EdgeId computed deterministically
        var src = NodeId.From("package", "a");
        var dst = NodeId.From("package", "b");
        var kind = "depends_on";

        var edgeId1 = EdgeId.From(src, kind, dst);
        var edgeId2 = EdgeId.From(src, kind, dst);

        Assert.Equal(edgeId1, edgeId2);
        Assert.Equal(64, edgeId1.Value.Length); // SHA256 hex
    }

    [Trait("Category", TestCategories.Unit)]
        [Fact]
    public void EdgeId_OrderingConsistentWithStringOrdering()
    {
        // EDGEID-9100-016: EdgeId ordering is consistent
        var edgeIds = new List<EdgeId>();
        for (int i = 0; i < 10; i++)
        {
            var src = NodeId.From("package", $"src{i}");
            var dst = NodeId.From("package", $"dst{i}");
            edgeIds.Add(EdgeId.From(src, "depends_on", dst));
        }

        var sorted1 = edgeIds.OrderBy(e => e).ToList();
        var sorted2 = edgeIds.OrderBy(e => e.Value, StringComparer.Ordinal).ToList();

        Assert.Equal(sorted1, sorted2);
    }

    [Trait("Category", TestCategories.Unit)]
        [Fact]
    public void GraphHash_ChangesWhenEdgeAddedOrRemoved()
    {
        // EDGEID-9100-017: Graph hash changes with edge changes
        var nodeA = Node.Create("package", "a");
        var nodeB = Node.Create("package", "b");
        var nodeC = Node.Create("package", "c");

        var edge1 = Edge.Create(nodeA.Id, "depends_on", nodeB.Id);
        var edge2 = Edge.Create(nodeB.Id, "depends_on", nodeC.Id);

        var graph1 = EvidenceGraph.Create(new[] { nodeA, nodeB, nodeC }, new[] { edge1 });
        var graph2 = EvidenceGraph.Create(new[] { nodeA, nodeB, nodeC }, new[] { edge1, edge2 });
        var graph3 = EvidenceGraph.Create(new[] { nodeA, nodeB, nodeC }, new[] { edge2 });

        Assert.NotEqual(graph1.GraphDigest, graph2.GraphDigest);
        Assert.NotEqual(graph1.GraphDigest, graph3.GraphDigest);
        Assert.NotEqual(graph2.GraphDigest, graph3.GraphDigest);
    }

    [Trait("Category", TestCategories.Unit)]
        [Fact]
    public void EdgeDelta_CorrectlyIdentifiesChanges()
    {
        // EDGEID-9100-018: Delta detection identifies changes
        var nodeA = Node.Create("package", "a");
        var nodeB = Node.Create("package", "b");
        var nodeC = Node.Create("package", "c");

        var edge1 = Edge.Create(nodeA.Id, "depends_on", nodeB.Id);
        var edge2 = Edge.Create(nodeB.Id, "depends_on", nodeC.Id);
        var edge3 = Edge.Create(nodeA.Id, "depends_on", nodeC.Id);

        var oldGraph = EvidenceGraph.Create(new[] { nodeA, nodeB, nodeC }, new[] { edge1, edge2 });
        var newGraph = EvidenceGraph.Create(new[] { nodeA, nodeB, nodeC }, new[] { edge1, edge3 });

        var detector = new DefaultEdgeDeltaDetector();
        var delta = detector.Detect(oldGraph, newGraph);

        Assert.Single(delta.AddedEdges); // edge3
        Assert.Single(delta.RemovedEdges); // edge2
        Assert.Empty(delta.ModifiedEdges);
    }

    [Trait("Category", TestCategories.Unit)]
        [Fact]
    public void EdgeId_IsIdempotent()
    {
        // EDGEID-9100-019: Property test - idempotent computation
        var src = NodeId.From("package", "test-src");
        var dst = NodeId.From("package", "test-dst");
        var kind = "test-kind";

        var results = Enumerable.Range(0, 100)
            .Select(_ => EdgeId.From(src, kind, dst))
            .ToList();

        Assert.All(results, r => Assert.Equal(results[0], r));
    }
}