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 Delay Map prefs (`conf_propagationdelaymap.properties`).

use std::path::Path;

use crate::error::{Med64Error, Result};
use crate::layout::WellPlate;
use crate::toolkit::propagation::{AverageBinKind, PropagationOptions};
use crate::toolkit::propagation_oversample::{OversampleMode, ShihyouBins};

#[derive(Debug, Clone)]
pub struct PropagationPrefs {
    /// Wire key `combooversample` string.
    pub oversample: OversampleMode,
    /// Wire key `comboshihyou` (5 / 10 / 20).
    pub shihyou: ShihyouBins,
    pub average_bin: AverageBinKind,
    pub well_plate: WellPlate,
    pub electrode_pitch_um: f64,
}

impl Default for PropagationPrefs {
    fn default() -> Self {
        Self {
            oversample: OversampleMode::None,
            shihyou: ShihyouBins::Off,
            average_bin: AverageBinKind::None,
            well_plate: WellPlate::Wells24,
            electrode_pitch_um: 150.0,
        }
    }
}

impl PropagationPrefs {
    pub fn apply_to(&self, options: &mut PropagationOptions) {
        options.average_bin = self.average_bin;
        options.well_plate = self.well_plate;
        options.electrode_pitch_um = self.electrode_pitch_um;
        options.oversample = self.oversample;
        options.shihyou = self.shihyou;
        // Do NOT map oversample → conduction_bins (spatial upsample ≠ time bins).
    }
}

pub fn load_propagation_prefs(path: impl AsRef<Path>) -> Result<PropagationPrefs> {
    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 = PropagationPrefs::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;
        };
        let k = k.trim();
        let v = v.trim();
        match k {
            "combooversample" | "oversample" => {
                if let Some(m) = OversampleMode::parse(v) {
                    prefs.oversample = m;
                }
            }
            "comboshihyou" | "shihyou" => {
                if let Some(s) = ShihyouBins::parse(v) {
                    prefs.shihyou = s;
                }
            }
            "average_bin" | "avebin" | "bin" => {
                if let Some(b) = AverageBinKind::parse(v) {
                    prefs.average_bin = b;
                }
            }
            "wellsuu" | "plate" | "well_plate" => {
                if let Some(p) = WellPlate::parse(v) {
                    prefs.well_plate = p;
                }
            }
            "electrode_pitch_um" | "pitch" => {
                prefs.electrode_pitch_um = v.parse().unwrap_or(150.0);
            }
            _ => {}
        }
    }
    Ok(prefs)
}

pub fn write_propagation_prefs(prefs: &PropagationPrefs, path: impl AsRef<Path>) -> Result<()> {
    let path = path.as_ref();
    let bin = match prefs.average_bin {
        AverageBinKind::None => "none",
        AverageBinKind::Bin16 => "16",
        AverageBinKind::Bin32 => "32",
        AverageBinKind::Presto => "presto",
    };
    let plate = match prefs.well_plate {
        WellPlate::Wells6 => "6",
        WellPlate::Wells24 => "24",
        WellPlate::Wells48 => "48",
        WellPlate::Wells96 => "96",
    };
    let body = format!(
        "# Propagation Delay Map prefs (pdm99)\n\
         combooversample={}\n\
         comboshihyou={}\n\
         average_bin={bin}\n\
         wellsuu={plate}\n\
         electrode_pitch_um={}\n",
        prefs.oversample.as_wire_str(),
        prefs.shihyou.levels(),
        prefs.electrode_pitch_um
    );
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent).ok();
    }
    std::fs::write(path, body)
        .map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })
}

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

    #[test]
    fn prefs_roundtrip_wire_strings() {
        let dir = std::env::temp_dir().join(format!("med64-pdmprefs-{}", std::process::id()));
        let _ = std::fs::create_dir_all(&dir);
        let path = dir.join("conf_propagationdelaymap.properties");
        let prefs = PropagationPrefs {
            oversample: OversampleMode::Linear64,
            shihyou: ShihyouBins::Twenty,
            average_bin: AverageBinKind::Presto,
            well_plate: WellPlate::Wells24,
            electrode_pitch_um: 200.0,
        };
        write_propagation_prefs(&prefs, &path).unwrap();
        let loaded = load_propagation_prefs(&path).unwrap();
        assert_eq!(loaded.oversample, OversampleMode::Linear64);
        assert_eq!(loaded.shihyou, ShihyouBins::Twenty);
        let mut opts = PropagationOptions::default();
        loaded.apply_to(&mut opts);
        assert_eq!(opts.oversample, OversampleMode::Linear64);
        assert_eq!(opts.conduction_bins, 1); // must not steal oversample
        let _ = std::fs::remove_dir_all(dir);
    }
}