namespace ThreadSafeRepo;

// Незмінна модель (immutable record — thread-safe за природою)
public sealed record Product(
    int Id,
    string Name,
    string Category,
    decimal Price,
    int Stock
);

// Команди оновлення (теж immutable)
public sealed record PriceUpdate(int ProductId, decimal NewPrice);
public sealed record StockAdjustment(int ProductId, int Delta);

// Статистика
public sealed record RepoSnapshot(
    int TotalProducts,
    decimal TotalValue,
    IReadOnlyDictionary<string, int> CountByCategory
);

using System.Collections.Generic;
using System.Threading;

namespace ThreadSafeRepo;

/// <summary>
/// Thread-safe in-memory repository з двома рівнями lock granularity:
/// - _globalLock: для операцій що зачіпають структуру (Add/Remove/Snapshot)
/// - _priceLocks: fine-grained locks для оновлення ціни конкретного продукту
/// </summary>
public class ProductRepository
{
    private readonly Dictionary<int, Product> _products = new();
    private readonly object _globalLock = new object();

    // Fine-grained locks: окремий lock для ціни кожного продукту
    // Дозволяє оновлювати ціни різних продуктів паралельно
    private readonly Dictionary<int, object> _priceLocks = new();

    private long _readCount = 0;
    private long _writeCount = 0;

    // ─── Read Operations ─────────────────────────────────────────

    /// <summary>Отримати продукт за ID. Thread-safe читання.</summary>
    public Product? GetById(int id)
    {
        Interlocked.Increment(ref _readCount);

        // Dictionary не thread-safe → потрібен lock навіть для читання
        lock (_globalLock)
        {
            return _products.GetValueOrDefault(id);
        }
    }

    /// <summary>Отримати всі продукти категорії.</summary>
    public IReadOnlyList<Product> GetByCategory(string category)
    {
        Interlocked.Increment(ref _readCount);
        lock (_globalLock)
        {
            // Повертаємо копію! Не посилання на внутрішню колекцію.
            return _products.Values
                .Where(p => p.Category == category)
                .ToList()
                .AsReadOnly();
        }
    }

    // ─── Write Operations ─────────────────────────────────────────

    /// <summary>Додати або замінити продукт.</summary>
    public void AddOrUpdate(Product product)
    {
        Interlocked.Increment(ref _writeCount);
        lock (_globalLock)
        {
            _products[product.Id] = product;
            // Реєструємо fine-grained lock для нового продукту
            _priceLocks.TryAdd(product.Id, new object());
        }
    }

    /// <summary>
    /// Оновити ціну конкретного продукту.
    /// Використовує fine-grained lock: паралельне оновлення різних продуктів ✓
    /// </summary>
    public bool UpdatePrice(PriceUpdate update)
    {
        Interlocked.Increment(ref _writeCount);

        // Спочатку отримуємо fine-grained lock (без globalLock!)
        object? priceLock;
        lock (_globalLock)
        {
            _priceLocks.TryGetValue(update.ProductId, out priceLock);
        }

        if (priceLock is null) return false;

        // Оновлюємо ціну через fine-grained lock
        lock (priceLock)
        {
            lock (_globalLock)
            {
                if (!_products.TryGetValue(update.ProductId, out var current))
                    return false;

                if (update.NewPrice < 0) return false;

                // record: незмінний, тому "оновлення" = створення нового record
                _products[update.ProductId] = current with { Price = update.NewPrice };
                return true;
            }
        }
        // Інший потік може оновлювати _products[otherId] одночасно ✓
    }

    /// <summary>Скоригувати кількість на складі (delta може бути від'ємним).</summary>
    public bool AdjustStock(StockAdjustment adjustment)
    {
        Interlocked.Increment(ref _writeCount);
        lock (_globalLock)
        {
            if (!_products.TryGetValue(adjustment.ProductId, out var current))
                return false;

            var newStock = current.Stock + adjustment.Delta;
            if (newStock < 0) return false;  // ← atomic check-and-set за lock

            _products[adjustment.ProductId] = current with { Stock = newStock };
            return true;
        }
    }

    /// <summary>Bulk операція: застосувати список оновлень цін атомарно.</summary>
    public void BulkUpdatePrices(IEnumerable<PriceUpdate> updates)
    {
        // Для bulk операцій — один lock на весь блок → атомарно
        lock (_globalLock)
        {
            foreach (var u in updates)
            {
                if (_products.TryGetValue(u.ProductId, out var p))
                    _products[u.ProductId] = p with { Price = u.NewPrice };
            }
        }
    }

