using System;
using System.Threading;

/// <summary>
/// Спрощена реалізація Work Stealing Queue.
/// Власник бере з кінця (LIFO), інші крадуть з початку (FIFO).
/// </summary>
public class WorkStealingQueue<T>
{
    private T[] _array = new T[32];
    private int _mask = 31;  // Для швидкого modulo через bitwise AND

    private volatile int _headIndex = 0;  // Для крадіїв (FIFO)
    private volatile int _tailIndex = 0;  // Для власника (LIFO)

    private readonly object _foreignLock = new();  // Тільки для крадіїв

    /// <summary>Додати задачу (викликає тільки власник).</summary>
    public void LocalPush(T item)
    {
        int tail = _tailIndex;

        // Перевірка чи потрібно розширити масив
        if (tail - _headIndex >= _mask)
        {
            lock (_foreignLock)
            {
                GrowArray();
            }
        }

        _array[tail & _mask] = item;
        _tailIndex = tail + 1;  // Publish нового tail
    }

    /// <summary>Забрати задачу (викликає тільки власник, LIFO).</summary>
    public bool LocalPop(out T? item)
    {
        int tail = _tailIndex - 1;
        Interlocked.Exchange(ref _tailIndex, tail);  // Atomic decrement

        if (_headIndex <= tail)
        {
            // Черга не порожня
            item = _array[tail & _mask];
            return true;
        }
        else
        {
            // Черга порожня або конфлікт з крадієм
            _tailIndex = tail + 1;  // Відкат
            item = default;
            return false;
        }
    }

    /// <summary>Вкрасти задачу (викликають інші потоки, FIFO).</summary>
    public bool TrySteal(out T? item)
    {
        lock (_foreignLock)  // Крадії синхронізуються між собою
        {
            int head = _headIndex;
            int tail = _tailIndex;

            if (head < tail)
            {
                // Є задачі для крадіжки
                item = _array[head & _mask];
                _headIndex = head + 1;  // Atomic increment
                return true;
            }

            item = default;
            return false;
        }
    }

    private void GrowArray()
    {
        int newSize = (_array.Length - 1) * 2 + 1;  // Подвоїти розмір
        var newArray = new T[newSize];

        int head = _headIndex;
        int tail = _tailIndex;

        for (int i = head; i < tail; i++)
        {
            newArray[i & (newSize - 1)] = _array[i & _mask];
        }

        _array = newArray;
        _mask = newSize - 1;
    }

    public int Count => Math.Max(0, _tailIndex - _headIndex);
}

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

/// <summary>
/// Спрощена реалізація ThreadPool для навчання.
/// Підтримує: динамічну кількість потоків, graceful shutdown, статистику.
/// </summary>
public class CustomThreadPool : IDisposable
{
    private readonly ConcurrentQueue<Action> _workQueue = new();
    private readonly List<Thread> _workers = new();
    private readonly ManualResetEventSlim _workAvailable = new(false);

    private readonly int _minThreads;
    private readonly int _maxThreads;
    private int _currentThreads = 0;

    private long _completedWorkItems = 0;
    private long _totalWorkItems = 0;

    private volatile bool _shutdown = false;

    public CustomThreadPool(int minThreads = 4, int maxThreads = 100)
    {
        _minThreads = minThreads;
        _maxThreads = maxThreads;

        // Створюємо мінімальну кількість потоків одразу
        for (int i = 0; i < _minThreads; i++)
        {
            CreateWorkerThread();
        }
    }

    /// <summary>Додати задачу у чергу.</summary>
    public void QueueUserWorkItem(Action work)
    {
        if (_shutdown)
            throw new InvalidOperationException("ThreadPool is shutting down");

        Interlocked.Increment(ref _totalWorkItems);
        _workQueue.Enqueue(work);
        _workAvailable.Set();  // Сигнал: є робота

        // Простий injection logic: якщо черга довга і є місце → додати потік
        if (_workQueue.Count > _currentThreads * 2 && _currentThreads < _maxThreads)
        {
            lock (_workers)
            {
                if (_currentThreads < _maxThreads)
                {
                    CreateWorkerThread();
                }
            }
        }
    }

    private void CreateWorkerThread()
    {
        var worker = new Thread(WorkerLoop)
        {
            IsBackground = true,
            Name = $"CustomThreadPool-Worker-{_currentThreads}"
        };

        _workers.Add(worker);
        Interlocked.Increment(ref _currentThreads);
        worker.Start();
    }

