using RobotNet10.GlobalPathPlanner.Model;

namespace RobotNet10.GlobalPathPlanner.UnitTest;

public class GlobalEdgeTests
{
    [Fact]
    public void GlobalEdge_Properties_ShouldBeSettable()
    {
        // Arrange & Act
        var edge = new GlobalEdge
        {
            Id = Guid.NewGuid(),
            MapId = Guid.NewGuid(),
            StartNodeId = Guid.NewGuid(),
            EndNodeId = Guid.NewGuid(),
            Degree = 2,
            ControlPoint1X = 5.0,
            ControlPoint1Y = 5.0,
            ControlPoint2X = 10.0,
            ControlPoint2Y = 10.0
        };

        // Assert
        Assert.NotEqual(Guid.Empty, edge.Id);
        Assert.NotEqual(Guid.Empty, edge.MapId);
        Assert.NotEqual(Guid.Empty, edge.StartNodeId);
        Assert.NotEqual(Guid.Empty, edge.EndNodeId);
        Assert.Equal(2, edge.Degree);
        Assert.Equal(5.0, edge.ControlPoint1X);
        Assert.Equal(5.0, edge.ControlPoint1Y);
        Assert.Equal(10.0, edge.ControlPoint2X);
        Assert.Equal(10.0, edge.ControlPoint2Y);
    }

    [Fact]
    public void GlobalEdge_AsRecord_ShouldSupportEquality()
    {
        // Arrange
        var id = Guid.NewGuid();
        var mapId = Guid.NewGuid();
        var startNodeId = Guid.NewGuid();
        var endNodeId = Guid.NewGuid();

        var edge1 = new GlobalEdge
        {
            Id = id,
            MapId = mapId,
            StartNodeId = startNodeId,
            EndNodeId = endNodeId,
            Degree = 1
        };

        var edge2 = new GlobalEdge
        {
            Id = id,
            MapId = mapId,
            StartNodeId = startNodeId,
            EndNodeId = endNodeId,
            Degree = 1
        };

        // Act & Assert
        Assert.Equal(edge1, edge2);
    }

    [Fact]
    public void GlobalEdge_WithDifferentIds_ShouldNotBeEqual()
    {
        // Arrange
        var edge1 = new GlobalEdge { Id = Guid.NewGuid() };
        var edge2 = new GlobalEdge { Id = Guid.NewGuid() };

        // Act & Assert
        Assert.NotEqual(edge1, edge2);
    }

    [Fact]
    public void GlobalEdge_Degree_CanBeOne()
    {
        // Arrange & Act
        var edge = new GlobalEdge { Degree = 1 };

        // Assert
        Assert.Equal(1, edge.Degree);
    }

    [Fact]
    public void GlobalEdge_Degree_CanBeTwo()
    {
        // Arrange & Act
        var edge = new GlobalEdge { Degree = 2 };

        // Assert
        Assert.Equal(2, edge.Degree);
    }

    [Fact]
    public void GlobalEdge_Degree_CanBeThree()
    {
        // Arrange & Act
        var edge = new GlobalEdge { Degree = 3 };

        // Assert
        Assert.Equal(3, edge.Degree);
    }

    [Fact]
    public void GlobalEdge_ControlPoints_CanBeZero()
    {
        // Arrange & Act
        var edge = new GlobalEdge
        {
            ControlPoint1X = 0.0,
            ControlPoint1Y = 0.0,
            ControlPoint2X = 0.0,
            ControlPoint2Y = 0.0
        };

        // Assert
        Assert.Equal(0.0, edge.ControlPoint1X);
        Assert.Equal(0.0, edge.ControlPoint1Y);
        Assert.Equal(0.0, edge.ControlPoint2X);
        Assert.Equal(0.0, edge.ControlPoint2Y);
    }
}