    // ─── Snapshot / Analytics ─────────────────────────────────────

    /// <summary>Консистентний знімок стану (atomic read of derived data).</summary>
    public RepoSnapshot GetSnapshot()
    {
        Interlocked.Increment(ref _readCount);
        lock (_globalLock)
        {
            // Всередині lock — всі читання консистентні
            var total = _products.Count;
            var value = _products.Values.Sum(p => p.Price * p.Stock);
            var byCategory = _products.Values
                .GroupBy(p => p.Category)
                .ToDictionary(g => g.Key, g => g.Count());

            return new RepoSnapshot(total, value, byCategory);
        }
    }

    public long ReadCount  => Interlocked.Read(ref _readCount);
    public long WriteCount => Interlocked.Read(ref _writeCount);
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using ThreadSafeRepo;

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=== Thread-Safe Product Repository ===\n");

var repo = new ProductRepository();
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));

// ─── Seed initial data ─────────────────────────────────
var categories = new[] { "Electronics", "Clothing", "Food", "Books" };
for (int i = 1; i <= 50; i++)
{
    repo.AddOrUpdate(new Product(
        Id:       i,
        Name:     $"Product-{i:D3}",
        Category: categories[i % categories.Length],
        Price:    Random.Shared.Next(10, 1000),
        Stock:    Random.Shared.Next(5, 100)
    ));
}

Console.WriteLine($"Seeded {50} products\n");
var sw = Stopwatch.StartNew();

// ─── Concurrent workers ─────────────────────────────────

// 4 Readers: постійно читають різні продукти
var readers = Enumerable.Range(0, 4).Select(i => Task.Run(async () =>
{
    var rng = new Random(i * 7);
    long ops = 0;
    while (!cts.Token.IsCancellationRequested)
    {
        int id = rng.Next(1, 51);
        var product = repo.GetById(id);

        if (product is not null)
            _ = repo.GetByCategory(product.Category);

        ops++;
        await Task.Delay(rng.Next(1, 5), cts.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
    }
    return ops;
})).ToList();

// 2 Price Updaters: оновлюють ціни
var priceUpdaters = Enumerable.Range(0, 2).Select(i => Task.Run(async () =>
{
    var rng = new Random(i * 13 + 17);
    long ops = 0;
    while (!cts.Token.IsCancellationRequested)
    {
        for (int j = 0; j < 5; j++)
        {
            int id = rng.Next(1, 51);
            decimal newPrice = rng.Next(5, 1500);
            bool ok = repo.UpdatePrice(new PriceUpdate(id, newPrice));
            if (ok) ops++;
        }
        await Task.Delay(rng.Next(10, 30), cts.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
    }
    return ops;
})).ToList();

// 1 Stock Manager: коригує кількість на складі
var stockManager = Task.Run(async () =>
{
    var rng = new Random(99);
    long ops = 0;
    while (!cts.Token.IsCancellationRequested)
    {
        int id = rng.Next(1, 51);
        int delta = rng.Next(-10, 20);
        bool ok = repo.AdjustStock(new StockAdjustment(id, delta));
        if (ok) ops++;
        await Task.Delay(rng.Next(5, 15), cts.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
    }
    return ops;
});

// 1 Analytics: знімає snapshot кожну секунду
var analytics = Task.Run(async () =>
{
    while (!cts.Token.IsCancellationRequested)
    {
        await Task.Delay(1000, cts.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
        if (cts.Token.IsCancellationRequested) break;

        var snap = repo.GetSnapshot();
        Console.WriteLine(
            $"[t={sw.Elapsed.TotalSeconds:F0}s] " +
            $"Products: {snap.TotalProducts} | " +
            $"TotalValue: {snap.TotalValue:C0} | " +
            $"Reads: {repo.ReadCount:N0} | " +
            $"Writes: {repo.WriteCount:N0}");

        foreach (var (cat, count) in snap.CountByCategory.OrderBy(x => x.Key))
            Console.WriteLine($"  {cat}: {count} products");
    }
});

await Task.WhenAll(readers.Concat(priceUpdaters).Append(stockManager).Append(analytics));

Console.WriteLine($"\n=== Завершено ===");
Console.WriteLine($"Total Reads:  {repo.ReadCount:N0}");
Console.WriteLine($"Total Writes: {repo.WriteCount:N0}");
Console.WriteLine($"Duration: {sw.Elapsed.TotalSeconds:F2}s");