using System.Threading;

static Task DelayWithTimerAsync(int millisecondsDelay, CancellationToken ct = default)
{
    var tcs = new TaskCompletionSource<bool>();

    // Реєструємо cancellation ДО створення Timer
    ct.Register(() =>
    {
        tcs.TrySetCanceled(ct);
    });

    // Створюємо Timer, що спрацює один раз через millisecondsDelay
    Timer? timer = null;
    timer = new Timer(_ =>
    {
        timer?.Dispose();  // Звільняємо ресурси
        tcs.TrySetResult(true);  // Завершуємо Task
    }, null, millisecondsDelay, Timeout.Infinite);

    // Якщо cancellation вже запитано — одразу dispose
    if (ct.IsCancellationRequested)
    {
        timer.Dispose();
        tcs.TrySetCanceled(ct);
    }

    return tcs.Task;
}

// Використання — ідентично Task.Delay
await DelayWithTimerAsync(2000);
Console.WriteLine("2 секунди минуло через Timer!");

using System.IO;

static Task<FileSystemEventArgs> WaitForFileChangeAsync(
    string path,
    CancellationToken ct = default)
{
    var tcs = new TaskCompletionSource<FileSystemEventArgs>();
    var watcher = new FileSystemWatcher(path)
    {
        EnableRaisingEvents = true
    };

    // Обробник події — спрацює при першій зміні
    void OnChanged(object sender, FileSystemEventArgs e)
    {
        watcher.EnableRaisingEvents = false;  // Зупиняємо спостереження
        watcher.Dispose();
        tcs.TrySetResult(e);
    }

    watcher.Changed += OnChanged;
    watcher.Created += OnChanged;
    watcher.Deleted += OnChanged;

    // Підтримка cancellation
    ct.Register(() =>
    {
        watcher.EnableRaisingEvents = false;
        watcher.Dispose();
        tcs.TrySetCanceled(ct);
    });

    return tcs.Task;
}

// Використання
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
try
{
    var change = await WaitForFileChangeAsync(@"C:\Temp", cts.Token);
    Console.WriteLine($"Файл змінено: {change.FullPath}, тип: {change.ChangeType}");
}
catch (OperationCanceledException)
{
    Console.WriteLine("Таймаут — жодних змін за 30 секунд");
}

// За замовчуванням — Task виконується на ThreadPool
var tcs1 = new TaskCompletionSource<int>();

// RunContinuationsAsynchronously — continuation НЕ виконується синхронно
// при SetResult (запобігає блокуванню потоку, що встановлює результат)
var tcs2 = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);

tcs2.Task.ContinueWith(t =>
{
    // Цей код виконається на ThreadPool, а НЕ на потоці, що викликав SetResult
    Console.WriteLine($"Результат: {t.Result}");
});

// Потік, що встановлює результат, НЕ блокується на виконанні continuation
tcs2.SetResult(42);

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

// Метод повертає IAsyncEnumerable<T> і використовує yield return
async IAsyncEnumerable<int> GenerateNumbersAsync(int count)
{
    for (int i = 0; i < count; i++)
    {
        // Можемо робити await всередині ітератора!
        await Task.Delay(100);  // Імітація async операції
        yield return i;         // Повертаємо елемент "по мірі готовності"
    }
}

// Споживання через await foreach
await foreach (var number in GenerateNumbersAsync(10))
{
    Console.WriteLine($"Отримано: {number}");
    // Виводиться по одному числу кожні 100ms, а НЕ все одразу після 1 секунди
}

using System.Net.Http;
using System.Text.Json;
using System.Collections.Generic;
using System.Threading;

record User(int Id, string Name);

async IAsyncEnumerable<User> FetchAllUsersAsync(
    HttpClient http,
    [EnumeratorCancellation] CancellationToken ct = default)
{
    int page = 1;
    bool hasMore = true;

    while (hasMore)
    {
        // Запит до API: GET /users?page=1&limit=100
        var response = await http.GetStringAsync(
            $"https://api.example.com/users?page={page}&limit=100", ct);

        var users = JsonSerializer.Deserialize<List<User>>(response);

        if (users == null || users.Count == 0)
        {
            hasMore = false;
            yield break;  // Завершуємо ітерацію
        }

        // Повертаємо кожного користувача окремо
        foreach (var user in users)
        {
            yield return user;
        }

        page++;
    }
}

