OpenNest/OpenNest.Engine.Tests/Jobs/JobAdapterTests.cs

using OpenNest.CNC;
using OpenNest.Geometry;

namespace OpenNest.Engine.Tests.Jobs;

public class JobAdapterTests
{
    [Fact]
    public void LegacyMutationsCannotDoubleSubtractOrReachCallerObjects()
    {
        var drawing = new Drawing("same name", TestDrawingFactory.Rectangle());
        drawing.Quantity.Required = 9;
        var item = new NestItem { Drawing = drawing, Quantity = 3, Priority = 7, StepAngle = 0 };
        var sourcePlate = new Plate(100, 200) { Quantity = 3, PartSpacing = 2 };
        var job = new NestJob(new[] { DrawingJobMapper.FromItem("requirement", item) },
            new[] { DrawingJobMapper.FromPlate("stock", sourcePlate, 3) });
        var quantities = new List<int>();
        var adapter = new LegacyPlateNesterAdapter(p => new MutatingEngine(p, items =>
        {
            var privateItem = Assert.Single(items);
            quantities.Add(privateItem.Quantity);
            Assert.NotSame(drawing, privateItem.Drawing);
            Assert.Equal(0, privateItem.StepAngle);
            Assert.Equal(7, privateItem.Priority);
            var part = new Part(privateItem.Drawing);
            privateItem.Quantity = 0;
            privateItem.Drawing.Quantity.Required = 0;
            return new List<Part> { part };
        }));
        var result = new NestJobRunner(_ => adapter).Solve(job);
        var materialized = NestResultMaterializer.Materialize(job, result);
        Assert.Equal(new[] { 3, 2, 1 }, quantities);
        Assert.Equal(NestJobStatus.Complete, result.Status);
        Assert.Equal(3, materialized.Nest.Plates.Count);
        Assert.All(materialized.Nest.Plates, p => { Assert.Equal(1, p.Quantity); Assert.Single(p.Parts); });
        var outputDrawing = materialized.DrawingsByPartId["requirement"];
        Assert.Equal(3, outputDrawing.Quantity.Required);
        Assert.Equal(3, outputDrawing.Quantity.Nested);
        Assert.All(materialized.Nest.Plates, p => Assert.Same(outputDrawing, p.Parts[0].BaseDrawing));
        Assert.NotSame(drawing, outputDrawing);
        Assert.Equal(9, drawing.Quantity.Required);
        Assert.Equal(0, drawing.Quantity.Nested);
        Assert.Equal(3, item.Quantity);
        Assert.Equal(3, sourcePlate.Quantity);
        Assert.Empty(sourcePlate.Parts);
        Assert.Equal(2, sourcePlate.PartSpacing);
        Assert.Equal(PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle()).Motions,
            PartGeometrySnapshot.FromProgram(drawing.Program).Motions);
    }

    [Fact]
    public void ReferenceIdentityNotNamesControlsLegacyPlacements()
    {
        var drawing = new Drawing("duplicate", TestDrawingFactory.Rectangle());
        var job = new NestJob(new[] { DrawingJobMapper.FromDrawing("a", drawing, 1),
            DrawingJobMapper.FromDrawing("b", drawing, 1) }, FiniteStockJobTests.Job(1).Plates);
        var adapter = new LegacyPlateNesterAdapter(p => new MutatingEngine(p, items =>
        {
            Assert.NotSame(items[0].Drawing, items[1].Drawing);
            foreach (var item in items) item.Drawing.Name = "identical";
            return new List<Part>
            {
                new Part(items[0].Drawing, new Vector(0, 0)),
                new Part(items[1].Drawing, new Vector(10, 0))
            };
        }));
        var result = new NestJobRunner(_ => adapter).Solve(job);
        Assert.Equal(new[] { "a", "b" }, result.Plates[0].Placements.Select(p => p.PartId));
        var output = NestResultMaterializer.Materialize(job, result);
        Assert.NotSame(output.DrawingsByPartId["a"], output.DrawingsByPartId["b"]);
        Assert.All(output.DrawingsByPartId.Values, d => Assert.Equal(1, d.Quantity.Nested));
    }

    [Fact]
    public void UnknownPrivateDrawingIsRejectedEvenWithMatchingName()
    {
        var adapter = new LegacyPlateNesterAdapter(p => new MutatingEngine(p, items => new List<Part>
            { new(new Drawing(items[0].Drawing.Name, TestDrawingFactory.Rectangle())) }));
        Assert.Throws<InvalidOperationException>(() => new NestJobRunner(_ => adapter).Solve(FiniteStockJobTests.Job()));
        Assert.Throws<NotSupportedException>(() => LegacyPlateNesterAdapter.Create("not registered"));
    }

    [Fact]
    public void ExactGeometryRoundTripsIncludingOriginArcHoleAndMode()
    {
        var program = TestDrawingFactory.Rectangle();
        program.Offset(-17.123456789, 5.25);
        program.MoveTo(-14, 9);
        program.ArcTo(-14, 9, -13, 9, RotationType.CW);
        ((ArcMove)program.Codes[^1]).Layer = LayerType.Cut;
        var drawing = new Drawing("shape", program);
        var part = DrawingJobMapper.FromDrawing("p", drawing, 1);
        var snapshot = part.Geometry.Motions.ToArray();
        ((Motion)program.Codes[1]).EndPoint = new Vector(999, 888);
        Assert.Equal(snapshot, part.Geometry.Motions);
        var roundTrip = DrawingJobMapper.ToProgram(part.Geometry);
        Assert.Equal(snapshot, PartGeometrySnapshot.FromProgram(roundTrip).Motions);
        Assert.Equal(program.Mode, roundTrip.Mode);
        roundTrip.Codes.Clear();
        Assert.Equal(snapshot, part.Geometry.Motions);
        var incremental = new Program(Mode.Incremental);
        incremental.MoveTo(5, -3);
        incremental.LineTo(7, 4);
        var incrementalSnapshot = PartGeometrySnapshot.FromProgram(incremental);
        Assert.Equal(Mode.Incremental, DrawingJobMapper.ToProgram(incrementalSnapshot).Mode);
        Assert.Equal(incrementalSnapshot.Motions,
            PartGeometrySnapshot.FromProgram(DrawingJobMapper.ToProgram(incrementalSnapshot)).Motions);
    }

    [Fact]
    public void RealDefaultEngineRunsFromDrawingThroughMaterialization()
    {
        var drawing = new Drawing("generated asymmetric rectangle", TestDrawingFactory.Rectangle(13, 7));
        drawing.Quantity.Required = 1;
        var job = new NestJob(new[] { DrawingJobMapper.FromDrawing("rectangle", drawing, 1) },
            new[] { new NestPlateStock("sheet", new Size(40, 60), 1, 1, new Spacing(2, 2, 2, 2)) });
        var result = new NestJobRunner(LegacyPlateNesterAdapter.Create).Solve(job);
        Assert.Equal(NestJobStatus.Complete, result.Status);
        Assert.Equal(new StockUsage("sheet", 1, 0), Assert.Single(result.StockUsage));
        var pose = Assert.Single(Assert.Single(result.Plates).Placements);
        var output = NestResultMaterializer.Materialize(job, result);
        var physicalPlate = Assert.Single(output.Nest.Plates);
        var placed = Assert.Single(physicalPlate.Parts);
        Assert.Equal(1, physicalPlate.Quantity);
        Assert.Same(output.DrawingsByPartId["rectangle"], placed.BaseDrawing);
        Assert.Equal(pose.X, placed.Location.X);
        Assert.Equal(pose.Y, placed.Location.Y);
        Assert.Equal(pose.Rotation, placed.Rotation, 10);
        Assert.Equal(1, placed.BaseDrawing.Quantity.Nested);
        Assert.Equal(0, drawing.Quantity.Nested);
        Assert.Equal(1, drawing.Quantity.Required);
        var bounds = placed.BoundingBox;
        var work = physicalPlate.WorkArea();
        Assert.True(bounds.Left >= work.Left - 1e-6 && bounds.Bottom >= work.Bottom - 1e-6);
        Assert.True(bounds.Right <= work.Right + 1e-6 && bounds.Top <= work.Top + 1e-6);
    }

    [Fact]
    public void MaterializationRotatesAboutSnapshotOriginThenTranslates()
    {
        var program = TestDrawingFactory.Rectangle();
        program.Offset(-5, 3);
        var job = new NestJob(new[] { new NestJobPart("p", PartGeometrySnapshot.FromProgram(program), 1) },
            FiniteStockJobTests.Job(1).Plates);
        var result = new NestJobRunner(_ => new FiniteStockJobTests.Nester(_ => new PlateCandidate(new[]
            { new NestJobPlacement("p", 0, 23, 31, 0.7) }))).Solve(job);
        var output = NestResultMaterializer.Materialize(job, result);
        var part = output.Nest.Plates[0].Parts[0];
        var expected = new Vector(-5, 3).Rotate(0.7);
        Assert.Equal(expected.X, ((Motion)part.Program.Codes[0]).EndPoint.X, 10);
        Assert.Equal(expected.Y, ((Motion)part.Program.Codes[0]).EndPoint.Y, 10);
        Assert.Equal(new Vector(23, 31), part.Location);
    }

    private sealed class MutatingEngine(Plate plate, Func<List<NestItem>, List<Part>> nest) : NestEngineBase(plate)
    {
        public override string Name => "test";
        public override string Description => "mutates private demand";
        public override List<Part> Nest(List<NestItem> items, IProgress<NestProgress> progress, CancellationToken token)
            => nest(items);
    }
}