use std::fs;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{SystemTime, UNIX_EPOCH};
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use crate::domain::{Board, Task};
#[derive(Debug, Serialize, Deserialize)]
struct FileSchema {
#[serde(default)]
tasks: Vec<Task>,
}
pub struct Loaded {
pub board: Board,
pub damaged: Option<Damage>,
}
#[derive(Debug, Clone)]
pub struct Damage {
pub backup: Option<PathBuf>,
pub reason: String,
}
impl Damage {
pub fn detail(&self) -> String {
match &self.backup {
Some(path) => format!(
"board unreadable ({}) \u{b7} saved as {}",
self.reason,
path.display()
),
None => format!("board unreadable ({})", self.reason),
}
}
}
pub struct Store {
path: PathBuf,
}
impl Store {
pub fn new(path: impl Into<PathBuf>) -> Self {
Self { path: path.into() }
}
pub fn path(&self) -> &Path {
&self.path
}
pub fn load(&self) -> Loaded {
let text = match fs::read_to_string(&self.path) {
Ok(text) => text,
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
return Loaded {
board: Board::new(),
damaged: None,
};
}
Err(err) => {
return Loaded {
board: Board::new(),
damaged: Some(Damage {
backup: None,
reason: err.to_string(),
}),
};
}
};
match serde_json::from_str::<FileSchema>(&text) {
Ok(schema) => Loaded {
board: Board::from_tasks(schema.tasks),
damaged: None,
},
Err(err) => {
let reason = err.to_string();
let (backup, reason) = match self.backup() {
Ok(path) => (Some(path), reason),
Err(move_err) => (
None,
format!("{reason}; could not move it aside: {move_err}"),
),
};
Loaded {
board: Board::new(),
damaged: Some(Damage { backup, reason }),
}
}
}
}
pub fn save(&self, board: &Board) -> Result<()> {
if let Some(parent) = self.path.parent() {
fs::create_dir_all(parent).context("failed to create data directory")?;
}
let json = serialize(board).context("failed to serialize board")?;
atomic_write(&self.path, &json)
}
pub fn read_bytes(&self) -> std::io::Result<Option<Vec<u8>>> {
match fs::read(&self.path) {
Ok(bytes) => Ok(Some(bytes)),
Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
Err(err) => Err(err),
}
}
pub fn write_bytes(&self, bytes: &[u8]) -> Result<()> {
if let Some(parent) = self.path.parent() {
fs::create_dir_all(parent).context("failed to create data directory")?;
}
atomic_write(&self.path, bytes)
}
pub fn mtime(&self) -> Option<SystemTime> {
fs::metadata(&self.path)
.and_then(|meta| meta.modified())
.ok()
}
fn backup(&self) -> std::io::Result<PathBuf> {
let file_name = self
.path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| "todos.json".to_string());
let seconds = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or_default();
let mut backup = self
.path
.with_file_name(format!("{file_name}.corrupt-{seconds}"));
let mut suffix = 1;
while backup.exists() {
backup = self
.path
.with_file_name(format!("{file_name}.corrupt-{seconds}.{suffix}"));
suffix += 1;
}
fs::rename(&self.path, &backup)?;
Ok(backup)
}
}
fn atomic_write(path: &Path, bytes: &[u8]) -> Result<()> {
static SEQ: AtomicU64 = AtomicU64::new(0);
let seq = SEQ.fetch_add(1, Ordering::Relaxed);
let tmp = path.with_file_name(format!(
"{}.{}.{seq}.tmp",
path.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| "todos.json".to_string()),
std::process::id(),
));
fs::write(&tmp, bytes).context("failed to write temporary file")?;
if let Err(err) = fs::rename(&tmp, path) {
let _ = fs::remove_file(&tmp);
return Err(err).context("failed to replace board file");
}
Ok(())
}
pub fn board_from_bytes(bytes: &[u8]) -> Option<Board> {
let schema = serde_json::from_slice::<FileSchema>(bytes).ok()?;
Some(Board::from_tasks(schema.tasks))
}
fn serialize(board: &Board) -> serde_json::Result<Vec<u8>> {
#[derive(Serialize)]
struct FileSchemaRef<'a> {
#[serde(default)]
tasks: &'a [Task],
}
serde_json::to_vec_pretty(&FileSchemaRef {
tasks: board.tasks(),
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MergeSide {
Base,
Other,
}
pub fn merge_files(base: &[u8], other: &[u8]) -> Result<Vec<u8>, MergeSide> {
let base = board_from_bytes(base).ok_or(MergeSide::Base)?;
let other = board_from_bytes(other).ok_or(MergeSide::Other)?;
serialize(&base.merged_with(&other)).map_err(|_| MergeSide::Base)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::test_time::at;
fn board_bytes(tasks: &[(&str, u32)]) -> Vec<u8> {
let schema = FileSchema {
tasks: tasks
.iter()
.map(|(title, day)| Task::new(*title, at(2026, 10, *day)))
.collect(),
};
serde_json::to_vec(&schema).unwrap()
}
#[test]
fn merging_files_matches_tasks_by_creation_time() {
let base = board_bytes(&[("shared", 5), ("base only", 6)]);
let other = board_bytes(&[("shared", 5), ("other only", 7)]);
let merged: FileSchema =
serde_json::from_slice(&merge_files(&base, &other).unwrap()).unwrap();
let titles: Vec<&str> = merged.tasks.iter().map(|t| t.title.as_str()).collect();
assert_eq!(titles, vec!["shared", "base only", "other only"]);
}
#[test]
fn a_remote_board_with_duplicate_copies_is_collapsed_on_read() {
let twin = FileSchema {
tasks: vec![
Task::new("twin", at(2026, 10, 5)),
Task::new("twin", at(2026, 10, 5)),
],
};
let bytes = serde_json::to_vec(&twin).unwrap();
assert_eq!(board_from_bytes(&bytes).unwrap().len(), 1);
}
#[test]
fn merging_names_the_side_it_cannot_read() {
let ok = board_bytes(&[("a", 5)]);
assert_eq!(merge_files(b"not json", &ok), Err(MergeSide::Base));
assert_eq!(merge_files(&ok, b"neither is this"), Err(MergeSide::Other));
}
fn store_in(dir: &tempfile::TempDir) -> Store {
Store::new(dir.path().join("todos.json"))
}
#[test]
fn missing_file_loads_empty() {
let dir = tempfile::tempdir().unwrap();
let loaded = store_in(&dir).load();
assert!(loaded.board.is_empty());
assert!(loaded.damaged.is_none(), "a missing file is not damage");
}
#[test]
fn roundtrips_a_board() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
let mut board = Board::new();
board.add("Nand2Tetris 第å…ç« ", at(2026, 10, 5));
board.add("å¦ä¹ GPUI", at(2026, 10, 6));
store.save(&board).unwrap();
let loaded = store.load();
assert_eq!(loaded.board.len(), 2);
assert_eq!(loaded.board.task(0).unwrap().title, "Nand2Tetris 第å…ç« ");
assert_eq!(loaded.board.task(1).unwrap().title, "å¦ä¹ GPUI");
assert!(loaded.damaged.is_none());
}
#[test]
fn writes_a_tasks_array() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
store.save(&Board::new()).unwrap();
let value: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(store.path()).unwrap()).unwrap();
assert!(value.get("tasks").is_some_and(serde_json::Value::is_array));
}
#[test]
fn corrupt_file_is_backed_up_not_lost() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
std::fs::write(store.path(), "{ not json").unwrap();
let loaded = store.load();
assert!(loaded.board.is_empty());
let damage = loaded.damaged.expect("a corrupt file is damaged");
assert!(damage.backup.is_some(), "the original was moved aside");
let backups: Vec<_> = std::fs::read_dir(dir.path())
.unwrap()
.filter_map(Result::ok)
.map(|entry| entry.file_name().to_string_lossy().into_owned())
.filter(|name| name.contains(".corrupt-"))
.collect();
assert_eq!(backups.len(), 1);
}
#[test]
fn repeated_damage_does_not_overwrite_the_first_backup() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
std::fs::write(store.path(), "{ not json").unwrap();
store.load();
std::fs::write(store.path(), "{ also not json").unwrap();
store.load();
let backups = std::fs::read_dir(dir.path())
.unwrap()
.filter_map(Result::ok)
.filter(|entry| entry.file_name().to_string_lossy().contains(".corrupt-"))
.count();
assert_eq!(backups, 2, "each bad board must be kept");
}
#[test]
fn save_replaces_the_previous_file() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
let mut board = Board::new();
board.add("old", at(2026, 10, 5));
store.save(&board).unwrap();
let mut board = Board::new();
board.add("new", at(2026, 10, 6));
store.save(&board).unwrap();
assert_eq!(store.load().board.len(), 1);
assert_eq!(store.load().board.task(0).unwrap().title, "new");
}
#[test]
fn mtime_is_available_once_saved() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
assert!(store.mtime().is_none());
store.save(&Board::new()).unwrap();
assert!(store.mtime().is_some());
}
#[test]
fn raw_bytes_roundtrip_through_the_atomic_path() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
assert!(
store.read_bytes().unwrap().is_none(),
"a missing file reads as None"
);
store.write_bytes(b"{\"tasks\":[]}").unwrap();
assert_eq!(
store.read_bytes().unwrap().as_deref(),
Some(&b"{\"tasks\":[]}"[..])
);
}
#[test]
fn unreadable_file_is_an_error_not_a_missing_board() {
let dir = tempfile::tempdir().unwrap();
let store = store_in(&dir);
std::fs::create_dir(store.path()).unwrap();
assert!(store.read_bytes().is_err());
}
}