metrics_lib/

system_health.rs

//! # System Health Monitoring
//!
//! Ultra-fast system resource monitoring with process introspection.
//!
//! ## Features
//!
//! - **Process CPU/Memory tracking** - Automatic detection of current app usage
//! - **System-wide monitoring** - CPU, memory, load average
//! - **Sub-millisecond updates** - Fast health checks
//! - **Cross-platform** - Works on Linux, macOS, Windows
//! - **Zero allocations** - Pure atomic operations
//! - **Health scoring** - Intelligent system health assessment

use std::io;
use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
use std::time::{Duration, Instant};

#[cfg(not(target_os = "linux"))]
use sysinfo::{get_current_pid, CpuExt, ProcessExt, System, SystemExt};

/// System health monitor with process introspection
///
/// Tracks both system-wide and process-specific resource usage.
/// Cache-line aligned for maximum performance.
#[repr(align(64))]
pub struct SystemHealth {
    /// Last system CPU usage (percentage * 100)
    system_cpu: AtomicU32,
    /// Last process CPU usage (percentage * 100)
    process_cpu: AtomicU32,
    /// System memory usage in MB
    system_memory_mb: AtomicU64,
    /// Process memory usage in MB
    process_memory_mb: AtomicU64,
    /// System load average (1 min * 100)
    load_average: AtomicU32,
    /// Process thread count
    thread_count: AtomicU32,
    /// Process file descriptor count
    fd_count: AtomicU32,
    /// Overall health score (0-10000, where 10000 = 100%)
    health_score: AtomicU32,
    /// Milliseconds since `created_at` at the last metrics refresh.
    ///
    /// Stored as a single time unit (milliseconds) so the throttle check in
    /// [`Self::maybe_update`] compares like-for-like. Earlier revisions stored
    /// this as nanoseconds while the throttle compared it against
    /// `update_interval_ms`, freezing refreshes indefinitely.
    last_update_ms: AtomicU64,
    /// Update interval in milliseconds
    update_interval_ms: u64,
    /// Creation timestamp
    created_at: Instant,
    /// Linux-only delta-sample state for process CPU. Stores `(prev_clock_ticks, prev_elapsed_ms)`.
    /// `prev_elapsed_ms = u64::MAX` sentinel = "no prior sample yet".
    #[cfg(target_os = "linux")]
    proc_cpu_prev: std::sync::atomic::AtomicU64,
    #[cfg(target_os = "linux")]
    proc_cpu_prev_ms: std::sync::atomic::AtomicU64,
    #[cfg(not(target_os = "linux"))]
    sys: parking_lot::Mutex<System>,
    #[cfg(not(target_os = "linux"))]
    pid: Option<sysinfo::Pid>,
}

/// System resource usage snapshot
#[derive(Debug, Clone)]
pub struct SystemSnapshot {
    /// System CPU usage percentage (0.0-100.0)
    pub system_cpu_percent: f64,
    /// Process CPU usage percentage (0.0-100.0)  
    pub process_cpu_percent: f64,
    /// System memory usage in MB
    pub system_memory_mb: u64,
    /// Process memory usage in MB
    pub process_memory_mb: u64,
    /// System load average (1 minute)
    pub load_average: f64,
    /// Number of process threads
    pub thread_count: u32,
    /// Number of file descriptors
    pub fd_count: u32,
    /// Overall health score (0.0-100.0)
    pub health_score: f64,
    /// Time since last update
    pub last_update: Duration,
}

/// Process-specific resource usage
#[derive(Debug, Clone)]
pub struct ProcessStats {
    /// CPU usage percentage
    pub cpu_percent: f64,
    /// Memory usage in megabytes
    pub memory_mb: f64,
    /// Number of threads
    pub threads: u32,
    /// Number of file handles
    pub file_handles: u32,
    /// Process uptime
    pub uptime: Duration,
}

