Catalog Lite

CatalogLite/ImageProcessingCoordinator.cs

@@ -0,0 +1,95 @@
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using MaddoShared;
+using Microsoft.Extensions.Logging;
+
+namespace CatalogLite;
+
+public readonly record struct ImageProcessedUpdate(string Status, int Total, int Processed);
+
+public sealed class ImageProcessingRunResult
+{
+    public required string FinalSpeedCounter { get; init; }
+}
+
+public sealed class ImageProcessingCoordinator
+{
+    private readonly ImageCreationService _imageCreationService;
+    private readonly ILogger<ImageProcessingCoordinator> _logger;
+
+    public ImageProcessingCoordinator(ImageCreationService imageCreationService, ILogger<ImageProcessingCoordinator> logger)
+    {
+        _imageCreationService = imageCreationService;
+        _logger = logger;
+    }
+
+    public async Task<ImageProcessingRunResult> RunAsync(
+        ImageCreationService.Options options,
+        CancellationToken token,
+        Action<ImageProcessedUpdate> onImageProcessed,
+        Action<string> onSpeedUpdated)
+    {
+        var results = new ConcurrentBag<string>();
+        var recentDiffs = new Queue<int>();
+        const int recentWindowSize = 5;
+
+        var currentAmount = 0;
+        var previousAmount = 0;
+        var processedAtomic = 0;
+        var speedWatch = Stopwatch.StartNew();
+
+        using var speedTimer = new System.Threading.Timer(_ =>
+        {
+            try
+            {
+                previousAmount = currentAmount;
+                currentAmount = Volatile.Read(ref processedAtomic);
+                var diff = Math.Max(0, currentAmount - previousAmount);
+
+                lock (recentDiffs)
+                {
+                    recentDiffs.Enqueue(diff);
+                    if (recentDiffs.Count > recentWindowSize)
+                    {
+                        recentDiffs.Dequeue();
+                    }
+                }
+
+                double recentAverage;
+                lock (recentDiffs)
+                {
+                    recentAverage = recentDiffs.Count == 0 ? 0.0 : recentDiffs.Average();
+                }
+
+                var total = Volatile.Read(ref processedAtomic);
+                var overall = speedWatch.Elapsed.TotalSeconds > 0 ? total / speedWatch.Elapsed.TotalSeconds : 0.0;
+                var elapsed = speedWatch.Elapsed;
+                var elapsedText = $"{(int)elapsed.TotalHours}h {elapsed.Minutes}m {elapsed.Seconds}s";
+
+                onSpeedUpdated($"{recentAverage:0.00} f/s (media: {overall:0.00} f/s) - {elapsedText}{Environment.NewLine}media: {recentAverage * 60.0:0.00} f/m");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogDebug(ex, "Errore durante l'aggiornamento della velocita");
+            }
+        }, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
+
+        EventHandler<Tuple<string, int>> onImageProcessedInternal = (_, args) =>
+        {
+            var processed = Interlocked.Increment(ref processedAtomic);
+            onImageProcessed(new ImageProcessedUpdate(args.Item1, args.Item2, processed));
+        };
+
+        await _imageCreationService.CreaCatalogoParallel(options, results, onImageProcessedInternal, token).ConfigureAwait(false);
+
+        speedWatch.Stop();
+        var finalProcessed = Volatile.Read(ref processedAtomic);
+        var finalAverage = speedWatch.Elapsed.TotalSeconds > 0 ? finalProcessed / speedWatch.Elapsed.TotalSeconds : 0.0;
+        var finalElapsed = speedWatch.Elapsed;
+
+        return new ImageProcessingRunResult
+        {
+            FinalSpeedCounter = $"{(int)finalElapsed.TotalHours}h {finalElapsed.Minutes}m {finalElapsed.Seconds}s{Environment.NewLine}media: {finalAverage:0.00} f/s{Environment.NewLine}media: {finalAverage * 60.0:0.00} f/m"
+        };
+    }
+}