    private void WorkerLoop()
    {
        DateTime lastWorkTime = DateTime.UtcNow;

        while (!_shutdown)
        {
            if (_workQueue.TryDequeue(out var work))
            {
                try
                {
                    work();
                    Interlocked.Increment(ref _completedWorkItems);
                    lastWorkTime = DateTime.UtcNow;
                }
                catch (Exception ex)
                {
                    Console.Error.WriteLine($"Worker exception: {ex.Message}");
                }
            }
            else
            {
                // Немає роботи

                // Thread retirement: якщо не було роботи 30 секунд і потоків більше ніж min
                if (_currentThreads > _minThreads &&
                    (DateTime.UtcNow - lastWorkTime).TotalSeconds > 30)
                {
                    // Завершуємо цей потік
                    Interlocked.Decrement(ref _currentThreads);
                    return;
                }

                // Чекаємо на сигнал (з timeout для перевірки shutdown)
                _workAvailable.Wait(TimeSpan.FromSeconds(1));
                _workAvailable.Reset();
            }
        }
    }

    /// <summary>Graceful shutdown: чекаємо завершення всіх задач.</summary>
    public void Shutdown(TimeSpan timeout)
    {
        _shutdown = true;
        _workAvailable.Set();  // Розбудити всіх

        var deadline = DateTime.UtcNow + timeout;

        foreach (var worker in _workers)
        {
            var remaining = deadline - DateTime.UtcNow;
            if (remaining > TimeSpan.Zero)
            {
                worker.Join(remaining);
            }
        }
    }

    public void Dispose()
    {
        Shutdown(TimeSpan.FromSeconds(10));
        _workAvailable.Dispose();
    }

    // Статистика
    public int CurrentThreads => _currentThreads;
    public int QueueLength => _workQueue.Count;
    public long CompletedWorkItems => Interlocked.Read(ref _completedWorkItems);
    public long TotalWorkItems => Interlocked.Read(ref _totalWorkItems);
    public double CompletionRate => TotalWorkItems > 0
        ? CompletedWorkItems / (double)TotalWorkItems
        : 0;
}

using System;
using System.Diagnostics;
using System.Threading;

var pool = new CustomThreadPool(minThreads: 2, maxThreads: 10);

Console.WriteLine("=== Custom ThreadPool Demo ===\n");

// Моніторинг у фоні
var monitor = new Thread(() =>
{
    while (true)
    {
        Console.WriteLine($"[Monitor] Threads: {pool.CurrentThreads}, " +
                         $"Queue: {pool.QueueLength}, " +
                         $"Completed: {pool.CompletedWorkItems}/{pool.TotalWorkItems} " +
                         $"({pool.CompletionRate:P0})");
        Thread.Sleep(500);
    }
}) { IsBackground = true };
monitor.Start();

// Тест 1: Раптовий сплеск навантаження
Console.WriteLine("Test 1: Burst of 1000 tasks...");
var sw = Stopwatch.StartNew();

for (int i = 0; i < 1000; i++)
{
    int taskId = i;
    pool.QueueUserWorkItem(() =>
    {
        Thread.Sleep(Random.Shared.Next(10, 50));  // Симуляція роботи
    });
}

// Чекаємо завершення
while (pool.CompletedWorkItems < 1000)
{
    Thread.Sleep(100);
}

sw.Stop();
Console.WriteLine($"Completed in {sw.ElapsedMilliseconds}ms\n");

// Тест 2: Тривале навантаження
Console.WriteLine("Test 2: Sustained load for 10 seconds...");
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));

int submitted = 0;
while (!cts.Token.IsCancellationRequested)
{
    pool.QueueUserWorkItem(() =>
    {
        Thread.Sleep(Random.Shared.Next(5, 20));
    });
    submitted++;
    Thread.Sleep(10);
}

Console.WriteLine($"Submitted {submitted} tasks during sustained load\n");

// Cleanup
Thread.Sleep(2000);  // Дати час завершити
pool.Dispose();

Console.WriteLine("=== Demo Complete ===");

using System;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;

// Сервер що обслуговує багато клієнтів

// ❌ Blocking I/O: один потік на клієнта
class BlockingServer
{
    public void Start(int port)
    {
        var listener = new TcpListener(IPAddress.Any, port);
        listener.Start();

        while (true)
        {
            var client = listener.AcceptTcpClient();  // Блокує

            // Новий потік для кожного клієнта!
            new Thread(() => HandleClient(client)) { IsBackground = true }.Start();
        }
    }

    private void HandleClient(TcpClient client)
    {
        var stream = client.GetStream();
        byte[] buffer = new byte[1024];

        while (true)
        {
            int read = stream.Read(buffer, 0, buffer.Length);  // Блокує потік!
            if (read == 0) break;

            stream.Write(buffer, 0, read);  // Echo назад
        }
    }
}

// ✅ IOCP: async/await
class IOCPServer
{
    public async Task StartAsync(int port)
    {
        var listener = new TcpListener(IPAddress.Any, port);
        listener.Start();

        while (true)
        {
            var client = await listener.AcceptTcpClientAsync();  // Async

            // Не створюємо потік — просто запускаємо Task
            _ = HandleClientAsync(client);
        }
    }

