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
//! Burst Detector batch-export preference matrix (`batch_export_prefs.properties`).

use std::path::Path;

use crate::error::{Med64Error, Result};

/// Wire `exportTraceType` — 0 / 1 / 2.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ExportTraceType {
    #[default]
    Single = 0,
    AllInEach = 1,
    AllInOne = 2,
}

/// Wire `chartImageType` — 0 = BMP, 1 = PNG.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ChartImageType {
    #[default]
    Bmp = 0,
    Png = 1,
}

/// Burst Detector batch export toggles + filename suffixes.
#[derive(Debug, Clone)]
pub struct BatchExportPrefs {
    pub export_trace_type: ExportTraceType,
    pub chart_image_type: ChartImageType,
    pub export_spike_events: bool,
    pub spike_events_suffix: String,
    pub export_chart: bool,
    pub chart_suffix: String,
    pub export_burst: bool,
    pub burst_suffix: String,
    pub export_summary_values: bool,
    pub summary_values_suffix: String,
    pub export_individual_values: bool,
    pub individual_values_suffix: String,
    pub export_details: bool,
    pub details_suffix: String,
}

impl Default for BatchExportPrefs {
    fn default() -> Self {
        // `default.properties`: all export_* false.
        Self {
            export_trace_type: ExportTraceType::Single,
            chart_image_type: ChartImageType::Bmp,
            export_spike_events: false,
            spike_events_suffix: "Spikes events".into(),
            export_chart: false,
            chart_suffix: "Chart".into(),
            export_burst: false,
            burst_suffix: "Burst".into(),
            export_summary_values: false,
            summary_values_suffix: "Summary values".into(),
            export_individual_values: false,
            individual_values_suffix: "Individual values".into(),
            export_details: false,
            details_suffix: "Details".into(),
        }
    }
}

impl BatchExportPrefs {
    /// True when no export target toggle is selected.
    pub fn is_not_target_selected(&self) -> bool {
        !self.export_spike_events
            && !self.export_chart
            && !self.export_burst
            && !self.export_summary_values
            && !self.export_individual_values
            && !self.export_details
    }

    /// Practical CLI default when `--burst-batch` is used without `--export-*`.
    pub fn cli_burst_batch_default() -> Self {
        Self {
            export_chart: true,
            export_burst: true,
            export_summary_values: true,
            export_individual_values: true,
            export_details: true,
            ..Self::default()
        }
    }

    /// Build output stem+suffix path (without directory).
    pub fn filename(&self, basename: &str, suffix: &str) -> String {
        match self.export_trace_type {
            ExportTraceType::AllInEach => format!("{basename}_001_{suffix}.csv"),
            ExportTraceType::Single | ExportTraceType::AllInOne => {
                format!("{basename}{suffix}.csv")
            }
        }
    }

    pub fn image_filename(&self, basename: &str, suffix: &str) -> String {
        let ext = match self.chart_image_type {
            ChartImageType::Bmp => "bmp",
            ChartImageType::Png => "png",
        };
        match self.export_trace_type {
            ExportTraceType::AllInEach => format!("{basename}_001_{suffix}.{ext}"),
            ExportTraceType::Single | ExportTraceType::AllInOne => {
                format!("{basename}{suffix}.{ext}")
            }
        }
    }
}

fn parse_bool(v: &str) -> bool {
    matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on")
}

fn parse_trace_type(v: &str) -> ExportTraceType {
    let t = v.trim();
    if let Ok(n) = t.parse::<i32>() {
        return match n {
            1 => ExportTraceType::AllInEach,
            2 => ExportTraceType::AllInOne,
            _ => ExportTraceType::Single,
        };
    }
    match t.to_ascii_lowercase().replace('_', "").as_str() {
        "allineach" | "all-in-each" | "each" => ExportTraceType::AllInEach,
        "allinone" | "all-in-one" | "one" => ExportTraceType::AllInOne,
        _ => ExportTraceType::Single,
    }
}

fn parse_image_type(v: &str) -> ChartImageType {
    let t = v.trim();
    if let Ok(n) = t.parse::<i32>() {
        return if n == 1 { ChartImageType::Png } else { ChartImageType::Bmp };
    }
    match t.to_ascii_lowercase().as_str() {
        "png" | "1" => ChartImageType::Png,
        _ => ChartImageType::Bmp,
    }
}

