retch_sysinfo/

fetch.rs

// SPDX-FileCopyrightText: 2026 Ken Tobias
// SPDX-License-Identifier: GPL-3.0-or-later

//! System information gathering.
//!
//! Uses the `sysinfo` crate and other heuristics to collect details
//! about the OS, hardware, and environment.

use crate::gpu;
use chrono::TimeZone;
use sysinfo::{Components, System};
// `Users` is only used for the non-Windows user count; on Windows the WTS-based
// `win_users` path is used instead, so importing it there would be an unused import.
#[cfg(not(target_os = "windows"))]
use sysinfo::Users;

/// Options for controlling what system information is gathered.
///
/// This decouples the collection logic from the CLI argument parser,
/// allowing `retch-sysinfo` to be used as a standalone library.
#[derive(Debug, Default, Clone)]
pub struct CollectOptions {
    /// Show all disk mounts (long/full mode); when false, shows only the home-directory mount.
    pub long: bool,
    /// Include FUSE mounts (full mode only).
    pub full: bool,
    /// List of fields that are requested to be displayed. If None, all fields are collected.
    pub fields: Option<Vec<String>>,
    /// Optional location override for weather lookup (city, ZIP, airport code, coordinates).
    pub weather_location: Option<String>,
    /// Temperature unit for weather display.
    pub weather_unit: crate::weather::WeatherUnit,
}

/// Comprehensive system information data structure.
///
/// This struct holds all the metrics collected from the system,
/// ranging from OS details to hardware specs and network status.
#[derive(Debug)]
pub struct SystemInfo {
    /// Operating system name and version.
    pub os: String,
    /// Kernel version.
    pub kernel: Option<String>,
    /// System hostname.
    pub hostname: Option<String>,
    /// CPU architecture (e.g., x86_64).
    pub arch: String,
    /// CPU model brand string.
    pub cpu: String,
    /// Total number of logical CPU cores.
    pub cpu_cores: usize,
    /// Formatted core topology string (e.g. "8C / 16T" or "6P + 4E / 16T").
    pub cpu_core_info: String,
    /// Formatted memory usage (Used / Total).
    pub memory: String,
    /// Formatted swap usage (Used / Total).
    pub swap: String,
    /// System uptime formatted as a duration.
    pub uptime: String,
    /// Number of currently running processes.
    pub processes: usize,
    /// Load average (1, 5, 15 minutes).
    pub load_avg: Option<String>,
    /// List of mounted disks with usage information.
    pub disks: Vec<String>,
    /// Hardware component temperatures.
    pub temps: Vec<String>,
    /// Network interface statistics and status.
    pub networks: Vec<crate::network::NetworkInterface>,
    /// System boot time in ISO 8601 format.
    pub boot_time: String,
    /// Battery status (currently placeholder for future feature).
    pub battery: Option<String>,
    /// Path to the current user's shell.
    pub shell: Option<String>,
    /// Name of the terminal emulator in use.
    pub terminal: Option<String>,
    /// Detected desktop environment or window manager.
    pub desktop: Option<String>,
    /// Current CPU frequency (formatted).
    pub cpu_freq: Option<String>,
    /// Number of interactive users (UID >= 1000).
    pub users: usize,
    /// List of detected GPUs with model names.
    pub gpu: Vec<String>,
    /// Total count of installed packages across supported managers.
    pub packages: Option<usize>,
    /// Name of the user running the process.
    pub current_user: Option<String>,
    /// Primary local IP address.
    pub local_ip: Option<String>,
    /// Public IP address (best effort).
    pub public_ip: Option<String>,
    /// Name of the active/default network interface.
    pub active_interface: Option<String>,
    /// Detected motherboard name and manufacturer.
    pub motherboard: Option<String>,
    /// Detected BIOS details.
    pub bios: Option<String>,
    /// List of connected display resolutions and refresh rates.
    pub displays: Vec<String>,
    /// Detected active audio driver/server and devices.
    pub audio: Option<String>,
    /// Connected Wi-Fi SSID and speed.
    pub wifi: Option<String>,
    /// Bluetooth power status.
    pub bluetooth: Option<String>,
    /// UI Theme (GTK, Qt, macOS, Windows).
    pub ui_theme: Option<String>,
    /// Icon theme (GTK/Qt).
    pub icons: Option<String>,
    /// Cursor theme (GTK/Qt).
    pub cursor: Option<String>,
    /// System Font.
    pub font: Option<String>,
    /// Terminal Font (configured in terminal emulator).
    pub terminal_font: Option<String>,
    /// Connected camera/webcam names.
    pub camera: Vec<String>,
    /// Connected gamepad/controller names.
    pub gamepad: Vec<String>,
    /// CPU cache sizes (L1d, L1i, L2, L3).
    pub cpu_cache: Option<String>,
    /// Current CPU utilization as a percentage.
    pub cpu_usage: Option<String>,
    /// Physical disk models, sizes, and types.
    pub physical_disks: Vec<String>,
    /// Vulkan API version and driver, e.g. `1.4.354 - radv [Mesa 26.1.8]`. Linux only.
    pub vulkan: Option<String>,
    /// OpenGL version string from a headless context. Linux only.
    pub opengl: Option<String>,
    /// OpenCL platform version, provider, and the device it exposes (if any). Linux only.
    pub opencl: Option<String>,
    /// Per-disk read/write throughput over the collection window. Linux only.
    pub disk_io: Vec<String>,
    /// Per-interface RX/TX throughput over the collection window. Linux only.
    pub net_io: Vec<String>,
    /// Physical memory (RAM) slot summary — type, speed, capacity.
    pub physical_memory: Option<String>,
    /// PID 1 / init system (systemd, runit, OpenRC, launchd, etc.).
    pub init_system: Option<String>,
    /// Chassis type (Desktop, Laptop, Server, etc.).
    pub chassis: Option<String>,
    /// System locale (from $LANG / $LC_ALL).
    pub locale: Option<String>,
    /// Second-stage bootloader (GRUB, systemd-boot, etc.).
    pub bootmgr: Option<String>,
    /// Default editor ($VISUAL / $EDITOR).
    pub editor: Option<String>,
    /// Current weather from wttr.in.
    pub weather: Option<String>,
    /// Active window manager name.
    pub wm: Option<String>,
    /// Configured DNS nameservers.
    pub dns: Vec<String>,
    /// Configured DNS domain name (Linux: the default-route interface's own domain; falls
    /// back to `domain`/first `search` in resolv.conf. See [`crate::network::detect_domain`]).
    pub domain: Option<String>,
    /// Per-interface DNS search domain lists (from resolvectl or resolv.conf `search`),
    /// excluding systemd routing-only (`~`-prefixed) domains.
    pub domain_search: Vec<String>,
    /// Terminal dimensions as "COLSxROWS".
    pub terminal_size: Option<String>,
    /// Mounted btrfs filesystems with label and space allocation.
    pub btrfs: Vec<String>,
    /// Imported ZFS pools with allocation and health status.
    pub zpool: Vec<String>,
    /// Active display/login manager (GDM, SDDM, LightDM, …). Linux only.
    pub login_manager: Option<String>,
    /// Current backlight brightness as a percentage. Linux only.
    pub brightness: Option<String>,
    /// AC power adapter name and connection state. Linux only.
    pub power_adapter: Option<String>,
    /// Connected keyboards. Linux only; see [`crate::input`] for why a device can be
    /// deliberately absent from both this and [`Self::mouse`].
    pub keyboard: Vec<String>,
    /// Connected pointing devices (mice, touchpads, tablets). Linux only.
    pub mouse: Vec<String>,
    /// TPM specification version (e.g. "2.0"). Linux only.
    pub tpm: Option<String>,
    /// Currently playing media track (e.g. "Artist - Title").
    pub media: Option<String>,
    /// Active media player (e.g. "Spotify (Playing)").
    pub player: Option<String>,
    /// Active window manager theme / decoration style.
    pub wm_theme: Option<String>,
    /// Active desktop background wallpaper file path or URI.
    pub wallpaper: Option<String>,
    /// Terminal emulator color scheme / theme name.
    pub terminal_theme: Option<String>,
}

/// Builds the `CpuRefreshKind` for a run, or `None` when no selected field needs the
/// sysinfo CPU list at all.
///
/// The two flags inside `CpuRefreshKind` are the expensive ones, and neither is needed
/// for the `cpu` field itself: brand and core count come from the *static* CPU list,
/// which `RefreshKind::with_cpu` populates whatever refresh kind it is handed
/// (sysinfo builds it on the first refresh regardless — `unix/linux/cpu.rs` guards it
/// with `if first || refresh_kind.cpu_usage()`, and `windows/cpu.rs::init_cpus` reads
/// the brand via `GetSystemInfo` unconditionally).
///
/// Frequency is what costs: on Windows `init_cpus` calls `get_frequencies()` only when
/// `refresh_kind.frequency()` is set, and that first touch of the performance-counter
/// machinery measured ~195 ms on arrakis — paid by every run, including `--short`,
/// which does not display a frequency. Asking only for what a selected field reads
/// drops `System::new_with_specifics` to ~0.5 ms there.
///
/// The plain `cpu` field no longer counts (v0.20.4): its name and core count are read
/// by the concurrent `cpu` probe with [`own_cpu_refresh_kind`] instead, so `sys` loads
/// the CPU list — a ~0.4 ms `/proc/cpuinfo` read on Linux, serial before the scope —
/// only when `cpu-freq` or `cpu-usage` needs it there.
fn cpu_refresh_kind(want_freq: bool, want_usage: bool) -> Option<sysinfo::CpuRefreshKind> {
    if !(want_freq || want_usage) {
        return None;
    }
    let mut kind = sysinfo::CpuRefreshKind::nothing();
    if want_freq {
        kind = kind.with_frequency();
    }
    // Only the non-Windows `cpu-usage` arm reads sysinfo's counters; Windows diffs its
    // own `GetSystemTimes` samples (see the `cpu_usage` block below), so asking sysinfo
    // to prime a reading nothing consumes would be pure cost.
    if want_usage && !cfg!(target_os = "windows") {
        kind = kind.with_cpu_usage();
    }
    Some(kind)
}

/// What the concurrent `cpu` probe asks sysinfo for when `sys` has no CPU list: the list
/// alone. Never frequency — on Windows that first touches performance counters, ~195 ms
/// for a field `cpu` does not display — and never usage, which nothing there reads.
fn own_cpu_refresh_kind() -> sysinfo::CpuRefreshKind {
    sysinfo::CpuRefreshKind::nothing()
}

/// The CPU name as `cpu` reports it: the first CPU's brand, or `Unknown CPU`.
///
/// On Windows an empty brand falls back to the registry's `ProcessorNameString`: sysinfo
/// reads the brand only through the x86 `CPUID` instruction, so on Windows on ARM it is
/// always empty, and until v0.20.4 the field rendered as `CPU:  (12 cores)`.
fn cpu_brand(cpus: &[sysinfo::Cpu]) -> String {
    let brand = cpus
        .first()
        .map(|c| c.brand().to_string())
        .unwrap_or_else(|| "Unknown CPU".to_string());
    #[cfg(target_os = "windows")]
    if brand.trim().is_empty() {
        if let Some(name) = windows_cpu_name() {
            return name;
        }
    }
    brand
}

/// `HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0\ProcessorNameString`, trimmed —
/// the name Windows itself shows, present on x86 and ARM alike.
#[cfg(target_os = "windows")]
fn windows_cpu_name() -> Option<String> {
    crate::win_reg::get_reg_string(
        crate::win_reg::HKEY_LOCAL_MACHINE,
        r"HARDWARE\DESCRIPTION\System\CentralProcessor\0",
        "ProcessorNameString",
    )
    .map(|s| s.trim().to_string())
    .filter(|s| !s.is_empty())
}

/// How much longer to wait before a second sample, given the `interval` the two samples
/// must be apart and the time already `elapsed` since the first. Zero once the interval
/// has passed — the work done in between counts toward it.
#[cfg_attr(target_os = "windows", allow(dead_code))]
fn remaining_wait(
    interval: std::time::Duration,
    elapsed: std::time::Duration,
) -> std::time::Duration {
    interval.saturating_sub(elapsed)
}

/// System-wide CPU usage with retch's own share taken out.
///
/// `usage` is sysinfo's percentage averaged over all `cpus` across `window`; `own` is the
/// CPU time retch and its finished child processes used in that same window. Their share
/// of the machine is `own / (window × cpus)`, which is removed so the figure describes the
/// system rather than the tool measuring it. Clamped at zero, since sampling granularity
/// can make the estimate of retch's share slightly exceed the whole measured load.
#[cfg_attr(target_os = "windows", allow(dead_code))]
fn exclude_own_usage(
    usage: f32,
    own: std::time::Duration,
    window: std::time::Duration,
    cpus: usize,
) -> f32 {
    if cpus == 0 || window.is_zero() {
        return usage;
    }
    let own_pct = 100.0 * own.as_secs_f64() / (window.as_secs_f64() * cpus as f64);
    (f64::from(usage) - own_pct).max(0.0) as f32
}

