using System.Diagnostics;

const int TaskCount = 10_000;

// Benchmark 1: Створення нових потоків
var sw1 = Stopwatch.StartNew();
var threads = new Thread[TaskCount];

for (int i = 0; i < TaskCount; i++)
{
    threads[i] = new Thread(() => { /* мінімальна робота */ });
    threads[i].Start();
}

foreach (var t in threads)
    t.Join();

sw1.Stop();
Console.WriteLine($"new Thread() × {TaskCount}: {sw1.ElapsedMilliseconds}ms");

// Benchmark 2: ThreadPool
var sw2 = Stopwatch.StartNew();
var countdown = new CountdownEvent(TaskCount);

for (int i = 0; i < TaskCount; i++)
{
    ThreadPool.QueueUserWorkItem(_ =>
    {
        // мінімальна робота
        countdown.Signal();
    });
}

countdown.Wait();
sw2.Stop();
Console.WriteLine($"ThreadPool × {TaskCount}: {sw2.ElapsedMilliseconds}ms");

Console.WriteLine($"Прискорення: {sw1.ElapsedMilliseconds / (double)sw2.ElapsedMilliseconds:F1}x");

// Отримання поточних лімітів
ThreadPool.GetMinThreads(out int minWorker, out int minIOCP);
ThreadPool.GetMaxThreads(out int maxWorker, out int maxIOCP);

Console.WriteLine($"Worker Threads: min={minWorker}, max={maxWorker}");
Console.WriteLine($"IOCP Threads:   min={minIOCP}, max={maxIOCP}");

// Типовий вивід на 8-core машині:
// Worker Threads: min=8, max=32767
// IOCP Threads:   min=8, max=1000

using System.Threading;

// Варіант 1: без параметрів
ThreadPool.QueueUserWorkItem(_ =>
{
    Console.WriteLine($"Виконується у потоці {Thread.CurrentThread.ManagedThreadId}");
    Console.WriteLine($"IsThreadPoolThread: {Thread.CurrentThread.IsThreadPoolThread}");
});

// Варіант 2: з параметром (object? state)
ThreadPool.QueueUserWorkItem(state =>
{
    var data = (string)state!;
    Console.WriteLine($"Отримано: {data}");
}, "Hello from ThreadPool");

// Варіант 3: з typed state (C# 9+, без boxing)
ThreadPool.QueueUserWorkItem(data =>
{
    Console.WriteLine($"Typed state: {data.Id}, {data.Name}");
}, new WorkData(42, "Task"), preferLocal: true);

record WorkData(int Id, string Name);

// Звичайний QueueUserWorkItem копіює ExecutionContext (AsyncLocal, SecurityContext тощо)
ThreadPool.QueueUserWorkItem(_ => DoWork());

// UnsafeQueueUserWorkItem НЕ копіює ExecutionContext — швидше, але небезпечно
ThreadPool.UnsafeQueueUserWorkItem(_ => DoWork(), null);

using System.Threading;

var signal = new ManualResetEvent(false);

// ❌ ПОГАНО: блокує worker thread
ThreadPool.QueueUserWorkItem(_ =>
{
    signal.WaitOne();  // потік простоює!
    Console.WriteLine("Signal received");
});

// ✅ ДОБРЕ: не блокує потік
var registration = ThreadPool.RegisterWaitForSingleObject(
    waitObject: signal,
    callbackMethod: (state, timedOut) =>
    {
        if (!timedOut)
            Console.WriteLine("Signal received efficiently!");
    },
    state: null,
    timeout: TimeSpan.FromSeconds(30),
    executeOnlyOnce: true
);

// Через 5 секунд подаємо сигнал
Thread.Sleep(5000);
signal.Set();

// Cleanup
registration.Unregister(signal);

using System.Threading;

// AsyncLocal<T> — thread-local змінна що flow через ExecutionContext
var requestId = new AsyncLocal<string>();
requestId.Value = "REQ-12345";

Console.WriteLine($"Main thread: {requestId.Value}");

ThreadPool.QueueUserWorkItem(_ =>
{
    // ExecutionContext скопійовано → requestId доступний!
    Console.WriteLine($"Worker thread: {requestId.Value}");

    requestId.Value = "REQ-99999";  // зміна НЕ впливає на Main thread
});

Thread.Sleep(100);
Console.WriteLine($"Main thread after: {requestId.Value}");  // досі REQ-12345