impl SystemHealth {
    /// Create new system health monitor
    #[inline]
    pub fn new() -> Self {
        let instance = Self {
            system_cpu: AtomicU32::new(0),
            process_cpu: AtomicU32::new(0),
            system_memory_mb: AtomicU64::new(0),
            process_memory_mb: AtomicU64::new(0),
            load_average: AtomicU32::new(0),
            thread_count: AtomicU32::new(0),
            fd_count: AtomicU32::new(0),
            health_score: AtomicU32::new(10000), // Start with perfect health
            last_update_ms: AtomicU64::new(0),
            update_interval_ms: 1000, // 1 second default
            created_at: Instant::now(),
            #[cfg(target_os = "linux")]
            proc_cpu_prev: std::sync::atomic::AtomicU64::new(0),
            #[cfg(target_os = "linux")]
            proc_cpu_prev_ms: std::sync::atomic::AtomicU64::new(u64::MAX),
            #[cfg(not(target_os = "linux"))]
            sys: parking_lot::Mutex::new(System::new()),
            #[cfg(not(target_os = "linux"))]
            pid: get_current_pid().ok(),
        };

        // Do initial update
        instance.update_metrics();
        instance
    }

    /// Create with custom update interval
    #[inline]
    pub fn with_interval(interval: Duration) -> Self {
        let mut instance = Self::new();
        instance.update_interval_ms = interval.as_millis() as u64;
        instance
    }

    /// Get system CPU usage percentage - SIMPLE AF API
    #[inline]
    pub fn cpu_used(&self) -> f64 {
        self.maybe_update();
        self.system_cpu.load(Ordering::Relaxed) as f64 / 100.0
    }

    /// Get system CPU free percentage
    #[inline]
    pub fn cpu_free(&self) -> f64 {
        100.0 - self.cpu_used()
    }

    /// Get system memory usage in MB
    #[inline]
    pub fn mem_used_mb(&self) -> f64 {
        self.maybe_update();
        self.system_memory_mb.load(Ordering::Relaxed) as f64
    }

    /// Get system memory usage in GB
    #[inline]
    pub fn mem_used_gb(&self) -> f64 {
        self.mem_used_mb() / 1024.0
    }

    /// Get process CPU usage percentage
    #[inline]
    pub fn process_cpu_used(&self) -> f64 {
        self.maybe_update();
        self.process_cpu.load(Ordering::Relaxed) as f64 / 100.0
    }

    /// Get process memory usage in MB
    #[inline]
    pub fn process_mem_used_mb(&self) -> f64 {
        self.maybe_update();
        self.process_memory_mb.load(Ordering::Relaxed) as f64
    }

    /// Get system load average
    #[inline]
    pub fn load_avg(&self) -> f64 {
        self.maybe_update();
        self.load_average.load(Ordering::Relaxed) as f64 / 100.0
    }

    /// Get process thread count
    #[inline]
    pub fn thread_count(&self) -> u32 {
        self.maybe_update();
        self.thread_count.load(Ordering::Relaxed)
    }

    /// Get process file descriptor count
    #[inline]
    pub fn fd_count(&self) -> u32 {
        self.maybe_update();
        self.fd_count.load(Ordering::Relaxed)
    }

    /// Get overall system health score (0.0-100.0)
    #[inline]
    pub fn health_score(&self) -> f64 {
        self.maybe_update();
        self.health_score.load(Ordering::Relaxed) as f64 / 100.0
    }

    /// Quick health check - sub-microsecond if cached
    #[inline(always)]
    pub fn quick_check(&self) -> HealthStatus {
        let score = self.health_score();

        if score >= 80.0 {
            HealthStatus::Healthy
        } else if score >= 60.0 {
            HealthStatus::Warning
        } else if score >= 40.0 {
            HealthStatus::Degraded
        } else {
            HealthStatus::Critical
        }
    }

    /// Force immediate update of all metrics
    #[inline]
    pub fn update(&self) {
        self.update_metrics();
    }