/// CPU time used so far by this process (all threads) plus its children that have been
/// waited for — the `curl` and other helpers the probes run.
#[cfg(not(target_os = "windows"))]
fn own_cpu_time() -> std::time::Duration {
    fn to_duration(t: libc::timeval) -> std::time::Duration {
        std::time::Duration::from_secs(t.tv_sec.max(0) as u64)
            + std::time::Duration::from_micros(t.tv_usec.max(0) as u64)
    }
    fn usage(who: libc::c_int) -> std::time::Duration {
        // SAFETY: `rusage` is a plain C struct of integers and `timeval`s, for which the
        // all-zero bit pattern is a valid value.
        let mut ru: libc::rusage = unsafe { std::mem::zeroed() };
        // SAFETY: `who` is RUSAGE_SELF or RUSAGE_CHILDREN, and `&mut ru` points to a live,
        // correctly sized `rusage` that getrusage only writes into for the call's duration.
        if unsafe { libc::getrusage(who, &mut ru) } != 0 {
            return std::time::Duration::ZERO;
        }
        to_duration(ru.ru_utime) + to_duration(ru.ru_stime)
    }
    usage(libc::RUSAGE_SELF) + usage(libc::RUSAGE_CHILDREN)
}

/// Whether to call `System::load_average()` at all.
///
/// Two reasons to skip it, and the second is Windows-only:
///
/// 1. It was ungated, so a run that never displays `Load` still paid for it — `load` is
///    `min_mode: Standard` in `retch-cli`'s field table, so `--short` and any narrow
///    `--fields` selection excludes it.
/// 2. On Windows the answer is always `0.0, 0.0, 0.0`. sysinfo has no native
///    load-average source there, so it synthesises one: `init_load_avg()` opens a PDH
///    query on `\System\Cpu Queue Length` and registers a callback that decays a
///    process-local static, with `SAMPLING_INTERVAL = 5` **seconds** between samples.
///    The static starts at zero and retch exits long before the first callback fires,
///    so the caller's `avg.one > 0.0` guard has never once been true on Windows — while
///    the PDH setup itself measured ~183–194 ms. That is why NOTES §6a lists `load`
///    under "deliberately not implemented on Windows"; this makes the code agree.
fn should_probe_load(want_load: bool) -> bool {
    want_load && !cfg!(target_os = "windows")
}

/// Whether `sys` must be built with the process list.
///
/// `procs` counts processes and `audio` consults them, but `shell` and `terminal` depend
/// on the list just as much: both identify the running program by walking the process
/// tree up from retch's own pid, and `sys.process(pid)` finds nothing in a list that was
/// never loaded. Keyed on `procs`/`audio` alone, that walk only worked when one of those
/// happened to be selected as well, so `--fields shell` on its own fell through to
/// guessing from the environment — on Windows under PowerShell 7 it reported
/// `powershell 5.1`, the shell `PSModulePath` implies, instead of the `pwsh` running it.
///
/// **Never on Linux**: there all four read `/proc` directly through `crate::proc_tree`,
/// because loading the table walks every process *and thread* (~48 ms on a desktop,
/// most of the default mode) when none of them needs more than a few entries.
fn needs_process_list(procs: bool, audio: bool, shell: bool, terminal: bool) -> bool {
    !cfg!(target_os = "linux") && (procs || audio || shell || terminal)
}

