//! aldermon — Alder Lake hardware monitor (i5-12600KF / Z690M ITX/ax).
//!
//! Modes: no args = one-shot sensor dump; `--tui` = live TUI (vCore hero,
//! per-core bars, braille graphs, F2 settings); `--vid` = root-only VID vs
//! in0 cross-check (debug spike, kept as a tool); `--log` = append CSV rows
//! to ./aldermon-vid.log for off-line analysis.

mod config;
mod log;
mod plot;
mod sensors;
mod ui;

use std::io::IsTerminal;
use std::path::Path;
use std::thread::sleep;
use std::time::{Duration, Instant};

use sensors::{cpu_frequencies, discover_chips, rapl_domains, rapl_energy_uj};

const USAGE: &str = "\
usage: aldermon [OPTION]

  (no option)  one-shot sensor dump to stdout
  --tui        live monitoring TUI (q/Esc quit, F2 settings)
  --vid        VID vs SIO in0 cross-check spike (needs MSR access, see below)
  --log        append CSV samples to ./aldermon-vid.log
  --help       show this help
  --version    print version and exit

The TUI always shows the delivered vCore, the requested VID and the delta.
VID needs MSR access: run as root, or install the setcap'd aldermon-msr
helper (doas make install + aldermon-install.sh); otherwise it shows
'VID n/a (no msr access)'.
--log appends one CSV row per poll; with --tui it logs live, with --vid it
logs continuously until interrupted (otherwise --vid runs a 5-sample spike).

Short flags group: -lvt == --log --vid --tui. -V == --version.";

#[derive(Default, Clone, Copy)]
struct Opts {
    tui: bool,
    vid: bool,
    log: bool,
}

pub const LOG_PATH: &str = "aldermon-vid.log";

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let mut opts = Opts::default();
    for a in &args[1..] {
        if let Some(long) = a.strip_prefix("--") {
            match long {
                "tui" => opts.tui = true,
                "vid" => opts.vid = true,
                "log" => opts.log = true,
                "version" => {
                    println!("aldermon {}", env!("CARGO_PKG_VERSION"));
                    return;
                }
                "help" => {
                    println!("{USAGE}");
                    return;
                }
                _ => bad_flag(a),
            }
        } else if let Some(short) = a.strip_prefix('-') {
            for c in short.chars() {
                match c {
                    't' => opts.tui = true,
                    'v' => opts.vid = true,
                    'l' => opts.log = true,
                    'V' => {
                        println!("aldermon {}", env!("CARGO_PKG_VERSION"));
                        return;
                    }
                    'h' => {
                        println!("{USAGE}");
                        return;
                    }
                    _ => bad_flag(a),
                }
            }
        }
    }

    if opts.tui {
        if !std::io::stdout().is_terminal() {
            eprintln!("aldermon: --tui needs a real terminal (stdout is not a tty)");
            std::process::exit(1);
        }
        ui::run_tui(opts.log);
        return;
    }
    if opts.vid {
        vid_spike(opts.log);
        return;
    }
    if opts.log {
        eprintln!("aldermon: --log needs --tui or --vid (nothing to sample)\n{USAGE}");
        std::process::exit(2);
    }
    dump();
}

fn bad_flag(a: &str) -> ! {
    eprintln!("aldermon: unknown option '{a}'\n{USAGE}");
    std::process::exit(2);
}

fn dump() {
    println!("== hwmon ==");
    for chip in discover_chips() {
        println!("[{}] {}", chip.name, chip.path.display());
        for (label, volts) in sensors::voltages(&chip) {
            println!("  {:>18}: {:8.3} V", label, volts);
        }
        for (label, temp) in sensors::temperatures(&chip) {
            println!("  {:>18}: {:7.1} °C", label, temp);
        }
        for (label, rpm) in sensors::fans(&chip) {
            println!("  {:>18}: {:7.0} RPM", label, rpm);
        }
    }

    println!("\n== cpu frequency (MHz) ==");
    for (cpu, khz) in cpu_frequencies() {
        println!("  cpu{:>2}: {:8.1} MHz", cpu, khz as f64 / 1000.0);
    }

    println!("\n== RAPL power (sampled over 500 ms) ==");
    let domains = rapl_domains();
    let first: Vec<Option<u64>> = domains.iter().map(|d| rapl_energy_uj(&d.id)).collect();
    let start = Instant::now();
    sleep(Duration::from_millis(500));
    let elapsed = start.elapsed().as_secs_f64();
    for (domain, first) in domains.iter().zip(first) {
        match (first, rapl_energy_uj(&domain.id)) {
            (Some(a), Some(b)) if b >= a => {
                let watts = (b - a) as f64 / 1_000_000.0 / elapsed;
                println!("  {:>18} ({}): {:6.2} W", domain.name, domain.id, watts);
            }
            _ => println!("  {:>18} ({}): unreadable", domain.name, domain.id),
        }
    }
}

