using System.Diagnostics;

static long ComputePrimes(long upTo)
{
    long count = 0;
    for (long n = 2; n <= upTo; n++)
    {
        bool isPrime = true;
        for (long d = 2; d * d <= n; d++)
        {
            if (n % d == 0) { isPrime = false; break; }
        }
        if (isPrime) count++;
    }
    return count;
}

Console.WriteLine("Починаємо підрахунок простих чисел...");
Console.WriteLine("Спробуйте ввести текст під час обчислення:");

var sw = Stopwatch.StartNew();

// ❌ Цей виклик блокує головний потік (і весь застосунок) на ~10 секунд
long result = ComputePrimes(5_000_000);

sw.Stop();
Console.WriteLine($"Результат: {result} простих чисел за {sw.ElapsedMilliseconds}ms");

using System.Threading;

// Варіант 1: іменований метод
static void Worker()
{
    Console.WriteLine($"ThreadStart: Thread ID = {Thread.CurrentThread.ManagedThreadId}");
}

var t1 = new Thread(new ThreadStart(Worker));
t1.Start();

// Варіант 2: анонімний метод
var t2 = new Thread(new ThreadStart(delegate
{
    Console.WriteLine("Anonymous ThreadStart");
}));
t2.Start();

// Варіант 3: lambda (найпоширеніший у сучасному коді)
var t3 = new Thread(() => Console.WriteLine("Lambda ThreadStart"));
t3.Start();

// Конструктор приймає ThreadStart — можна опустити явне створення делегату
var t4 = new Thread(Worker);  // автоматичне перетворення method group
t4.Start();

using System.Threading;

// ParameterizedThreadStart: приймає object? — потребує boxing/unboxing
static void ProcessItem(object? data)
{
    // Необхідний явний каст — ризик InvalidCastException
    var item = (WorkItem)data!;
    Console.WriteLine($"Обробляємо: {item.Id} у {Thread.CurrentThread.ManagedThreadId}");
}

record WorkItem(int Id, string Payload);

var thread = new Thread(new ParameterizedThreadStart(ProcessItem));
thread.Start(new WorkItem(42, "SomeData"));  // параметр передається у Start()

using System.Threading;

// Типізовані змінні — без boxing, без каста
string userName = "Alice";
int taskId = 100;
DateTime startTime = DateTime.UtcNow;

var thread = new Thread(() =>
{
    // userName, taskId, startTime "захоплені" closure — повністю типобезпечно
    Console.WriteLine($"[Thread {Thread.CurrentThread.ManagedThreadId}] " +
                      $"User={userName}, Task={taskId}, Started={startTime:HH:mm:ss}");
});

thread.Name = $"Worker-for-task-{taskId}";  // ім'я для debugging
thread.Start();

using System.Threading;

Console.WriteLine("=== ❌ НЕПРАВИЛЬНО: Closure Pitfall ===");
for (int i = 0; i < 5; i++)
{
    // Lambda захоплює ПОСИЛАННЯ на 'i', не поточне значення
    // На момент виконання потоку 'i' вже може бути 5
    var thread = new Thread(() => Console.Write($"{i} "));
    thread.Start();
}

Thread.Sleep(100);  // чекаємо завершення
Console.WriteLine("\nОчікували: 0 1 2 3 4");
Console.WriteLine("Отримали: 5 5 5 5 5 (або будь-яку комбінацію)");

Console.WriteLine("\n=== ✅ ПРАВИЛЬНО: Копіюємо значення ===");
for (int i = 0; i < 5; i++)
{
    int captured = i;  // нова змінна на КОЖНІЙ ітерації
    // Тепер lambda захоплює 'captured' — окрему копію для кожного i
    var thread = new Thread(() => Console.Write($"{captured} "));
    thread.Start();
}

Thread.Sleep(100);
Console.WriteLine("\nКожне значення рівно раз (порядок може відрізнятись)");

using System.Threading;
using System.Diagnostics;

long result = 0;
Exception? caughtException = null;

var thread = new Thread(() =>
{
    try
    {
        result = ComputePrimes(5_000_000);  // пишемо з дочірнього потоку
    }
    catch (Exception ex)
    {
        caughtException = ex;  // зберігаємо виключення для головного потоку
    }
});

thread.Start();

// Головний потік може виконувати інші дії поки потік обчислює
Console.WriteLine("Головний потік: виконуємо паралельну роботу...");
DoSomeOtherWork();

thread.Join();  // чекаємо завершення → після цього 'result' safe to read

if (caughtException is not null)
    throw new Exception("Worker failed", caughtException);

Console.WriteLine($"Результат: {result}");