// ❌ АНТИПАТЕРН: блокування worker threads
for (int i = 0; i < 100; i++)
{
    ThreadPool.QueueUserWorkItem(_ =>
    {
        // Блокуємо потік на 10 секунд!
        Thread.Sleep(10_000);
    });
}

// Ця задача НЕ виконається одразу — всі потоки зайняті Sleep!
ThreadPool.QueueUserWorkItem(_ =>
{
    Console.WriteLine("Нарешті виконалось!");
});

// ❌ ПОГАНО: довга задача у ThreadPool
ThreadPool.QueueUserWorkItem(_ =>
{
    while (true)  // нескінченний цикл!
    {
        ProcessMessages();
        Thread.Sleep(100);
    }
});

// ✅ ДОБРЕ: окремий потік для довгої задачі
var task = Task.Factory.StartNew(() =>
{
    while (!cancellationToken.IsCancellationRequested)
    {
        ProcessMessages();
        Thread.Sleep(100);
    }
}, TaskCreationOptions.LongRunning);  // створює окремий Thread!

// Поточна кількість потоків
ThreadPool.GetAvailableThreads(out int availableWorker, out int availableIOCP);
ThreadPool.GetMaxThreads(out int maxWorker, out int maxIOCP);

int busyWorker = maxWorker - availableWorker;
int busyIOCP = maxIOCP - availableIOCP;

Console.WriteLine($"Worker threads: {busyWorker}/{maxWorker} busy");
Console.WriteLine($"IOCP threads:   {busyIOCP}/{maxIOCP} busy");

// Кількість задач у черзі (C# 11+)
long pending = ThreadPool.PendingWorkItemCount;
Console.WriteLine($"Pending work items: {pending}");

// Кількість завершених задач (lifetime counter)
long completed = ThreadPool.CompletedWorkItemCount;
Console.WriteLine($"Completed work items: {completed}");

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Threading;

public class ParallelFileScanner
{
    private readonly ConcurrentBag<string> _results = new();
    private long _filesScanned = 0;
    private long _directoriesScanned = 0;

    public void ScanDirectory(string rootPath, string searchPattern)
    {
        var countdown = new CountdownEvent(1);  // Починаємо з 1 (root)

        ScanDirectoryRecursive(rootPath, searchPattern, countdown);

        countdown.Signal();  // Знімаємо початковий 1
        countdown.Wait();    // Чекаємо завершення всіх задач

        Console.WriteLine($"Scan complete:");
        Console.WriteLine($"  Files scanned: {_filesScanned:N0}");
        Console.WriteLine($"  Directories scanned: {_directoriesScanned:N0}");
        Console.WriteLine($"  Matches found: {_results.Count:N0}");
    }

    private void ScanDirectoryRecursive(string path, string pattern, CountdownEvent countdown)
    {
        try
        {
            // Сканування файлів у поточній директорії
            var files = Directory.GetFiles(path, pattern);
            Interlocked.Add(ref _filesScanned, files.Length);

            foreach (var file in files)
            {
                _results.Add(file);
            }

            // Рекурсивне сканування піддиректорій (паралельно!)
            var directories = Directory.GetDirectories(path);
            Interlocked.Add(ref _directoriesScanned, directories.Length);

            foreach (var dir in directories)
            {
                countdown.AddCount();  // Додаємо задачу

                // Кожна піддиректорія сканується у окремій ThreadPool задачі
                ThreadPool.QueueUserWorkItem(_ =>
                {
                    try
                    {
                        ScanDirectoryRecursive(dir, pattern, countdown);
                    }
                    finally
                    {
                        countdown.Signal();  // Завершили задачу
                    }
                });
            }
        }
        catch (UnauthorizedAccessException)
        {
            // Пропускаємо директорії без доступу
        }
    }

    public IReadOnlyCollection<string> Results => _results.ToArray();
}

// Використання:
var scanner = new ParallelFileScanner();
var sw = System.Diagnostics.Stopwatch.StartNew();

scanner.ScanDirectory(@"C:\Windows", "*.dll");

sw.Stop();
Console.WriteLine($"Time: {sw.ElapsedMilliseconds}ms");
Console.WriteLine($"\nFirst 10 matches:");
foreach (var file in scanner.Results.Take(10))
{
    Console.WriteLine($"  {file}");
}

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

public class SimpleConnectionPool<TConnection> where TConnection : class, IDisposable
{
    private readonly ConcurrentBag<TConnection> _connections = new();
    private readonly Func<TConnection> _connectionFactory;
    private readonly int _maxConnections;
    private int _currentCount = 0;

