fsys 0.6.0

//! Windows-specific hardware probe.
//!
//! Probes use Win32 APIs:
//! - Memory: `GlobalMemoryStatusEx`.
//! - Drive capacity / free space: `GetDiskFreeSpaceExW`.
//! - Drive sector sizes: `GetDiskFreeSpaceW` + `IOCTL_STORAGE_QUERY_PROPERTY`
//!   with `StorageAccessAlignmentProperty` for finer detail when reachable.
//! - CPU: `GetSystemInfo` (logical cores) + `GetLogicalProcessorInformationEx`
//!   (physical cores + cache sizes).
//! - PLP: deferred to 0.6.0 alongside NVMe IOCTL passthrough.
//!
//! All probes are non-fatal — failures degrade to documented defaults
//! and do not error handle creation.

#![cfg(target_os = "windows")]

use std::ffi::{OsStr, OsString};
use std::os::windows::ffi::{OsStrExt, OsStringExt};
use std::path::Path;

use windows_sys::Win32::Storage::FileSystem::{
    GetDiskFreeSpaceExW, GetDiskFreeSpaceW, GetVolumePathNameW,
};
use windows_sys::Win32::System::SystemInformation::{GlobalMemoryStatusEx, MEMORYSTATUSEX};

use super::PlpStatus;
use crate::hardware::cpu::{CpuFeatures, CpuInfo};
use crate::hardware::drive::DriveInfo;
use crate::hardware::io_primitives::IoPrimitives;
use crate::hardware::memory::MemoryInfo;

// ─────────────────────────────────────────────────────────────────────────────
// Drive
// ─────────────────────────────────────────────────────────────────────────────

/// Probes the storage device hosting the current working directory.
///
/// Strategy:
/// 1. Find the volume containing the cwd via `GetVolumePathNameW`.
/// 2. Read total/free bytes via `GetDiskFreeSpaceExW`.
/// 3. Read sector sizes via `GetDiskFreeSpaceW`.
///
/// Drive kind classification is conservative on Windows: refining it
/// would require `IOCTL_STORAGE_QUERY_PROPERTY` with
/// `StorageDeviceSeekPenaltyProperty` (rotational vs non-rotational)
/// and bus-type inspection. That landed in 0.6.0 alongside NVMe IOCTL
/// support; for 0.5.0 we report `Unknown` for kind unless the volume
/// path makes the drive type unambiguous (which it rarely does on
/// Windows).
pub(crate) fn probe_drive() -> DriveInfo {
    let cwd = match std::env::current_dir() {
        Ok(p) => p,
        Err(_) => return DriveInfo::default(),
    };

    let mut info = DriveInfo::default();

    let volume = match volume_path(&cwd) {
        Some(v) => v,
        None => return info,
    };

    // Capacity and free space via GetDiskFreeSpaceExW.
    let mut free_to_caller: u64 = 0;
    let mut total: u64 = 0;
    let mut free_total: u64 = 0;
    let volume_w = wide(volume.as_os_str());
    // SAFETY: `GetDiskFreeSpaceExW` reads from `volume_w` (a NUL-
    // terminated wide string we just allocated) and writes into the
    // three properly-sized `u64` outputs. The pointers are valid for
    // the duration of the call.
    let ok = unsafe {
        GetDiskFreeSpaceExW(
            volume_w.as_ptr(),
            &mut free_to_caller,
            &mut total,
            &mut free_total,
        )
    };
    if ok != 0 {
        info.total_bytes = total;
        info.available_bytes = free_to_caller;
    }

    // Sector sizes via GetDiskFreeSpaceW.
    let mut sectors_per_cluster: u32 = 0;
    let mut bytes_per_sector: u32 = 0;
    let mut free_clusters: u32 = 0;
    let mut total_clusters: u32 = 0;
    // SAFETY: same pattern as above; volume_w is a valid NUL-terminated
    // wide string and the four `u32` outputs are all valid for write.
    let ok = unsafe {
        GetDiskFreeSpaceW(
            volume_w.as_ptr(),
            &mut sectors_per_cluster,
            &mut bytes_per_sector,
            &mut free_clusters,
            &mut total_clusters,
        )
    };
    if ok != 0 && bytes_per_sector > 0 {
        info.logical_sector = bytes_per_sector;
        // Windows doesn't easily expose physical sector size without
        // IOCTL_STORAGE_QUERY_PROPERTY; default to logical when we
        // can't tell more.
        info.physical_sector = bytes_per_sector;
        // Cluster size is the natural "optimal block" hint at the FS
        // level on Windows.
        let cluster = bytes_per_sector.saturating_mul(sectors_per_cluster);
        if cluster > 0 {
            info.optimal_block = cluster;
        }
    }

    // PLP — deferred (see crate-level docs for this module).
    let _: PlpStatus = PlpStatus::Unknown;

    info
}

