record EmailJob(
    string To,
    string Subject,
    string Body,
    DateTime EnqueuedAt
);

using Microsoft.Extensions.Hosting;
using System.Threading.Channels;

class EmailBackgroundService : BackgroundService
{
    private readonly ChannelReader<EmailJob> _reader;
    private readonly ILogger<EmailBackgroundService> _logger;

    public EmailBackgroundService(
        ChannelReader<EmailJob> reader,
        ILogger<EmailBackgroundService> logger)
    {
        _reader = reader;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Email service запущено");

        await foreach (var job in _reader.ReadAllAsync(stoppingToken))
        {
            try
            {
                await SendEmailAsync(job, stoppingToken);
                _logger.LogInformation("Email відправлено: {To}", job.To);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Помилка відправки email: {To}", job.To);
            }
        }

        _logger.LogInformation("Email service зупинено");
    }

    private async Task SendEmailAsync(EmailJob job, CancellationToken ct)
    {
        // Імітація відправки email
        await Task.Delay(500, ct);
        Console.WriteLine($"📧 Email → {job.To}: {job.Subject}");
    }
}

using System.Threading.Channels;

var builder = WebApplication.CreateBuilder(args);

// Створюємо bounded channel (обмежуємо чергу до 100 emails)
var emailChannel = Channel.CreateBounded<EmailJob>(new BoundedChannelOptions(100)
{
    FullMode = BoundedChannelFullMode.Wait  // Backpressure якщо черга повна
});

// Реєструємо Reader та Writer окремо
builder.Services.AddSingleton(emailChannel.Reader);
builder.Services.AddSingleton(emailChannel.Writer);

// Реєструємо BackgroundService
builder.Services.AddHostedService<EmailBackgroundService>();

var app = builder.Build();

using Microsoft.AspNetCore.Mvc;
using System.Threading.Channels;

[ApiController]
[Route("api/[controller]")]
class EmailController : ControllerBase
{
    private readonly ChannelWriter<EmailJob> _emailQueue;

    public EmailController(ChannelWriter<EmailJob> emailQueue)
    {
        _emailQueue = emailQueue;
    }

    [HttpPost("send")]
    public async Task<IActionResult> SendEmail([FromBody] EmailRequest request)
    {
        var job = new EmailJob(
            request.To,
            request.Subject,
            request.Body,
            DateTime.UtcNow
        );

        // Додаємо у чергу (async, не блокує request thread)
        var written = await _emailQueue.WriteAsync(job);

        return Accepted(new { message = "Email додано у чергу" });
    }
}

record EmailRequest(string To, string Subject, string Body);

record ImageJob(
    string InputPath,
    string OutputPath,
    int TargetWidth,
    int TargetHeight
);

record ProcessedImage(
    string OutputPath,
    long OriginalSize,
    long ProcessedSize,
    TimeSpan ProcessingTime
);

using System.Threading.Channels;

class FileScanner
{
    public async Task ScanAsync(
        string inputDir,
        string outputDir,
        ChannelWriter<ImageJob> output,
        CancellationToken ct = default)
    {
        var imageFiles = Directory.GetFiles(inputDir, "*.jpg")
            .Concat(Directory.GetFiles(inputDir, "*.png"))
            .ToArray();

        Console.WriteLine($"Знайдено {imageFiles.Length} зображень");

        foreach (var inputPath in imageFiles)
        {
            var fileName = Path.GetFileName(inputPath);
            var outputPath = Path.Combine(outputDir, $"resized_{fileName}");

            var job = new ImageJob(inputPath, outputPath, 800, 600);
            await output.WriteAsync(job, ct);
        }

        output.Complete();
        Console.WriteLine("Сканування завершено");
    }
}

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using System.Diagnostics;
using System.Threading.Channels;

class ImageProcessor
{
    private readonly int _workerId;

    public ImageProcessor(int workerId)
    {
        _workerId = workerId;
    }

    public async Task ProcessAsync(
        ChannelReader<ImageJob> input,
        ChannelWriter<ProcessedImage> output,
        CancellationToken ct = default)
    {
        await foreach (var job in input.ReadAllAsync(ct))
        {
            var sw = Stopwatch.StartNew();

            try
            {
                var originalSize = new FileInfo(job.InputPath).Length;

                // Завантаження та обробка зображення
                using var image = await Image.LoadAsync(job.InputPath, ct);
                
                image.Mutate(x => x.Resize(job.TargetWidth, job.TargetHeight));
                
                await image.SaveAsJpegAsync(job.OutputPath, ct);

                var processedSize = new FileInfo(job.OutputPath).Length;
                sw.Stop();

                var result = new ProcessedImage(
                    job.OutputPath,
                    originalSize,
                    processedSize,
                    sw.Elapsed
                );

                await output.WriteAsync(result, ct);

                Console.WriteLine($"Worker {_workerId}: {Path.GetFileName(job.InputPath)} " +
                    $"({originalSize / 1024}KB → {processedSize / 1024}KB) за {sw.ElapsedMilliseconds}ms");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Worker {_workerId}: Помилка обробки {job.InputPath}: {ex.Message}");
            }
        }

        Console.WriteLine($"Worker {_workerId} завершив роботу");
    }
}

