roundabout

use std::{ffi::CString, os::unix::ffi::OsStrExt, path::Path};

use crate::{sched::FsId, units::Bytes};

pub fn cores() -> u32 {

    std::thread::available_parallelism().map_or(1, |n| n.get() as u32)

}

pub struct FsStat {

    pub id: FsId,

    pub free: Bytes,

    pub size: Bytes,

}

pub fn fs(path: &Path) -> Option<FsStat> {

    let c = CString::new(path.as_os_str().as_bytes()).ok()?;

    let mut vfs = std::mem::MaybeUninit::<libc::statvfs>::uninit();

    let mut st = std::mem::MaybeUninit::<libc::stat>::uninit();

    unsafe {

        if libc::statvfs(c.as_ptr(), vfs.as_mut_ptr()) != 0

            || libc::stat(c.as_ptr(), st.as_mut_ptr()) != 0

        {

            return None;

        }

        let vfs = vfs.assume_init();

        let st = st.assume_init();

        #[allow(clippy::unnecessary_cast)]

        let block = vfs.f_frsize as u64;

        #[allow(clippy::unnecessary_cast)]

        Some(FsStat {

            id: st.st_dev as u64,

            free: Bytes(vfs.f_bavail as u64 * block),

            size: Bytes(vfs.f_blocks as u64 * block),

        })

    }

}

pub fn page_size() -> u64 {

    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as u64 }

}

#[cfg(target_os = "linux")]

mod imp {

    use std::fs;

    use crate::units::Bytes;

    pub fn memory() -> (Bytes, Bytes) {

        let text = fs::read_to_string("/proc/meminfo").unwrap_or_default();

        let field = |name: &str| {

            text.lines()

                .find_map(|l| l.strip_prefix(name))

                .and_then(|rest| {

                    rest.trim()

                        .trim_end_matches("kB")

                        .trim()

                        .parse::<u64>()

                        .ok()

                })

                .map_or(Bytes::ZERO, |kib| Bytes(kib * 1024))

        };

        (field("MemTotal:"), field("MemAvailable:"))

    }

    pub fn pressure() -> Option<f64> {

        let text = fs::read_to_string("/proc/pressure/memory").ok()?;

        text.lines()

            .find(|l| l.starts_with("some"))?

            .split_whitespace()

            .find_map(|kv| kv.strip_prefix("avg10="))?

            .parse()

            .ok()

    }

    pub fn group_rss(pgid: i32) -> Bytes {

        let page = super::page_size();

        let Ok(dir) = fs::read_dir("/proc") else {

            return Bytes::ZERO;

        };

        let mut total = 0;

        for entry in dir.flatten() {

            let name = entry.file_name();

            if !name.as_encoded_bytes().iter().all(u8::is_ascii_digit) {

                continue;

            }

            let Ok(stat) = fs::read_to_string(entry.path().join("stat")) else {

                continue;

            };

            // comm can hold spaces and parens, fields only make sense after the last ')'

            let Some(tail) = stat.rsplit_once(')').map(|(_, t)| t) else {

                continue;

            };

            let fields: Vec<&str> = tail.split_whitespace().collect();

            let pgrp = fields.get(2).and_then(|f| f.parse::<i32>().ok());

            let rss = fields.get(21).and_then(|f| f.parse::<u64>().ok());

            if pgrp == Some(pgid) {

                total += rss.unwrap_or(0) * page;

            }

        }

        Bytes(total)

    }

}

#[cfg(target_os = "macos")]

mod imp {

    use std::process::Command;

    use crate::units::Bytes;

    pub fn memory() -> (Bytes, Bytes) {

        let mut total: u64 = 0;

        let mut len = std::mem::size_of::<u64>();

        unsafe {

            libc::sysctlbyname(

                c"hw.memsize".as_ptr(),

                (&raw mut total).cast(),

                &raw mut len,

                std::ptr::null_mut(),

                0,

            );

        }

        // vm_stat over mach calls, libc's mach bindings are deprecated and this

        // runs once a second at most

        let out = Command::new("vm_stat")

            .output()

            .map(|o| o.stdout)

            .unwrap_or_default();

        let text = String::from_utf8_lossy(&out);

        let pages = |name: &str| {

            text.lines()

                .find_map(|l| l.strip_prefix(name))

                .and_then(|r| r.trim().trim_end_matches('.').parse::<u64>().ok())

                .unwrap_or(0)

        };

        let avail = (pages("Pages free:") + pages("Pages inactive:") + pages("Pages purgeable:"))

            * super::page_size();

        (Bytes(total), Bytes(avail))

    }

    pub const fn pressure() -> Option<f64> {

        None

    }

    pub fn group_rss(pgid: i32) -> Bytes {

        let out = Command::new("ps")

            .args(["-A", "-o", "pgid=,rss="])

            .output()

            .map(|o| o.stdout)

            .unwrap_or_default();

        let kib: u64 = String::from_utf8_lossy(&out)

            .lines()

            .filter_map(|l| {

                let mut f = l.split_whitespace();

                let g = f.next()?.parse::<i32>().ok()?;

                let rss = f.next()?.parse::<u64>().ok()?;

                (g == pgid).then_some(rss)

            })

            .sum();

        Bytes(kib * 1024)

    }

}

pub use imp::{group_rss, memory, pressure};