fn volume_path(path: &Path) -> Option<OsString> {
    let path_w = wide(path.as_os_str());
    let mut buf: Vec<u16> = vec![0u16; 261];
    // SAFETY: `GetVolumePathNameW` reads from `path_w` (NUL-terminated
    // wide string) and writes up to `buf.len()` UTF-16 code units into
    // `buf`, NUL-terminating the result on success.
    let ok = unsafe { GetVolumePathNameW(path_w.as_ptr(), buf.as_mut_ptr(), buf.len() as u32) };
    if ok == 0 {
        return None;
    }
    let len = buf.iter().position(|&c| c == 0).unwrap_or(buf.len());
    Some(OsString::from_wide(&buf[..len]))
}

fn wide(s: &OsStr) -> Vec<u16> {
    let mut v: Vec<u16> = s.encode_wide().collect();
    v.push(0);
    v
}

// ─────────────────────────────────────────────────────────────────────────────
// Memory
// ─────────────────────────────────────────────────────────────────────────────

/// Probes total and available memory via `GlobalMemoryStatusEx`.
pub(crate) fn probe_memory() -> MemoryInfo {
    // SAFETY: `MEMORYSTATUSEX` is plain old data and zero-init is
    // valid; we set `dwLength` to the struct size before the call as
    // required by the Win32 contract.
    let mut status: MEMORYSTATUSEX = unsafe { std::mem::zeroed() };
    status.dwLength = std::mem::size_of::<MEMORYSTATUSEX>() as u32;
    // SAFETY: `&mut status` is a valid `*mut MEMORYSTATUSEX` with the
    // correctly-set `dwLength`. The kernel writes to fields up to that
    // length.
    let ok = unsafe { GlobalMemoryStatusEx(&mut status) };
    if ok == 0 {
        return MemoryInfo::default();
    }
    MemoryInfo {
        total_bytes: status.ullTotalPhys,
        available_bytes: status.ullAvailPhys,
    }
}

// ─────────────────────────────────────────────────────────────────────────────
// CPU
// ─────────────────────────────────────────────────────────────────────────────

/// Probes CPU info.
///
/// Logical cores via [`std::thread::available_parallelism`] (works
/// correctly on Windows with affinity-mask awareness). Physical cores
/// via `GetLogicalProcessorInformationEx`. Compile-time CPU features.
pub(crate) fn probe_cpu() -> CpuInfo {
    let cores_logical = std::thread::available_parallelism()
        .map(|n| u32::try_from(n.get()).unwrap_or(u32::MAX))
        .unwrap_or(1);

    let cores_physical = probe_physical_cores().unwrap_or(cores_logical);
    let (l1, l2, l3) = probe_cache_sizes().unwrap_or((0, 0, 0));

    CpuInfo {
        cores_logical,
        cores_physical,
        features: detect_compile_time_features(),
        cache_l1: l1,
        cache_l2: l2,
        cache_l3: l3,
    }
}

fn probe_physical_cores() -> Option<u32> {
    use windows_sys::Win32::System::SystemInformation::{
        GetLogicalProcessorInformationEx, RelationProcessorCore,
        SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX,
    };

    // Two-pass: first call with NULL buffer to get the required size.
    let mut needed: u32 = 0;
    // SAFETY: passing `null_mut()` and `&mut needed` is the documented
    // size-query pattern for this API; the call writes the required
    // byte count into `needed` and returns 0 on the expected
    // ERROR_INSUFFICIENT_BUFFER path.
    unsafe {
        let _ = GetLogicalProcessorInformationEx(
            RelationProcessorCore,
            std::ptr::null_mut(),
            &mut needed,
        );
    }
    if needed == 0 {
        return None;
    }
    let mut buf: Vec<u8> = vec![0u8; needed as usize];
    // SAFETY: `buf` has at least `needed` bytes; the cast is valid for
    // a buffer that the kernel will populate with packed
    // SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX records.
    let ok = unsafe {
        GetLogicalProcessorInformationEx(
            RelationProcessorCore,
            buf.as_mut_ptr() as *mut SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX,
            &mut needed,
        )
    };
    if ok == 0 {
        return None;
    }

    // Walk the variable-length array of records. Each record's `Size`
    // field is its own length in bytes.
    let mut count = 0u32;
    let mut offset = 0usize;
    while offset < needed as usize {
        // SAFETY: We bounds-check `offset + size_of<header>` before
        // reading; the kernel guarantees the buffer is well-formed
        // when `ok != 0`.
        let header = unsafe {
            &*(buf.as_ptr().add(offset) as *const SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX)
        };
        if header.Relationship == RelationProcessorCore {
            count += 1;
        }
        if header.Size == 0 {
            break; // defensive against corrupt buffers
        }
        offset += header.Size as usize;
    }
    if count == 0 {
        None
    } else {
        Some(count)
    }
}