/// Load `batch_export_prefs.properties`.
pub fn load_batch_export_prefs(path: impl AsRef<Path>) -> Result<BatchExportPrefs> {
    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 = BatchExportPrefs::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 {
            "exportTraceType" => prefs.export_trace_type = parse_trace_type(v),
            "chartImageType" => prefs.chart_image_type = parse_image_type(v),
            "exportSpikeEvents" => prefs.export_spike_events = parse_bool(v),
            "spikeEventsSuffix" => prefs.spike_events_suffix = v.to_string(),
            "exportChart" => prefs.export_chart = parse_bool(v),
            "chartSuffix" => prefs.chart_suffix = v.to_string(),
            "exportBurst" => prefs.export_burst = parse_bool(v),
            "burstSuffix" => prefs.burst_suffix = v.to_string(),
            "exportSummaryValues" => prefs.export_summary_values = parse_bool(v),
            "summaryValuesSuffix" => prefs.summary_values_suffix = v.to_string(),
            "exportIndividualValues" => prefs.export_individual_values = parse_bool(v),
            "individualValuesSuffix" => prefs.individual_values_suffix = v.to_string(),
            "exportDetails" => prefs.export_details = parse_bool(v),
            "detailsSuffix" => prefs.details_suffix = v.to_string(),
            _ => {}
        }
    }
    Ok(prefs)
}

/// Write `batch_export_prefs.properties`.
pub fn write_batch_export_prefs(prefs: &BatchExportPrefs, path: impl AsRef<Path>) -> Result<()> {
    let path = path.as_ref();
    let body = format!(
        "# med64 Burst Detector batch export prefs\n\
         exportTraceType={}\n\
         chartImageType={}\n\
         exportSpikeEvents={}\n\
         spikeEventsSuffix={}\n\
         exportChart={}\n\
         chartSuffix={}\n\
         exportBurst={}\n\
         burstSuffix={}\n\
         exportSummaryValues={}\n\
         summaryValuesSuffix={}\n\
         exportIndividualValues={}\n\
         individualValuesSuffix={}\n\
         exportDetails={}\n\
         detailsSuffix={}\n",
        prefs.export_trace_type as i32,
        prefs.chart_image_type as i32,
        prefs.export_spike_events,
        prefs.spike_events_suffix,
        prefs.export_chart,
        prefs.chart_suffix,
        prefs.export_burst,
        prefs.burst_suffix,
        prefs.export_summary_values,
        prefs.summary_values_suffix,
        prefs.export_individual_values,
        prefs.individual_values_suffix,
        prefs.export_details,
        prefs.details_suffix,
    );
    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 })?;
    Ok(())
}

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

    #[test]
    fn batch_export_prefs_roundtrip() {
        let dir = std::env::temp_dir().join(format!("med64-bep-{}", std::process::id()));
        let _ = std::fs::create_dir_all(&dir);
        let path = dir.join("batch_export_prefs.properties");
        let prefs = BatchExportPrefs {
            export_trace_type: ExportTraceType::AllInOne,
            chart_image_type: ChartImageType::Png,
            export_chart: true,
            export_burst: true,
            chart_suffix: "Chart".into(),
            burst_suffix: "Burst".into(),
            ..BatchExportPrefs::default()
        };
        write_batch_export_prefs(&prefs, &path).unwrap();
        let loaded = load_batch_export_prefs(&path).unwrap();
        assert_eq!(loaded.export_trace_type, ExportTraceType::AllInOne);
        assert_eq!(loaded.chart_image_type, ChartImageType::Png);
        assert!(loaded.export_chart);
        assert!(loaded.export_burst);
        assert!(!loaded.is_not_target_selected());
        assert_eq!(loaded.filename("rec", "Chart"), "recChart.csv");
        let each = BatchExportPrefs { export_trace_type: ExportTraceType::AllInEach, ..prefs };
        assert_eq!(each.filename("rec", "Chart"), "rec_001_Chart.csv");
        let _ = std::fs::remove_dir_all(dir);
    }

    #[test]
    fn parse_trace_and_image_aliases() {
        assert_eq!(parse_trace_type("AllInEach"), ExportTraceType::AllInEach);
        assert_eq!(parse_trace_type("all-in-one"), ExportTraceType::AllInOne);
        assert_eq!(parse_image_type("png"), ChartImageType::Png);
        assert_eq!(parse_image_type("0"), ChartImageType::Bmp);
    }
}