OpenNest/OpenNest.Engine.Tests/Jobs/NestJobValidationTests.cs

using OpenNest.CNC;
using OpenNest.Geometry;

namespace OpenNest.Engine.Tests.Jobs;

public class NestJobValidationTests
{
    [Fact]
    public void IncrementalContoursUseAccumulatedCoordinates()
    {
        var program = new Program(Mode.Incremental);
        program.MoveTo(0, 0);
        program.LineTo(4, 0);
        program.LineTo(0, 3);
        program.LineTo(-4, 0);
        program.LineTo(0, -3);
        var job = new NestJob(
            new[] { new NestJobPart("part", PartGeometrySnapshot.FromProgram(program), 1) },
            new[] { new NestPlateStock("stock", new Size(10, 10), 1) }
        );

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

        Assert.Equal(NestJobStatus.Complete, result.Status);
        Assert.Equal(new PartFulfillment("part", 1, 1, 0), Assert.Single(result.Fulfillment));
    }

    [Fact]
    public void CandidateInsideAnotherRequirementsHoleDoesNotOverlapMaterial()
    {
        var outer = new NestJobPart(
            "outer",
            PartGeometrySnapshot.FromProgram(RectangleWithHole()),
            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) }
        );

        var result = Solve(
            job,
            new NestJobPlacement("outer", 0, 0, 0, 0),
            new NestJobPlacement("inner", 0, 4, 4, 0)
        );

        Assert.Equal(NestJobStatus.Complete, result.Status);
        Assert.Single(result.Plates);
        Assert.Equal(2, result.Plates[0].Placements.Count);
    }

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

        Assert.Throws<InvalidOperationException>(() =>
            Solve(
                job,
                new NestJobPlacement("part", 0, 0, 0, 0),
                new NestJobPlacement("part", 1, 9, 9, 0)
            )
        );
    }

    [Theory]
    [InlineData(10.0, 0.0)]
    [InlineData(10.0, 10.0)]
    public void BoundaryContactWithZeroSpacingIsAccepted(double x, double y)
    {
        var part = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(10, 10)),
            2
        );
        var job = new NestJob(
            new[] { part },
            new[] { new NestPlateStock("stock", new Size(20, 20), 1) }
        );

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

        Assert.Equal(NestJobStatus.Complete, result.Status);
        Assert.Equal(2, Assert.Single(result.Plates).Placements.Count);
    }

    [Fact]
    public void UnknownOrOverproducingCandidateFailsBeforeCommitWithoutChangingInput()
    {
        var reports = new List<NestJobProgress>();
        var part = new NestJobPart(
            "part",
            PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)),
            1
        );
        var stock = new NestPlateStock("stock", new Size(20, 20), 1);
        var job = new NestJob(new[] { part }, new[] { stock });
        var runner = new NestJobRunner(_ => new CandidateNester(
            new[]
            {
                new NestJobPlacement("part", 0, 0, 0, 0),
                new NestJobPlacement("unknown", 0, 4, 0, 0),
            }
        ));

        Assert.Throws<InvalidOperationException>(() =>
            runner.Solve(job, new InlineProgress(reports.Add))
        );

        Assert.Equal(1, job.Parts[0].Quantity);
        Assert.Equal(1, job.Plates[0].Quantity);
        Assert.DoesNotContain(reports, report => report.Stage == NestJobStage.PlateCommitted);
    }

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

        Assert.Throws<InvalidOperationException>(() =>
            Solve(
                job,
                new NestJobPlacement("part", 0, 0, 0, 0),
                new NestJobPlacement("part", 1, 4, 0, 0)
            )
        );

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

    [Theory]
    [InlineData(true)]
    [InlineData(false)]
    public void OpenOrZeroLengthContoursAreRejected(bool zeroLength)
    {
        var program = new Program();
        program.MoveTo(0, 0);
        program.LineTo(4, 0);
        if (zeroLength)
            program.LineTo(4, 0);
        program.LineTo(4, 3);
        program.LineTo(0, 3);
        if (zeroLength)
            program.LineTo(0, 0);
        var job = new NestJob(
            new[] { new NestJobPart("part", PartGeometrySnapshot.FromProgram(program), 1) },
            new[] { new NestPlateStock("stock", new Size(20, 20), 1) }
        );

        Assert.Throws<ArgumentException>(() =>
            new NestJobRunner(_ => new CandidateNester(Array.Empty<NestJobPlacement>())).Solve(job)
        );
    }

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

    private static Program RectangleWithHole()
    {
        var program = TestDrawingFactory.Rectangle(10, 10);
        program.MoveTo(3, 3);
        program.LineTo(3, 7);
        program.LineTo(7, 7);
        program.LineTo(7, 3);
        program.LineTo(3, 3);
        return program;
    }

    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 InlineProgress(Action<NestJobProgress> report) : IProgress<NestJobProgress>
    {
        public void Report(NestJobProgress value) => report(value);
    }
}