impl SystemInfo {
    /// Collects system information using sysinfo and environment probes.
    ///
    /// This method aggregates data from the operating system, hardware,
    /// and current user environment into a `SystemInfo` struct.
    pub fn collect(opts: CollectOptions) -> anyhow::Result<Self> {
        crate::timing::start();
        let should_collect = |field_name: &str| -> bool {
            match &opts.fields {
                Some(fields) => {
                    let norm_field = field_name.to_lowercase().replace(['-', '_'], " ");
                    let norm_field_no_spaces = norm_field.replace(' ', "");
                    fields.iter().any(|f| {
                        let norm_f = f.to_lowercase().replace(['-', '_'], " ");
                        norm_f == norm_field || norm_f.replace(' ', "") == norm_field_no_spaces
                    })
                }
                None => true,
            }
        };

        // Windows: sample cumulative CPU times before the concurrent probes run, so CPU
        // usage can be computed over the real collection window below. In a normal run the
        // window is already long enough; a floor is enforced later only for tiny requests.
        #[cfg(target_os = "windows")]
        let cpu_sample0 = win_cpu::sample();
        #[cfg(target_os = "windows")]
        let cpu_t0 = std::time::Instant::now();

        // Disk/network I/O are rates, and the kernel only exposes cumulative counters, so
        // they need two samples and an interval. Take the first here — before the
        // concurrent probes — and diff it after them, making the collection window the
        // sampling window. That is the v0.3.49 `cpu-usage` approach, and it is why these
        // fields cost no wall-clock in a normal run where fastfetch spends a full second.
        let want_disk_io = should_collect("disk-io") || should_collect("disk io");
        let want_net_io = should_collect("net-io") || should_collect("net io");
        let disk_io_sample0 = if want_disk_io {
            crate::io::sample_disk_io()
        } else {
            Vec::new()
        };
        let net_io_sample0 = if want_net_io {
            crate::io::sample_net_io()
        } else {
            Vec::new()
        };
        let io_t0 = std::time::Instant::now();

        // Probes that borrow nothing start here, before the serial setup below, so the
        // ~0.1-0.35 ms a new thread waits for an idle core to wake (measured on arrakis;
        // C3 exit latency is 350 us) overlaps `sys-init`, `os`, `disk` and the rest instead
        // of following them (v0.20.5). Only the probes that borrow `sys` wait for the
        // scope further down. All are joined there.
        let sys_needs_cpus =
            cpu_refresh_kind(should_collect("cpu-freq"), should_collect("cpu-usage")).is_some();
        // The `cpu` name probe, when `sys` will not load the CPU list anyway: it builds
        // its own minimal `System`, so it borrows nothing and can start now.
        let cpu_early_handle = (should_collect("cpu") && !sys_needs_cpus).then(|| {
            std::thread::spawn(move || {
                crate::timing::timed("cpu", || {
                    let own = System::new_with_specifics(
                        sysinfo::RefreshKind::nothing().with_cpu(own_cpu_refresh_kind()),
                    );
                    let (brand, logical) = (cpu_brand(own.cpus()), own.cpus().len());
                    (brand, logical, hybrid_cores(logical))
                })
            })
        });
        // `NC / NT` needs sysinfo's physical-core count and, on Linux, the hybrid-CPU
        // check that reads two sysfs files per cpufreq policy: ~0.8 ms together on a
        // 32-thread machine, all of it serial before the scope until v0.20.3.
        // The physical-core count is a second `/proc/cpuinfo` read on Linux and
        // needs nothing else, so it runs beside the name probe, not after it.
        let cpu_physical_handle = if should_collect("cpu") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("cpu-physical", System::physical_core_count)
            }))
        } else {
            None
        };
        let gpu_handle = if should_collect("gpu") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("gpu", || {
                    gpu::detect_gpus()
                        .into_iter()
                        .map(|g| g.format())
                        .collect::<Vec<String>>()
                })
            }))
        } else {
            None
        };
        let packages_handle = if should_collect("packages") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("packages", crate::packages::detect_packages)
            }))
        } else {
            None
        };
        let public_ip_handle = if should_collect("public ip") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("public-ip", crate::network::detect_public_ip)
            }))
        } else {
            None
        };
        // The interface list needs only this probe's answer, so it is built on the
        // same thread. Until v0.20.3 it ran serially after the whole scope.
        let network_ips_handle = if should_collect("net") {
            Some(std::thread::spawn(move || {
                let (local_ip, active_interface) = crate::timing::timed(
                    "net",
                    crate::network::detect_active_interface_and_local_ip,
                );
                let networks = crate::timing::timed("net-detail", || {
                    crate::network::detect_networks(
                        active_interface.as_deref(),
                        local_ip.as_deref(),
                    )
                });
                ((local_ip, active_interface), networks)
            }))
        } else {
            None
        };
        let motherboard_handle = if should_collect("motherboard") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("motherboard", crate::motherboard::detect_motherboard)
            }))
        } else {
            None
        };
        let bios_handle = if should_collect("bios") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("bios", crate::bios::detect_bios)
            }))
        } else {
            None
        };
        let displays_handle = if should_collect("display") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("display", crate::display::detect_displays)
            }))
        } else {
            None
        };
        let wifi_handle = if should_collect("wifi") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("wifi", crate::network::detect_wifi)
            }))
        } else {
            None
        };
        let bluetooth_handle = if should_collect("bluetooth") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("bluetooth", crate::bluetooth::detect_bluetooth)
            }))
        } else {
            None
        };
        let ui_theme_and_fonts_handle = if should_collect("theme")
            || should_collect("icons")
            || should_collect("cursor")
            || should_collect("font")
        {
            Some(std::thread::spawn(move || {
                crate::timing::timed("theme+fonts", crate::theme::detect_ui_theme_and_fonts)
            }))
        } else {
            None
        };
        let camera_handle = if should_collect("camera") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("camera", crate::camera::detect_camera)
            }))
        } else {
            None
        };
        let gamepad_handle = if should_collect("gamepad") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("gamepad", crate::gamepad::detect_gamepad)
            }))
        } else {
            None
        };
        let physical_disks_handle = if should_collect("phys disk") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("phys-disk", crate::disk::detect_physical_disks)
            }))
        } else {
            None
        };
        let physical_memory_handle = if should_collect("phys mem") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("phys-mem", crate::memory::detect_physical_memory)
            }))
        } else {
            None
        };
        let weather_location = opts.weather_location.clone();
        let weather_unit = opts.weather_unit;
        let weather_handle = if should_collect("weather") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("weather", || {
                    crate::weather::detect_weather(weather_location.as_deref(), weather_unit)
                })
            }))
        } else {
            None
        };
        let btrfs_handle = if should_collect("btrfs") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("btrfs", crate::btrfs::detect_btrfs)
            }))
        } else {
            None
        };
        let zpool_handle = if should_collect("zpool") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("zpool", crate::zfs::detect_zpool)
            }))
        } else {
            None
        };
        let media_handle = if should_collect("media") || should_collect("player") {
            Some(std::thread::spawn(move || {
                crate::timing::timed("media", crate::media::detect_media)
            }))
        } else {
            None
        };
        // Vulkan/OpenGL/OpenCL are collected together: all three dlopen a loader and
        // talk to the same driver stack, so splitting them across threads would buy
        // contention rather than overlap.
        let gpu_apis_handle =
            if should_collect("vulkan") || should_collect("opengl") || should_collect("opencl") {
                Some(std::thread::spawn(move || {
                    crate::timing::timed("gpu-apis", crate::gpu_api::detect_gpu_apis)
                }))
            } else {
                None
            };

        let mut refresh_kind = sysinfo::RefreshKind::nothing();
        // `cpu-cache` is deliberately absent: `detect_cpu_cache()` reads its own source
        // and never touches `sys`, so it never needed the CPU list.
        let sys_has_cpus =
            match cpu_refresh_kind(should_collect("cpu-freq"), should_collect("cpu-usage")) {
                Some(cpu_kind) => {
                    refresh_kind = refresh_kind.with_cpu(cpu_kind);
                    true
                }
                None => false,
            };
        if should_collect("memory")
            || should_collect("swap")
            || should_collect("phys mem")
            || should_collect("phys-mem")
        {
            refresh_kind = refresh_kind.with_memory(sysinfo::MemoryRefreshKind::everything());
        }
        if needs_process_list(
            should_collect("procs"),
            should_collect("audio"),
            should_collect("shell"),
            should_collect("terminal"),
        ) {
            refresh_kind = refresh_kind.with_processes(sysinfo::ProcessRefreshKind::nothing());
        }

        // `mut` is only needed off-Windows (refresh_cpu_usage below); on Windows CPU usage
        // comes from GetSystemTimes, so `sys` is never mutated there.
        #[cfg_attr(target_os = "windows", allow(unused_mut))]
        let mut sys = crate::timing::timed("sys-init", || System::new_with_specifics(refresh_kind));
        // On Unix, `sys-init` just took the first CPU-usage sample (see `cpu_refresh_kind`).
        // Mark when, so the `cpu_usage` block only waits for whatever part of sysinfo's
        // minimum interval the probes in between have not already spent.
        #[cfg(not(target_os = "windows"))]
        let cpu_usage_t0 = std::time::Instant::now();
        // retch's own CPU time at the same moment, so its share of the window can be taken
        // back out of the reading (see `exclude_own_usage`).
        #[cfg(not(target_os = "windows"))]
        let cpu_usage_own0 = own_cpu_time();

        let os = crate::timing::timed("os", || {
            System::long_os_version()
                .or_else(System::name)
                .unwrap_or_else(|| "Unknown".to_string())
        });

        let kernel = crate::timing::timed("kernel", System::kernel_version);
        let hostname = crate::timing::timed("host", System::host_name);

        // `cpu`'s name and logical count: from `sys` when it already loaded the CPU list
        // for `cpu-freq`/`cpu-usage` (free here), otherwise read by the concurrent `cpu`
        // probe below, off the serial path.
        let cpu_from_sys: Option<(String, usize)> = (should_collect("cpu") && sys_has_cpus)
            .then(|| (cpu_brand(sys.cpus()), sys.cpus().len()));
        let memory = if should_collect("memory") {
            let total_mem = sys.total_memory() as f64 / 1024.0 / 1024.0 / 1024.0;
            let used_mem = sys.used_memory() as f64 / 1024.0 / 1024.0 / 1024.0;
            format!("{:.1} / {:.1} GB", used_mem, total_mem)
        } else {
            String::new()
        };

        let swap = if should_collect("swap") {
            let total_swap = sys.total_swap() as f64 / 1024.0 / 1024.0 / 1024.0;
            let used_swap = sys.used_swap() as f64 / 1024.0 / 1024.0 / 1024.0;
            if total_swap > 0.0 {
                format!("{:.1} / {:.1} GB", used_swap, total_swap)
            } else {
                "No swap".to_string()
            }
        } else {
            String::new()
        };

        let uptime = format!("{}s", crate::timing::timed("uptime", System::uptime));

        let disks: Vec<String> = if should_collect("disk") {
            let disks_list =
                crate::timing::timed("disk", || crate::disk::detect_logical_disks(opts.full));
            let format_disk = |(mount, total, avail, fs): &(String, u64, u64, String)| {
                let total_gb = *total as f64 / 1024.0 / 1024.0 / 1024.0;
                let avail_gb = *avail as f64 / 1024.0 / 1024.0 / 1024.0;
                format!(
                    "{} ({}): {:.1} GB free / {:.1} GB",
                    mount, fs, avail_gb, total_gb
                )
            };
            if !opts.long {
                let home = dirs::home_dir().unwrap_or_else(|| std::path::PathBuf::from("/"));
                let home_path = std::path::Path::new(&home);
                let best = disks_list
                    .iter()
                    .filter(|(mp, ..)| home_path.starts_with(mp))
                    .max_by_key(|(mp, ..)| std::path::Path::new(mp).components().count());
                if let Some(disk) = best {
                    vec![format_disk(disk)]
                } else {
                    disks_list.iter().map(format_disk).collect()
                }
            } else {
                disks_list.iter().map(format_disk).collect()
            }
        } else {
            Vec::new()
        };

        let battery = if should_collect("battery") {
            crate::timing::timed("battery", crate::battery::get_battery_info).map(|bat| {
                let pct = bat.percentage;
                let state = match bat.state {
                    crate::battery::BatteryState::Charging => "charging",
                    crate::battery::BatteryState::Discharging => "discharging",
                    crate::battery::BatteryState::Full => "full",
                    _ => "not charging",
                };
                let vendor = bat.vendor;
                let model = bat.model;

                // Format time remaining as "Xh Ym" or "Xd Yh"
                let time_str = match bat.state {
                    crate::battery::BatteryState::Charging => bat.time_remaining.map(|d| {
                        let total_mins = d.as_secs() / 60;
                        let hours = total_mins / 60;
                        let mins = total_mins % 60;
                        if hours >= 24 {
                            let days = hours / 24;
                            let rem_hours = hours % 24;
                            format!("{}d {}h until full", days, rem_hours)
                        } else if hours > 0 {
                            format!("{}h {}m until full", hours, mins)
                        } else {
                            format!("{}m until full", mins)
                        }
                    }),
                    crate::battery::BatteryState::Discharging => bat.time_remaining.map(|d| {
                        let total_mins = d.as_secs() / 60;
                        let hours = total_mins / 60;
                        let mins = total_mins % 60;
                        if hours >= 24 {
                            let days = hours / 24;
                            let rem_hours = hours % 24;
                            format!("{}d {}h remaining", days, rem_hours)
                        } else if hours > 0 {
                            format!("{}h {}m remaining", hours, mins)
                        } else {
                            format!("{}m remaining", mins)
                        }
                    }),
                    _ => None,
                };

                let mut parts = vec![state.to_string()];
                if let Some(t) = time_str {
                    parts.insert(0, t);
                }
                if let Some(health) = bat.health {
                    if health < 99.0 {
                        parts.push(format!("{:.0}% health", health));
                    }
                }

                let base = format!("{:.0}% ({})", pct, parts.join(", "));

                match (vendor, model) {
                    (Some(v), Some(m)) => format!("{} [{} {}]", base, v, m),
                    (Some(v), None) => format!("{} [{}]", base, v),
                    _ => base,
                }
            })
        } else {
            None
        };

        let arch = crate::timing::timed("arch", System::cpu_arch);

        let processes = if should_collect("procs") || should_collect("audio") {
            #[cfg(target_os = "linux")]
            {
                crate::timing::timed("procs", crate::proc_tree::task_count)
            }
            #[cfg(not(target_os = "linux"))]
            {
                sys.processes().len()
            }
        } else {
            0
        };

        let load_avg = if should_probe_load(should_collect("load")) {
            let avg = System::load_average();
            if avg.one > 0.0 || avg.five > 0.0 {
                Some(format!(
                    "{:.2}, {:.2}, {:.2}",
                    avg.one, avg.five, avg.fifteen
                ))
            } else {
                None
            }
        } else {
            None
        };

        // Compute slow system queries concurrently in parallel threads
        let (
            gpu,
            packages,
            public_ip,
            ((local_ip, active_interface), networks),
            motherboard,
            bios,
            displays,
            audio,
            wifi,
            bluetooth,
            (ui_theme, icons, cursor, font),
            camera,
            gamepad,
            physical_disks,
            physical_memory,
            weather,
            btrfs,
            zpool,
            (media, player),
            gpu_apis,
            shell,
            (cpu, cpu_cores, cpu_hybrid),
            cpu_physical,
        ) = crate::timing::timed("scope", || {
            std::thread::scope(|s| {
                // With `cpu-freq`/`cpu-usage`, `sys` already holds the CPU list, so the
                // name comes from it and only the hybrid check runs here.
                let cpu_cores_handle = if should_collect("cpu") && sys_has_cpus {
                    let known = cpu_from_sys.clone();
                    Some(s.spawn(move || {
                        crate::timing::timed("cpu", || {
                            let (brand, logical) = known.unwrap_or_else(|| {
                                let own = System::new_with_specifics(
                                    sysinfo::RefreshKind::nothing()
                                        .with_cpu(own_cpu_refresh_kind()),
                                );
                                (cpu_brand(own.cpus()), own.cpus().len())
                            });
                            (brand, logical, hybrid_cores(logical))
                        })
                    }))
                } else {
                    None
                };
                let audio_handle = if should_collect("audio") {
                    Some(s.spawn(|| {
                        crate::timing::timed("audio", || crate::audio::detect_audio(&sys))
                    }))
                } else {
                    None
                };
                // `shell` reports the running shell's version by spawning the shell to ask it,
                // which on Windows means starting PowerShell — measured at ~570 ms on arrakis.
                // Until v0.17.6 that ran serially after this scope and was the largest single
                // cost in `--long` and `--full`; here it overlaps the other probes instead. It
                // only reads `sys`, as `audio` does.
                let shell_handle = if should_collect("shell") {
                    Some(s.spawn(|| {
                        crate::timing::timed("shell", || crate::shell::detect_shell(&sys))
                    }))
                } else {
                    None
                };
                (
                    gpu_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    packages_handle.and_then(|h| h.join().ok().flatten()),
                    public_ip_handle.and_then(|h| h.join().ok().flatten()),
                    network_ips_handle
                        .map(|h| h.join().unwrap_or(((None, None), Vec::new())))
                        .unwrap_or(((None, None), Vec::new())),
                    motherboard_handle.and_then(|h| h.join().ok().flatten()),
                    bios_handle.and_then(|h| h.join().ok().flatten()),
                    displays_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    audio_handle.and_then(|h| h.join().ok().flatten()),
                    wifi_handle.and_then(|h| h.join().ok().flatten()),
                    bluetooth_handle.and_then(|h| h.join().ok().flatten()),
                    ui_theme_and_fonts_handle
                        .map(|h| h.join().unwrap_or((None, None, None, None)))
                        .unwrap_or((None, None, None, None)),
                    camera_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    gamepad_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    physical_disks_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    physical_memory_handle.and_then(|h| h.join().ok().flatten()),
                    weather_handle.and_then(|h| h.join().ok().flatten()),
                    btrfs_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    zpool_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    media_handle
                        .map(|h| h.join().unwrap_or((None, None)))
                        .unwrap_or((None, None)),
                    gpu_apis_handle
                        .map(|h| h.join().unwrap_or_default())
                        .unwrap_or_default(),
                    shell_handle.and_then(|h| h.join().ok().flatten()),
                    cpu_early_handle
                        .map(|h| h.join().unwrap_or_default())
                        .or_else(|| cpu_cores_handle.map(|h| h.join().unwrap_or_default()))
                        .unwrap_or_default(),
                    cpu_physical_handle.and_then(|h| h.join().ok().flatten()),
                )
            })
        });

        let cpu_core_info = if should_collect("cpu") {
            cpu_hybrid.unwrap_or_else(|| format_cpu_cores_plain(cpu_cores, cpu_physical))
        } else {
            String::new()
        };

        let mut temps: Vec<String> = if should_collect("temp") {
            crate::timing::timed("temp", Components::new_with_refreshed_list)
                .iter()
                .filter_map(|c| {
                    c.temperature().and_then(|t| {
                        if t > 0.0 {
                            Some(format!("{}: {:.0}°C", c.label(), t))
                        } else {
                            None
                        }
                    })
                })
                .collect()
        } else {
            Vec::new()
        };

        // Sort so CPU temperatures appear first
        temps.sort_by(|a, b| {
            let a_cpu = a.to_lowercase().contains("cpu") || a.to_lowercase().contains("core");
            let b_cpu = b.to_lowercase().contains("cpu") || b.to_lowercase().contains("core");
            b_cpu.cmp(&a_cpu)
        });

        let boot_timestamp = crate::timing::timed("boot-time", System::boot_time);
        let boot_dt = chrono::Local
            .timestamp_opt(boot_timestamp as i64, 0)
            .single()
            .map(|dt| dt.format("%Y-%m-%dT%H:%M:%S%:z").to_string())
            .unwrap_or_else(|| boot_timestamp.to_string());
        let boot_time = boot_dt;

        // Environment-based info. (`shell` is collected inside the concurrent scope above.)
        let terminal = if should_collect("terminal") {
            crate::timing::timed("terminal", || crate::terminal::detect_terminal(&sys))
        } else {
            None
        };
        let terminal_font = if should_collect("terminal font")
            || should_collect("terminal-font")
            || should_collect("terminal_font")
        {
            crate::timing::timed("terminal-font", || {
                crate::terminal::detect_terminal_font(terminal.as_deref())
            })
        } else {
            None
        };
        let desktop = if should_collect("desktop") {
            std::env::var("XDG_CURRENT_DESKTOP")
                .or_else(|_| std::env::var("DESKTOP_SESSION"))
                .or_else(|_| std::env::var("XDG_SESSION_DESKTOP"))
                .or_else(|_| std::env::var("GDMSESSION"))
                .ok()
                .map(|s| normalize_desktop_name(&s))
                .filter(|s| !s.is_empty())
                .or_else(|| crate::timing::timed("desktop-proc", detect_desktop_from_proc))
        } else {
            None
        };

        // CPU frequency (current from sysinfo + min/max range from sysfs)
        let cpu_freq = if should_collect("cpu-freq")
            || should_collect("cpu freq")
            || should_collect("cpu_freq")
        {
            sys.cpus().first().map(|c| {
                let current = format!("{:.2} GHz", c.frequency() as f64 / 1000.0);
                if let Some((min_khz, max_khz)) =
                    crate::timing::timed("cpu-freq", detect_cpu_freq_range)
                {
                    let min_ghz = min_khz as f64 / 1_000_000.0;
                    let max_ghz = max_khz as f64 / 1_000_000.0;
                    format!("{} ({:.2} \u{2013} {:.2} GHz)", current, min_ghz, max_ghz)
                } else {
                    current
                }
            })
        } else {
            None
        };

        // CPU cache sizes
        let cpu_cache = if should_collect("cpu-cache")
            || should_collect("cpu cache")
            || should_collect("cpu_cache")
        {
            crate::timing::timed("cpu-cache", detect_cpu_cache)
        } else {
            None
        };

        // CPU usage. On Unix, sysinfo needs a delta between two refreshes at least
        // `MINIMUM_CPU_UPDATE_INTERVAL` apart (200 ms on Linux and macOS). The first refresh
        // was `sys-init`, before the concurrent scope, so only the part of the interval the
        // scope has not already used is waited out — in `--long` usually none of it. Until
        // v0.19.2 this slept the full 200 ms *after* the scope, which RETCH_TIMING showed as
        // pure serial waste (scope 237 ms, then 200 ms more). On Windows we instead diff the
        // GetSystemTimes sample taken before the concurrent scope against a fresh one — the
        // collection window is the delta, so no sleep is added to the run.
        let cpu_usage = if should_collect("cpu-usage")
            || should_collect("cpu usage")
            || should_collect("cpu_usage")
        {
            #[cfg(not(target_os = "windows"))]
            {
                let wait =
                    remaining_wait(sysinfo::MINIMUM_CPU_UPDATE_INTERVAL, cpu_usage_t0.elapsed());
                crate::timing::timed("cpu-usage-wait", || std::thread::sleep(wait));
                sys.refresh_cpu_usage();
                let window = cpu_usage_t0.elapsed();
                let own = own_cpu_time().saturating_sub(cpu_usage_own0);
                let raw: f32 =
                    sys.cpus().iter().map(|c| c.cpu_usage()).sum::<f32>() / sys.cpus().len() as f32;
                // The window now overlaps retch's own probes rather than an idle sleep, so
                // their CPU time would otherwise read as load (+1.3 points on a 32-thread
                // machine, ~+13 on a 4-core one). `raw` still decides whether sysinfo had
                // a reading at all: an idle system may legitimately adjust to 0.0%.
                let usage = exclude_own_usage(raw, own, window, sys.cpus().len());
                let avg = System::load_average();
                let load_str = format!("{:.2}, {:.2}, {:.2}", avg.one, avg.five, avg.fifteen);
                if raw > 0.0 {
                    Some(format!("{:.1}% (load: {})", usage, load_str))
                } else if avg.one > 0.0 {
                    Some(format!("load: {}", load_str))
                } else {
                    None
                }
            }
            #[cfg(target_os = "windows")]
            {
                // The concurrent scope above is usually the sampling window; only top it up
                // to a ~100 ms floor when few fields were requested (so an isolated
                // `--fields cpu-usage` still reads sensibly rather than sampling noise).
                let floor = std::time::Duration::from_millis(100);
                let elapsed = cpu_t0.elapsed();
                if elapsed < floor {
                    std::thread::sleep(floor - elapsed);
                }
                match (cpu_sample0, win_cpu::sample()) {
                    (Some(s0), Some(s1)) => {
                        let usage = win_cpu::usage_percent(s0, s1);
                        if usage > 0.0 {
                            Some(format!("{:.1}%", usage))
                        } else {
                            None
                        }
                    }
                    _ => None,
                }
            }
        } else {
            None
        };

        // Second I/O sample. Deliberately after the `cpu_usage` block above: on Unix that
        // block may still wait out the rest of sysinfo's minimum refresh interval, and taking
        // the second sample afterwards folds any such wait into the window instead of paying
        // for it twice. The floor below therefore only ever fires for a request so small that
        // neither the concurrent scope nor a CPU wait filled it.
        let (disk_io, net_io) = if want_disk_io || want_net_io {
            let floor = std::time::Duration::from_millis(100);
            let elapsed = io_t0.elapsed();
            if elapsed < floor {
                std::thread::sleep(floor - elapsed);
            }
            let elapsed_secs = io_t0.elapsed().as_secs_f64();
            let disk_io = if want_disk_io {
                crate::io::compute_rates(
                    &disk_io_sample0,
                    &crate::io::sample_disk_io(),
                    elapsed_secs,
                )
                .iter()
                .map(|r| crate::io::format_io_line(r, "R", "W"))
                .collect()
            } else {
                Vec::new()
            };
            let net_io = if want_net_io {
                let rates = crate::io::compute_rates(
                    &net_io_sample0,
                    &crate::io::sample_net_io(),
                    elapsed_secs,
                );
                crate::io::select_net_rates(rates, active_interface.as_deref())
                    .iter()
                    .map(|r| crate::io::format_io_line(r, "RX", "TX"))
                    .collect()
            } else {
                Vec::new()
            };
            (disk_io, net_io)
        } else {
            (Vec::new(), Vec::new())
        };

        let init_system = if should_collect("init") || should_collect("init system") {
            crate::timing::timed("init", detect_init_system)
        } else {
            None
        };

        let chassis = if should_collect("chassis") {
            crate::timing::timed("chassis", detect_chassis)
        } else {
            None
        };

        let locale = if should_collect("locale") {
            std::env::var("LC_ALL")
                .ok()
                .filter(|s| !s.is_empty())
                .or_else(|| std::env::var("LC_MESSAGES").ok().filter(|s| !s.is_empty()))
                .or_else(|| std::env::var("LANG").ok().filter(|s| !s.is_empty()))
        } else {
            None
        };

        let bootmgr = if should_collect("bootmgr") || should_collect("boot") {
            crate::timing::timed("bootmgr", detect_bootmgr)
        } else {
            None
        };

        let login_manager = if should_collect("login-manager") || should_collect("lm") {
            crate::timing::timed("login-manager", detect_login_manager)
        } else {
            None
        };

        let brightness = if should_collect("brightness") {
            crate::timing::timed("brightness", detect_brightness)
        } else {
            None
        };

        let power_adapter = if should_collect("power-adapter") {
            crate::timing::timed("power-adapter", detect_power_adapter)
        } else {
            None
        };

        // Keyboards and mice come from one file read, so they are collected together and then
        // split rather than parsing `/proc/bus/input/devices` twice.
        let (keyboard, mouse) = if should_collect("keyboard") || should_collect("mouse") {
            let (kbds, mice) = crate::timing::timed("input", crate::input::detect_input_devices);
            (
                if should_collect("keyboard") {
                    kbds
                } else {
                    Vec::new()
                },
                if should_collect("mouse") {
                    mice
                } else {
                    Vec::new()
                },
            )
        } else {
            (Vec::new(), Vec::new())
        };

        let tpm = if should_collect("tpm") {
            crate::timing::timed("tpm", detect_tpm)
        } else {
            None
        };

        let editor = if should_collect("editor") {
            std::env::var("VISUAL")
                .ok()
                .filter(|s| !s.is_empty())
                .or_else(|| std::env::var("EDITOR").ok().filter(|s| !s.is_empty()))
        } else {
            None
        };

        let wm = if should_collect("wm") || should_collect("window manager") {
            crate::timing::timed("wm", crate::wm::detect_wm)
        } else {
            None
        };

        let dns = if should_collect("dns") {
            crate::timing::timed("dns", crate::network::detect_dns)
        } else {
            Vec::new()
        };

        let domain = if should_collect("domain") {
            crate::timing::timed("domain", crate::network::detect_domain)
        } else {
            None
        };

        let domain_search = if should_collect("domain-search") || should_collect("domain search") {
            crate::timing::timed("domain-search", crate::network::detect_domain_search)
        } else {
            Vec::new()
        };

        let terminal_size = if should_collect("terminal size")
            || should_collect("terminal-size")
            || should_collect("terminal_size")
        {
            crate::timing::timed("terminal-size", crate::terminal::detect_terminal_size)
        } else {
            None
        };

        // Current logged in user
        let current_user = std::env::var("USER").ok();

        // Number of interactive users. On Unix, count local human accounts (UID >= 1000,
        // excluding system accounts). On Windows, `sysinfo` keys users by SID (which won't
        // parse as a UID), so count active interactive login sessions via the WTS API
        // instead. A 0 result is suppressed at display time (see `display.rs`).
        let users = if should_collect("users") {
            #[cfg(target_os = "windows")]
            {
                crate::win_users::active_user_session_count()
            }
            #[cfg(not(target_os = "windows"))]
            {
                crate::timing::timed("users", Users::new_with_refreshed_list)
                    .iter()
                    .filter(|user| {
                        // UID is exposed via Display
                        user.id()
                            .to_string()
                            .parse::<u32>()
                            .map(|uid| uid >= 1000)
                            .unwrap_or(false)
                    })
                    .count()
            }
        } else {
            0
        };

        let wm_theme = if should_collect("wm-theme")
            || should_collect("wm theme")
            || should_collect("wm_theme")
        {
            crate::timing::timed("wm-theme", || {
                crate::theme::detect_wm_theme(wm.as_deref(), desktop.as_deref())
            })
        } else {
            None
        };

        let wallpaper = if should_collect("wallpaper") {
            crate::timing::timed("wallpaper", || {
                crate::theme::detect_wallpaper(desktop.as_deref(), wm.as_deref())
            })
        } else {
            None
        };

        let terminal_theme = if should_collect("terminal-theme")
            || should_collect("terminal theme")
            || should_collect("terminal_theme")
        {
            crate::timing::timed("terminal-theme", || {
                crate::terminal::detect_terminal_theme(terminal.as_deref())
            })
        } else {
            None
        };

        crate::timing::mark("collect-done");

        Ok(Self {
            os,
            kernel,
            hostname,
            arch,
            cpu,
            cpu_cores,
            cpu_core_info,
            memory,
            swap,
            uptime,
            processes,
            load_avg,
            disks,
            temps,
            networks,
            boot_time,
            battery,
            shell,
            terminal,
            desktop,
            cpu_freq,
            users,
            gpu,
            packages,
            current_user,
            local_ip,
            public_ip,
            active_interface,
            motherboard,
            bios,
            displays,
            audio,
            wifi,
            bluetooth,
            ui_theme,
            icons,
            cursor,
            font,
            terminal_font,
            camera,
            gamepad,
            cpu_cache,
            cpu_usage,
            physical_disks,
            vulkan: gpu_apis.vulkan,
            opengl: gpu_apis.opengl,
            opencl: gpu_apis.opencl,
            disk_io,
            net_io,
            physical_memory,
            init_system,
            chassis,
            locale,
            bootmgr,
            editor,
            weather,
            wm,
            dns,
            domain,
            domain_search,
            terminal_size,
            btrfs,
            zpool,
            login_manager,
            brightness,
            power_adapter,
            keyboard,
            mouse,
            tpm,
            media,
            player,
            wm_theme,
            wallpaper,
            terminal_theme,
        })
    }
}

