//! Static board config: rail labels + display limits. Zero deps: simple
//! `KEY = VALUE` lines, `#` comments, blank lines ignored. Unknown keys are
//! ignored (forward compatibility). Loaded once at startup.

/// Which hwmon input of the SIO chip maps to what. `(key, label)` pairs;
/// the key is the sysfs stem, e.g. "in0" → `in0_input`.
pub struct Rail {
    pub input: String,
    pub label: String,
    /// Inputs not connected on this board report garbage (floating) values;
    /// hide them unless the user maps them.
    pub hide: bool,
}

pub struct Config {
    pub rails: Vec<Rail>,
    pub vcore_limit: f64,
    pub temp_warn: f64,
    pub temp_crit: f64,
    pub vcore_bar_max: f64,
    pub power_bar_max: f64,
    /// Core-column arrangement: auto (2 cols if wide), single, or dual.
    pub layout: Layout,
    /// Show nvtop-style line graphs in the package zone.
    pub graphs: bool,
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Layout {
    Auto,
    Single,
    Dual,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            rails: default_rails(),
            vcore_limit: 1.403,
            temp_warn: 80.0,
            temp_crit: 95.0,
            vcore_bar_max: 1.50,
            power_bar_max: 200.0,
            layout: Layout::Auto,
            graphs: true,
        }
    }
}

/// Default rail map: ASRock Z690M ITX/ax (nct6798). in0 CONFIRMED Vcore
/// (shown as the hero meter, not a rail row). v2 view: only CPU-relevant
/// rails visible by default (in4 VCCIO?, in9 1.05V PROC); the others stay
/// mapped but hidden — re-enable via `rail.inN.hide = false` in the conf.
/// Differential stress-ng probing 2026-08-29 + BIOS cross-check; "?" =
/// evidence-based guess.
pub fn default_rails() -> Vec<Rail> {
    vec![
        rail("in0", "CPU Vcore", false),
        rail("in1", "Fixed 1.01", true),
        rail("in2", "Fixed 3.42", true),
        rail("in3", "+3.3V", true),
        rail("in4", "VCCIO?", false),
        rail("in5", "", true),
        rail("in6", "", true),
        rail("in7", "Fixed 3.42", true),
        rail("in8", "3.3V aux", true),
        rail("in9", "1.05V PROC", false),
        rail("in10", "", true),
        rail("in11", "", true),
        rail("in12", "Fixed 1.14", true),
        rail("in13", "", true),
        rail("in14", "Fixed 1.5V", true),
    ]
}

fn rail(input: &str, label: &str, hide: bool) -> Rail {
    Rail {
        input: input.to_string(),
        label: label.to_string(),
        hide,
    }
}

/// Parse config text over a default Config. Lines:
///   rail.in12.label = VCCSA
///   rail.in5.hide = true
///   vcore_limit = 1.35
fn apply_line(cfg: &mut Config, line: &str) {
    let line = line.split('#').next().unwrap_or("").trim();
    if line.is_empty() {
        return;
    }
    let Some((key, val)) = line.split_once('=') else {
        return;
    };
    let key = key.trim();
    let val = val.trim();
    match key {
        "vcore_limit" => cfg.vcore_limit = val.parse().unwrap_or(cfg.vcore_limit),
        "temp_warn" => cfg.temp_warn = val.parse().unwrap_or(cfg.temp_warn),
        "temp_crit" => cfg.temp_crit = val.parse().unwrap_or(cfg.temp_crit),
        "vcore_bar_max" => cfg.vcore_bar_max = val.parse().unwrap_or(cfg.vcore_bar_max),
        "power_bar_max" => cfg.power_bar_max = val.parse().unwrap_or(cfg.power_bar_max),
        "graphs" => cfg.graphs = val == "true",
        "layout" => {
            cfg.layout = match val {
                "single" => Layout::Single,
                "dual" => Layout::Dual,
                _ => Layout::Auto,
            }
        }
        "rail.hide" => return, // needs input suffix; handled below
        _ => {}
    }
    if let Some(rest) = key.strip_prefix("rail.") {
        match rest.split_once('.') {
            Some((input, "label")) => set_rail(cfg, input, val, None),
            Some((input, "hide")) => set_rail(cfg, input, "", Some(val == "true")),
            _ => {}
        }
    }
}

fn set_rail(cfg: &mut Config, input: &str, label: &str, hide: Option<bool>) {
    if let Some(r) = cfg.rails.iter_mut().find(|r| r.input == input) {
        if !label.is_empty() {
            r.label = label.to_string();
        }
        if let Some(h) = hide {
            r.hide = h;
        }
    } else {
        cfg.rails.push(Rail {
            input: input.to_string(),
            label: label.to_string(),
            hide: hide.unwrap_or(false),
        });
    }
}

pub fn load() -> Config {
    let mut cfg = Config::default();
    // Search order: ./adlermon.conf then ~/.config/adlermon/adlermon.conf
    let candidates = [
        Some(std::path::PathBuf::from("adlermon.conf")),
        dirs_home().map(|h| h.join(".config/adlermon/adlermon.conf")),
    ];
    for path in candidates.into_iter().flatten() {
        if let Ok(text) = std::fs::read_to_string(&path) {
            for line in text.lines() {
                apply_line(&mut cfg, line);
            }
            break;
        }
    }
    cfg
}

fn dirs_home() -> Option<std::path::PathBuf> {
    std::env::var_os("HOME").map(std::path::PathBuf::from)
}

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

    #[test]
    fn parses_rail_label() {
        let mut cfg = Config::default();
        apply_line(&mut cfg, "rail.in12.label = CPU Vccio  # note");
        assert_eq!(cfg.rails.iter().find(|r| r.input == "in12").unwrap().label, "CPU Vccio");
    }

    #[test]
    fn parses_hide_and_limits() {
        let mut cfg = Config::default();
        apply_line(&mut cfg, "rail.in5.hide = true");
        apply_line(&mut cfg, "vcore_limit = 1.35");
        assert!(cfg.rails.iter().find(|r| r.input == "in5").unwrap().hide);
        assert_eq!(cfg.vcore_limit, 1.35);
    }

    #[test]
    fn tolerates_junk() {
        let mut cfg = Config::default();
        apply_line(&mut cfg, "not a config line");
        apply_line(&mut cfg, "unknown_key = 42");
        apply_line(&mut cfg, "vcore_limit = notanumber");
        assert_eq!(cfg.vcore_limit, 1.403);
    }

    #[test]
    fn parses_layout_and_graphs() {
        let mut cfg = Config::default();
        apply_line(&mut cfg, "layout = dual");
        apply_line(&mut cfg, "graphs = false");
        assert_eq!(cfg.layout, Layout::Dual);
        assert!(!cfg.graphs);
        apply_line(&mut cfg, "layout = nonsense");
        assert_eq!(cfg.layout, Layout::Auto);
    }

    #[test]
    fn non_cpu_rails_hidden_by_default() {
        let cfg = Config::default();
        let hidden: Vec<&str> = cfg.rails.iter().filter(|r| r.hide).map(|r| r.input.as_str()).collect();
        assert_eq!(hidden, ["in1", "in2", "in3", "in5", "in6", "in7", "in8", "in10", "in11", "in12", "in13", "in14"]);
        let shown: Vec<&str> = cfg.rails.iter().filter(|r| !r.hide && r.input != "in0").map(|r| r.input.as_str()).collect();
        assert_eq!(shown, ["in4", "in9"]);
    }
}