use std::path::Path;
use crate::error::{Med64Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ExportTraceType {
#[default]
Single = 0,
AllInEach = 1,
AllInOne = 2,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ChartImageType {
#[default]
Bmp = 0,
Png = 1,
}
#[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 {
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 {
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
}
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()
}
}
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,
}
}
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)
}
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);
}
}