/// Detects CPU cache sizes.
///
/// Linux: reads from `/sys/devices/system/cpu/cpu0/cache/` sysfs entries.
/// macOS: reads `hw.l1dcachesize`, `hw.l1icachesize`, `hw.l2cachesize`, `hw.l3cachesize` via sysctlbyname.
/// Returns `None` on Windows or if data is unavailable.
pub fn detect_cpu_cache() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        use std::fs;
        let cache_dir = std::path::Path::new("/sys/devices/system/cpu/cpu0/cache");
        if !cache_dir.exists() {
            return None;
        }

        struct CacheEntry {
            level: u32,
            kind: String,
            size_kb: u64,
        }

        let mut entries: Vec<CacheEntry> = Vec::new();

        let Ok(indices) = fs::read_dir(cache_dir) else {
            return None;
        };

        for entry in indices.flatten() {
            let path = entry.path();
            // Skip non-index entries (e.g. the uevent file)
            if !path.is_dir() {
                continue;
            }
            let level_str = match fs::read_to_string(path.join("level")) {
                Ok(s) => s,
                Err(_) => continue,
            };
            let level: u32 = match level_str.trim().parse() {
                Ok(n) => n,
                Err(_) => continue,
            };
            let kind = match fs::read_to_string(path.join("type")) {
                Ok(s) => s.trim().to_string(),
                Err(_) => continue,
            };
            let size_str = match fs::read_to_string(path.join("size")) {
                Ok(s) => s,
                Err(_) => continue,
            };
            let size_raw = size_str.trim();
            let size_kb: u64 = if let Some(k) = size_raw.strip_suffix('K') {
                match k.parse() {
                    Ok(n) => n,
                    Err(_) => continue,
                }
            } else if let Some(m) = size_raw.strip_suffix('M') {
                match m.parse::<u64>() {
                    Ok(n) => n * 1024,
                    Err(_) => continue,
                }
            } else {
                match size_raw.parse() {
                    Ok(n) => n,
                    Err(_) => continue,
                }
            };

            if kind != "Instruction" && kind != "Data" && kind != "Unified" {
                continue;
            }

            entries.push(CacheEntry {
                level,
                kind,
                size_kb,
            });
        }

        if entries.is_empty() {
            return None;
        }

        entries.sort_by_key(|e| (e.level, e.kind.clone()));

        let fmt_size = |kb: u64| -> String {
            if kb >= 1024 && kb.is_multiple_of(1024) {
                format!("{}M", kb / 1024)
            } else if kb >= 1024 {
                format!("{:.2}M", kb as f64 / 1024.0)
                    .trim_end_matches('0')
                    .trim_end_matches('.')
                    .to_string()
                    + "M"
            } else {
                format!("{}K", kb)
            }
        };

        // Deduplicate by label (cpu0 cache dir lists each index separately)
        let mut seen = std::collections::HashSet::new();
        let mut parts: Vec<String> = Vec::new();
        for e in &entries {
            let label = match (e.level, e.kind.as_str()) {
                (1, "Data") => "L1d".to_string(),
                (1, "Instruction") => "L1i".to_string(),
                (1, "Unified") => "L1".to_string(),
                (n, _) => format!("L{}", n),
            };
            if seen.insert(label.clone()) {
                parts.push(format!("{}: {}", label, fmt_size(e.size_kb)));
            }
        }

        if parts.is_empty() {
            None
        } else {
            Some(parts.join(", "))
        }
    }
    #[cfg(target_os = "macos")]
    {
        extern "C" {
            fn sysctlbyname(
                name: *const i8,
                oldp: *mut std::ffi::c_void,
                oldlenp: *mut usize,
                newp: *mut std::ffi::c_void,
                newlen: usize,
            ) -> i32;
        }

        let read_u64 = |key: &str| -> Option<u64> {
            let name = std::ffi::CString::new(key).ok()?;
            let mut value: u64 = 0;
            let mut size = std::mem::size_of::<u64>();
            let ret = unsafe {
                sysctlbyname(
                    name.as_ptr(),
                    &mut value as *mut u64 as *mut std::ffi::c_void,
                    &mut size,
                    std::ptr::null_mut(),
                    0,
                )
            };
            if ret == 0 && value > 0 {
                Some(value)
            } else {
                None
            }
        };

        let fmt_bytes = |bytes: u64| -> String {
            if bytes >= 1024 * 1024 {
                format!("{}M", bytes / (1024 * 1024))
            } else {
                format!("{}K", bytes / 1024)
            }
        };

        let mut parts = Vec::new();
        if let Some(v) = read_u64("hw.l1dcachesize") {
            parts.push(format!("L1d: {}", fmt_bytes(v)));
        }
        if let Some(v) = read_u64("hw.l1icachesize") {
            parts.push(format!("L1i: {}", fmt_bytes(v)));
        }
        if let Some(v) = read_u64("hw.l2cachesize") {
            parts.push(format!("L2: {}", fmt_bytes(v)));
        }
        if let Some(v) = read_u64("hw.l3cachesize") {
            parts.push(format!("L3: {}", fmt_bytes(v)));
        }

        if parts.is_empty() {
            None
        } else {
            Some(parts.join(", "))
        }
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        None
    }
}