    /// Get detailed system snapshot
    pub fn snapshot(&self) -> SystemSnapshot {
        self.maybe_update();

        // Report **time since last update** (not "monotonic ms at last update").
        let now_ms = self.created_at.elapsed().as_millis() as u64;
        let last_ms = self.last_update_ms.load(Ordering::Relaxed);
        let last_update = Duration::from_millis(now_ms.saturating_sub(last_ms));

        SystemSnapshot {
            system_cpu_percent: self.system_cpu.load(Ordering::Relaxed) as f64 / 100.0,
            process_cpu_percent: self.process_cpu.load(Ordering::Relaxed) as f64 / 100.0,
            system_memory_mb: self.system_memory_mb.load(Ordering::Relaxed),
            process_memory_mb: self.process_memory_mb.load(Ordering::Relaxed),
            load_average: self.load_average.load(Ordering::Relaxed) as f64 / 100.0,
            thread_count: self.thread_count.load(Ordering::Relaxed),
            fd_count: self.fd_count.load(Ordering::Relaxed),
            health_score: self.health_score.load(Ordering::Relaxed) as f64 / 100.0,
            last_update,
        }
    }

    /// Get process-specific statistics
    pub fn process(&self) -> ProcessStats {
        self.maybe_update();

        ProcessStats {
            cpu_percent: self.process_cpu.load(Ordering::Relaxed) as f64 / 100.0,
            memory_mb: self.process_memory_mb.load(Ordering::Relaxed) as f64,
            threads: self.thread_count.load(Ordering::Relaxed),
            file_handles: self.fd_count.load(Ordering::Relaxed),
            uptime: self.created_at.elapsed(),
        }
    }

    // Internal implementation

    #[inline]
    fn maybe_update(&self) {
        let now_ms = self.created_at.elapsed().as_millis() as u64;
        let last_ms = self.last_update_ms.load(Ordering::Relaxed);

        if now_ms.saturating_sub(last_ms) > self.update_interval_ms {
            self.update_metrics();
        }
    }

    fn update_metrics(&self) {
        let now_ms = self.created_at.elapsed().as_millis() as u64;

        // Update system metrics
        if let Ok(cpu) = self.get_system_cpu() {
            self.system_cpu
                .store((cpu * 100.0) as u32, Ordering::Relaxed);
        }

        if let Ok(memory_mb) = self.get_system_memory_mb() {
            self.system_memory_mb.store(memory_mb, Ordering::Relaxed);
        }

        if let Ok(load) = self.get_load_average() {
            self.load_average
                .store((load * 100.0) as u32, Ordering::Relaxed);
        }

        // Update process metrics
        if let Ok(cpu) = self.get_process_cpu() {
            self.process_cpu
                .store((cpu * 100.0) as u32, Ordering::Relaxed);
        }

        if let Ok(memory_mb) = self.get_process_memory_mb() {
            self.process_memory_mb.store(memory_mb, Ordering::Relaxed);
        }

        if let Ok(threads) = self.get_thread_count() {
            self.thread_count.store(threads, Ordering::Relaxed);
        }

        if let Ok(fds) = self.get_fd_count() {
            self.fd_count.store(fds, Ordering::Relaxed);
        }

        // Calculate health score
        let health = self.calculate_health_score();
        self.health_score
            .store((health * 100.0) as u32, Ordering::Relaxed);

        self.last_update_ms.store(now_ms, Ordering::Relaxed);
    }

