using System.Diagnostics;

// Спосіб 1: Поточний процес — найшвидший, без системних викликів
Process current = Process.GetCurrentProcess();

// Спосіб 2: Всі процеси на локальній машині
// Увага: може зайняти 100-300ms при великій кількості процесів
Process[] all = Process.GetProcesses();

// Спосіб 3: Пошук за іменем (повертає масив — може бути кілька примірників)
// Ім'я без розширення, case-insensitive на Windows
Process[] chromes = Process.GetProcessesByName("chrome");
Process[] dotnetProcs = Process.GetProcessesByName("dotnet");

// Спосіб 4: За конкретним PID — викидає ArgumentException якщо не знайдено
try
{
    Process specific = Process.GetProcessById(1234);
}
catch (ArgumentException)
{
    Console.WriteLine("Процес з таким PID не знайдено або вже завершився");
}

// Важливо: Process реалізує IDisposable
// Клас тримає native handle на процес — завжди використовуйте using
using var p = Process.GetCurrentProcess();

using System.Diagnostics;

static string FormatBytes(long bytes)
{
    return bytes switch
    {
        >= 1_073_741_824 => $"{bytes / 1_073_741_824.0:F1} GB",
        >= 1_048_576     => $"{bytes / 1_048_576.0:F1} MB",
        >= 1_024         => $"{bytes / 1_024.0:F1} KB",
        _                => $"{bytes} B"
    };
}

// Отримуємо всі процеси, сортуємо за WorkingSet
var processes = Process.GetProcesses()
    .OrderByDescending(p =>
    {
        try { return p.WorkingSet64; }
        catch { return 0L; } // UnauthorizedAccessException для деяких системних процесів
    })
    .Take(20);

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine($"{"PID",-8} {"Назва",-25} {"RAM",-12} {"CPU (s)",-10} {"Потоки",-8} {"Handles",-8}");
Console.WriteLine(new string('─', 75));

foreach (var p in processes)
{
    try
    {
        var cpuSeconds = p.TotalProcessorTime.TotalSeconds;
        Console.WriteLine(
            $"{p.Id,-8} " +
            $"{p.ProcessName[..Math.Min(24, p.ProcessName.Length)],-25} " +
            $"{FormatBytes(p.WorkingSet64),-12} " +
            $"{cpuSeconds,-10:F1} " +
            $"{p.Threads.Count,-8} " +
            $"{p.HandleCount,-8}");
    }
    catch
    {
        // Системні процеси (System, Idle) можуть мати обмежений доступ
        Console.WriteLine($"{p.Id,-8} {p.ProcessName,-25} {"<обмежений доступ>"}");
    }
    finally
    {
        p.Dispose();
    }
}

using System.Diagnostics;

// Сценарій 1: Відкрити URL у браузері (UseShellExecute = true)
var openBrowser = new ProcessStartInfo
{
    FileName = "https://docs.microsoft.com",
    UseShellExecute = true  // обов'язково для URL
};
Process.Start(openBrowser);

// Сценарій 2: Відкрити файл у відповідній програмі
var openDoc = new ProcessStartInfo
{
    FileName = @"C:\report.docx",
    UseShellExecute = true,
    Verb = "open"  // або "print", "edit" — залежить від асоціації файлу
};
Process.Start(openDoc);

// Сценарій 3: Запуск з правами адміністратора
var runAsAdmin = new ProcessStartInfo
{
    FileName = "notepad.exe",
    Arguments = @"C:\Windows\System32\drivers\etc\hosts",
    UseShellExecute = true,
    Verb = "runas"  // ініціює UAC prompt
};
// Process.Start(runAsAdmin);

// Сценарій 4: Програмна взаємодія (UseShellExecute = false обов'язково!)
var psi = new ProcessStartInfo
{
    FileName = "git",                              // команда у PATH
    Arguments = "log --oneline -10",
    UseShellExecute = false,
    RedirectStandardOutput = true,                 // читаємо stdout програмно
    RedirectStandardError = true,                  // читаємо stderr
    WorkingDirectory = @"C:\MyProject",            // де виконувати команду
    CreateNoWindow = true                          // без зайвого консольного вікна
};

using System.Diagnostics;

// ❌ НЕБЕЗПЕЧНО: синхронне послідовне читання stdout потім stderr!
// Якщо процес генерує багато stderr, буфер ПЕРЕПОВНИТЬСЯ і виникне deadlock
static string RunCommandUnsafe(string command, string arguments)
{
    using var process = new Process();
    process.StartInfo = new ProcessStartInfo
    {
        FileName = command,
        Arguments = arguments,
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        CreateNoWindow = true
    };

    process.Start();

    // DEADLOCK RISK: якщо stderr переповниться, процес чекає — а ми чекаємо stdout
    string stdout = process.StandardOutput.ReadToEnd();   // блокуємо тут...
    string stderr = process.StandardError.ReadToEnd();     // ...ніколи не доходимо

    process.WaitForExit();
    return stdout;
}