// Споживання — обробка по мірі надходження
var http = new HttpClient();
await foreach (var user in FetchAllUsersAsync(http))
{
    Console.WriteLine($"Обробка: {user.Name}");
    // Кожна сторінка завантажується ТІЛЬКИ коли попередня оброблена
    // Споживання RAM: ~100 користувачів одночасно, а НЕ мільйон
}

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

try
{
    await foreach (var user in FetchAllUsersAsync(http).WithCancellation(cts.Token))
    {
        Console.WriteLine(user.Name);
        // Якщо обробка займе > 10 секунд — OperationCanceledException
    }
}
catch (OperationCanceledException)
{
    Console.WriteLine("Обробка скасована через таймаут");
}

// Клас, що реалізує IAsyncDisposable
class AsyncResource : IAsyncDisposable
{
    private readonly HttpClient _http = new();

    public async Task<string> FetchDataAsync()
    {
        return await _http.GetStringAsync("https://example.com");
    }

    public async ValueTask DisposeAsync()
    {
        Console.WriteLine("Async cleanup...");
        // Асинхронне звільнення ресурсів
        await Task.Delay(100);  // Імітація async операції (flush, close connection)
        _http.Dispose();
        Console.WriteLine("Cleanup завершено");
    }
}

// Використання через await using
await using (var resource = new AsyncResource())
{
    var data = await resource.FetchDataAsync();
    Console.WriteLine(data);
}  // DisposeAsync() викликається автоматично тут

// Або скорочений синтаксис
await using var resource2 = new AsyncResource();
// DisposeAsync() викликається в кінці scope

class DatabaseConnection : IDisposable, IAsyncDisposable
{
    private bool _disposed;

    // Async dispose — рекомендований спосіб
    public async ValueTask DisposeAsync()
    {
        if (_disposed) return;

        // Async cleanup
        await FlushBuffersAsync();
        await CloseConnectionAsync();

        _disposed = true;
        GC.SuppressFinalize(this);  // Не потрібен finalizer
    }

    // Sync dispose — fallback для legacy коду
    public void Dispose()
    {
        if (_disposed) return;

        // Синхронне закриття (може бути менш ефективним)
        FlushBuffersAsync().GetAwaiter().GetResult();  // Блокуюче очікування
        CloseConnectionAsync().GetAwaiter().GetResult();

        _disposed = true;
        GC.SuppressFinalize(this);
    }

    private async Task FlushBuffersAsync()
    {
        await Task.Delay(50);  // Імітація flush
        Console.WriteLine("Buffers flushed");
    }

    private async Task CloseConnectionAsync()
    {
        await Task.Delay(50);  // Імітація close
        Console.WriteLine("Connection closed");
    }
}

using System.Collections.Concurrent;

class AsyncCache<TKey, TValue> where TKey : notnull
{
    private readonly ConcurrentDictionary<TKey, TValue> _cache = new();
    private readonly Func<TKey, Task<TValue>> _valueFactory;

    public AsyncCache(Func<TKey, Task<TValue>> valueFactory)
    {
        _valueFactory = valueFactory;
    }

    // Повертає ValueTask — синхронно якщо в кеші, async якщо ні
    public async ValueTask<TValue> GetAsync(TKey key)
    {
        // Cache hit — синхронне повернення (zero allocation)
        if (_cache.TryGetValue(key, out var cached))
        {
            return cached;
        }

        // Cache miss — асинхронне завантаження
        var value = await _valueFactory(key);
        _cache[key] = value;
        return value;
    }
}

// Використання
var cache = new AsyncCache<int, string>(async id =>
{
    await Task.Delay(100);  // Імітація DB query
    return $"User_{id}";
});

// Перший виклик — async (cache miss)
string user1 = await cache.GetAsync(1);  // 100ms delay

