class AsyncCounter
{
    private int _count;
    private readonly SemaphoreSlim _lock = new(1, 1);  // initialCount: 1, maxCount: 1

    public async Task<int> IncrementAsync()
    {
        // Асинхронне очікування доступу (не блокує потік)
        await _lock.WaitAsync();
        try
        {
            // Critical section — тільки один task одночасно
            await Task.Delay(10);  // ✅ await всередині "lock" — OK!
            _count++;
            return _count;
        }
        finally
        {
            // Звільнення lock — ЗАВЖДИ у finally
            _lock.Release();
        }
    }
}

// Використання — 10 паралельних tasks
var counter = new AsyncCounter();
var tasks = Enumerable.Range(0, 10)
    .Select(_ => counter.IncrementAsync())
    .ToArray();

await Task.WhenAll(tasks);
Console.WriteLine($"Final count: {await counter.IncrementAsync()}");  // 11

class AsyncLock
{
    private readonly SemaphoreSlim _semaphore = new(1, 1);

    public async Task<IDisposable> LockAsync()
    {
        await _semaphore.WaitAsync();
        return new ReleaseWrapper(_semaphore);
    }

    private class ReleaseWrapper : IDisposable
    {
        private readonly SemaphoreSlim _semaphore;

        public ReleaseWrapper(SemaphoreSlim semaphore) => _semaphore = semaphore;

        public void Dispose() => _semaphore.Release();
    }
}

// Використання — елегантний синтаксис
var asyncLock = new AsyncLock();

using (await asyncLock.LockAsync())
{
    // Critical section
    await Task.Delay(100);
}  // Автоматичний Release при виході з using

class ThrottledHttpClient
{
    private readonly HttpClient _http = new();
    private readonly SemaphoreSlim _throttle = new(5, 5);  // Максимум 5 одночасних запитів

    public async Task<string> GetAsync(string url, CancellationToken ct = default)
    {
        // Чекаємо доки з'явиться "слот" для запиту
        await _throttle.WaitAsync(ct);
        try
        {
            Console.WriteLine($"Запит до {url} (активних: {5 - _throttle.CurrentCount})");
            return await _http.GetStringAsync(url, ct);
        }
        finally
        {
            // Звільняємо слот
            _throttle.Release();
        }
    }
}

// Використання — 20 паралельних запитів, але максимум 5 одночасно
var client = new ThrottledHttpClient();
var urls = Enumerable.Range(1, 20)
    .Select(i => $"https://jsonplaceholder.typicode.com/posts/{i}")
    .ToArray();

var tasks = urls.Select(url => client.GetAsync(url)).ToArray();
var results = await Task.WhenAll(tasks);

Console.WriteLine($"Завантажено {results.Length} сторінок");

class RateLimiter
{
    private readonly int _maxRequests;
    private readonly TimeSpan _timeWindow;
    private readonly Queue<DateTime> _requestTimestamps = new();
    private readonly SemaphoreSlim _lock = new(1, 1);

    public RateLimiter(int maxRequests, TimeSpan timeWindow)
    {
        _maxRequests = maxRequests;
        _timeWindow = timeWindow;
    }

    public async Task WaitAsync(CancellationToken ct = default)
    {
        await _lock.WaitAsync(ct);
        try
        {
            var now = DateTime.UtcNow;
            var windowStart = now - _timeWindow;

            // Видаляємо старі timestamps (поза вікном)
            while (_requestTimestamps.Count > 0 && _requestTimestamps.Peek() < windowStart)
            {
                _requestTimestamps.Dequeue();
            }

            // Якщо досягнуто ліміту — чекаємо
            if (_requestTimestamps.Count >= _maxRequests)
            {
                var oldestRequest = _requestTimestamps.Peek();
                var delay = oldestRequest + _timeWindow - now;

                if (delay > TimeSpan.Zero)
                {
                    Console.WriteLine($"Rate limit досягнуто. Чекаємо {delay.TotalSeconds:F1}s...");
                    await Task.Delay(delay, ct);
                }

                // Після затримки — видаляємо найстаріший
                _requestTimestamps.Dequeue();
            }

            // Реєструємо новий запит
            _requestTimestamps.Enqueue(now);
        }
        finally
        {
            _lock.Release();
        }
    }
}

// Використання — максимум 10 запитів на 5 секунд
var rateLimiter = new RateLimiter(maxRequests: 10, timeWindow: TimeSpan.FromSeconds(5));

for (int i = 0; i < 25; i++)
{
    await rateLimiter.WaitAsync();
    Console.WriteLine($"Запит {i + 1} виконано о {DateTime.Now:HH:mm:ss.fff}");
}

static async Task<T> WithTimeout<T>(Task<T> task, TimeSpan timeout)
{
    var delayTask = Task.Delay(timeout);
    var completedTask = await Task.WhenAny(task, delayTask);

    if (completedTask == delayTask)
    {
        throw new TimeoutException($"Операція не завершилась за {timeout}");
    }

    return await task;  // Повертаємо результат
}

// Використання
try
{
    var result = await WithTimeout(
        SlowOperationAsync(),
        TimeSpan.FromSeconds(5)
    );
    Console.WriteLine($"Результат: {result}");
}
catch (TimeoutException ex)
{
    Console.WriteLine($"Таймаут: {ex.Message}");
}

async Task<string> SlowOperationAsync()
{
    await Task.Delay(10_000);  // 10 секунд
    return "Completed";
}

static async Task<T> WithTimeoutAndCancellation<T>(
    Func<CancellationToken, Task<T>> operation,
    TimeSpan timeout)
{
    using var cts = new CancellationTokenSource(timeout);
    return await operation(cts.Token);
}