    fn calculate_health_score(&self) -> f64 {
        let mut score: f64 = 100.0;

        // CPU penalty (system)
        let system_cpu = self.system_cpu.load(Ordering::Relaxed) as f64 / 100.0;
        if system_cpu > 80.0 {
            score -= 30.0; // Heavy penalty for high CPU
        } else if system_cpu > 60.0 {
            score -= 15.0;
        } else if system_cpu > 40.0 {
            score -= 5.0;
        }

        // Load average penalty
        let load = self.load_average.load(Ordering::Relaxed) as f64 / 100.0;
        let cpu_count = num_cpus::get() as f64;
        if load > cpu_count * 2.0 {
            score -= 25.0;
        } else if load > cpu_count * 1.5 {
            score -= 10.0;
        } else if load > cpu_count {
            score -= 5.0;
        }

        // Process CPU penalty
        let process_cpu = self.process_cpu.load(Ordering::Relaxed) as f64 / 100.0;
        if process_cpu > 50.0 {
            score -= 15.0;
        } else if process_cpu > 25.0 {
            score -= 8.0;
        }

        // Memory pressure (simplified - would need actual available memory)
        let memory_gb = self.system_memory_mb.load(Ordering::Relaxed) as f64 / 1024.0;
        if memory_gb > 16.0 {
            // Assuming this is high usage
            score -= 10.0;
        } else if memory_gb > 8.0 {
            score -= 5.0;
        }

        // Thread count penalty (too many threads can indicate issues)
        let threads = self.thread_count.load(Ordering::Relaxed);
        if threads > 1000 {
            score -= 20.0;
        } else if threads > 500 {
            score -= 10.0;
        } else if threads > 200 {
            score -= 5.0;
        }

        // File descriptor penalty
        let fds = self.fd_count.load(Ordering::Relaxed);
        if fds > 10000 {
            score -= 15.0;
        } else if fds > 5000 {
            score -= 8.0;
        } else if fds > 1000 {
            score -= 3.0;
        }

        score.max(0.0)
    }

    // Platform-specific implementations

    #[cfg(target_os = "linux")]
    fn get_system_cpu(&self) -> io::Result<f64> {
        let contents = std::fs::read_to_string("/proc/stat")?;
        if let Some(line) = contents.lines().next() {
            let parts: Vec<&str> = line.split_whitespace().collect();
            if parts.len() >= 5 && parts[0] == "cpu" {
                let user: u64 = parts[1].parse().unwrap_or(0);
                let nice: u64 = parts[2].parse().unwrap_or(0);
                let system: u64 = parts[3].parse().unwrap_or(0);
                let idle: u64 = parts[4].parse().unwrap_or(0);

                let total = user + nice + system + idle;
                let used = user + nice + system;

                if total > 0 {
                    return Ok(used as f64 / total as f64 * 100.0);
                }
            }
        }
        Ok(0.0)
    }

    #[cfg(not(target_os = "linux"))]
    fn get_system_cpu(&self) -> io::Result<f64> {
        // Cross-platform via sysinfo
        let mut guard = self.sys.lock();
        guard.refresh_cpu();
        Ok(guard.global_cpu_info().cpu_usage() as f64)
    }

    #[cfg(target_os = "linux")]
    fn get_system_memory_mb(&self) -> io::Result<u64> {
        let contents = std::fs::read_to_string("/proc/meminfo")?;
        let mut total_kb = 0u64;
        let mut free_kb = 0u64;
        let mut available_kb = 0u64;

        for line in contents.lines() {
            if line.starts_with("MemTotal:") {
                total_kb = line
                    .split_whitespace()
                    .nth(1)
                    .and_then(|s| s.parse().ok())
                    .unwrap_or(0);
            } else if line.starts_with("MemFree:") {
                free_kb = line
                    .split_whitespace()
                    .nth(1)
                    .and_then(|s| s.parse().ok())
                    .unwrap_or(0);
            } else if line.starts_with("MemAvailable:") {
                available_kb = line
                    .split_whitespace()
                    .nth(1)
                    .and_then(|s| s.parse().ok())
                    .unwrap_or(0);
            }
        }

        // Use available if present, otherwise fall back to free
        let used_kb = if available_kb > 0 {
            total_kb - available_kb
        } else {
            total_kb - free_kb
        };

        Ok(used_kb / 1024) // Convert to MB
    }

    #[cfg(not(target_os = "linux"))]
    fn get_system_memory_mb(&self) -> io::Result<u64> {
        let mut guard = self.sys.lock();
        guard.refresh_memory();
        // sysinfo reports memory in KiB
        let used_kib = guard.used_memory();
        Ok(used_kib / 1024)
    }