/// Formats a CPU core topology string.
///
/// Returns `"NP + NE / NT"` on Intel hybrid CPUs (different max frequencies per cluster),
/// `"NC / NT"` when physical < logical (hyperthreading), or `"N cores"` otherwise.
pub fn format_cpu_cores(logical: usize, physical: Option<usize>) -> String {
    hybrid_cores(logical).unwrap_or_else(|| format_cpu_cores_plain(logical, physical))
}

/// The host's hybrid P/E string, if it is a hybrid CPU: cpufreq max-frequency tiers on
/// Linux, `hw.perflevel*` sysctls on macOS, `None` elsewhere. Split out of
/// [`format_cpu_cores`] so `collect` can run it on a different thread from the
/// physical-core count (v0.20.4); the two together are exactly `format_cpu_cores`.
fn hybrid_cores(logical: usize) -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        detect_hybrid_cores(logical)
    }
    #[cfg(target_os = "macos")]
    {
        detect_macos_hybrid_cores(logical)
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        let _ = logical;
        None
    }
}

/// Pure fallback formatter used when no hybrid (P/E) topology is detected.
///
/// `Some(p)` with `p < logical` → `"{p}C / {logical}T"` (SMT/hyperthreading present);
/// otherwise `"{logical} cores"`. This is split out of [`format_cpu_cores`] so it can
/// be unit-tested deterministically: [`format_cpu_cores`] reads the *host's* real CPU
/// topology (`/sys/.../cpufreq` on Linux, `hw.perflevel*` sysctls on macOS) and returns
/// a `"NP + ME / KT"` string on hybrid machines, so calling it with fixed arguments does
/// not exercise this fallback path on such hardware (which is exactly what made the old
/// tests fail on Intel P/E hybrids).
fn format_cpu_cores_plain(logical: usize, physical: Option<usize>) -> String {
    match physical {
        Some(p) if p < logical => format!("{}C / {}T", p, logical),
        _ => format!("{} cores", logical),
    }
}

/// On Linux, detects hybrid topology (P-cores + E-cores) by grouping CPUs by their maximum
/// cpufreq frequency. Returns `None` if not hybrid or unavailable.
#[cfg(target_os = "linux")]
fn detect_hybrid_cores(logical: usize) -> Option<String> {
    hybrid_cores_in(
        std::path::Path::new("/sys/devices/system/cpu/cpufreq"),
        logical,
    )
}

/// The reading half of [`detect_hybrid_cores`], against any cpufreq directory so tests can
/// use a fixture tree.
///
/// Two costs are avoided, since a 32-thread machine made this the slowest part of the `CPU`
/// field (~0.75 ms; v0.20.3):
/// - cpufreq policies partition the CPUs, so when there are as many policies as logical
///   CPUs each covers exactly one, and `affected_cpus` need not be read — half the reads on
///   the common per-CPU-policy x86 layout.
/// - Only exactly two frequency tiers mean hybrid, so the scan stops at a third.
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn hybrid_cores_in(cpufreq: &std::path::Path, logical: usize) -> Option<String> {
    use std::collections::HashMap;
    use std::fs;

    let policies: Vec<std::path::PathBuf> = fs::read_dir(cpufreq)
        .ok()?
        .flatten()
        .map(|e| e.path())
        .filter(|p| p.is_dir())
        .collect();
    let one_cpu_each = policies.len() == logical;

    // Map max_freq -> number of CPUs in the policies at that frequency.
    let mut freq_to_count: HashMap<u64, usize> = HashMap::new();
    let mut total_accounted = 0usize;
    for path in &policies {
        let max_freq: u64 = fs::read_to_string(path.join("cpuinfo_max_freq"))
            .ok()?
            .trim()
            .parse()
            .ok()?;
        let count = if one_cpu_each {
            1
        } else {
            fs::read_to_string(path.join("affected_cpus"))
                .ok()?
                .split_whitespace()
                .count()
        };
        *freq_to_count.entry(max_freq).or_insert(0) += count;
        total_accounted += count;
        if freq_to_count.len() > 2 {
            return None;
        }
    }
    hybrid_label(&freq_to_count, total_accounted, logical)
}

/// `"NP + ME / KT"` when exactly two frequency tiers account for every logical CPU; the
/// higher tier is the performance cores.
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn hybrid_label(
    freq_to_count: &std::collections::HashMap<u64, usize>,
    total_accounted: usize,
    logical: usize,
) -> Option<String> {
    if freq_to_count.len() != 2 || total_accounted != logical {
        return None;
    }
    let mut tiers: Vec<(u64, usize)> = freq_to_count.iter().map(|(f, c)| (*f, *c)).collect();
    tiers.sort_by_key(|t| std::cmp::Reverse(t.0)); // highest freq first = P-cores
    Some(format!("{}P + {}E / {}T", tiers[0].1, tiers[1].1, logical))
}

/// On macOS Apple Silicon, detects P/E cores via `hw.nperflevels` and
/// `hw.perflevelN.logicalcpu` sysctls. Returns `None` on Intel Macs or if unavailable.
#[cfg(target_os = "macos")]
fn detect_macos_hybrid_cores(logical: usize) -> Option<String> {
    extern "C" {
        fn sysctlbyname(
            name: *const i8,
            oldp: *mut std::ffi::c_void,
            oldlenp: *mut usize,
            newp: *mut std::ffi::c_void,
            newlen: usize,
        ) -> i32;
    }

    let read_u32 = |key: &str| -> Option<u32> {
        let name = std::ffi::CString::new(key).ok()?;
        let mut value: u32 = 0;
        let mut size = std::mem::size_of::<u32>();
        let ret = unsafe {
            sysctlbyname(
                name.as_ptr(),
                &mut value as *mut u32 as *mut std::ffi::c_void,
                &mut size,
                std::ptr::null_mut(),
                0,
            )
        };
        if ret == 0 {
            Some(value)
        } else {
            None
        }
    };

    // hw.nperflevels == 2 on M-series (P + E), absent or 1 on Intel
    let nlevels = read_u32("hw.nperflevels")?;
    if nlevels != 2 {
        return None;
    }

    let p_cores = read_u32("hw.perflevel0.logicalcpu")? as usize;
    let e_cores = read_u32("hw.perflevel1.logicalcpu")? as usize;

    if p_cores + e_cores != logical {
        return None;
    }

    Some(format!("{}P + {}E / {}T", p_cores, e_cores, logical))
}

/// Returns the overall (min_khz, max_khz) CPU frequency range from sysfs cpufreq policies.
/// min is the smallest `cpuinfo_min_freq` across all policies; max is the largest `cpuinfo_max_freq`.
pub fn detect_cpu_freq_range() -> Option<(u64, u64)> {
    #[cfg(target_os = "linux")]
    {
        use std::fs;
        let cpufreq = std::path::Path::new("/sys/devices/system/cpu/cpufreq");
        if !cpufreq.exists() {
            return None;
        }
        let mut global_min: Option<u64> = None;
        let mut global_max: Option<u64> = None;
        let Ok(policies) = fs::read_dir(cpufreq) else {
            return None;
        };
        for policy in policies.flatten() {
            let path = policy.path();
            if !path.is_dir() {
                continue;
            }
            if let Ok(s) = fs::read_to_string(path.join("cpuinfo_min_freq")) {
                if let Ok(v) = s.trim().parse::<u64>() {
                    global_min = Some(global_min.map_or(v, |m: u64| m.min(v)));
                }
            }
            if let Ok(s) = fs::read_to_string(path.join("cpuinfo_max_freq")) {
                if let Ok(v) = s.trim().parse::<u64>() {
                    global_max = Some(global_max.map_or(v, |m: u64| m.max(v)));
                }
            }
        }
        match (global_min, global_max) {
            (Some(min), Some(max)) => Some((min, max)),
            _ => None,
        }
    }
    #[cfg(not(target_os = "linux"))]
    {
        None
    }
}

#[cfg(not(target_os = "linux"))]
fn detect_desktop_from_proc() -> Option<String> {
    None
}

#[cfg(target_os = "linux")]
fn detect_desktop_from_proc() -> Option<String> {
    const DE_PROCS: &[(&str, &str)] = &[
        ("gnome-shell", "GNOME"),
        ("plasmashell", "KDE Plasma"),
        ("xfce4-session", "XFCE"),
        ("mate-session", "MATE"),
        ("cinnamon", "Cinnamon"),
        ("budgie-daemon", "Budgie"),
        ("budgie-panel", "Budgie"),
        ("lxsession", "LXDE"),
        ("lxqt-session", "LXQt"),
        ("deepin-session", "Deepin"),
        ("dde-session-daemon", "Deepin"),
        ("gala", "Pantheon"),
        ("enlightenment", "Enlightenment"),
    ];
    let Ok(entries) = std::fs::read_dir("/proc") else {
        return None;
    };
    for entry in entries.filter_map(|e| e.ok()) {
        let path = entry.path();
        if !path.is_dir() {
            continue;
        }
        let Ok(comm) = std::fs::read_to_string(path.join("comm")) else {
            continue;
        };
        let comm = comm.trim().to_lowercase();
        for (proc_name, de_name) in DE_PROCS {
            if comm == *proc_name || comm.starts_with(proc_name) {
                return Some(de_name.to_string());
            }
        }
    }
    None
}

fn normalize_desktop_name(raw: &str) -> String {
    let s = raw.trim();
    // Canonical casing for well-known desktop environments
    match s.to_lowercase().as_str() {
        "gnome" => "GNOME".to_string(),
        "kde" | "kde plasma" | "plasma" => "KDE Plasma".to_string(),
        "xfce" => "XFCE".to_string(),
        "lxde" => "LXDE".to_string(),
        "lxqt" => "LXQt".to_string(),
        "mate" => "MATE".to_string(),
        "cinnamon" => "Cinnamon".to_string(),
        "budgie" => "Budgie".to_string(),
        "deepin" => "Deepin".to_string(),
        "pantheon" => "Pantheon".to_string(),
        "unity" => "Unity".to_string(),
        "enlightenment" | "e" => "Enlightenment".to_string(),
        _ => {
            // Title-case if it's all lowercase; otherwise preserve as-is
            if s.chars().all(|c| c.is_lowercase() || !c.is_alphabetic()) {
                let mut chars = s.chars();
                match chars.next() {
                    None => String::new(),
                    Some(c) => c.to_uppercase().collect::<String>() + chars.as_str(),
                }
            } else {
                s.to_string()
            }
        }
    }
}

fn detect_init_system() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        let comm = std::fs::read_to_string("/proc/1/comm")
            .map(|s| s.trim().to_string())
            .ok()
            .filter(|s| !s.is_empty());
        if let Some(name) = comm {
            return Some(name);
        }
        std::fs::read_link("/proc/1/exe").ok().and_then(|p| {
            p.file_name()
                .and_then(|n| n.to_str())
                .map(|s| s.to_string())
        })
    }
    #[cfg(target_os = "macos")]
    {
        Some("launchd".to_string())
    }
    #[cfg(target_os = "windows")]
    {
        Some("SCM".to_string())
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
    {
        None
    }
}