// Використання
try
{
    var result = await WithTimeoutAndCancellation(
        ct => SlowOperationAsync(ct),
        TimeSpan.FromSeconds(5)
    );
    Console.WriteLine($"Результат: {result}");
}
catch (OperationCanceledException)
{
    Console.WriteLine("Операція скасована через таймаут");
}

async Task<string> SlowOperationAsync(CancellationToken ct)
{
    // Операція перевіряє cancellation
    await Task.Delay(10_000, ct);
    return "Completed";
}

async Task<string> FetchWithTimeoutAsync(string url, CancellationToken externalCt)
{
    // Створюємо токен з timeout
    using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
    
    // Об'єднуємо з зовнішнім токеном
    using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
        externalCt,
        timeoutCts.Token
    );

    // Операція скасується або при timeout, або при зовнішньому cancellation
    var response = await _http.GetStringAsync(url, linkedCts.Token);
    return response;
}

// Використання
using var userCts = new CancellationTokenSource();

// Користувач може скасувати через Ctrl+C
Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    userCts.Cancel();
};

try
{
    var data = await FetchWithTimeoutAsync("https://slow-api.com/data", userCts.Token);
    Console.WriteLine(data);
}
catch (OperationCanceledException)
{
    Console.WriteLine("Скасовано (timeout або користувач)");
}

static async Task<T> RetryWithTimeoutAsync<T>(
    Func<CancellationToken, Task<T>> operation,
    int maxRetries = 3,
    TimeSpan? initialDelay = null,
    CancellationToken ct = default)
{
    initialDelay ??= TimeSpan.FromSeconds(1);
    var delay = initialDelay.Value;

    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        using var attemptCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
        attemptCts.CancelAfter(TimeSpan.FromSeconds(5));  // Timeout на спробу

        try
        {
            return await operation(attemptCts.Token);
        }
        catch (Exception ex) when (attempt < maxRetries && 
            (ex is OperationCanceledException || ex is HttpRequestException))
        {
            Console.WriteLine($"Спроба {attempt} невдала: {ex.Message}. Повтор через {delay.TotalSeconds}s...");
            await Task.Delay(delay, ct);
            delay *= 2;  // Exponential backoff
        }
    }

    // Остання спроба без catch
    using var finalCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
    finalCts.CancelAfter(TimeSpan.FromSeconds(5));
    return await operation(finalCts.Token);
}

// Використання
var result = await RetryWithTimeoutAsync(
    async ct =>
    {
        var response = await _http.GetAsync("https://flaky-api.com/data", ct);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync(ct);
    },
    maxRetries: 5,
    initialDelay: TimeSpan.FromSeconds(1)
);

using Nito.AsyncEx;

class SharedResource
{
    private readonly AsyncLock _lock = new();
    private int _value;

    public async Task<int> IncrementAsync()
    {
        // using + await — елегантний синтаксис
        using (await _lock.LockAsync())
        {
            await Task.Delay(10);
            return ++_value;
        }
    }
}

using Nito.AsyncEx;

// Auto-reset: один waiter проходить, event скидається
var autoEvent = new AsyncAutoResetEvent(signaled: false);

// Producer
_ = Task.Run(async () =>
{
    await Task.Delay(1000);
    autoEvent.Set();  // Дозволяє одному waiter пройти
    Console.WriteLine("Event set");
});

// Consumer
await autoEvent.WaitAsync();
Console.WriteLine("Event received");

// Manual-reset: всі waiters проходять
var manualEvent = new AsyncManualResetEvent(signaled: false);

// Кілька consumers
var waiters = Enumerable.Range(0, 5)
    .Select(async i =>
    {
        await manualEvent.WaitAsync();
        Console.WriteLine($"Waiter {i} пройшов");
    })
    .ToArray();

await Task.Delay(1000);
manualEvent.Set();  // Всі 5 waiters проходять одночасно

await Task.WhenAll(waiters);

using Nito.AsyncEx;

var collection = new AsyncCollection<int>();

// Producer
_ = Task.Run(async () =>
{
    for (int i = 0; i < 10; i++)
    {
        await collection.AddAsync(i);
        await Task.Delay(100);
    }
    collection.CompleteAdding();
});

// Consumer
await foreach (var item in collection.GetConsumingAsyncEnumerable())
{
    Console.WriteLine($"Consumed: {item}");
}

using Nito.AsyncEx;

class ExpensiveService
{
    private readonly AsyncLazy<string> _data;

    public ExpensiveService()
    {
        _data = new AsyncLazy<string>(async () =>
        {
            Console.WriteLine("Ініціалізація...");
            await Task.Delay(2000);
            return "Expensive data";
        });
    }

    public Task<string> GetDataAsync() => _data.Task;
}

// Використання
var service = new ExpensiveService();

// Перший виклик — запускає ініціалізацію
var data1 = await service.GetDataAsync();  // 2 секунди

// Наступні виклики — повертають кешований результат
var data2 = await service.GetDataAsync();  // Instant
var data3 = await service.GetDataAsync();  // Instant

using Nito.AsyncEx;

class AsyncCache
{
    private readonly AsyncReaderWriterLock _lock = new();
    private readonly Dictionary<string, string> _cache = new();

    public async Task<string?> GetAsync(string key)
    {
        // Множинні readers можуть читати одночасно
        using (await _lock.ReaderLockAsync())
        {
            await Task.Delay(10);  // Імітація читання
            return _cache.TryGetValue(key, out var value) ? value : null;
        }
    }

    public async Task SetAsync(string key, string value)
    {
        // Тільки один writer одночасно
        using (await _lock.WriterLockAsync())
        {
            await Task.Delay(50);  // Імітація запису
            _cache[key] = value;
        }
    }
}