Program.cs

using System.ComponentModel;
using System.Diagnostics;
using System.Management;
using System.Runtime.InteropServices;
using System.Text;

#region Native Clipboard for Windows
internal static class WinClipboard
{
    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr OpenClipboard(IntPtr hWndNewOwner);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool EmptyClipboard();

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr SetClipboardData(uint uFormat, IntPtr hMem);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool CloseClipboard();

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr GlobalAlloc(uint uFlags, UIntPtr dwBytes);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr GlobalLock(IntPtr hMem);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool GlobalUnlock(IntPtr hMem);

    private const uint CF_UNICODETEXT = 13;
    private const uint GMEM_MOVEABLE = 2;

    public static void SetText(string text)
    {
        if (OpenClipboard(IntPtr.Zero) == IntPtr.Zero)
            throw new Win32Exception(Marshal.GetLastWin32Error());

        try
        {
            if (!EmptyClipboard())
                throw new Win32Exception(Marshal.GetLastWin32Error());

            // Allocate global memory for Unicode text
            int size = (text.Length + 1) * 2;
            IntPtr hGlobal = GlobalAlloc(GMEM_MOVEABLE, (UIntPtr)size);
            if (hGlobal == IntPtr.Zero)
                throw new OutOfMemoryException("GlobalAlloc failed.");

            IntPtr pLocked = GlobalLock(hGlobal);
            try
            {
                Marshal.Copy(text.ToCharArray(), 0, pLocked, text.Length);
                // Null-terminate
                Marshal.WriteInt16(pLocked + text.Length * 2, 0);
            }
            finally
            {
                GlobalUnlock(hGlobal);
            }

            if (SetClipboardData(CF_UNICODETEXT, hGlobal) == IntPtr.Zero)
                throw new Win32Exception(Marshal.GetLastWin32Error());

            hGlobal = IntPtr.Zero; // system now owns memory
        }
        finally
        {
            CloseClipboard();
        }
    }
}
#endregion

#region Clipboard abstraction
internal static class ClipboardHelper
{
    public static async Task SetTextAsync(string text)
    {
        if (OperatingSystem.IsWindows())
        {
            // Must be called from STA thread, which our Main has
            try
            {
                WinClipboard.SetText(text);
            }
            catch (Exception ex)
            {
                string filePath = Path.Combine(AppContext.BaseDirectory, "ndebugner_report.txt");
                await File.WriteAllTextAsync(filePath, text);
                Console.Error.WriteLine($"Clipboard failed: {ex.Message}. Report saved to {filePath}");
            }
        }
        else if (OperatingSystem.IsLinux())
        {
            bool copied = false;
            // Try xclip first (X11)
            copied = await TryLinuxClipboardAsync("xclip", text, "-selection", "clipboard");
            // Fallback to wl-copy (Wayland)
            if (!copied)
                copied = await TryLinuxClipboardAsync("wl-copy", text);
            if (!copied)
            {
                string filePath = Path.Combine(Directory.GetCurrentDirectory(), "ndebugner_report.txt");
                await File.WriteAllTextAsync(filePath, text);
                Console.Error.WriteLine($"Clipboard tools not available. Report saved to {filePath}");
            }
        }
        else
        {
            throw new PlatformNotSupportedException("Clipboard access is only supported on Windows and Linux.");
        }
    }

    private static async Task<bool> TryLinuxClipboardAsync(string command, string text, params string[] args)
    {
        try
        {
            using var proc = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = command,
                    RedirectStandardInput = true,
                    RedirectStandardError = true,
                    UseShellExecute = false,
                    CreateNoWindow = true
                }
            };
            // Build argument list
            foreach (var arg in args)
                proc.StartInfo.ArgumentList.Add(arg);

            proc.Start();
            // Write text to stdin
            using (var writer = proc.StandardInput)
            {
                await writer.WriteAsync(text);
            }
            await proc.WaitForExitAsync();
            return proc.ExitCode == 0;
        }
        catch
        {
            return false;
        }
    }
}
#endregion

#region Platform-specific information collectors
internal interface IHardwareInfoCollector
{
    Task<string> GatherAllAsync();
}