    #[cfg(target_os = "linux")]
    fn get_load_average(&self) -> io::Result<f64> {
        let contents = std::fs::read_to_string("/proc/loadavg")?;
        if let Some(first) = contents.split_whitespace().next() {
            return first
                .parse()
                .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Invalid load average"));
        }
        Ok(0.0)
    }

    #[cfg(not(target_os = "linux"))]
    fn get_load_average(&self) -> io::Result<f64> {
        let guard = self.sys.lock();
        let la = guard.load_average();
        Ok(la.one)
    }

    #[cfg(target_os = "linux")]
    fn get_process_cpu(&self) -> io::Result<f64> {
        // Delta sample: ((utime + stime) - prev) / (clock_ticks_per_sec * elapsed_s * cores) * 100
        // First sample returns 0 (no prior baseline) and seeds the state.
        let contents = std::fs::read_to_string("/proc/self/stat")?;
        let parts: Vec<&str> = contents.split_whitespace().collect();
        if parts.len() < 15 {
            return Ok(0.0);
        }
        let utime: u64 = parts[13].parse().unwrap_or(0);
        let stime: u64 = parts[14].parse().unwrap_or(0);
        let total_ticks = utime.saturating_add(stime);
        let now_ms = self.created_at.elapsed().as_millis() as u64;

        let prev_ticks = self.proc_cpu_prev.load(Ordering::Relaxed);
        let prev_ms = self.proc_cpu_prev_ms.load(Ordering::Relaxed);

        // Store current sample for the next call.
        self.proc_cpu_prev.store(total_ticks, Ordering::Relaxed);
        self.proc_cpu_prev_ms.store(now_ms, Ordering::Relaxed);

        if prev_ms == u64::MAX {
            // First sample — no delta yet.
            return Ok(0.0);
        }
        let elapsed_ms = now_ms.saturating_sub(prev_ms);
        if elapsed_ms == 0 {
            return Ok(0.0);
        }
        let delta_ticks = total_ticks.saturating_sub(prev_ticks) as f64;
        // Linux clock ticks per second is conventionally 100; the precise value
        // would come from `sysconf(_SC_CLK_TCK)`, but the standard kernel build
        // uses USER_HZ=100 and this matches `/proc/stat` semantics.
        let clk_tck: f64 = 100.0;
        let elapsed_s = elapsed_ms as f64 / 1000.0;
        let cores = num_cpus::get().max(1) as f64;
        // Per-core percentage: 100% means one whole core saturated.
        let pct = (delta_ticks / (clk_tck * elapsed_s * cores)) * 100.0;
        Ok(pct.clamp(0.0, 100.0))
    }

    #[cfg(not(target_os = "linux"))]
    fn get_process_cpu(&self) -> io::Result<f64> {
        let mut guard = self.sys.lock();
        if let Some(pid) = self.pid {
            guard.refresh_process(pid);
            if let Some(proc_) = guard.process(pid) {
                // sysinfo's cpu_usage can exceed 100 on multi-core hosts.
                // Normalize to per-core percentage (0..100).
                let raw = proc_.cpu_usage() as f64;
                let cores = num_cpus::get() as f64;
                let norm = if cores > 0.0 { raw / cores } else { raw };
                return Ok(norm.clamp(0.0, 100.0));
            }
        }
        Ok(0.0)
    }

    #[cfg(target_os = "linux")]
    fn get_process_memory_mb(&self) -> io::Result<u64> {
        let contents = std::fs::read_to_string("/proc/self/status")?;
        for line in contents.lines() {
            if line.starts_with("VmRSS:") {
                if let Some(kb_str) = line.split_whitespace().nth(1) {
                    if let Ok(kb) = kb_str.parse::<u64>() {
                        return Ok(kb / 1024); // Convert to MB
                    }
                }
            }
        }
        Ok(0)
    }

    #[cfg(not(target_os = "linux"))]
    fn get_process_memory_mb(&self) -> io::Result<u64> {
        let mut guard = self.sys.lock();
        if let Some(pid) = self.pid {
            guard.refresh_process(pid);
            if let Some(proc_) = guard.process(pid) {
                // memory() in KiB
                return Ok(proc_.memory() / 1024);
            }
        }
        Ok(0)
    }