    public SimpleConnectionPool(Func<TConnection> factory, int maxConnections)
    {
        _connectionFactory = factory;
        _maxConnections = maxConnections;
    }

    public TConnection Acquire()
    {
        // Спроба взяти існуюче з'єднання
        if (_connections.TryTake(out var connection))
        {
            return connection;
        }

        // Немає вільних — створюємо нове (якщо не досягли ліміту)
        if (Interlocked.Increment(ref _currentCount) <= _maxConnections)
        {
            return _connectionFactory();
        }

        // Досягли ліміту — чекаємо поки хтось поверне з'єднання
        Interlocked.Decrement(ref _currentCount);

        SpinWait spinner = new SpinWait();
        while (!_connections.TryTake(out connection))
        {
            spinner.SpinOnce();
        }

        return connection;
    }

    public void Release(TConnection connection)
    {
        _connections.Add(connection);
    }

    public int AvailableConnections => _connections.Count;
    public int TotalConnections => _currentCount;
}

// Демонстрація: 100 потоків конкурують за 10 з'єднань
public class FakeConnection : IDisposable
{
    public int Id { get; }
    public FakeConnection(int id) => Id = id;
    public void Dispose() { }
}

var pool = new SimpleConnectionPool<FakeConnection>(
    factory: () => new FakeConnection(Random.Shared.Next(1000)),
    maxConnections: 10
);

var countdown = new CountdownEvent(100);

for (int i = 0; i < 100; i++)
{
    int taskId = i;
    ThreadPool.QueueUserWorkItem(_ =>
    {
        try
        {
            var conn = pool.Acquire();
            Console.WriteLine($"[Task {taskId}] Got connection {conn.Id}");

            // Симуляція роботи
            Thread.Sleep(Random.Shared.Next(50, 200));

            pool.Release(conn);
            Console.WriteLine($"[Task {taskId}] Released connection {conn.Id}");
        }
        finally
        {
            countdown.Signal();
        }
    });
}

countdown.Wait();
Console.WriteLine($"\nPool stats:");
Console.WriteLine($"  Total connections created: {pool.TotalConnections}");
Console.WriteLine($"  Available connections: {pool.AvailableConnections}");

using System;
using System.Collections.Concurrent;
using System.Threading;

public class BackgroundTaskProcessor<T>
{
    private readonly ConcurrentQueue<T> _queue = new();
    private readonly Action<T> _processor;
    private readonly CancellationTokenSource _cts = new();
    private int _isProcessing = 0;

    public BackgroundTaskProcessor(Action<T> processor)
    {
        _processor = processor;
    }

    public void Enqueue(T item)
    {
        _queue.Enqueue(item);

        // Запускаємо обробку якщо ще не запущена
        if (Interlocked.CompareExchange(ref _isProcessing, 1, 0) == 0)
        {
            ThreadPool.QueueUserWorkItem(_ => ProcessQueue());
        }
    }

    private void ProcessQueue()
    {
        try
        {
            while (!_cts.Token.IsCancellationRequested)
            {
                if (_queue.TryDequeue(out var item))
                {
                    try
                    {
                        _processor(item);
                    }
                    catch (Exception ex)
                    {
                        Console.Error.WriteLine($"Error processing item: {ex.Message}");
                    }
                }
                else
                {
                    // Черга порожня — зупиняємо обробку
                    Interlocked.Exchange(ref _isProcessing, 0);

                    // Double-check: можливо хтось додав елемент між TryDequeue та Exchange
                    if (!_queue.IsEmpty && Interlocked.CompareExchange(ref _isProcessing, 1, 0) == 0)
                    {
                        continue;  // Продовжуємо обробку
                    }

                    break;  // Справді порожня — виходимо
                }
            }
        }
        finally
        {
            Interlocked.Exchange(ref _isProcessing, 0);
        }
    }

    public void Stop()
    {
        _cts.Cancel();
    }

    public int QueueLength => _queue.Count;
}

// Використання: фонова обробка логів
var processor = new BackgroundTaskProcessor<string>(log =>
{
    Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] {log}");
    Thread.Sleep(50);  // Симуляція запису у файл
});

// 1000 потоків генерують логи
Parallel.For(0, 1000, i =>
{
    processor.Enqueue($"Log message #{i} from thread {Thread.CurrentThread.ManagedThreadId}");
});

// Чекаємо поки черга спорожніє
while (processor.QueueLength > 0)
{
    Thread.Sleep(100);
}

processor.Stop();