internal sealed class WindowsCollector : IHardwareInfoCollector
{
    public async Task<string> GatherAllAsync()
    {
        var sb = new StringBuilder();
        sb.AppendLine("=== N-Debugner System Report (Windows) ===");
        sb.AppendLine();

        await Task.Run(() =>
        {
            AppendOsInfo(sb);
            AppendCpuInfo(sb);
            AppendMemoryInfo(sb);
            AppendGpuInfo(sb);
            AppendDiskInfo(sb);
            AppendNetworkInfo(sb);
            AppendBatteryInfo(sb);
            AppendTemperatureInfo(sb);
        });

        sb.AppendLine("=== End of Report ===");
        return sb.ToString();
    }

    private void AppendOsInfo(StringBuilder sb)
    {
        sb.AppendLine("[Operating System]");
        using var searcher = new ManagementObjectSearcher("SELECT Caption, Version, OSArchitecture FROM Win32_OperatingSystem");
        foreach (ManagementObject obj in searcher.Get())
        {
            sb.AppendLine($"  Name      : {obj["Caption"]}");
            sb.AppendLine($"  Version   : {obj["Version"]}");
            sb.AppendLine($"  Architecture: {obj["OSArchitecture"]}");
        }
        sb.AppendLine();
    }

    private void AppendCpuInfo(StringBuilder sb)
    {
        sb.AppendLine("[CPU]");
        using var searcher = new ManagementObjectSearcher("SELECT Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed FROM Win32_Processor");
        foreach (ManagementObject obj in searcher.Get())
        {
            sb.AppendLine($"  Name               : {obj["Name"]}");
            sb.AppendLine($"  Cores              : {obj["NumberOfCores"]}");
            sb.AppendLine($"  Logical Processors : {obj["NumberOfLogicalProcessors"]}");
            sb.AppendLine($"  Max Clock (MHz)    : {obj["MaxClockSpeed"]}");
        }
        sb.AppendLine();
    }

    private void AppendMemoryInfo(StringBuilder sb)
    {
        sb.AppendLine("[Memory]");
        using var searcher = new ManagementObjectSearcher("SELECT TotalPhysicalMemory FROM Win32_ComputerSystem");
        foreach (ManagementObject obj in searcher.Get())
        {
            ulong bytes = (ulong)obj["TotalPhysicalMemory"];
            sb.AppendLine($"  Total Physical RAM : {bytes / (1024 * 1024)} MB");
        }
        sb.AppendLine();
    }

    private void AppendGpuInfo(StringBuilder sb)
    {
        sb.AppendLine("[GPU]");
        using var searcher = new ManagementObjectSearcher("SELECT Name, DriverVersion, AdapterRAM FROM Win32_VideoController");
        foreach (ManagementObject obj in searcher.Get())
        {
            sb.AppendLine($"  Name          : {obj["Name"]}");
            sb.AppendLine($"  Driver Version: {obj["DriverVersion"]}");
            ulong? ram = obj["AdapterRAM"] as ulong?;
            if (ram.HasValue)
                sb.AppendLine($"  VRAM (Bytes)  : {ram.Value}");
        }
        sb.AppendLine();
    }

    private void AppendDiskInfo(StringBuilder sb)
    {
        sb.AppendLine("[Disks]");
        using var searcher = new ManagementObjectSearcher("SELECT Model, Size, MediaType FROM Win32_DiskDrive");
        foreach (ManagementObject obj in searcher.Get())
        {
            sb.AppendLine($"  Model    : {obj["Model"]}");
            if (obj["Size"] is ulong size)
                sb.AppendLine($"  Size (GB): {size / (1024 * 1024 * 1024)} GB");
            sb.AppendLine($"  Media    : {obj["MediaType"]}");
        }
        sb.AppendLine();
    }

    private void AppendNetworkInfo(StringBuilder sb)
    {
        sb.AppendLine("[Network Adapters]");
        using var searcher = new ManagementObjectSearcher("SELECT Name, NetConnectionStatus, AdapterType FROM Win32_NetworkAdapter WHERE NetConnectionStatus IS NOT NULL AND AdapterType IS NOT NULL");
        foreach (ManagementObject obj in searcher.Get())
        {
            string name = obj["Name"]?.ToString() ?? "Unknown";
            string type = obj["AdapterType"]?.ToString() ?? "Unknown";
            var status = obj["NetConnectionStatus"]; // 2 = connected, etc.
            sb.AppendLine($"  Name   : {name}");
            sb.AppendLine($"  Type   : {type}");
            sb.AppendLine($"  Status : {status}");
        }
        sb.AppendLine();
    }

