use std::path::{Path, PathBuf};
use serde::Serialize;
use crate::analysis::stats::percent_change_from_first;
use crate::analysis::task::{run_analysis, AnalysisOptions, AnalysisReport};
use crate::error::Result;
use crate::reader::discover_data_files;
use crate::reader::is_modat_file;
#[derive(Debug, Clone, Serialize)]
pub struct DosePoint {
pub path: PathBuf,
pub label: String,
pub spike_count: usize,
pub single_bursts: usize,
pub multi_bursts: usize,
pub mean_rate_hz: f64,
}
#[derive(Debug, Clone, Serialize)]
pub struct DoseSeriesReport {
pub points: Vec<DosePoint>,
}
#[derive(Debug, Clone, Serialize)]
pub struct DoseEditRow {
pub index: usize,
pub label: String,
pub spike_count: usize,
pub percent_change: f64,
}
#[derive(Debug, Clone, Serialize)]
pub struct DoseEditTable {
pub rows: Vec<DoseEditRow>,
}
impl DoseEditTable {
pub fn from_report(report: &DoseSeriesReport) -> Self {
let first = report.points.first().map(|p| p.spike_count as f64).unwrap_or(0.0);
let rows = report
.points
.iter()
.enumerate()
.map(|(i, p)| DoseEditRow {
index: i,
label: p.label.clone(),
spike_count: p.spike_count,
percent_change: percent_change_from_first(first, p.spike_count as f64, i == 0),
})
.collect();
Self { rows }
}
}
pub fn apply_dose_edits(
report: &DoseSeriesReport,
edits: &[(usize, Option<String>, Option<usize>)],
) -> DoseSeriesReport {
let mut out = report.clone();
for &(idx, ref label, spikes) in edits {
if let Some(row) = out.points.get_mut(idx) {
if let Some(l) = label {
row.label = l.clone();
}
if let Some(s) = spikes {
row.spike_count = s;
}
}
}
out
}
pub fn run_dose_series(dir: impl AsRef<Path>, options: &AnalysisOptions) -> Result<Vec<DosePoint>> {
Ok(run_dose_series_report(dir, options)?.points)
}
pub fn run_dose_series_report(
dir: impl AsRef<Path>,
options: &AnalysisOptions,
) -> Result<DoseSeriesReport> {
let dir = dir.as_ref();
let mut files = discover_data_files(dir)?;
files.retain(|p| is_modat_file(p));
files.sort();
let mut points = Vec::new();
for path in files {
let report: AnalysisReport = run_analysis(&path, options)?;
let label = path.file_stem().map(|s| s.to_string_lossy().into_owned()).unwrap_or_default();
let duration_sec = report.header.real_trace_duration_ms / 1000.0;
let mean_rate =
if duration_sec > 0.0 { report.spikes.len() as f64 / duration_sec } else { 0.0 };
points.push(DosePoint {
path,
label,
spike_count: report.spikes.len(),
single_bursts: report.single_bursts.len(),
multi_bursts: report.multi_bursts.len(),
mean_rate_hz: mean_rate,
});
}
Ok(DoseSeriesReport { points })
}
pub fn write_dose_csv(report: &DoseSeriesReport, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let mut w = std::io::BufWriter::new(std::fs::File::create(path).map_err(|source| {
crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source }
})?);
use std::io::Write;
writeln!(w, "label,spikes,single_bursts,multi_bursts,mean_rate_hz,path")
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
for p in &report.points {
writeln!(
w,
"{},{},{},{},{:.3},\"{}\"",
csv_escape(&p.label),
p.spike_count,
p.single_bursts,
p.multi_bursts,
p.mean_rate_hz,
p.path.display()
)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
}
Ok(())
}
pub fn write_dose_html(report: &DoseSeriesReport, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let labels: Vec<_> = report.points.iter().map(|p| p.label.clone()).collect();
let rates: Vec<_> = report.points.iter().map(|p| p.mean_rate_hz).collect();
let json_labels = serde_json::to_string(&labels).unwrap_or_else(|_| "[]".into());
let json_rates = serde_json::to_string(&rates).unwrap_or_else(|_| "[]".into());
let html = format!(
r#"<!DOCTYPE html><html><head><meta charset="utf-8"><title>Dose response</title>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script></head><body>
<h1>Mean spike rate vs condition</h1><canvas id="c" width="800" height="400"></canvas>
<script>
const ctx=document.getElementById('c');
new Chart(ctx,{{type:'line',data:{{labels:{json_labels},datasets:[{{label:'Hz',data:{json_rates},borderColor:'#2563eb'}}]}},options:{{scales:{{y:{{title:{{display:true,text:'Spikes/s'}}}}}}}}}});
</script></body></html>"#
);
std::fs::write(path, html)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
Ok(())
}
pub fn write_dose_interactive_html(
report: &DoseSeriesReport,
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let table = DoseEditTable::from_report(report);
let mut rows = String::new();
for r in &table.rows {
rows.push_str(&format!(
r#"<tr data-i="{i}"><td contenteditable="true" class="label">{label}</td>
<td contenteditable="true" class="spikes">{spikes}</td>
<td class="pct">{pct:.2}</td></tr>"#,
i = r.index,
label = html_escape(&r.label),
spikes = r.spike_count,
pct = r.percent_change,
));
}
let html = format!(
r#"<!DOCTYPE html><html><head><meta charset="utf-8"><title>Dose edit table</title>
<style>body{{font-family:system-ui;margin:1rem}}table{{border-collapse:collapse}}td,th{{border:1px solid #cbd5e1;padding:.4rem .6rem}}
td[contenteditable]{{background:#fffbeb}}</style></head><body>
<h1>Dose series (editable)</h1>
<p>Edit labels / spike counts; % change recalculates from the first row. Export CSV is client-side.</p>
<button id="export">Export CSV</button>
<table id="t"><thead><tr><th>Label</th><th>Spikes</th><th>% change</th></tr></thead>
<tbody>{rows}</tbody></table>
<script>
function pct(first,cur,isFirst){{return isFirst?100: (first===0?0:(first/cur)*100);}}
function recompute(){{
const trs=[...document.querySelectorAll('#t tbody tr')];
const first=parseFloat(trs[0]?.querySelector('.spikes')?.textContent)||0;
trs.forEach((tr,i)=>{{
const spikes=parseFloat(tr.querySelector('.spikes').textContent)||0;
tr.querySelector('.pct').textContent=pct(first,spikes,i===0).toFixed(2);
}});
}}
document.getElementById('t').addEventListener('input',recompute);
document.getElementById('export').onclick=()=>{{
const trs=[...document.querySelectorAll('#t tbody tr')];
let csv='label,spikes,percent_change\\n';
trs.forEach(tr=>{{
csv+=tr.querySelector('.label').textContent.trim()+','+
tr.querySelector('.spikes').textContent.trim()+','+
tr.querySelector('.pct').textContent.trim()+'\\n';
}});
const a=document.createElement('a');
a.href=URL.createObjectURL(new Blob([csv],{{type:'text/csv'}}));
a.download='dose_edit.csv';a.click();
}};
</script></body></html>"#
);
std::fs::write(path, html)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
Ok(())
}
fn html_escape(s: &str) -> String {
s.replace('&', "&").replace('<', "<").replace('>', ">")
}
fn csv_escape(s: &str) -> String {
if s.contains(',') || s.contains('"') {
format!("\"{}\"", s.replace('"', "\"\""))
} else {
s.to_string()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn interactive_html_has_contenteditable() {
let report = DoseSeriesReport {
points: vec![
DosePoint {
path: PathBuf::from("a.modat"),
label: "ctrl".into(),
spike_count: 100,
single_bursts: 1,
multi_bursts: 0,
mean_rate_hz: 1.0,
},
DosePoint {
path: PathBuf::from("b.modat"),
label: "drug".into(),
spike_count: 50,
single_bursts: 0,
multi_bursts: 0,
mean_rate_hz: 0.5,
},
],
};
let dir = std::env::temp_dir().join(format!("med64_dose_html_{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let path = dir.join("interactive.html");
write_dose_interactive_html(&report, &path).unwrap();
let html = std::fs::read_to_string(&path).unwrap();
assert!(html.contains("contenteditable"));
let edited = apply_dose_edits(&report, &[(1, Some("edited".into()), Some(25))]);
assert_eq!(edited.points[1].label, "edited");
assert_eq!(edited.points[1].spike_count, 25);
let _ = std::fs::remove_dir_all(&dir);
}
}