    #[cfg(target_os = "linux")]
    fn get_thread_count(&self) -> io::Result<u32> {
        let contents = std::fs::read_to_string("/proc/self/status")?;
        for line in contents.lines() {
            if line.starts_with("Threads:") {
                if let Some(count_str) = line.split_whitespace().nth(1) {
                    if let Ok(count) = count_str.parse() {
                        return Ok(count);
                    }
                }
            }
        }
        Ok(1) // At least 1 thread (current)
    }

    #[cfg(not(target_os = "linux"))]
    fn get_thread_count(&self) -> io::Result<u32> {
        // sysinfo doesn't expose per-process thread count uniformly; approximate with 1
        // until a portable method is added.
        Ok(1)
    }

    #[cfg(target_os = "linux")]
    fn get_fd_count(&self) -> io::Result<u32> {
        match std::fs::read_dir("/proc/self/fd") {
            Ok(entries) => Ok(entries.count() as u32),
            Err(_) => Ok(0),
        }
    }

    #[cfg(not(target_os = "linux"))]
    fn get_fd_count(&self) -> io::Result<u32> {
        // Not portable via sysinfo; return 0 on non-Linux.
        Ok(0)
    }
}

/// System health status
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HealthStatus {
    /// System is healthy (80%+ score)
    Healthy,
    /// System has warnings (60-80% score)
    Warning,
    /// System is degraded (40-60% score)
    Degraded,
    /// System is in critical state (<40% score)
    Critical,
}

impl HealthStatus {
    /// Check if status indicates system is degraded or worse
    #[inline]
    pub fn is_degraded(&self) -> bool {
        matches!(self, Self::Degraded | Self::Critical)
    }

    /// Check if status indicates system is healthy
    #[inline]
    pub fn is_healthy(&self) -> bool {
        matches!(self, Self::Healthy)
    }

    /// Check if status has warnings or worse
    #[inline]
    pub fn has_issues(&self) -> bool {
        !matches!(self, Self::Healthy)
    }
}

impl Default for SystemHealth {
    fn default() -> Self {
        Self::new()
    }
}

impl std::fmt::Display for SystemHealth {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let snapshot = self.snapshot();
        write!(
            f,
            "SystemHealth(CPU: {:.1}%, Mem: {} MB, Health: {:.1}%)",
            snapshot.system_cpu_percent, snapshot.system_memory_mb, snapshot.health_score
        )
    }
}

impl std::fmt::Debug for SystemHealth {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let snapshot = self.snapshot();
        f.debug_struct("SystemHealth")
            .field("system_cpu", &snapshot.system_cpu_percent)
            .field("process_cpu", &snapshot.process_cpu_percent)
            .field("system_memory_mb", &snapshot.system_memory_mb)
            .field("process_memory_mb", &snapshot.process_memory_mb)
            .field("load_average", &snapshot.load_average)
            .field("threads", &snapshot.thread_count)
            .field("fds", &snapshot.fd_count)
            .field("health_score", &snapshot.health_score)
            .finish()
    }
}

impl std::fmt::Display for HealthStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Healthy => write!(f, "Healthy"),
            Self::Warning => write!(f, "Warning"),
            Self::Degraded => write!(f, "Degraded"),
            Self::Critical => write!(f, "Critical"),
        }
    }
}

// Thread safety
// SystemHealth is composed of atomic types (Send + Sync), `Instant` (Send +
// Sync), `parking_lot::Mutex<sysinfo::System>` (Send + Sync via the contained
// `System: Send`), and a `sysinfo::Pid` (Send + Sync). The compiler derives
// Send + Sync automatically; no explicit `unsafe impl` is required.

#[cfg(test)]
mod tests {
    use super::*;
    use std::thread;