    private void AppendBatteryInfo(StringBuilder sb)
    {
        sb.AppendLine("[Battery]");
        ushort design = 0, full = 0;
        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT DesignCapacity, FullChargeCapacity, CycleCount, EstimatedChargeRemaining FROM Win32_Battery");
            foreach (ManagementObject obj in searcher.Get())
            {
                if (obj["DesignCapacity"] is ushort d) design = d;
                    sb.AppendLine($"  Design Capacity (mWh)  : {design}");
                if (obj["FullChargeCapacity"] is ushort f) full = f;
                    sb.AppendLine($"  Full Charge Capacity   : {full}");
                if (obj["CycleCount"] is ushort cycles)
                    sb.AppendLine($"  Cycle Count            : {cycles}");
                if (obj["EstimatedChargeRemaining"] is ushort remaining)
                    sb.AppendLine($"  Estimated Charge Remain: {remaining} %");
                if (design > 0 && full > 0)
                    sb.AppendLine($"  Battery Health         : {full * 100 / design} %");
            }
        }
        catch (Exception ex)
        {
            sb.AppendLine($"  Battery info unavailable: {ex.Message}");
        }
        sb.AppendLine();
    }

    private void AppendTemperatureInfo(StringBuilder sb)
    {
        sb.AppendLine("[Thermal Zones]");
        try
        {
            // Requires elevated access on many systems
            using var searcher = new ManagementObjectSearcher(@"root\WMI", "SELECT CurrentTemperature FROM MSAcpi_ThermalZoneTemperature");
            foreach (ManagementObject obj in searcher.Get())
            {
                uint temp = (uint)obj["CurrentTemperature"];
                // Temperature is in tenths of Kelvin, convert to Celsius
                double celsius = (temp / 10.0) - 273.15;
                sb.AppendLine($"  Zone temp : {celsius:F1} °C");
            }
        }
        catch (Exception ex)
        {
            sb.AppendLine($"  Temperature query failed: {ex.Message}");
        }
        sb.AppendLine();
    }
}

internal sealed class LinuxCollector : IHardwareInfoCollector
{
    public async Task<string> GatherAllAsync()
    {
        var sb = new StringBuilder();
        sb.AppendLine("=== N-Debugner System Report (Linux) ===");
        sb.AppendLine();

        await AppendOsInfoAsync(sb);
        await AppendCpuInfoAsync(sb);
        await AppendMemoryInfoAsync(sb);
        await AppendGpuInfoAsync(sb);
        await AppendDiskInfoAsync(sb);
        await AppendNetworkInfoAsync(sb);
        await AppendBatteryInfoAsync(sb);
        await AppendTemperatureInfoAsync(sb);
        await AppendDmidecodeInfoAsync(sb); // root needed, uses pkexec

        sb.AppendLine("=== End of Report ===");
        return sb.ToString();
    }

    private async Task AppendOsInfoAsync(StringBuilder sb)
    {
        sb.AppendLine("[Operating System]");
        if (File.Exists("/etc/os-release"))
        {
            var lines = await File.ReadAllLinesAsync("/etc/os-release");
            foreach (var line in lines)
            {
                if (line.StartsWith("PRETTY_NAME="))
                    sb.AppendLine($"  Name: {line.Split('=', 2)[1].Trim('"')}");
        }
    }
    var kernel = await ExecuteWithOutputAsync("uname", "-r");
    sb.AppendLine($"  Kernel: {kernel?.Trim()}");
    sb.AppendLine();
}

private async Task AppendCpuInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[CPU]");
    // Parse /proc/cpuinfo for model name, cores, etc.
    if (File.Exists("/proc/cpuinfo"))
    {
        string[] lines = await File.ReadAllLinesAsync("/proc/cpuinfo");
        string? modelName = null;
        int processors = 0;
        string? cpuCores = null;
        string? siblings = null;
        foreach (var line in lines)
        {
            if (line.StartsWith("model name"))
            {
                modelName = line.Split(':', 2)[1].Trim();
                processors++;
            }
            else if (line.StartsWith("cpu cores"))
                cpuCores = line.Split(':', 2)[1].Trim();
            else if (line.StartsWith("siblings"))
                siblings = line.Split(':', 2)[1].Trim();
        }
        sb.AppendLine($"  Model              : {modelName ?? "Unknown"}");
        sb.AppendLine($"  Physical Cores     : {cpuCores ?? "?"}");
        sb.AppendLine($"  Logical Processors : {siblings ?? "?"}");
    }
    sb.AppendLine();
}

private async Task AppendMemoryInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[Memory]");
    if (File.Exists("/proc/meminfo"))
    {
        string content = await File.ReadAllTextAsync("/proc/meminfo");
        foreach (var line in content.Split('\n'))
        {
            if (line.StartsWith("MemTotal:"))
            {
                var parts = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
                if (parts.Length >= 2 && long.TryParse(parts[1], out long kb))
                    sb.AppendLine($"  Total RAM: {kb / 1024} MB");
                break;
            }
        }
    }
    sb.AppendLine();
}