// Тільки після Join() гарантовано видно зміни з іншого потоку
// (happens-before relationship встановлено через Join())

class ComputationResult
{
    public long Value { get; set; }
    public TimeSpan Duration { get; set; }
    public Exception? Error { get; set; }
    public bool IsCompleted { get; set; }
}

var container = new ComputationResult();

var thread = new Thread(() =>
{
    var sw = Stopwatch.StartNew();
    try
    {
        container.Value = ComputePrimes(5_000_000);
        container.IsCompleted = true;
    }
    catch (Exception ex)
    {
        container.Error = ex;
    }
    finally
    {
        container.Duration = sw.Elapsed;
    }
});

thread.Start();
thread.Join();

if (!container.IsCompleted)
    Console.WriteLine($"Помилка: {container.Error?.Message}");
else
    Console.WriteLine($"Результат: {container.Value} за {container.Duration.TotalSeconds:F2}s");

var thread = new Thread(() => Thread.Sleep(10_000));  // довгий потік
thread.Start();

// Варіант 1: Join без аргументів — чекаємо нескінченно
// ОБЕРЕЖНО: може заблокувати назавжди якщо потік зависне
thread.Join();

// Варіант 2: Join з таймаутом — повертає false якщо потік ще живий
bool completed = thread.Join(millisecondsTimeout: 3000);
if (!completed)
    Console.WriteLine("Потік досі виконується після 3 секунд");

// Варіант 3: Join з TimeSpan
bool done = thread.Join(TimeSpan.FromSeconds(5));

// Thread.Sleep(ms) — призупиняє поточний потік
// ОС переводить потік у WaitSleepJoin стан і знімає з CPU
Thread.Sleep(500);                       // 500ms
Thread.Sleep(TimeSpan.FromSeconds(1.5)); // 1.5 секунди

// Thread.Sleep(0) — спеціальний: звільняє поточний квант
// але лише для потоків ТАКОГО Ж або ВИЩОГО пріоритету
Thread.Sleep(0);

// Thread.Yield() — звільняє квант для БУДЬ-ЯКОГО готового потоку
// більш "добровільний" варіант поступки процесорного часу
Thread.Yield();

// ВАЖЛИВО: Thread.Sleep НЕ є точним таймером!
// ОС планувальник може "прокинути" потік пізніше ніж зазначено
// через granularity (зазвичай ~15ms на Windows)
var sw = Stopwatch.StartNew();
Thread.Sleep(1);  // хочемо 1ms, отримаємо ~15ms!
Console.WriteLine($"Фактично: {sw.ElapsedMilliseconds}ms");

using System.Threading;

var foreground = new Thread(() =>
{
    Console.WriteLine("Foreground: стартував");
    Thread.Sleep(3000);
    Console.WriteLine("Foreground: завершив роботу (ВИКОНАЄТЬСЯ ЗАВЖДИ)");
});
// IsBackground за замовчуванням = false (foreground)

var background = new Thread(() =>
{
    Console.WriteLine("Background: стартував");
    Thread.Sleep(10_000);  // Спробує чекати 10 секунд
    Console.WriteLine("Background: завершив (МОЖЕ НЕ ВИКОНАТИСЬ)");
});
background.IsBackground = true;

foreground.Start();
background.Start();

Console.WriteLine("Main: завершую");
// Main thread завершується → Process продовжує жити (foreground thread живий)
// Через 3 секунди: foreground завершується → Process завершується
// Background thread вбивається після 3s, незважаючи на Sleep(10000)

using System.Threading;

// Іменування ДО Start()
var workerThread = new Thread(ProcessOrders)
{
    Name = "OrderProcessor",
    IsBackground = true,
    Priority = ThreadPriority.Normal
};

workerThread.Start();

// Thread ID (керований, не OS TID)
Console.WriteLine($"Managed ID: {workerThread.ManagedThreadId}");

// Головний потік
Thread.CurrentThread.Name = "MainThread";

// Виведення у debugger — ім'я буде видно у Threads Window (Ctrl+Alt+H у VS)
// Профайлери (dotnet-trace, PerfView) також показують імена

void ProcessOrders()
{
    Console.WriteLine($"[{Thread.CurrentThread.Name}] Починаємо обробку замовлень");

    for (int i = 0; i < 10; i++)
    {
        // Thread.CurrentThread доступний з будь-якого місця
        // ManagedThreadId стабільний протягом lifetime потоку
        Console.WriteLine($"[{Thread.CurrentThread.Name}#{Thread.CurrentThread.ManagedThreadId}] Замовлення {i}");
        Thread.Sleep(100);
    }
}