OpenNest/OpenNest.Benchmark/Report.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;

namespace OpenNest.Benchmark
{
    /// <summary>
    /// Console + CSV reporting for benchmark results. Ranking rule per job:
    /// valid beats invalid; higher aggregate utilization wins; if utilization
    /// ties and both engines fully placed every requested part, fewer plates
    /// used wins (the multi-plate analogue of "smaller remnant" - both are
    /// proxies for wasting less material). Ties beyond that are a shared win.
    /// </summary>
    public static class Report
    {
        private const double Epsilon = 1e-6;

        public static void PrintDetailed(List<JobResult> results)
        {
            foreach (var jobGroup in results.GroupBy(r => r.JobName))
            {
                Console.WriteLine();
                Console.WriteLine($"=== {jobGroup.Key} ===");

                var ranked = jobGroup.OrderBy(r => r, Comparer<JobResult>.Create(Compare)).ToList();
                var best = ranked.Count > 0 ? ranked[0] : null;

                Console.WriteLine($"{"Engine",-16} {"Result",-9} {"Parts",-10} {"Util%",-8} {"Plates",-18} {"Time(ms)",-9} Notes");

                foreach (var r in ranked)
                {
                    var isWinner = best != null && Compare(r, best) == 0 && r.Valid;
                    var marker = isWinner ? "*" : " ";
                    var status = r.Crashed ? "CRASH" : r.Valid ? "ok" : "INVALID";
                    var partsCol = $"{r.PartsPlaced}/{r.PartsRequested}";
                    var utilCol = r.Valid ? $"{r.Utilization * 100:F1}" : "-";
                    var platesCol = r.PlatesUsed > 0 ? $"{r.PlatesUsed} ({SizeSummary(r.SizeBreakdown)})" : "-";
                    var notes = r.Crashed ? r.Error : string.Join("; ", r.Violations.Take(2));

                    Console.WriteLine($"{marker}{r.EngineName,-15} {status,-9} {partsCol,-10} {utilCol,-8} {platesCol,-18} {r.ElapsedMs,-9} {notes}");
                }
            }
        }

        public static void PrintSummary(List<JobResult> results)
        {
            Console.WriteLine();
            Console.WriteLine("=== Summary ===");

            var byEngine = results
                .GroupBy(r => r.EngineName)
                .Select(g => new
                {
                    Engine = g.Key,
                    Jobs = g.Count(),
                    Valid = g.Count(r => r.Valid),
                    Crashed = g.Count(r => r.Crashed),
                    FullyPlaced = g.Count(r => r.FullyPlaced),
                    TotalUtilization = g.Sum(r => r.Utilization),
                    TotalPlates = g.Sum(r => r.PlatesUsed),
                    TotalTimeMs = g.Sum(r => r.ElapsedMs),
                })
                .OrderByDescending(e => e.TotalUtilization)
                .ToList();

            var wins = CountWins(results);

            Console.WriteLine($"{"Engine",-16} {"Jobs",-6} {"Valid",-7} {"Complete",-9} {"Wins",-6} {"AvgUtil%",-10} {"Plates",-8} {"TotalTime(ms)",-14}");

            foreach (var e in byEngine)
            {
                var avgUtil = e.Jobs > 0 ? e.TotalUtilization / e.Jobs * 100 : 0;
                var winCount = wins.TryGetValue(e.Engine, out var w) ? w : 0;
                Console.WriteLine($"{e.Engine,-16} {e.Jobs,-6} {e.Valid,-7} {e.FullyPlaced,-9} {winCount,-6} {avgUtil,-10:F1} {e.TotalPlates,-8} {e.TotalTimeMs,-14}");
            }
        }

        public static void WriteCsv(string path, List<JobResult> results)
        {
            var sb = new StringBuilder();
            sb.AppendLine("Job,Engine,Valid,Crashed,FullyPlaced,PartsPlaced,PartsRequested,Utilization,PlatesUsed,SizeBreakdown,ElapsedMs,Notes");

            foreach (var r in results)
            {
                var notes = r.Crashed ? r.Error : string.Join(" | ", r.Violations);
                sb.AppendLine(string.Join(",",
                    Csv(r.JobName), Csv(r.EngineName), r.Valid, r.Crashed, r.FullyPlaced,
                    r.PartsPlaced, r.PartsRequested,
                    r.Utilization.ToString("F4", CultureInfo.InvariantCulture),
                    r.PlatesUsed, Csv(SizeSummary(r.SizeBreakdown)),
                    r.ElapsedMs, Csv(notes)));
            }

            File.WriteAllText(path, sb.ToString());
        }

        private static string SizeSummary(Dictionary<string, int> breakdown)
        {
            if (breakdown == null || breakdown.Count == 0)
                return "-";

            return string.Join("; ", breakdown.Select(kv => $"{kv.Key}×{kv.Value}"));
        }

        private static string Csv(string value)
        {
            if (string.IsNullOrEmpty(value))
                return string.Empty;

            if (value.Contains(',') || value.Contains('"') || value.Contains('\n'))
                return $"\"{value.Replace("\"", "\"\"")}\"";

            return value;
        }

        private static Dictionary<string, int> CountWins(List<JobResult> results)
        {
            var wins = new Dictionary<string, int>();

            foreach (var jobGroup in results.GroupBy(r => r.JobName))
            {
                var ranked = jobGroup.OrderBy(r => r, Comparer<JobResult>.Create(Compare)).ToList();

                if (ranked.Count == 0 || !ranked[0].Valid)
                    continue;

                foreach (var r in ranked.TakeWhile(r => Compare(r, ranked[0]) == 0))
                    wins[r.EngineName] = wins.GetValueOrDefault(r.EngineName) + 1;
            }

            return wins;
        }

        /// <summary>Lower sorts first (better). Valid beats invalid, then higher
        /// aggregate utilization, then (if both fully placed) fewer plates used.</summary>
        private static int Compare(JobResult a, JobResult b)
        {
            if (a.Valid != b.Valid)
                return a.Valid ? -1 : 1;

            if (!a.Valid)
                return 0;

            var utilDiff = b.Utilization - a.Utilization;

            if (System.Math.Abs(utilDiff) > Epsilon)
                return utilDiff > 0 ? 1 : -1;

            if (a.FullyPlaced && b.FullyPlaced && a.PlatesUsed != b.PlatesUsed)
                return a.PlatesUsed > b.PlatesUsed ? 1 : -1;

            return 0;
        }
    }
}