med64 0.0.2

Headless MED64 electrophysiology toolkit: .modat I/O, spike/burst analysis, assays, spike-rate maps, and CSV/HTML/SVG/HDF5 export
Documentation
//! Propagation PAID prefs (`conf_propagationpaid.properties`).

use std::path::Path;

use crate::error::{Med64Error, Result};
use crate::toolkit::paid::PaidOptions;

#[derive(Debug, Clone)]
pub struct PaidPrefs {
    pub checksmoothing: bool,
    pub combohpf: String,
    pub combolpf: String,
    pub combooversample: String,
    pub comboshihyou: String,
}

impl Default for PaidPrefs {
    fn default() -> Self {
        Self {
            checksmoothing: false,
            combohpf: "None".into(),
            combolpf: "None".into(),
            combooversample: "None".into(),
            comboshihyou: "20".into(),
        }
    }
}

impl PaidPrefs {
    pub fn apply_to(&self, options: &mut PaidOptions) {
        options.smoothing_ms = if self.checksmoothing { 20.0 } else { 0.0 };
        let hp = self.combohpf.to_ascii_lowercase();
        if hp.contains("none") {
            options.analysis.highpass_hz = None;
        } else if hp.contains("highpass") || hp.contains("butterworth") {
            options.analysis.highpass_hz = Some(100.0);
        }
        let lp = self.combolpf.to_ascii_lowercase();
        if lp.contains("none") {
            options.analysis.lowpass_hz = None;
        } else if lp.contains("lowpass") || lp.contains("butterworth") {
            options.analysis.lowpass_hz = Some(2000.0);
        }
    }
}

pub fn load_paid_prefs(path: impl AsRef<Path>) -> Result<PaidPrefs> {
    let path = path.as_ref();
    let text = std::fs::read_to_string(path)
        .map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
    let mut prefs = PaidPrefs::default();
    for line in text.lines() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        let Some((k, v)) = line.split_once('=') else {
            continue;
        };
        match k.trim() {
            "checksmoothing" => {
                prefs.checksmoothing =
                    matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on");
            }
            "combohpf" => prefs.combohpf = v.trim().to_string(),
            "combolpf" => prefs.combolpf = v.trim().to_string(),
            "combooversample" => prefs.combooversample = v.trim().to_string(),
            "comboshihyou" => prefs.comboshihyou = v.trim().to_string(),
            _ => {}
        }
    }
    Ok(prefs)
}

pub fn write_paid_prefs(prefs: &PaidPrefs, path: impl AsRef<Path>) -> Result<()> {
    let path = path.as_ref();
    let body = format!(
        "# med64 propagation paid prefs\n\
         checksmoothing={}\n\
         combohpf={}\n\
         combolpf={}\n\
         combooversample={}\n\
         comboshihyou={}\n",
        if prefs.checksmoothing { "1" } else { "0" },
        prefs.combohpf,
        prefs.combolpf,
        prefs.combooversample,
        prefs.comboshihyou,
    );
    std::fs::write(path, body)
        .map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })
}

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

    #[test]
    fn paid_prefs_roundtrip() {
        let dir = std::env::temp_dir().join(format!("med64-paidpref-{}", std::process::id()));
        let _ = std::fs::create_dir_all(&dir);
        let path = dir.join("conf_propagationpaid.properties");
        let prefs = PaidPrefs {
            checksmoothing: false,
            combohpf: "None".into(),
            combolpf: "None".into(),
            combooversample: "None".into(),
            comboshihyou: "20".into(),
        };
        write_paid_prefs(&prefs, &path).unwrap();
        let loaded = load_paid_prefs(&path).unwrap();
        let mut opts = PaidOptions::default();
        loaded.apply_to(&mut opts);
        assert_eq!(opts.smoothing_ms, 0.0);
        let on = PaidPrefs { checksmoothing: true, ..prefs };
        on.apply_to(&mut opts);
        assert_eq!(opts.smoothing_ms, 20.0);
        let _ = std::fs::remove_dir_all(dir);
    }
}