/// VID cross-check: compare SIO in0 (delivered rail) with the CPU's requested
/// SVID setpoint (IA32_PERF_STATUS) per sample. Needs MSR access (root or
/// the setcap'd aldermon-msr helper).
/// Without `log` this is a bounded 5-sample spike; with `log` it runs until
/// interrupted, appending CSV rows to ./aldermon-vid.log.
fn vid_spike(log: bool) {
    let cpus = sensors::cpu_count();
    let access = sensors::probe_msr();
    let mut logger = if log {
        match log::VidLogger::open(Path::new(LOG_PATH), cpus) {
            Ok(l) => {
                println!("logging to ./{LOG_PATH} ({cpus} cpus) — Ctrl-C to stop");
                Some(l)
            }
            Err(e) => {
                eprintln!("aldermon: cannot open {LOG_PATH}: {e}");
                std::process::exit(1);
            }
        }
    } else {
        None
    };

    if logger.is_none() {
        println!("== VID cross-check (MSR access: root, or setcap'd aldermon-msr) ==");
        println!("(hint: --log appends to ./{LOG_PATH} continuously)");
        if !access.usable() {
            println!("(no MSR access — run under root, or install + setup the helper)");
        }
    }
    // Package-energy counter for the logged watts (None until the second
    // sample; the first delta has no baseline).
    let pkg = rapl_domains()
        .into_iter()
        .find(|d| d.name.starts_with("package"));
    let mut prev_energy: Option<(u64, Instant)> = None;
    let rounds: u64 = if logger.is_some() { u64::MAX } else { 5 };
    for round in 0..rounds {
        let vcore = sensors::sio_vcore();
        let msrs = sensors::vid_msrs(access, cpus);
        let vmax = sensors::vid_max(&msrs);
        let freqs = cpu_frequencies();

        // Watts over this inter-sample interval (same math as the TUI).
        let watts = pkg.as_ref().and_then(|d| {
            let e = sensors::rapl_energy_uj(&d.id)?;
            let w = prev_energy.and_then(|(prev, t0)| {
                let dt = t0.elapsed().as_secs_f64();
                (dt > 0.0 && e >= prev).then(|| (e - prev) as f64 / 1_000_000.0 / dt)
            });
            prev_energy = Some((e, Instant::now()));
            w
        });

        if let Some(l) = logger.as_mut() {
            let sample = log::Sample {
                sio_vcore: vcore,
                vid_max: vmax,
                pkg_watts: watts,
                vid_msr: msrs.clone(),
                freq_khz: freq_by_cpu(&freqs, cpus),
            };
            if let Err(e) = l.log(&sample) {
                eprintln!("aldermon: log write failed: {e}");
            }
            match (vcore, vmax) {
                (Some(got), Some(ask)) => {
                    println!("in0 {got:.3} V  VID {ask:.3} V  Δ{:+.3}", got - ask)
                }
                (Some(got), None) => println!("in0 {got:.3} V  VID unreadable"),
                (None, Some(ask)) => println!("in0 unreadable  VID {ask:.3} V"),
                (None, None) => println!("in0 unreadable  VID unreadable"),
            }
        } else {
            println!("-- sample {} --", round);
            match vcore {
                Some(v) => println!("  SIO in0 (vCore): {v:.3} V"),
                None => println!("  SIO in0 (vCore): UNAVAILABLE"),
            }
            for (cpu, msr) in msrs.iter().enumerate() {
                match msr {
                    Some(m) => println!(
                        "  cpu{cpu:>2} VID: {:.3} V  (0x{m:016x})",
                        sensors::vid_from_msr(*m)
                    ),
                    None => println!("  cpu{cpu:>2} VID: unreadable"),
                }
            }
        }
        sleep(Duration::from_millis(400));
    }
}

/// Per-logical-cpu frequency vector (kHz), empty where a cpu has no reading.
fn freq_by_cpu(freqs: &[(usize, u64)], cpus: usize) -> Vec<Option<u64>> {
    let mut out = vec![None; cpus];
    for (cpu, khz) in freqs {
        if let Some(slot) = out.get_mut(*cpu) {
            *slot = Some(*khz);
        }
    }
    out
}