fn detect_chassis() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        let raw = std::fs::read_to_string("/sys/class/dmi/id/chassis_type").ok()?;
        let n: u32 = raw.trim().parse().ok()?;
        let label = match n {
            3 => "Desktop",
            4 => "Low-Profile Desktop",
            6 => "Mini Tower",
            7 => "Tower",
            8 | 9 | 10 | 14 | 31 | 32 => "Laptop",
            11 => "Handheld",
            13 => "All-in-One",
            17 => "Main Server",
            23 => "Rack Server",
            28 => "Blade",
            30 => "Tablet",
            35 => "Mini PC",
            36 => "Stick PC",
            _ => return None,
        };
        Some(label.to_string())
    }
    #[cfg(target_os = "macos")]
    {
        let output = std::process::Command::new("sysctl")
            .args(["-n", "hw.model"])
            .output()
            .ok()?;
        let model = String::from_utf8(output.stdout).ok()?;
        let model = model.trim();
        if model.contains("MacBook") {
            Some("Laptop".to_string())
        } else if model.contains("MacPro") {
            Some("Desktop".to_string())
        } else if model.contains("Macmini") || model.contains("Mac mini") {
            Some("Mini PC".to_string())
        } else if model.contains("iMac") {
            Some("All-in-One".to_string())
        } else {
            Some(model.to_string())
        }
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        None
    }
}

fn detect_bootmgr() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        use std::path::Path;
        let is_uefi = Path::new("/sys/firmware/efi").exists();
        if Path::new("/boot/loader/entries").exists()
            || Path::new("/boot/loader/loader.conf").exists()
            || Path::new("/efi/loader/loader.conf").exists()
        {
            return Some("systemd-boot".to_string());
        }
        if Path::new("/boot/grub2/grub.cfg").exists() || Path::new("/boot/grub2").exists() {
            return Some("GRUB 2".to_string());
        }
        if Path::new("/boot/grub/grub.cfg").exists() || Path::new("/boot/grub").exists() {
            return Some("GRUB".to_string());
        }
        if is_uefi {
            Some("UEFI".to_string())
        } else {
            Some("BIOS".to_string())
        }
    }
    #[cfg(target_os = "macos")]
    {
        Some("Apple Boot ROM".to_string())
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        None
    }
}

/// Detects the active display/login manager (GDM, SDDM, LightDM, …).
///
/// Linux only. Resolves the `display-manager.service` systemd alias symlink
/// (`/etc/systemd/system/display-manager.service` → e.g. `…/gdm.service`) and prettifies
/// the unit name via [`login_manager_from_unit`]. This is the cheapest reliable signal on
/// any systemd system (no subprocess, single `read_link`); non-systemd setups return `None`.
fn detect_login_manager() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        let target = std::fs::read_link("/etc/systemd/system/display-manager.service").ok()?;
        let unit = target.file_name().and_then(|n| n.to_str())?;
        login_manager_from_unit(unit)
    }
    #[cfg(target_os = "macos")]
    {
        // macOS has exactly one login manager and always has: loginwindow. There is no
        // choice to detect, so the only informative part is its version, which is what
        // fastfetch reports too ("Login Window 9.0").
        let plist = std::fs::read_to_string(LOGINWINDOW_PLIST).ok()?;
        Some(format_login_window(parse_plist_string(
            &plist,
            "CFBundleShortVersionString",
        )))
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        None
    }
}

/// Path to loginwindow's bundle metadata.
#[cfg(target_os = "macos")]
const LOGINWINDOW_PLIST: &str = "/System/Library/CoreServices/loginwindow.app/Contents/Info.plist";

/// Extract a `<string>` value for `key` from an XML property list.
///
/// **Deliberately a small scanner rather than a plist dependency or a `defaults` call.**
/// This file is plain XML on macOS 26 (verified: it begins `<?xml ve`, not `bplist`), the
/// crate has a zero-subprocess policy for detection, and pulling in a plist parser to read
/// one string would be disproportionate. It is pure, so it is unit-tested against a
/// verbatim excerpt rather than the host's own file.
///
/// Returns `None` rather than guessing if the structure is not the expected
/// `<key>K</key><string>V</string>` pairing — a version is better omitted than invented.
#[cfg(any(target_os = "macos", test))]
fn parse_plist_string(xml: &str, key: &str) -> Option<String> {
    let needle = format!("<key>{key}</key>");
    let rest = xml.split_once(&needle)?.1;
    let open = rest.find("<string>")?;
    // Guard against the key's value being a non-string type: if another <key> appears
    // before the next <string>, this key does not have a string value.
    if let Some(next_key) = rest.find("<key>") {
        if next_key < open {
            return None;
        }
    }
    let after = &rest[open + "<string>".len()..];
    let end = after.find("</string>")?;
    let value = after[..end].trim();
    (!value.is_empty()).then(|| value.to_string())
}

/// Render the macOS login manager, with its version when one could be read.
///
/// Pure and separate from the file read so the formatting is testable without `/System`.
#[cfg(any(target_os = "macos", test))]
fn format_login_window(version: Option<String>) -> String {
    match version {
        Some(v) => format!("Login Window {v}"),
        None => "Login Window".to_string(),
    }
}

/// Pure helper: maps a systemd display-manager unit file name to a display name.
///
/// Strips a trailing `.service` and prettifies well-known managers; unknown managers are
/// Title-cased so new ones still render reasonably. Returns `None` for an empty stem.
/// Split out from [`detect_login_manager`] so it is unit-testable without touching `/etc`.
#[cfg(target_os = "linux")]
fn login_manager_from_unit(unit: &str) -> Option<String> {
    let stem = unit.strip_suffix(".service").unwrap_or(unit).trim();
    if stem.is_empty() {
        return None;
    }
    let pretty = match stem.to_lowercase().as_str() {
        "gdm" | "gdm3" => "GDM",
        "sddm" => "SDDM",
        "lightdm" => "LightDM",
        "lxdm" => "LXDM",
        "xdm" => "XDM",
        "ly" => "Ly",
        "greetd" => "greetd",
        "slim" => "SLiM",
        "nodm" => "nodm",
        "entrance" => "Entrance",
        _ => {
            // Title-case the first letter, keep the rest as-is (e.g. "emptty" → "Emptty").
            let mut chars = stem.chars();
            return chars
                .next()
                .map(|c| c.to_uppercase().collect::<String>() + chars.as_str());
        }
    };
    Some(pretty.to_string())
}

/// Detects the current backlight brightness as a percentage.
///
/// Linux only. Reads `brightness` and `max_brightness` from the first
/// `/sys/class/backlight/*` device (preferring a vendor backlight over a raw ACPI one), and
/// formats via [`brightness_percent`]. Machines with no backlight (most desktops) return
/// `None`, so the field simply does not render.
fn detect_brightness() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        use std::path::Path;
        let dir = Path::new("/sys/class/backlight");
        if !dir.exists() {
            return None;
        }
        // Collect device dirs; prefer a vendor/GPU backlight (e.g. intel_backlight,
        // amdgpu_bl0) over a generic ACPI one (acpi_video0) when several are present.
        let mut devices: Vec<std::path::PathBuf> = std::fs::read_dir(dir)
            .ok()?
            .flatten()
            .map(|e| e.path())
            .collect();
        devices.sort_by_key(|p| {
            let name = p
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("")
                .to_lowercase();
            // Lower sort key = higher preference.
            if name.contains("acpi") || name.contains("video") {
                1
            } else {
                0
            }
        });
        for dev in devices {
            let cur = std::fs::read_to_string(dev.join("brightness"))
                .ok()
                .and_then(|s| s.trim().parse::<u64>().ok());
            let max = std::fs::read_to_string(dev.join("max_brightness"))
                .ok()
                .and_then(|s| s.trim().parse::<u64>().ok());
            if let (Some(cur), Some(max)) = (cur, max) {
                if let Some(pct) = brightness_percent(cur, max) {
                    return Some(pct);
                }
            }
        }
        None
    }
    #[cfg(target_os = "macos")]
    {
        let (value, min, max) = crate::macos_ffi::get_backlight_brightness()?;
        // Rebased onto the shared `brightness_percent(cur, max)` helper by subtracting the
        // floor, so the percentage arithmetic lives in one tested place rather than two.
        // macOS reports min = 0 in practice (measured: 0 / 32768 / 65536), but the range
        // is expressed as a triple and a nonzero floor would otherwise inflate the figure.
        let span = max.checked_sub(min)?;
        let level = value.checked_sub(min)?;
        if span <= 0 || level < 0 {
            return None;
        }
        brightness_percent(level as u64, span as u64)
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        None
    }
}

/// Pure helper: formats a raw brightness/max pair as a rounded percentage string.
///
/// Returns `None` when `max` is 0 (divide-by-zero guard). Split out from
/// [`detect_brightness`] so it is unit-testable without a real backlight device.
///
/// Shared by both backlight arms: Linux passes the raw `brightness`/`max_brightness`
/// pair, and macOS passes the `AppleARMBacklight` triple rebased onto a zero floor, so
/// the percentage arithmetic exists in exactly one tested place.
#[cfg(any(target_os = "linux", target_os = "macos"))]
fn brightness_percent(cur: u64, max: u64) -> Option<String> {
    if max == 0 {
        return None;
    }
    let pct = (cur as f64 / max as f64 * 100.0).round() as u64;
    Some(format!("{}%", pct))
}

/// Detects the AC power adapter (name + connection state).
///
/// Linux only. Scans `/sys/class/power_supply/*` for a `Mains`-type supply (the AC
/// adapter), reads its `online` flag, and formats via [`format_power_adapter`]. Wattage is
/// not reported: `Mains` entries rarely expose it in sysfs, so emitting it would be
/// unreliable. Returns `None` when no AC adapter is present (e.g. a desktop with no
/// power_supply class, or a battery-only view).
fn detect_power_adapter() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        use std::path::Path;
        let dir = Path::new("/sys/class/power_supply");
        if !dir.exists() {
            return None;
        }
        for entry in std::fs::read_dir(dir).ok()?.flatten() {
            let path = entry.path();
            let supply_type = std::fs::read_to_string(path.join("type"))
                .map(|s| s.trim().to_string())
                .unwrap_or_default();
            if supply_type != "Mains" {
                continue;
            }
            let name = path
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("AC")
                .to_string();
            let online = std::fs::read_to_string(path.join("online"))
                .map(|s| s.trim().to_string())
                .unwrap_or_default();
            return Some(format_power_adapter(&name, &online));
        }
        None
    }
    #[cfg(target_os = "macos")]
    {
        // `IOPSCopyExternalPowerAdapterDetails` returns NULL on battery, so absence *is*
        // the unplugged signal and there is no separate flag to read. It also exposes no
        // `Name`, so macOS reports the wattage the Linux arm cannot — the reverse of the
        // Linux trade, and the reason these two arms format differently.
        let watts = crate::macos_ffi::get_power_adapter_watts()?;
        Some(format_power_adapter_watts(watts))
    }
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        None
    }
}

/// Render a macOS power adapter from its wattage.
///
/// Separate from [`format_power_adapter`] because the two platforms have different facts
/// to report: Linux has a supply *name* and an `online` flag but no wattage; macOS has
/// wattage and no name, and reports nothing at all when unplugged. A non-positive wattage
/// is dropped rather than printed — `0W (connected)` describes no real adapter.
#[cfg(any(target_os = "macos", test))]
fn format_power_adapter_watts(watts: i64) -> String {
    if watts > 0 {
        format!("{watts}W (connected)")
    } else {
        "connected".to_string()
    }
}

/// Pure helper: formats an AC adapter name + `online` flag ("0"/"1") into a display string.
///
/// Split out from [`detect_power_adapter`] so it is unit-testable without a real adapter.
#[cfg(target_os = "linux")]
fn format_power_adapter(name: &str, online: &str) -> String {
    let state = match online.trim() {
        "1" => "connected",
        "0" => "not connected",
        _ => "unknown",
    };
    format!("{} ({})", name, state)
}

/// Detects the Trusted Platform Module's specification version (e.g. "2.0").
///
/// Linux only. Reads `tpm_version_major` from the first `/sys/class/tpm/*` device and formats
/// via [`format_tpm_version`]. A machine with no TPM has no such class directory and returns
/// `None`, so the field does not render. The version is deliberately *not* guessed from the
/// device's mere presence: a TPM whose version cannot be read is reported as absent rather
/// than as a version that was never confirmed.
fn detect_tpm() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        use std::path::Path;
        let dir = Path::new("/sys/class/tpm");
        if !dir.exists() {
            return None;
        }
        let mut devices: Vec<std::path::PathBuf> = std::fs::read_dir(dir)
            .ok()?
            .flatten()
            .map(|e| e.path())
            .collect();
        // `tpm0` before `tpm1`, so a multi-TPM machine reports a stable one run to run.
        devices.sort();
        for dev in devices {
            if let Ok(major) = std::fs::read_to_string(dev.join("tpm_version_major")) {
                if let Some(v) = format_tpm_version(major.trim()) {
                    return Some(v);
                }
            }
        }
        None
    }
    #[cfg(not(target_os = "linux"))]
    {
        None
    }
}