    #[test]
    fn test_basic_functionality() {
        let health = SystemHealth::new();

        // Should be able to get all metrics
        let _cpu = health.cpu_used();
        let _mem = health.mem_used_mb();
        let _process_cpu = health.process_cpu_used();
        let _process_mem = health.process_mem_used_mb();
        let _load = health.load_avg();
        let _threads = health.thread_count();
        let _fds = health.fd_count();
        let _score = health.health_score();

        // Health check should work
        let status = health.quick_check();
        assert!(matches!(
            status,
            HealthStatus::Healthy
                | HealthStatus::Warning
                | HealthStatus::Degraded
                | HealthStatus::Critical
        ));
    }

    #[test]
    fn test_cpu_free() {
        let health = SystemHealth::new();

        let used = health.cpu_used();
        let free = health.cpu_free();

        // Used + free should approximately equal 100%
        assert!((used + free - 100.0).abs() < 0.1);
    }

    #[test]
    fn test_memory_units() {
        let health = SystemHealth::new();

        let mb = health.mem_used_mb();
        let gb = health.mem_used_gb();

        // GB should be approximately MB / 1024
        if mb > 0.0 {
            assert!((gb * 1024.0 - mb).abs() < 1.0);
        }
    }

    #[test]
    fn test_snapshot() {
        let health = SystemHealth::new();

        let snapshot = health.snapshot();

        // Snapshot should have reasonable values
        assert!(snapshot.system_cpu_percent >= 0.0);
        assert!(snapshot.system_cpu_percent <= 100.0);
        assert!(snapshot.health_score >= 0.0);
        assert!(snapshot.health_score <= 100.0);
        assert!(snapshot.thread_count > 0); // Should have at least 1 thread
    }

    #[test]
    fn test_process_stats() {
        let health = SystemHealth::new();

        let stats = health.process();

        assert!(stats.threads > 0); // Should have at least current thread
        assert!(stats.uptime > Duration::ZERO);
        assert!(stats.cpu_percent >= 0.0);
        assert!(stats.memory_mb >= 0.0);
    }

    #[test]
    fn test_health_status() {
        let healthy = HealthStatus::Healthy;
        let warning = HealthStatus::Warning;
        let degraded = HealthStatus::Degraded;
        let critical = HealthStatus::Critical;

        assert!(healthy.is_healthy());
        assert!(!healthy.is_degraded());
        assert!(!healthy.has_issues());

        assert!(!warning.is_healthy());
        assert!(!warning.is_degraded());
        assert!(warning.has_issues());

        assert!(!degraded.is_healthy());
        assert!(degraded.is_degraded());
        assert!(degraded.has_issues());

        assert!(!critical.is_healthy());
        assert!(critical.is_degraded());
        assert!(critical.has_issues());
    }

    #[test]
    fn test_custom_interval() {
        let health = SystemHealth::with_interval(Duration::from_millis(500));

        // Should still work with custom interval
        let _cpu = health.cpu_used();
        let _score = health.health_score();
    }

    #[test]
    fn test_maybe_update_actually_refreshes_after_interval() {
        // 0.9.2 regression: maybe_update previously compared milliseconds
        // against a nanosecond-typed `last_update`, which froze the throttle
        // and pinned all values to their initial reads. After the fix,
        // `last_update_ms` is observed to advance once the interval elapses.
        let health = SystemHealth::with_interval(Duration::from_millis(50));
        let snap_before = health.snapshot();
        let last_ms_before = health.last_update_ms.load(Ordering::Relaxed);

        // Sleep beyond the interval and then poke the cache.
        thread::sleep(Duration::from_millis(120));
        let _ = health.cpu_used(); // triggers maybe_update path
        let snap_after = health.snapshot();
        let last_ms_after = health.last_update_ms.load(Ordering::Relaxed);

        assert!(
            last_ms_after > last_ms_before,
            "last_update_ms should advance after sleeping past the throttle interval \
             (before={last_ms_before}, after={last_ms_after})",
        );
        // The `last_update` Duration on the snapshot should be small (since
        // we just refreshed) rather than equal-to-monotonic-time-since-creation,
        // which was the prior bug.
        assert!(
            snap_after.last_update <= Duration::from_secs(1),
            "snapshot.last_update should be 'time since last refresh', \
             got {:?}",
            snap_after.last_update,
        );
        // Sanity: snapshot fields still produce finite values.
        assert!(snap_before.system_cpu_percent.is_finite());
        assert!(snap_after.system_cpu_percent.is_finite());
    }