// Другий виклик — sync (cache hit, zero allocation)
string user1Again = await cache.GetAsync(1);  // Instant, no Task allocation

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class TaskVsValueTaskBenchmark
{
    private int _cachedValue = 42;

    [Benchmark(Baseline = true)]
    public async Task<int> TaskBased()
    {
        return await GetWithTaskAsync();
    }

    [Benchmark]
    public async ValueTask<int> ValueTaskBased()
    {
        return await GetWithValueTaskAsync();
    }

    private Task<int> GetWithTaskAsync()
    {
        // Синхронне повернення, але Task все одно allocate
        return Task.FromResult(_cachedValue);
    }

    private ValueTask<int> GetWithValueTaskAsync()
    {
        // Синхронне повернення, zero allocation
        return new ValueTask<int>(_cachedValue);
    }
}

// Запуск: dotnet run -c Release
BenchmarkRunner.Run<TaskVsValueTaskBenchmark>();

class ExpensiveResource
{
    // ❌ ПОГАНО: Lazy<T> не підтримує async
    private readonly Lazy<Task<string>> _data = new(() =>
    {
        // Не можемо використати await тут!
        return LoadDataAsync();
    });

    // ✅ ДОБРЕ: Lazy<Task<T>> pattern
    private readonly Lazy<Task<string>> _dataLazy = new(async () =>
    {
        await Task.Delay(1000);  // Імітація дорогої операції
        return "Expensive data";
    });

    public Task<string> GetDataAsync()
    {
        // Перший виклик — запускає async ініціалізацію
        // Наступні виклики — повертають той самий Task
        return _dataLazy.Value;
    }
}

// Використання
var resource = new ExpensiveResource();
string data1 = await resource.GetDataAsync();  // 1 секунда затримки
string data2 = await resource.GetDataAsync();  // Instant — той самий Task

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

    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        try
        {
            return await operation();
        }
        catch (Exception ex) when (attempt < maxRetries)
        {
            Console.WriteLine($"Спроба {attempt} невдала: {ex.Message}. Повтор через {delay}...");
            await Task.Delay(delay.Value, ct);
        }
    }

    // Останній attempt без catch — exception пробросується
    return await operation();
}

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

using System.Runtime.CompilerServices;

// Кастомний awaitable тип
class CustomTask
{
    private readonly Task _innerTask;

    public CustomTask(Task task) => _innerTask = task;

    // Pattern method — компілятор шукає саме цей метод
    public CustomAwaiter GetAwaiter() => new CustomAwaiter(_innerTask);
}

// Awaiter — виконує реальну роботу
class CustomAwaiter : INotifyCompletion
{
    private readonly TaskAwaiter _innerAwaiter;

    public CustomAwaiter(Task task) => _innerAwaiter = task.GetAwaiter();

    // Чи операція вже завершена?
    public bool IsCompleted => _innerAwaiter.IsCompleted;

    // Отримати результат (викликається після завершення)
    public void GetResult() => _innerAwaiter.GetResult();

    // Зареєструвати continuation (що виконати після завершення)
    public void OnCompleted(Action continuation) => _innerAwaiter.OnCompleted(continuation);
}

// Використання — await працює з CustomTask!
var customTask = new CustomTask(Task.Delay(1000));
await customTask;
Console.WriteLine("Custom await завершено!");

using System.Runtime.CompilerServices;

static class TaskExtensions
{
    public static TimeoutAwaitable<T> WithTimeout<T>(this Task<T> task, TimeSpan timeout)
    {
        return new TimeoutAwaitable<T>(task, timeout);
    }
}

class TimeoutAwaitable<T>
{
    private readonly Task<T> _task;
    private readonly TimeSpan _timeout;

    public TimeoutAwaitable(Task<T> task, TimeSpan timeout)
    {
        _task = task;
        _timeout = timeout;
    }

    public TaskAwaiter<T> GetAwaiter()
    {
        // Створюємо Task, що завершиться або при завершенні _task, або при timeout
        var timeoutTask = Task.Delay(_timeout).ContinueWith(_ =>
            throw new TimeoutException($"Операція не завершилась за {_timeout}"));

        var completedTask = Task.WhenAny(_task, timeoutTask)
            .ContinueWith(t => _task.Result);  // Повертаємо результат _task

        return completedTask.GetAwaiter();
    }
}

// Використання — елегантний синтаксис
var result = await FetchDataAsync().WithTimeout(TimeSpan.FromSeconds(5));