fn probe_cache_sizes() -> Option<(usize, usize, usize)> {
    use windows_sys::Win32::System::SystemInformation::{
        GetLogicalProcessorInformationEx, RelationCache, SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX,
    };

    let mut needed: u32 = 0;
    // SAFETY: same pattern as `probe_physical_cores` — null query for size.
    unsafe {
        let _ = GetLogicalProcessorInformationEx(RelationCache, std::ptr::null_mut(), &mut needed);
    }
    if needed == 0 {
        return None;
    }
    let mut buf: Vec<u8> = vec![0u8; needed as usize];
    // SAFETY: `buf` has at least `needed` bytes; cast as documented.
    let ok = unsafe {
        GetLogicalProcessorInformationEx(
            RelationCache,
            buf.as_mut_ptr() as *mut SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX,
            &mut needed,
        )
    };
    if ok == 0 {
        return None;
    }

    let mut l1 = 0usize;
    let mut l2 = 0usize;
    let mut l3 = 0usize;
    let mut offset = 0usize;
    while offset < needed as usize {
        // SAFETY: bounds-checked iteration as in `probe_physical_cores`.
        let header = unsafe {
            &*(buf.as_ptr().add(offset) as *const SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX)
        };
        if header.Relationship == RelationCache {
            // SAFETY: when Relationship == RelationCache, the union's
            // `Cache` arm is the active variant per the Win32
            // contract.
            let cache = unsafe { &header.Anonymous.Cache };
            let size = cache.CacheSize as usize;
            match cache.Level {
                1 => l1 = l1.max(size),
                2 => l2 = l2.max(size),
                3 => l3 = l3.max(size),
                _ => {}
            }
        }
        if header.Size == 0 {
            break;
        }
        offset += header.Size as usize;
    }
    Some((l1, l2, l3))
}

fn detect_compile_time_features() -> CpuFeatures {
    let mut f = CpuFeatures::empty();
    if cfg!(target_feature = "sse") {
        f |= CpuFeatures::SSE;
    }
    if cfg!(target_feature = "sse2") {
        f |= CpuFeatures::SSE2;
    }
    if cfg!(target_feature = "sse3") {
        f |= CpuFeatures::SSE3;
    }
    if cfg!(target_feature = "ssse3") {
        f |= CpuFeatures::SSSE3;
    }
    if cfg!(target_feature = "sse4.1") {
        f |= CpuFeatures::SSE4_1;
    }
    if cfg!(target_feature = "sse4.2") {
        f |= CpuFeatures::SSE4_2;
    }
    if cfg!(target_feature = "avx") {
        f |= CpuFeatures::AVX;
    }
    if cfg!(target_feature = "avx2") {
        f |= CpuFeatures::AVX2;
    }
    if cfg!(target_feature = "avx512f") {
        f |= CpuFeatures::AVX512F;
    }
    if cfg!(target_feature = "aes") {
        f |= CpuFeatures::AES;
    }
    if cfg!(target_feature = "pclmulqdq") {
        f |= CpuFeatures::PCLMULQDQ;
    }
    if cfg!(target_feature = "neon") {
        f |= CpuFeatures::NEON;
    }
    f
}

// ─────────────────────────────────────────────────────────────────────────────
// IO primitives
// ─────────────────────────────────────────────────────────────────────────────

/// Probes which kernel-level IO primitives are reachable on this
/// Windows host.
///
/// IOCP is always available since NT 3.5. mmap-equivalent
/// (`MapViewOfFile`) is universal. `FILE_FLAG_NO_BUFFERING` for direct
/// IO is universal at the API level (filesystem may still reject at
/// open). No io_uring on Windows; no NVMe passthrough in 0.5.0.
pub(crate) fn probe_io_primitives() -> IoPrimitives {
    IoPrimitives {
        io_uring: false,
        iocp: true,
        kqueue: false,
        nvme_passthrough: false, // 0.6.0
        direct_io: true,
        mmap: true,
    }
}

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

    #[test]
    fn test_probe_memory_reports_non_zero_total() {
        let m = probe_memory();
        assert!(
            m.total_bytes > 0,
            "Windows GlobalMemoryStatusEx must report >0"
        );
    }

    #[test]
    fn test_probe_drive_reports_logical_sector() {
        let info = probe_drive();
        assert!(info.logical_sector >= 512);
    }

    #[test]
    fn test_probe_cpu_reports_at_least_one_logical_core() {
        let c = probe_cpu();
        assert!(c.cores_logical >= 1);
        assert!(c.cores_physical >= 1);
    }

    #[test]
    fn test_probe_io_primitives_iocp_and_mmap_true() {
        let p = probe_io_primitives();
        assert!(p.iocp);
        assert!(p.mmap);
        assert!(!p.io_uring);
    }
}