    #[test]
    fn test_force_update() {
        let health = SystemHealth::new();

        let score_before = health.health_score();

        // Force update
        health.update();

        let score_after = health.health_score();

        // Scores might be different or the same, but both should be valid
        assert!(score_before >= 0.0);
        assert!(score_after >= 0.0);
    }

    #[test]
    fn test_concurrent_access() {
        let health = std::sync::Arc::new(SystemHealth::new());
        let mut handles = vec![];

        // Spawn multiple threads accessing health metrics
        for _ in 0..10 {
            let health_clone = health.clone();
            let handle = thread::spawn(move || {
                for _ in 0..100 {
                    let _cpu = health_clone.cpu_used();
                    let _mem = health_clone.mem_used_mb();
                    let _status = health_clone.quick_check();
                }
            });
            handles.push(handle);
        }

        // Wait for all threads
        for handle in handles {
            handle.join().unwrap();
        }

        // Should still be functional
        let final_score = health.health_score();
        assert!((0.0..=100.0).contains(&final_score));
    }

    #[test]
    fn test_display_formatting() {
        let health = SystemHealth::new();

        let display_str = format!("{health}");
        assert!(display_str.contains("SystemHealth"));
        assert!(display_str.contains("CPU"));
        assert!(display_str.contains("Mem"));

        let debug_str = format!("{health:?}");
        assert!(debug_str.contains("SystemHealth"));

        let status = health.quick_check();
        let status_str = format!("{status}");
        assert!(!status_str.is_empty());
    }
}

#[cfg(all(test, feature = "bench-tests", not(tarpaulin)))]
#[allow(unused_imports)]
mod benchmarks {
    use super::*;
    use std::time::Instant;

    #[cfg_attr(not(feature = "bench-tests"), ignore)]
    #[test]
    fn bench_quick_check() {
        let health = SystemHealth::new();
        let iterations = 1_000_000;

        let start = Instant::now();
        for _ in 0..iterations {
            let _ = health.quick_check();
        }
        let elapsed = start.elapsed();

        println!(
            "SystemHealth quick_check: {:.2} ns/op",
            elapsed.as_nanos() as f64 / iterations as f64
        );

        // Should be extremely fast when cached (relaxed from 100ns to 200ns)
        assert!(elapsed.as_nanos() / iterations < 200);
    }

    #[cfg_attr(not(feature = "bench-tests"), ignore)]
    #[test]
    fn bench_cached_metrics() {
        let health = SystemHealth::new();
        let iterations = 1_000_000;

        let start = Instant::now();
        for _ in 0..iterations {
            let _ = health.cpu_used();
            let _ = health.mem_used_mb();
            let _ = health.health_score();
        }
        let elapsed = start.elapsed();

        println!(
            "SystemHealth cached metrics: {:.2} ns/op",
            elapsed.as_nanos() as f64 / iterations as f64 / 3.0
        );

        // Should be very fast when cached (relaxed from 500ns to 1000ns)
        assert!(elapsed.as_nanos() / iterations < 1000);
    }

    #[cfg_attr(not(feature = "bench-tests"), ignore)]
    #[test]
    fn bench_force_update() {
        let health = SystemHealth::new();
        let iterations = 1000; // Less iterations since this does real work

        let start = Instant::now();
        for _ in 0..iterations {
            health.update();
        }
        let elapsed = start.elapsed();

        println!(
            "SystemHealth force update: {:.2} μs/op",
            elapsed.as_micros() as f64 / iterations as f64
        );

        // Should complete updates reasonably fast (relaxed from 1000ms to 2000ms)
        assert!(elapsed.as_millis() < 2000);
    }
}