    private async Task HandleClientAsync(TcpClient client)
    {
        var stream = client.GetStream();
        byte[] buffer = new byte[1024];

        while (true)
        {
            int read = await stream.ReadAsync(buffer);  // НЕ блокує потік!
            if (read == 0) break;

            await stream.WriteAsync(buffer.AsMemory(0, read));  // Echo назад
        }
    }
}

// Результати для 10,000 одночасних клієнтів:
// Blocking: 10,000 потоків, ~10GB RAM, CPU 100% (context switching)
// IOCP:     ~20 потоків, ~200MB RAM, CPU 5% (ефективно!)

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

public enum Priority { Low, Normal, High }

public class PriorityThreadPool
{
    private readonly SortedDictionary<Priority, Queue<Action>> _queues = new()
    {
        { Priority.High, new Queue<Action>() },
        { Priority.Normal, new Queue<Action>() },
        { Priority.Low, new Queue<Action>() }
    };

    private readonly object _lock = new();
    private readonly ManualResetEventSlim _workAvailable = new(false);
    private volatile bool _shutdown = false;

    public PriorityThreadPool(int workerCount = 4)
    {
        for (int i = 0; i < workerCount; i++)
        {
            ThreadPool.QueueUserWorkItem(_ => WorkerLoop());
        }
    }

    public void Enqueue(Action work, Priority priority = Priority.Normal)
    {
        lock (_lock)
        {
            _queues[priority].Enqueue(work);
            _workAvailable.Set();
        }
    }

    private void WorkerLoop()
    {
        while (!_shutdown)
        {
            Action? work = null;

            lock (_lock)
            {
                // Шукаємо задачу з найвищим пріоритетом
                foreach (var priority in new[] { Priority.High, Priority.Normal, Priority.Low })
                {
                    if (_queues[priority].Count > 0)
                    {
                        work = _queues[priority].Dequeue();
                        break;
                    }
                }
            }

            if (work != null)
            {
                work();
            }
            else
            {
                _workAvailable.Wait(TimeSpan.FromSeconds(1));
                _workAvailable.Reset();
            }
        }
    }

    public void Shutdown() => _shutdown = true;
}

using System;
using System.Threading;

public class RateLimitedThreadPool
{
    private readonly SemaphoreSlim _semaphore;
    private readonly int _maxConcurrent;

    public RateLimitedThreadPool(int maxConcurrent)
    {
        _maxConcurrent = maxConcurrent;
        _semaphore = new SemaphoreSlim(maxConcurrent, maxConcurrent);
    }

    public async Task ExecuteAsync(Func<Task> work)
    {
        await _semaphore.WaitAsync();

        try
        {
            await work();
        }
        finally
        {
            _semaphore.Release();
        }
    }

    public int AvailableSlots => _semaphore.CurrentCount;
}

// Використання: обмежити до 5 concurrent HTTP requests
var rateLimiter = new RateLimitedThreadPool(maxConcurrent: 5);

var tasks = Enumerable.Range(0, 100).Select(i =>
    rateLimiter.ExecuteAsync(async () =>
    {
        await httpClient.GetStringAsync($"https://api.example.com/item/{i}");
    })
);

await Task.WhenAll(tasks);
// Максимум 5 requests одночасно, решта чекають

using System;
using System.Threading;

public class CircuitBreaker
{
    private enum State { Closed, Open, HalfOpen }

    private State _state = State.Closed;
    private int _failureCount = 0;
    private DateTime _lastFailureTime;

    private readonly int _failureThreshold;
    private readonly TimeSpan _timeout;
    private readonly object _lock = new();

    public CircuitBreaker(int failureThreshold = 5, TimeSpan? timeout = null)
    {
        _failureThreshold = failureThreshold;
        _timeout = timeout ?? TimeSpan.FromSeconds(60);
    }

    public async Task<T> ExecuteAsync<T>(Func<Task<T>> operation)
    {
        lock (_lock)
        {
            if (_state == State.Open)
            {
                if (DateTime.UtcNow - _lastFailureTime > _timeout)
                {
                    _state = State.HalfOpen;
                }
                else
                {
                    throw new InvalidOperationException("Circuit breaker is OPEN");
                }
            }
        }

        try
        {
            var result = await operation();

            lock (_lock)
            {
                _failureCount = 0;
                _state = State.Closed;
            }

            return result;
        }
        catch
        {
            lock (_lock)
            {
                _failureCount++;
                _lastFailureTime = DateTime.UtcNow;

                if (_failureCount >= _failureThreshold)
                {
                    _state = State.Open;
                }
            }

            throw;
        }
    }

    public string CurrentState => _state.ToString();
}