OpenNest/OpenNest.Engine.Tests/Jobs/NestJobGeometryTests.cs

using OpenNest.Geometry;

namespace OpenNest.Engine.Tests.Jobs;

public class NestJobGeometryTests
{
    [Fact]
    public void CandidateOutsideUsableWorkAreaFailsWithoutMutatingInput()
    {
        var part = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)),
            1
        );
        var sourceGeometry = part.Geometry.Motions.ToArray();
        var stock = new NestPlateStock(
            "stock",
            new Size(20, 30),
            1,
            edgeSpacing: new Spacing(2, 1, 3, 4)
        );
        var job = new NestJob(new[] { part }, new[] { stock });
        var runner = new NestJobRunner(_ => new CandidateNester(
            new[] { new NestJobPlacement("part", 0, 26, 1, 0) }
        ));

        Assert.Throws<InvalidOperationException>(() => runner.Solve(job));

        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
        Assert.Equal(1, job.Parts[0].Quantity);
        Assert.Equal(1, job.Plates[0].Quantity);
    }

    [Theory]
    [InlineData(1, 0, 0)]
    [InlineData(2, -11, 0)]
    [InlineData(3, -11, -7)]
    [InlineData(4, 0, -7)]
    public void UnequalRectanglesFitAtEachQuadrantsUsableOrigin(int quadrant, double x, double y)
    {
        var part = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 3)),
            1
        );
        var stock = new NestPlateStock("stock", new Size(7, 11), 1, quadrant: quadrant);
        var job = new NestJob(new[] { part }, new[] { stock });

        var result = Solve(job, new NestJobPlacement("part", 0, x, y, 0));

        Assert.Equal(NestJobStatus.Complete, result.Status);
        Assert.Equal(
            new NestJobPlacement("part", 0, x, y, 0),
            Assert.Single(result.Plates[0].Placements)
        );
    }

    [Fact]
    public void FixedAndBoundedRotationPoliciesRejectDisallowedAngles()
    {
        var fixedPart = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 2)),
            1,
            rotation: RotationPolicy.Fixed(System.Math.PI / 2)
        );
        var fixedJob = new NestJob(
            new[] { fixedPart },
            new[] { new NestPlateStock("stock", new Size(10, 10), 1) }
        );
        Assert.Throws<InvalidOperationException>(() =>
            Solve(fixedJob, new NestJobPlacement("part", 0, 0, 0, 0))
        );

        var fixedResult = Solve(
            fixedJob,
            new NestJobPlacement("part", 0, 2, 0, System.Math.PI / 2)
        );
        Assert.Equal(NestJobStatus.Complete, fixedResult.Status);

        var boundedPart = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 2)),
            1,
            rotation: RotationPolicy.BoundedSweep(0, System.Math.PI / 2, System.Math.PI / 4)
        );
        var boundedJob = new NestJob(
            new[] { boundedPart },
            new[] { new NestPlateStock("stock", new Size(10, 10), 1) }
        );
        Assert.Throws<InvalidOperationException>(() =>
            Solve(boundedJob, new NestJobPlacement("part", 0, 2, 0, System.Math.PI / 3))
        );

        var boundedResult = Solve(
            boundedJob,
            new NestJobPlacement("part", 0, 2, 0, System.Math.PI / 4)
        );
        Assert.Equal(NestJobStatus.Complete, boundedResult.Status);
    }

    [Fact]
    public void EdgeTouchingIsAllowedAtZeroSpacingAndRejectedAtPositiveSpacing()
    {
        var part = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)),
            2
        );
        var touching = new[]
        {
            new NestJobPlacement("part", 0, 0, 0, 0),
            new NestJobPlacement("part", 1, 2, 0, 0),
        };
        var zeroSpacing = new NestJob(
            new[] { part },
            new[] { new NestPlateStock("stock", new Size(10, 10), 1) }
        );
        var positiveSpacing = new NestJob(
            new[] { part },
            new[] { new NestPlateStock("stock", new Size(10, 10), 1, 0.1) }
        );

        Assert.Equal(NestJobStatus.Complete, Solve(zeroSpacing, touching).Status);
        Assert.Throws<InvalidOperationException>(() => Solve(positiveSpacing, touching));
    }

    [Fact]
    public void OverlapAndContainmentAreRejected()
    {
        var outer = new NestJobPart(
            "outer",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(6, 6)),
            1
        );
        var inner = new NestJobPart(
            "inner",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)),
            1
        );
        var job = new NestJob(
            new[] { outer, inner },
            new[] { new NestPlateStock("stock", new Size(20, 20), 1) }
        );

        Assert.Throws<InvalidOperationException>(() =>
            Solve(
                job,
                new NestJobPlacement("outer", 0, 0, 0, 0),
                new NestJobPlacement("inner", 0, 2, 2, 0)
            )
        );
    }

    [Fact]
    public void EmptyStockStopsWithoutCallingCandidateNester()
    {
        var nester = new CountingNester();
        var part = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)),
            1
        );
        var job = new NestJob(new[] { part }, Array.Empty<NestPlateStock>());

        var result = new NestJobRunner(_ => nester).Solve(job);

        Assert.Equal(NestJobStopReason.StockExhausted, result.StopReason);
        Assert.Equal(0, nester.Calls);
    }

    [Theory]
    [InlineData("Default")]
    [InlineData("Strip")]
    public void RealEngineSmokeCasesPreserveInputAndProduceSafeAccounting(string strategy)
    {
        var drawing = new Drawing("generated rectangle", TestDrawingFactory.Rectangle(6, 4));
        var part = DrawingJobMapper.FromDrawing("part", drawing, 3);
        var sourceGeometry = part.Geometry.Motions.ToArray();
        var stock = new NestPlateStock("stock", new Size(30, 50), 1, 1, new Spacing(1, 1, 1, 1));
        var job = new NestJob(new[] { part }, new[] { stock }, new NestJobOptions(strategy));

        var result = new NestJobRunner(PlateNesterFactory.Create).Solve(job);
        var materialized = NestResultMaterializer.Materialize(job, result);

        Assert.Equal(NestJobStatus.Complete, result.Status);
        Assert.All(
            result.Fulfillment,
            fulfillment =>
                Assert.Equal(fulfillment.Requested, fulfillment.Placed + fulfillment.Unplaced)
        );
        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
        Assert.Equal(3, job.Parts[0].Quantity);
        Assert.Equal(1, job.Plates[0].Quantity);
        Assert.All(
            materialized.Nest.Plates,
            plate =>
            {
                var workArea = plate.WorkArea();
                Assert.All(
                    plate.Parts,
                    placed =>
                    {
                        Assert.True(placed.BoundingBox.Left >= workArea.Left - 1e-6);
                        Assert.True(placed.BoundingBox.Right <= workArea.Right + 1e-6);
                        Assert.True(placed.BoundingBox.Bottom >= workArea.Bottom - 1e-6);
                        Assert.True(placed.BoundingBox.Top <= workArea.Top + 1e-6);
                    }
                );
                for (var left = 0; left < plate.Parts.Count; left++)
                for (var right = left + 1; right < plate.Parts.Count; right++)
                    Assert.False(plate.Parts[left].Intersects(plate.Parts[right], out _));
            }
        );
    }

    private static NestJobResult Solve(NestJob job, params NestJobPlacement[] placements) =>
        new NestJobRunner(_ => new CandidateNester(placements)).Solve(job);

    private sealed class CandidateNester(IEnumerable<NestJobPlacement> placements) : IPlateNester
    {
        public PlateCandidate Place(
            PlatePlacementRequest request,
            IProgress<NestJobProgress>? progress = null,
            CancellationToken token = default
        ) => new(placements);
    }

    private sealed class CountingNester : IPlateNester
    {
        public int Calls { get; private set; }

        public PlateCandidate Place(
            PlatePlacementRequest request,
            IProgress<NestJobProgress>? progress = null,
            CancellationToken token = default
        )
        {
            Calls++;
            return new PlateCandidate(Array.Empty<NestJobPlacement>());
        }
    }
}