// ✅ ПРАВИЛЬНО: async паралельне читання обох потоків
static async Task<(string Output, string Error, int ExitCode)> RunCommandAsync(
    string command, string arguments, CancellationToken ct = default)
{
    using var process = new Process();
    process.StartInfo = new ProcessStartInfo
    {
        FileName = command,
        Arguments = arguments,
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        CreateNoWindow = true
    };

    process.Start();

    // Запускаємо читання stdout і stderr паралельно,
    // що унеможливлює deadlock від переповнення буфера
    Task<string> outputTask = process.StandardOutput.ReadToEndAsync(ct);
    Task<string> errorTask  = process.StandardError.ReadToEndAsync(ct);

    await process.WaitForExitAsync(ct);

    string output = await outputTask;
    string error  = await errorTask;

    return (output, error, process.ExitCode);
}

// Використання
var (output, error, code) = await RunCommandAsync("git", "log --oneline -5");
Console.WriteLine($"Exit: {code}");
Console.WriteLine(output);
if (!string.IsNullOrEmpty(error))
    Console.Error.WriteLine($"Errors:\n{error}");

using System.Diagnostics;

static async Task<int> RunWithStreamingOutputAsync(
    string command,
    string arguments,
    Action<string>? onOutput = null,
    Action<string>? onError = null,
    CancellationToken ct = default)
{
    using var process = new Process();

    process.StartInfo = new ProcessStartInfo
    {
        FileName = command,
        Arguments = arguments,
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        CreateNoWindow = true
    };

    // Підписуємося на події ДО виклику Start()
    process.OutputDataReceived += (_, e) =>
    {
        if (e.Data is not null)
            onOutput?.Invoke(e.Data);
    };

    process.ErrorDataReceived += (_, e) =>
    {
        if (e.Data is not null)
            onError?.Invoke(e.Data);
    };

    process.Start();

    // Активуємо асинхронне читання — тепер події будуть вогнем
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();

    await process.WaitForExitAsync(ct);

    // WaitForExitAsync без аргументу (або з CT) для BeginOutputReadLine
    // правильно чекатиме дочитування буферів після завершення процесу
    return process.ExitCode;
}

// Приклад: запуск dotnet test з живим виводом
int exitCode = await RunWithStreamingOutputAsync(
    command: "dotnet",
    arguments: "test ./MyTests/ --verbosity normal",
    onOutput: line =>
    {
        // Підфарбовуємо рядки за змістом
        if (line.Contains("PASSED"))
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine($"  ✓ {line}");
        }
        else if (line.Contains("FAILED"))
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"  ✗ {line}");
        }
        else
        {
            Console.ResetColor();
            Console.WriteLine($"  {line}");
        }
        Console.ResetColor();
    },
    onError: line => Console.Error.WriteLine($"ERR: {line}")
);

Console.WriteLine($"\nExit code: {exitCode}");

using System.Diagnostics;

static async Task GracefulShutdownAsync(Process process, int gracePeriodMs = 5000)
{
    // Спочатку пробуємо graceful shutdown
    bool hasClosed = process.CloseMainWindow();

    if (!hasClosed)
    {
        // Немає головного вікна — для консольних застосунків можна надіслати Ctrl+C через stdin
        // Або одразу переходити до Kill()
        Console.WriteLine("Немає вікна — примусовий Kill");
        process.Kill(entireProcessTree: true);
        return;
    }

    // Чекаємо грейс-period на самостійне завершення
    using var cts = new CancellationTokenSource(gracePeriodMs);
    try
    {
        await process.WaitForExitAsync(cts.Token);
        Console.WriteLine($"Процес завершився сам. ExitCode={process.ExitCode}");
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"Не завершився за {gracePeriodMs}ms — примусово вбиваємо");
        if (!process.HasExited)
            process.Kill(entireProcessTree: true);
    }
}

// Реакція на завершення через подію (не блокує потік)
process.EnableRaisingEvents = true;
process.Exited += (sender, _) =>
{
    var p = (Process)sender!;
    Console.WriteLine($"Процес {p.ProcessName} (PID={p.Id}) завершився. Code={p.ExitCode}");
};

using System.Diagnostics;

// Імітуємо введення даних до інтерактивної програми
static async Task RunInteractiveAsync()
{
    using var process = new Process();
    process.StartInfo = new ProcessStartInfo
    {
        FileName = "powershell",
        Arguments = "-NoLogo -NoProfile -NonInteractive",
        UseShellExecute = false,
        RedirectStandardInput = true,   // будемо "вводити" команди програмно
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        CreateNoWindow = true
    };

    process.Start();

    Task<string> outputTask = process.StandardOutput.ReadToEndAsync();
    Task<string> errorTask  = process.StandardError.ReadToEndAsync();

    // Пишемо команди у stdin PowerShell
    await process.StandardInput.WriteLineAsync("Get-Date");
    await process.StandardInput.WriteLineAsync("$env:USERNAME");
    await process.StandardInput.WriteLineAsync("exit");
    process.StandardInput.Close();  // сигналізуємо EOF — PowerShell завершиться

    await process.WaitForExitAsync();

    Console.WriteLine(await outputTask);
}