/// Pure helper: maps sysfs `tpm_version_major` to a TPM specification version string.
///
/// The kernel exposes only the major number, but the published specification names are "1.2"
/// and "2.0" — not "1.0"/"2.0" — so the minor part is a lookup, not arithmetic. An
/// unrecognised or unparseable major yields `None` rather than an invented version. Split out
/// from [`detect_tpm`] so it is unit-testable without a real TPM.
#[cfg(target_os = "linux")]
fn format_tpm_version(major: &str) -> Option<String> {
    match major.trim() {
        "1" => Some("1.2".to_string()),
        "2" => Some("2.0".to_string()),
        _ => None,
    }
}

/// Windows CPU-usage sampling via `GetSystemTimes` (kernel32, default-linked).
///
/// Replaces the per-run 200 ms sleep sysinfo needs for a usage delta: two samples are
/// diffed across the existing concurrent-probe window instead, so no sleep is added.
#[cfg(target_os = "windows")]
mod win_cpu {
    #[repr(C)]
    struct FileTime {
        low: u32,
        high: u32,
    }

    impl FileTime {
        fn ticks(&self) -> u64 {
            ((self.high as u64) << 32) | self.low as u64
        }
    }

    extern "system" {
        fn GetSystemTimes(idle: *mut FileTime, kernel: *mut FileTime, user: *mut FileTime) -> i32;
    }

    /// Cumulative `(idle, kernel, user)` CPU ticks (100 ns units). `kernel` includes idle,
    /// per the Win32 contract. `None` if the call fails.
    pub fn sample() -> Option<(u64, u64, u64)> {
        let mut idle = FileTime { low: 0, high: 0 };
        let mut kernel = FileTime { low: 0, high: 0 };
        let mut user = FileTime { low: 0, high: 0 };
        // SAFETY: three valid, writable FILETIME out-parameters.
        let ok = unsafe { GetSystemTimes(&mut idle, &mut kernel, &mut user) };
        if ok == 0 {
            None
        } else {
            Some((idle.ticks(), kernel.ticks(), user.ticks()))
        }
    }

    /// System-wide CPU busy percentage between two `sample()` snapshots. Because `kernel`
    /// includes idle, `total = Δkernel + Δuser` and `busy = total − Δidle`.
    pub fn usage_percent(s0: (u64, u64, u64), s1: (u64, u64, u64)) -> f32 {
        let idle = s1.0.saturating_sub(s0.0);
        let kernel = s1.1.saturating_sub(s0.1);
        let user = s1.2.saturating_sub(s0.2);
        let total = kernel + user;
        if total == 0 {
            0.0
        } else {
            (100.0 * total.saturating_sub(idle) as f64 / total as f64) as f32
        }
    }

    #[cfg(test)]
    mod layout {
        use std::mem::size_of;

        // Two u32 FILETIME words = 8 bytes; the ticks() reader depends on this.
        #[test]
        fn filetime_size() {
            assert_eq!(size_of::<super::FileTime>(), 8);
        }
    }
}

#[cfg(test)]
mod tests {