using System.Threading.Channels;

class StatisticsCollector
{
    public async Task CollectAsync(
        ChannelReader<ProcessedImage> input,
        CancellationToken ct = default)
    {
        int totalImages = 0;
        long totalOriginalSize = 0;
        long totalProcessedSize = 0;
        var totalProcessingTime = TimeSpan.Zero;

        await foreach (var result in input.ReadAllAsync(ct))
        {
            totalImages++;
            totalOriginalSize += result.OriginalSize;
            totalProcessedSize += result.ProcessedSize;
            totalProcessingTime += result.ProcessingTime;
        }

        var compressionRatio = totalOriginalSize > 0
            ? (1 - (double)totalProcessedSize / totalOriginalSize) * 100
            : 0;

        Console.WriteLine("\n" + new string('═', 60));
        Console.WriteLine("📊 СТАТИСТИКА ОБРОБКИ");
        Console.WriteLine(new string('─', 60));
        Console.WriteLine($"Оброблено зображень: {totalImages}");
        Console.WriteLine($"Оригінальний розмір:  {totalOriginalSize / 1024 / 1024:F2} MB");
        Console.WriteLine($"Після обробки:        {totalProcessedSize / 1024 / 1024:F2} MB");
        Console.WriteLine($"Стиснення:            {compressionRatio:F1}%");
        Console.WriteLine($"Загальний час:        {totalProcessingTime.TotalSeconds:F2}s");
        Console.WriteLine($"Середній час/зображення: {totalProcessingTime.TotalMilliseconds / totalImages:F0}ms");
        Console.WriteLine(new string('═', 60));
    }
}

using System.Threading.Channels;

class ImagePipeline
{
    private readonly string _inputDir;
    private readonly string _outputDir;
    private readonly int _workerCount;

    public ImagePipeline(string inputDir, string outputDir, int workerCount = 4)
    {
        _inputDir = inputDir;
        _outputDir = outputDir;
        _workerCount = workerCount;

        Directory.CreateDirectory(_outputDir);
    }

    public async Task RunAsync(CancellationToken ct = default)
    {
        // Створюємо channels з backpressure
        var scanToProcess = Channel.CreateBounded<ImageJob>(new BoundedChannelOptions(10)
        {
            FullMode = BoundedChannelFullMode.Wait,
            SingleWriter = true  // Тільки один scanner
        });

        var processToStats = Channel.CreateBounded<ProcessedImage>(new BoundedChannelOptions(10)
        {
            FullMode = BoundedChannelFullMode.Wait,
            SingleReader = true  // Тільки один stats collector
        });

        // Stage 1: Scanner
        var scanner = new FileScanner();
        var scanTask = scanner.ScanAsync(_inputDir, _outputDir, scanToProcess.Writer, ct);

        // Stage 2: Processors (паралельні workers)
        var processorTasks = Enumerable.Range(0, _workerCount)
            .Select(id =>
            {
                var processor = new ImageProcessor(id);
                return processor.ProcessAsync(scanToProcess.Reader, processToStats.Writer, ct);
            })
            .ToArray();

        // Закриваємо processToStats.Writer після завершення всіх processors
        _ = Task.WhenAll(processorTasks).ContinueWith(_ => processToStats.Writer.Complete());

        // Stage 3: Statistics
        var statsCollector = new StatisticsCollector();
        var statsTask = statsCollector.CollectAsync(processToStats.Reader, ct);

        // Чекаємо завершення всього pipeline
        await Task.WhenAll(scanTask, statsTask);
    }
}

using System;
using System.Threading;

if (args.Length < 2)
{
    Console.WriteLine("Використання: ImagePipeline <input_dir> <output_dir> [worker_count]");
    return;
}

string inputDir = args[0];
string outputDir = args[1];
int workerCount = args.Length > 2 ? int.Parse(args[2]) : 4;

var cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    Console.WriteLine("\n⚠️ Скасування pipeline...");
    cts.Cancel();
};

var pipeline = new ImagePipeline(inputDir, outputDir, workerCount);

var sw = System.Diagnostics.Stopwatch.StartNew();

try
{
    await pipeline.RunAsync(cts.Token);
    sw.Stop();
    Console.WriteLine($"\n✅ Pipeline завершено за {sw.Elapsed.TotalSeconds:F2}s");
}
catch (OperationCanceledException)
{
    Console.WriteLine("Pipeline скасовано користувачем");
}
catch (Exception ex)
{
    Console.WriteLine($"❌ Помилка: {ex.Message}");
}