namespace LockFreeDemo;

/// <summary>
/// Lock-free кільцевий буфер для одного Producer та одного Consumer (SPSC).
/// Використовує volatile для координації та Interlocked для лічильників.
/// НЕ підходить для Multiple-Producer або Multiple-Consumer без додаткової синхронізації.
/// </summary>
public class LockFreeRingBuffer<T>
{
    private readonly T[] _buffer;
    private readonly int _capacity;

    // volatile: Producer пише _writeIndex, Consumer читає
    private volatile int _writeIndex = 0;
    // volatile: Consumer пише _readIndex, Producer читає
    private volatile int _readIndex = 0;

    // Статистика через Interlocked
    private long _totalProduced = 0;
    private long _totalConsumed = 0;
    private long _droppedItems = 0;

    public LockFreeRingBuffer(int capacity)
    {
        // Capacity має бути степенем двійки для ефективного % через бітову маску
        // (для простоти тут просто перевіряємо)
        if (capacity <= 0) throw new ArgumentException("Capacity must be > 0");
        _capacity = capacity;
        _buffer = new T[capacity];
    }

    /// <summary>
    /// Записати елемент у буфер (Thread: тільки Producer).
    /// Якщо буфер повний — повертає false і елемент втрачається.
    /// </summary>
    public bool TryEnqueue(T item)
    {
        int write = _writeIndex;
        int next  = (write + 1) % _capacity;

        // Якщо next == _readIndex — буфер повний
        if (next == _readIndex)
        {
            Interlocked.Increment(ref _droppedItems);
            return false;
        }

        _buffer[write] = item;  // записуємо дані

        // CRITICAL: спочатку записуємо дані, ПОТІМ оновлюємо _writeIndex
        // volatile write гарантує Release semantics — _writeIndex видимий після даних
        _writeIndex = next;

        Interlocked.Increment(ref _totalProduced);
        return true;
    }

    /// <summary>
    /// Прочитати елемент з буфера (Thread: тільки Consumer).
    /// Якщо буфер порожній — повертає false.
    /// </summary>
    public bool TryDequeue(out T item)
    {
        // volatile read гарантує Acquire semantics — бачимо актуальний _writeIndex
        if (_readIndex == _writeIndex)
        {
            item = default!;
            return false;
        }

        // Після перевірки _writeIndex (Acquire) — _buffer[_readIndex] вже записаний Producer-ом
        item = _buffer[_readIndex];
        _readIndex = (_readIndex + 1) % _capacity;

        Interlocked.Increment(ref _totalConsumed);
        return true;
    }

    public int Count
    {
        get
        {
            int w = _writeIndex;
            int r = _readIndex;
            return w >= r ? w - r : _capacity - r + w;
        }
    }

    public long TotalProduced => Interlocked.Read(ref _totalProduced);
    public long TotalConsumed => Interlocked.Read(ref _totalConsumed);
    public long DroppedItems  => Interlocked.Read(ref _droppedItems);
}

namespace LockFreeDemo;

record WorkItem(int Id, string Payload, DateTime CreatedAt);

class Producer(LockFreeRingBuffer<WorkItem> buffer, CancellationToken ct)
{
    private volatile int _id = 0;

    public async Task RunAsync()
    {
        Console.WriteLine("[Producer] Старт");

        while (!ct.IsCancellationRequested)
        {
            int id = Interlocked.Increment(ref _id);
            var item = new WorkItem(id, $"task-{id:D6}", DateTime.UtcNow);

            bool enqueued = false;
            int retries = 0;

            // Retry: якщо буфер повний — чекаємо трохи
            while (!enqueued && retries < 5)
            {
                enqueued = buffer.TryEnqueue(item);
                if (!enqueued)
                {
                    await Task.Delay(1, ct);  // не блокуємо потік
                    retries++;
                }
            }

            // Невелика пауза між елементами (имітуємо реальну роботу)
            if (id % 10 == 0)
                await Task.Delay(1, ct);
        }

        Console.WriteLine($"[Producer] Зупинено. Вироблено: {Interlocked.Read(ref _id)}");
    }
}

class Consumer(LockFreeRingBuffer<WorkItem> buffer, string name, CancellationToken ct)
{
    private long _processed = 0;

    public async Task RunAsync()
    {
        Console.WriteLine($"[{name}] Старт");

        while (!ct.IsCancellationRequested)
        {
            if (buffer.TryDequeue(out var item))
            {
                // Обробляємо елемент
                var latency = (DateTime.UtcNow - item.CreatedAt).TotalMilliseconds;
                Interlocked.Increment(ref _processed);

                if (item.Id % 1000 == 0)  // логуємо кожен 1000-й
                    Console.WriteLine($"  [{name}] Обробили #{item.Id}, latency: {latency:F1}ms");
            }
            else
            {
                // Буфер порожній — невелика пауза щоб не молотити CPU
                await Task.Delay(1, ct);
            }
        }

        Console.WriteLine($"[{name}] Зупинено. Оброблено: {Interlocked.Read(ref _processed)}");
    }

    public long Processed => Interlocked.Read(ref _processed);
}

using System.Diagnostics;
using LockFreeDemo;

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=== Lock-Free Producer-Consumer Demo ===\n");

using var cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) => { e.Cancel = true; cts.Cancel(); };

// Буфер на 1024 елементи (SPSC: один producer, один consumer)
var buffer = new LockFreeRingBuffer<WorkItem>(capacity: 1024);

var producer = new Producer(buffer, cts.Token);
var consumer = new Consumer(buffer, "Consumer-1", cts.Token);

var sw = Stopwatch.StartNew();

// Запускаємо всі компоненти паралельно
var prodTask = producer.RunAsync();
var consTask = consumer.RunAsync();

// Моніторинг кожну секунду
var monitorTask = Task.Run(async () =>
{
    long lastProduced = 0, lastConsumed = 0;

    while (!cts.Token.IsCancellationRequested)
    {
        await Task.Delay(1000, cts.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
        if (cts.Token.IsCancellationRequested) break;

        long produced = buffer.TotalProduced;
        long consumed = buffer.TotalConsumed;
        long dropped  = buffer.DroppedItems;

        long prodRate = produced - lastProduced;
        long consRate = consumed - lastConsumed;
        lastProduced = produced;
        lastConsumed = consumed;

        Console.WriteLine(
            $"[Monitor] t={sw.Elapsed.TotalSeconds:F0}s | " +
            $"Produced: {produced:N0} (+{prodRate:N0}/s) | " +
            $"Consumed: {consumed:N0} (+{consRate:N0}/s) | " +
            $"Buffer: {buffer.Count} | " +
            $"Dropped: {dropped:N0}");
    }
});

// Автозупинка через 10 секунд для демонстрації
await Task.Delay(TimeSpan.FromSeconds(10), CancellationToken.None);
cts.Cancel();

await Task.WhenAll(prodTask, consTask, monitorTask);

Console.WriteLine($"\n=== Фінальна статистика ===");
Console.WriteLine($"Загалом вироблено: {buffer.TotalProduced:N0}");
Console.WriteLine($"Загалом оброблено: {buffer.TotalConsumed:N0}");
Console.WriteLine($"Загублено (buffer full): {buffer.DroppedItems:N0}");
Console.WriteLine($"Ефективність: {100.0 * buffer.TotalConsumed / buffer.TotalProduced:F2}%");