private async Task AppendGpuInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[GPU]");
    // Use lspci (no root needed for basic GPU info)
    var lspciOutput = await ExecuteWithOutputAsync("lspci", "-mm");
    if (!string.IsNullOrEmpty(lspciOutput))
    {
        foreach (var line in lspciOutput.Split('\n'))
        {
            if (line.Contains("VGA compatible controller", StringComparison.OrdinalIgnoreCase))
                sb.AppendLine($"  {line.Trim()}");
        }
    }
    sb.AppendLine();
}

private async Task AppendDiskInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[Disks]");
    // Use lsblk to get disks without partitions
    var lsblkOutput = await ExecuteWithOutputAsync("lsblk", "-ndo", "NAME,SIZE,TYPE,ROTA");
    if (!string.IsNullOrEmpty(lsblkOutput))
    {
        foreach (var line in lsblkOutput.Split('\n'))
        {
            if (string.IsNullOrWhiteSpace(line)) continue;
            var parts = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (parts.Length < 3) continue;
            string name = parts[0];
            string size = parts[1];
            string type = parts[2];
            string rota = parts.Length > 3 ? parts[3] : "0";
            if (type != "disk") continue;

            string diskType = rota == "0" ? "SSD" : "HDD";
            sb.AppendLine($"  Device: /dev/{name}, Size: {size}, Type: {diskType}");
        }
    }
    sb.AppendLine();
}

private async Task AppendNetworkInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[Network Interfaces]");
    // Use ip link (no IP addresses!)
    var ipOutput = await ExecuteWithOutputAsync("ip", "-br", "link", "show");
    if (!string.IsNullOrEmpty(ipOutput))
    {
        foreach (var line in ipOutput.Split('\n'))
        {
            if (string.IsNullOrWhiteSpace(line)) continue;
            // Example: lo               UNKNOWN        00:00:00:00:00:00 <LOOPBACK,UP,LOWER_UP>
            // We'll extract interface name and state (UP/DOWN) and maybe type
            var parts = line.Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (parts.Length >= 2)
            {
                string name = parts[0];
                string state = parts[1];
                // Avoid loopback if desired, but we'll include
                sb.AppendLine($"  Interface: {name}, State: {state}");
            }
        }
    }
    sb.AppendLine();
}

private async Task AppendBatteryInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[Battery]");
    // Try BATS0/BAT1
    for (int i = 0; i < 5; i++)
    {
        string path = $"/sys/class/power_supply/BAT{i}";
        if (!Directory.Exists(path)) continue;

        var uevent = Path.Combine(path, "uevent");
        if (File.Exists(uevent))
        {
            string content = await File.ReadAllTextAsync(uevent);
            var dict = new Dictionary<string, string>();
            foreach (var line in content.Split('\n'))
            {
                var kv = line.Split('=', 2);
                if (kv.Length == 2)
                    dict[kv[0]] = kv[1];
            }
            sb.AppendLine($"  Battery {i}:");
            string? design = null;
            string? full = null;
            if (dict.TryGetValue("POWER_SUPPLY_MODEL_NAME", out var model))
                sb.AppendLine($"    Model: {model}");
            if (dict.TryGetValue("POWER_SUPPLY_CHARGE_FULL_DESIGN", out design))
                sb.AppendLine($"    Design Capacity (µAh): {design}");
            if (dict.TryGetValue("POWER_SUPPLY_CHARGE_FULL", out full))
                sb.AppendLine($"    Full Charge Capacity (µAh): {full}");
            if (dict.TryGetValue("POWER_SUPPLY_CYCLE_COUNT", out var cycles))
                sb.AppendLine($"    Cycle Count: {cycles}");
            if (dict.TryGetValue("POWER_SUPPLY_CAPACITY", out var capacity))
                sb.AppendLine($"    Current Charge %: {capacity}");
            if (int.TryParse(design, out int d) && int.TryParse(full, out int f) && d > 0)
                sb.AppendLine($"    Health: {f * 100 / d} %");
        }
    }
    sb.AppendLine();
}