    /// Builds a fake cpufreq tree: one `policyN` per `(max_freq, affected)` entry, where
    /// `affected: None` writes no `affected_cpus` file at all.
    fn fake_cpufreq(name: &str, policies: &[(u64, Option<&str>)]) -> std::path::PathBuf {
        let root =
            std::env::temp_dir().join(format!("retch-cpufreq-{name}-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&root);
        for (i, (freq, affected)) in policies.iter().enumerate() {
            let dir = root.join(format!("policy{i}"));
            std::fs::create_dir_all(&dir).unwrap();
            std::fs::write(dir.join("cpuinfo_max_freq"), format!("{freq}\n")).unwrap();
            if let Some(a) = affected {
                std::fs::write(dir.join("affected_cpus"), a).unwrap();
            }
        }
        root
    }

    #[test]
    fn hybrid_per_cpu_policies_need_no_affected_cpus() {
        // 4 P-cores at 5 GHz, 8 E-cores at 3.8 GHz, one policy per CPU, and no
        // `affected_cpus` files: the count must come from the policy count alone.
        let mut p: Vec<(u64, Option<&str>)> = vec![(5_000_000, None); 4];
        p.extend(vec![(3_800_000, None); 8]);
        let root = fake_cpufreq("percpu", &p);
        assert_eq!(hybrid_cores_in(&root, 12).as_deref(), Some("4P + 8E / 12T"));
        let _ = std::fs::remove_dir_all(&root);
    }

    #[test]
    fn hybrid_cluster_policies_still_read_affected_cpus() {
        // big.LITTLE style: cluster policies, deliberately unequal in size so a P/E swap
        // cannot produce the same string.
        let root = fake_cpufreq(
            "cluster",
            &[
                (2_400_000, Some("0 1\n")),
                (1_800_000, Some("2 3 4 5 6 7\n")),
            ],
        );
        assert_eq!(hybrid_cores_in(&root, 8).as_deref(), Some("2P + 6E / 8T"));
        let _ = std::fs::remove_dir_all(&root);
    }

    #[test]
    fn hybrid_is_none_for_one_or_three_tiers() {
        let one = fake_cpufreq("one", &vec![(3_000_000, None); 8]);
        assert_eq!(
            hybrid_cores_in(&one, 8),
            None,
            "a single tier is not hybrid"
        );
        let _ = std::fs::remove_dir_all(&one);
        let three = fake_cpufreq(
            "three",
            &[(3_000_000, None), (2_000_000, None), (1_000_000, None)],
        );
        assert_eq!(hybrid_cores_in(&three, 3), None, "three tiers are not P/E");
        let _ = std::fs::remove_dir_all(&three);
    }

    #[test]
    fn hybrid_is_none_when_policies_do_not_cover_every_cpu() {
        let root = fake_cpufreq(
            "partial",
            &[(5_000_000, Some("0 1\n")), (3_000_000, Some("2\n"))],
        );
        assert_eq!(hybrid_cores_in(&root, 8), None);
        let _ = std::fs::remove_dir_all(&root);
    }

    #[test]
    fn remaining_wait_covers_only_what_the_work_in_between_did_not() {
        use std::time::Duration;
        let ms = Duration::from_millis;
        assert_eq!(remaining_wait(ms(200), ms(0)), ms(200), "nothing elapsed");
        assert_eq!(remaining_wait(ms(200), ms(157)), ms(43), "the remainder");
        assert_eq!(remaining_wait(ms(200), ms(200)), ms(0), "exactly spent");
        // The `--long` case this exists for: a 237 ms scope already covers the interval,
        // so the old fixed 200 ms sleep after it was entirely wasted.
        assert_eq!(
            remaining_wait(ms(200), ms(237)),
            ms(0),
            "overspent, no wait"
        );
    }

    #[test]
    fn exclude_own_usage_removes_retchs_share_of_the_machine() {
        use std::time::Duration;
        let ms = Duration::from_millis;
        // 100 ms of retch CPU over a 200 ms window on 4 CPUs is 12.5% of the machine.
        assert!((exclude_own_usage(20.0, ms(100), ms(200), 4) - 7.5).abs() < 1e-4);
        // The same work is a far smaller share of a 32-thread machine: 1.5625%.
        assert!((exclude_own_usage(3.0, ms(100), ms(200), 32) - 1.4375).abs() < 1e-4);
        // No own time, nothing removed.
        assert_eq!(exclude_own_usage(5.0, ms(0), ms(200), 8), 5.0);
    }

    #[test]
    fn exclude_own_usage_never_goes_negative_or_divides_by_zero() {
        use std::time::Duration;
        let ms = Duration::from_millis;
        assert_eq!(exclude_own_usage(1.0, ms(100), ms(200), 4), 0.0, "clamped");
        assert_eq!(
            exclude_own_usage(5.0, ms(10), ms(0), 4),
            5.0,
            "empty window"
        );
        assert_eq!(exclude_own_usage(5.0, ms(10), ms(200), 0), 5.0, "no CPUs");
    }

    /// `own_cpu_time` must actually move when this process burns CPU — a getrusage call
    /// that silently returned zero would make the correction a no-op.
    #[cfg(not(target_os = "windows"))]
    #[test]
    fn own_cpu_time_counts_work_done_by_this_process() {
        let before = own_cpu_time();
        let t = std::time::Instant::now();
        let mut x: u64 = 0;
        while t.elapsed() < std::time::Duration::from_millis(50) {
            x = std::hint::black_box(x.wrapping_mul(6364136223846793005).wrapping_add(1));
        }
        let used = own_cpu_time().saturating_sub(before);
        assert!(
            used >= std::time::Duration::from_millis(20),
            "50 ms of busy work registered as {used:?}"
        );
    }

    /// `cpu-usage` requested on its own has no probes to overlap with, so the run must
    /// still span the full minimum interval — a shorter one would diff two samples taken
    /// almost together and report noise. Guards against the wait being computed from the
    /// wrong starting point, or skipped.
    #[cfg(not(target_os = "windows"))]
    #[test]
    fn cpu_usage_alone_still_waits_out_the_minimum_interval() {
        let opts = CollectOptions {
            fields: Some(vec!["cpu-usage".to_string()]),
            ..Default::default()
        };
        let t0 = std::time::Instant::now();
        let _ = SystemInfo::collect(opts).expect("collect");
        let elapsed = t0.elapsed();
        assert!(
            elapsed >= sysinfo::MINIMUM_CPU_UPDATE_INTERVAL,
            "cpu-usage alone took {elapsed:?}, under sysinfo's {:?} minimum",
            sysinfo::MINIMUM_CPU_UPDATE_INTERVAL
        );
    }

    #[test]
    fn cpu_refresh_kind_is_none_unless_freq_or_usage_needs_sys() {
        // Plain `cpu` no longer loads the list into `sys`; its probe reads its own.
        assert!(cpu_refresh_kind(false, false).is_none());
    }

    #[test]
    fn cpu_refresh_kind_for_plain_cpu_asks_for_neither_flag() {
        // Brand and core count come from the static CPU list. Asking for frequency here
        // is what made every `--short` run pay ~195 ms of performance-counter setup on
        // Windows for a field it does not display.
        let kind = own_cpu_refresh_kind();
        assert!(!kind.frequency(), "plain `cpu` must not request frequency");
        assert!(!kind.cpu_usage(), "plain `cpu` must not request cpu usage");
    }

    #[test]
    fn cpu_refresh_kind_asks_for_frequency_only_for_cpu_freq() {
        let kind = cpu_refresh_kind(true, false).expect("cpu-freq selected");
        assert!(
            kind.frequency(),
            "`cpu-freq` reads Cpu::frequency() and must request it"
        );
    }

    #[test]
    fn cpu_refresh_kind_asks_for_usage_only_off_windows() {
        let kind = cpu_refresh_kind(false, true).expect("cpu-usage selected");
        if cfg!(target_os = "windows") {
            // The Windows arm diffs its own GetSystemTimes samples and never reads
            // sysinfo's counters, so priming them would be unread cost.
            assert!(!kind.cpu_usage());
        } else {
            // The Unix arm deltas against this baseline; without it the reading is zero.
            assert!(kind.cpu_usage());
        }
        assert!(!kind.frequency(), "cpu-usage must not drag in frequency");
    }

    fn collect_fields(fields: &[&str]) -> SystemInfo {
        SystemInfo::collect(CollectOptions {
            fields: Some(fields.iter().map(|f| f.to_string()).collect()),
            ..Default::default()
        })
        .expect("collect")
    }

    /// `cpu` is filled by two different paths since v0.20.4 — its own probe when `sys` has
    /// no CPU list, `sys` when `cpu-freq` loaded one — and both must give the same name
    /// and a real core string. A path that forgot to fill a value would show here as an
    /// empty name or zero cores.
    #[test]
    fn cpu_fields_are_the_same_whichever_path_fills_them() {
        let alone = collect_fields(&["cpu"]);
        let with_freq = collect_fields(&["cpu", "cpu-freq"]);
        assert!(!alone.cpu.is_empty(), "name read by the probe itself");
        assert!(
            alone.cpu_cores > 0,
            "logical count read by the probe itself"
        );
        assert!(!alone.cpu_core_info.is_empty());
        assert_eq!(alone.cpu, with_freq.cpu, "same name from either path");
        assert_eq!(alone.cpu_cores, with_freq.cpu_cores);
        assert_eq!(alone.cpu_core_info, with_freq.cpu_core_info);
    }

    /// The concurrent split (hybrid on one thread, physical count on another, joined
    /// afterwards) must produce exactly what the public `format_cpu_cores` does.
    #[test]
    fn cpu_core_string_matches_format_cpu_cores() {
        let info = collect_fields(&["cpu"]);
        assert_eq!(
            info.cpu_core_info,
            format_cpu_cores(info.cpu_cores, System::physical_core_count())
        );
    }

    /// The Windows fallback source must exist and hold a name on real Windows machines —
    /// including the ARM64 runner, where sysinfo's own brand is always empty.
    #[cfg(target_os = "windows")]
    #[test]
    fn windows_registry_has_a_cpu_name() {
        let name = windows_cpu_name();
        assert!(
            name.as_deref().is_some_and(|n| !n.is_empty()),
            "ProcessorNameString missing: {name:?}"
        );
    }

    #[test]
    fn cpu_fields_stay_empty_when_cpu_is_not_requested() {
        let info = collect_fields(&["os"]);
        assert!(info.cpu.is_empty());
        assert_eq!(info.cpu_cores, 0);
        assert!(info.cpu_core_info.is_empty());
    }

    #[test]
    fn load_is_probed_only_when_selected_and_never_on_windows() {
        assert!(
            !should_probe_load(false),
            "an unselected `load` must not be probed on any platform"
        );
        if cfg!(target_os = "windows") {
            assert!(
                !should_probe_load(true),
                "sysinfo's Windows load average samples every 5 s from a zeroed static,                  so it can only ever report 0.00 in a process this short-lived"
            );
        } else {
            assert!(should_probe_load(true));
        }
    }

    #[test]
    fn shell_and_terminal_each_load_the_process_list_on_their_own() {
        // Both walk the process tree from retch's own pid. Before v0.17.6 only `procs` and
        // `audio` loaded the list, so `--fields shell` alone found no tree to walk and
        // reported the shell the environment implied rather than the one running retch.
        // On Linux none of the four uses the list any more (they read /proc through
        // `proc_tree`, whose live test proves the walk works with no list at all), so
        // there the rule inverts: the list must never be loaded.
        let expected = !cfg!(target_os = "linux");
        assert_eq!(
            needs_process_list(false, false, true, false),
            expected,
            "shell alone"
        );
        assert_eq!(
            needs_process_list(false, false, false, true),
            expected,
            "terminal alone"
        );
        assert_eq!(
            needs_process_list(true, false, false, false),
            expected,
            "procs alone"
        );
        assert_eq!(
            needs_process_list(false, true, false, false),
            expected,
            "audio alone"
        );
        assert!(
            !needs_process_list(false, false, false, false),
            "no consumer selected: the list must not be loaded"
        );
    }

    use super::*;

    #[cfg(target_os = "linux")]
    #[test]
    fn test_login_manager_from_unit() {
        assert_eq!(
            login_manager_from_unit("gdm.service").as_deref(),
            Some("GDM")
        );
        assert_eq!(
            login_manager_from_unit("gdm3.service").as_deref(),
            Some("GDM")
        );
        assert_eq!(
            login_manager_from_unit("sddm.service").as_deref(),
            Some("SDDM")
        );
        assert_eq!(
            login_manager_from_unit("lightdm.service").as_deref(),
            Some("LightDM")
        );
        // Unknown manager: Title-cased, .service stripped, rest preserved.
        assert_eq!(
            login_manager_from_unit("emptty.service").as_deref(),
            Some("Emptty")
        );
        // No .service suffix is tolerated.
        assert_eq!(login_manager_from_unit("ly").as_deref(), Some("Ly"));
        // Empty / suffix-only stems yield None.
        assert_eq!(login_manager_from_unit("").as_deref(), None);
        assert_eq!(login_manager_from_unit(".service").as_deref(), None);
    }

    #[cfg(any(target_os = "linux", target_os = "macos"))]
    #[test]
    fn test_brightness_percent() {
        assert_eq!(brightness_percent(50, 100).as_deref(), Some("50%"));
        assert_eq!(brightness_percent(100, 100).as_deref(), Some("100%"));
        assert_eq!(brightness_percent(0, 100).as_deref(), Some("0%"));
        // Rounding: 133/255 ≈ 52.16% → 52%.
        assert_eq!(brightness_percent(133, 255).as_deref(), Some("52%"));
        // Divide-by-zero guard.
        assert_eq!(brightness_percent(10, 0), None);
    }

    /// Verbatim excerpt from `/System/Library/CoreServices/loginwindow.app/Contents/
    /// Info.plist` on macOS 26 — the file is plain XML there, not a binary plist, which is
    /// what makes a dependency-free scan reasonable.
    #[test]
    fn test_parse_plist_string() {
        const PLIST: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
<plist version="1.0">
<dict>
	<key>CFBundleName</key>
	<string>loginwindow</string>
	<key>CFBundleShortVersionString</key>
	<string>9.0</string>
	<key>CFBundleVersion</key>
	<string>3085.6.3</string>
</dict>
</plist>"#;
        assert_eq!(
            parse_plist_string(PLIST, "CFBundleShortVersionString").as_deref(),
            Some("9.0")
        );
        assert_eq!(
            parse_plist_string(PLIST, "CFBundleVersion").as_deref(),
            Some("3085.6.3")
        );
        // A key that is not present yields None rather than the next string in the file,
        // which is the failure mode a naive scan would have.
        assert_eq!(parse_plist_string(PLIST, "NoSuchKey"), None);
    }

    /// A key whose value is not a string must not borrow the *next* key's string.
    ///
    /// Without the intervening-`<key>` guard this returns `"unrelated"` for `Flag` — a
    /// confidently wrong version number rather than an absent one.
    #[test]
    fn test_parse_plist_string_rejects_a_non_string_value() {
        const PLIST: &str = r#"<dict>
	<key>Flag</key>
	<true/>
	<key>Other</key>
	<string>unrelated</string>
</dict>"#;
        assert_eq!(parse_plist_string(PLIST, "Flag"), None);
        assert_eq!(
            parse_plist_string(PLIST, "Other").as_deref(),
            Some("unrelated")
        );
    }

    #[test]
    fn test_format_login_window() {
        assert_eq!(format_login_window(Some("9.0".into())), "Login Window 9.0");
        // No version read: still name the manager rather than reporting nothing, since
        // macOS always has exactly one and its presence is not in doubt.
        assert_eq!(format_login_window(None), "Login Window");
    }

    #[test]
    fn test_format_power_adapter_watts() {
        assert_eq!(format_power_adapter_watts(96), "96W (connected)");
        // A non-positive wattage describes no real adapter, so the number is dropped
        // rather than printed as "0W (connected)".
        assert_eq!(format_power_adapter_watts(0), "connected");
        assert_eq!(format_power_adapter_watts(-1), "connected");
    }

    /// The macOS backlight triple is rebased onto a zero floor before being handed to the
    /// shared percentage helper. Pins that arithmetic with the values this machine
    /// actually reports, plus a nonzero-floor case the hardware here does not produce.
    #[cfg(any(target_os = "linux", target_os = "macos"))]
    #[test]
    fn test_backlight_triple_rebasing() {
        // Measured on an M3 Pro: value 32768, min 0, max 65536.
        assert_eq!(
            brightness_percent((32768i64 - 0) as u64, (65536i64 - 0) as u64).as_deref(),
            Some("50%")
        );
        // A nonzero floor must not inflate the reading: halfway between 100 and 300 is
        // 50%, not the 67% a naive value/max would give.
        assert_eq!(
            brightness_percent((200i64 - 100) as u64, (300i64 - 100) as u64).as_deref(),
            Some("50%")
        );
    }

    #[cfg(target_os = "linux")]
    #[test]
    fn test_format_power_adapter() {
        assert_eq!(format_power_adapter("AC", "1"), "AC (connected)");
        assert_eq!(format_power_adapter("ADP1", "0"), "ADP1 (not connected)");
        // Missing/garbage online flag degrades to "unknown" rather than panicking.
        assert_eq!(format_power_adapter("AC", ""), "AC (unknown)");
    }

    #[cfg(target_os = "linux")]
    #[test]
    fn test_format_tpm_version() {
        // The spec names are 1.2 and 2.0, so the minor part is a lookup, not "major.0".
        assert_eq!(format_tpm_version("2").as_deref(), Some("2.0"));
        assert_eq!(format_tpm_version("1").as_deref(), Some("1.2"));
        // sysfs reads carry a trailing newline.
        assert_eq!(format_tpm_version("2\n").as_deref(), Some("2.0"));
        // An unrecognised or unreadable major is reported as absent, never invented.
        assert_eq!(format_tpm_version("3"), None);
        assert_eq!(format_tpm_version(""), None);
        assert_eq!(format_tpm_version("garbage"), None);
    }

    #[cfg(target_os = "windows")]
    #[test]
    fn test_win_cpu_usage_percent() {
        use super::win_cpu::usage_percent;
        // kernel includes idle. Δidle=50, Δkernel=100 (incl. idle), Δuser=50 → total=150,
        // busy=150-50=100 → 66.67%.
        let u = usage_percent((0, 0, 0), (50, 100, 50));
        assert!((u - 66.6667).abs() < 0.01, "got {}", u);

        // Fully idle: Δidle == Δkernel, Δuser=0 → 0%.
        assert_eq!(usage_percent((0, 0, 0), (100, 100, 0)), 0.0);

        // Fully busy: no idle delta → 100%.
        assert_eq!(usage_percent((0, 0, 0), (0, 100, 100)), 100.0);

        // No time elapsed (zero total) → 0%, no divide-by-zero.
        assert_eq!(usage_percent((5, 10, 10), (5, 10, 10)), 0.0);
    }

    // NOTE: these exercise the pure fallback formatter `format_cpu_cores_plain`, not the
    // public `format_cpu_cores`. The latter first reads the *host's* real CPU topology and
    // returns a "NP + ME / KT" hybrid string on Intel P/E (and Apple Silicon) machines,
    // ignoring the passed-in counts — so calling it with fixed args is machine-dependent
    // and fails on hybrids (an i7-1360P produced "8P + 8E / 16T" for `(16, Some(8))`).
    #[test]
    fn test_format_cpu_cores_no_hyperthreading() {
        // Physical == logical: show plain "N cores"
        assert_eq!(format_cpu_cores_plain(4, Some(4)), "4 cores");
    }

    #[test]
    fn test_format_cpu_cores_hyperthreaded() {
        // Physical < logical: show "NC / NT"
        assert_eq!(format_cpu_cores_plain(16, Some(8)), "8C / 16T");
    }

    #[test]
    fn test_format_cpu_cores_unknown_physical() {
        // No physical count available: fall back to "N cores"
        assert_eq!(format_cpu_cores_plain(8, None), "8 cores");
    }

    #[test]
    fn test_format_cpu_cores_physical_equals_zero() {
        // Degenerate: physical reported as 0 — treat same as unknown
        // physical(0) < logical(8), so would print "0C / 8T"; acceptable but
        // let's confirm the branch taken
        let result = format_cpu_cores_plain(8, Some(0));
        assert!(result.contains("8"), "should mention 8 threads: {}", result);
    }

    #[cfg(target_os = "linux")]
    #[test]
    fn test_detect_cpu_cache_returns_some_on_linux() {
        // On a real Linux machine the sysfs cache dir exists; result should be Some
        // and contain at least one cache level label.
        if std::path::Path::new("/sys/devices/system/cpu/cpu0/cache").exists() {
            let result = detect_cpu_cache();
            assert!(result.is_some(), "expected cache info on Linux with sysfs");
            let s = result.unwrap();
            assert!(
                s.contains("L1") || s.contains("L2") || s.contains("L3"),
                "expected cache level labels, got: {}",
                s
            );
        }
    }

    #[test]
    fn test_normalize_desktop_name_known() {
        assert_eq!(normalize_desktop_name("gnome"), "GNOME");
        assert_eq!(normalize_desktop_name("GNOME"), "GNOME");
        assert_eq!(normalize_desktop_name("kde"), "KDE Plasma");
        assert_eq!(normalize_desktop_name("plasma"), "KDE Plasma");
        assert_eq!(normalize_desktop_name("KDE Plasma"), "KDE Plasma");
        assert_eq!(normalize_desktop_name("xfce"), "XFCE");
        assert_eq!(normalize_desktop_name("lxqt"), "LXQt");
        assert_eq!(normalize_desktop_name("mate"), "MATE");
        assert_eq!(normalize_desktop_name("cinnamon"), "Cinnamon");
        assert_eq!(normalize_desktop_name("e"), "Enlightenment");
    }

    #[test]
    fn test_normalize_desktop_name_unknown_lowercase() {
        // Unknown all-lowercase names get title-cased.
        assert_eq!(normalize_desktop_name("budgie"), "Budgie");
        assert_eq!(normalize_desktop_name("niri"), "Niri");
    }

    #[test]
    fn test_normalize_desktop_name_unknown_mixed() {
        // Unknown mixed-case names are preserved as-is.
        assert_eq!(normalize_desktop_name("MyDE"), "MyDE");
    }

    #[test]
    fn test_normalize_desktop_name_trims_whitespace() {
        assert_eq!(normalize_desktop_name("  gnome  "), "GNOME");
        assert_eq!(normalize_desktop_name(" niri "), "Niri");
    }

    #[cfg(target_os = "linux")]
    #[test]
    fn test_detect_desktop_from_proc_returns_option() {
        // Just verify it runs without panicking and returns a sane value.
        let result = detect_desktop_from_proc();
        if let Some(ref de) = result {
            assert!(!de.is_empty(), "desktop name should not be empty");
        }
    }

    #[cfg(target_os = "linux")]
    #[test]
    fn test_detect_cpu_freq_range_returns_ordered_pair() {
        if std::path::Path::new("/sys/devices/system/cpu/cpufreq").exists() {
            if let Some((min, max)) = detect_cpu_freq_range() {
                assert!(
                    min <= max,
                    "min freq should be <= max freq: {} > {}",
                    min,
                    max
                );
                assert!(min > 0, "min freq should be positive");
            }
        }
    }
}