OpenNest/Posts/OpenNest.Posts.GravographIS/GravographISPostProcessor.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Ports;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using OpenNest.Geometry;

namespace OpenNest.Posts.GravographIS
{
    /// <summary>
    /// IPostProcessor implementation for the Gravograph IS8000. <see cref="Post(Nest, Stream)"/>
    /// writes the binary HPGL bytes. For serial streaming, use <see cref="Stream(Nest, string, Handshake, CancellationToken)"/>.
    ///
    /// Geometry is split by <see cref="OpenNest.CNC.LayerType"/> into an engrave pass
    /// (Scribe) and a cut pass (Cut), each with its own feed/depth from <see cref="Config"/>.
    /// The cut pass pauses by default so the operator can swap/adjust the tool.
    /// </summary>
    public sealed class GravographISPostProcessor : IJsonConfigPostProcessor
    {
        private static readonly JsonSerializerOptions JsonOptions = new()
        {
            WriteIndented = true,
            Converters = { new JsonStringEnumConverter() },
        };

        public string Name => "Gravograph IS8000";
        public string Author => "OpenNest";
        public string Description =>
            "Gravograph IS8000 mechanical engraver (binary HPGL over serial)";

        public GravographISWriterOptions WriterOptions { get; } = new GravographISWriterOptions();

        public NestPolylineExtractor Extractor { get; } = new NestPolylineExtractor();

        public double StitchTolerance { get; set; } = PolylinePrePass.DefaultStitchTolerance;

        public bool AllowReverse { get; set; } = true;

        public GravographISPostConfig Config { get; private set; }

        object IConfigurablePostProcessor.Config => Config;

        /// <summary>Loads this PC's saved settings, else the shipped defaults (see <see cref="PostSettingsFile"/>).</summary>
        public GravographISPostProcessor()
        {
            var json = PostSettingsFile.Read(typeof(GravographISPostProcessor).Assembly);
            Config = json == null
                ? new GravographISPostConfig()
                : JsonSerializer.Deserialize<GravographISPostConfig>(json, JsonOptions) ?? new GravographISPostConfig();
        }

        public GravographISPostProcessor(GravographISPostConfig config)
        {
            Config = config ?? throw new ArgumentNullException(nameof(config));
        }

        public void SaveConfig() => PostSettingsFile.Write(typeof(GravographISPostProcessor).Assembly, SerializeConfig());

        public string SerializeConfig() => JsonSerializer.Serialize(Config, JsonOptions);

        public void LoadConfig(string json) =>
            Config =
                JsonSerializer.Deserialize<GravographISPostConfig>(json, JsonOptions)
                ?? throw new JsonException("The post settings are empty.");

        public void Post(Nest nest, Stream outputStream)
        {
            if (nest == null)
                throw new ArgumentNullException(nameof(nest));
            if (outputStream == null)
                throw new ArgumentNullException(nameof(outputStream));

            CNC.CommonLineCuts.EnsurePostable(nest, this);
            var passes = BuildPasses(Extractor.ExtractLayered(nest));
            new GravographISWriter(WriterOptions).Write(passes, outputStream);
        }

        public void Post(Nest nest, string outputFile)
        {
            // Refuse before creating the file, so a refusal never empties an existing program.
            CNC.DisplayPerimeterTail.EnsurePostable(nest);
            CNC.CommonLineCuts.EnsurePostable(nest, this);
            using var fs = new FileStream(outputFile, FileMode.Create, FileAccess.Write);
            Post(nest, fs);
        }

        /// <summary>
        /// Groups layer-tagged polylines into ordered tool passes: engrave (Scribe)
        /// first, then cut. Each group is stitch/reverse-optimized independently.
        /// Geometry whose layer maps to no config (Display) is skipped. When only one
        /// group is present, a single pass is returned (and so the writer emits no pause).
        /// </summary>
        public IReadOnlyList<GravographPass> BuildPasses(IEnumerable<LayeredPolyline> polylines)
        {
            if (polylines == null)
                throw new ArgumentNullException(nameof(polylines));

            var engrave = new List<IReadOnlyList<Vector>>();
            var cut = new List<IReadOnlyList<Vector>>();

            foreach (var poly in polylines)
            {
                if (poly == null)
                    continue;
                var block = Config.ConfigFor(poly.Layer);
                if (block == null)
                    continue; // non-cutting (Display) geometry
                if (ReferenceEquals(block, Config.Engrave))
                    engrave.Add(poly.Points);
                else
                    cut.Add(poly.Points);
            }

            var passes = new List<GravographPass>();
            if (engrave.Count > 0)
                passes.Add(MakePass(Config.Engrave, engrave));
            if (cut.Count > 0)
                passes.Add(MakePass(Config.Cut, cut));

            return passes;
        }

        private GravographPass MakePass(LayerCutConfig block, List<IReadOnlyList<Vector>> polylines)
        {
            return new GravographPass
            {
                Polylines = PolylinePrePass.Prepare(polylines, StitchTolerance, AllowReverse),
                FeedMmPerSec = block.FeedMmPerSec,
                DepthInches = block.Depth,
                PauseBefore = block.PauseBefore,
                PauseMessage = block.PauseMessage ?? "",
            };
        }

        /// <summary>
        /// Buffers the encoded job in memory, then streams it to the named COM port.
        /// </summary>
        public void Stream(
            Nest nest,
            string portName,
            Handshake handshake = Handshake.RequestToSend,
            CancellationToken cancellationToken = default
        )
        {
            byte[] bytes;
            using (var ms = new MemoryStream())
            {
                Post(nest, ms);
                bytes = ms.ToArray();
            }

            using var port = new GravographISPort();
            port.Open(portName, handshake);
            port.StreamJob(bytes, cancellationToken);
        }
    }
}