private async Task AppendTemperatureInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[Temperatures]");
    // Try sensors -j (lm-sensors)
    var sensorsJson = await ExecuteWithOutputAsync("sensors", "-j");
    if (!string.IsNullOrEmpty(sensorsJson))
    {
        sb.AppendLine("  (sensors output)");
        sb.AppendLine(sensorsJson);
    }
    else
    {
        // Fallback to hwmon
        sb.AppendLine("  (from /sys/class/hwmon)");
        string hwmonBase = "/sys/class/hwmon";
        if (Directory.Exists(hwmonBase))
        {
            foreach (var hwmonDir in Directory.EnumerateDirectories(hwmonBase))
            {
                string nameFile = Path.Combine(hwmonDir, "name");
                string hwmonName = File.Exists(nameFile) ? (await File.ReadAllTextAsync(nameFile)).Trim() : "unknown";
                foreach (var tempFile in Directory.EnumerateFiles(hwmonDir, "temp*_input"))
                {
                    try
                    {
                        string raw = await File.ReadAllTextAsync(tempFile);
                        if (int.TryParse(raw.Trim(), out int millidegrees))
                            sb.AppendLine($"  {hwmonName}/{Path.GetFileName(tempFile)}: {millidegrees / 1000.0} °C");
                    }
                    catch { /* ignore */ }
                }
            }
        }
    }
    sb.AppendLine();
}

private async Task AppendDmidecodeInfoAsync(StringBuilder sb)
{
    sb.AppendLine("[System Information (dmidecode)]");
    // Requires root, use pkexec (prompts for password)
    var output = await ExecuteWithOutputAsRootAsync("dmidecode", "-t", "system,baseboard,chassis");
    if (string.IsNullOrEmpty(output))
        sb.AppendLine("  Could not obtain (dmidecode requires root, pkexec failed or user cancelled).");
    else
        sb.AppendLine(output);
    sb.AppendLine();
}

private static async Task<string?> ExecuteWithOutputAsync(string filename, params string[] args)
{
    try
    {
        using var proc = new Process
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = filename,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true
            }
        };
        foreach (var arg in args)
            proc.StartInfo.ArgumentList.Add(arg);

        proc.Start();
        string stdout = await proc.StandardOutput.ReadToEndAsync();
        await proc.WaitForExitAsync();
        return proc.ExitCode == 0 ? stdout : null;
    }
    catch
    {
        return null;
    }
}

private static async Task<string?> ExecuteWithOutputAsRootAsync(string filename, params string[] args)
{
    // Use pkexec to run the command
    var allArgs = new List<string> { filename };
    allArgs.AddRange(args);
    return await ExecuteWithOutputAsync("pkexec", allArgs.ToArray());
}
}
#endregion

#region Program entry point
internal class Program
{
    [STAThread] // Required for Windows clipboard
    private static async Task Main(string[] args)
    {
        try
        {
            // Ensure proper elevation if needed
            if (OperatingSystem.IsWindows())
            {
                if (!IsAdministrator())
                {
                    // Relaunch as admin
                    var startInfo = new ProcessStartInfo
                    {
                        FileName = Environment.ProcessPath,
                        UseShellExecute = true,
                        Verb = "runas"
                    };
                    Process.Start(startInfo);
                    return; // Current instance exits
                }
            }
            // On Linux we stay normal user (elevated subprocesses are used where needed)

            // Choose collector based on platform
            IHardwareInfoCollector collector = OperatingSystem.IsWindows()
            ? new WindowsCollector()
            : new LinuxCollector();

            string report = await collector.GatherAllAsync();
            await ClipboardHelper.SetTextAsync(report);
            Console.WriteLine("Hardware information copied to clipboard successfully.");
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Fatal error: {ex.Message}");
            Console.Error.WriteLine(ex.StackTrace);
        }
    }

    private static bool IsAdministrator()
    {
        if (OperatingSystem.IsWindows())
        {
            using var identity = System.Security.Principal.WindowsIdentity.GetCurrent();
            var principal = new System.Security.Principal.WindowsPrincipal(identity);
            return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
        }
        return false;
    }
}
#endregion