use std::time::{Instant, SystemTime};
use chrono::{DateTime, Local};
use crate::config::Config;
use crate::domain::settle;
use crate::store::{Loaded, Store};
use crate::sync::Sync;
use super::action::{Action, Effect};
use super::model::{Model, Problem, SyncStatus};
use super::tracker::{Due, SyncTracker};
pub struct Runtime {
store: Store,
sync: Option<Sync>,
tracker: SyncTracker,
last_mtime: Option<SystemTime>,
unsaved: bool,
quit_error: Option<String>,
}
impl Runtime {
pub fn new(config: &Config) -> Self {
let sync = config
.remote
.as_ref()
.map(|remote| Sync::new(config.data_dir.clone(), Some(remote.clone())));
Self {
store: Store::new(config.board_path()),
tracker: SyncTracker::new(sync.is_some(), Instant::now()),
sync,
last_mtime: None,
unsaved: false,
quit_error: None,
}
}
pub fn status(&self) -> SyncStatus {
self.tracker.status()
}
pub fn problem(&self) -> Option<&Problem> {
self.tracker.problem()
}
pub fn needs_flush(&self) -> bool {
self.tracker.needs_flush()
}
pub fn quit_error(&self) -> Option<&str> {
self.quit_error.as_deref()
}
pub fn load_board(&mut self, now: DateTime<Local>) -> Loaded {
let loaded = self.store.load();
let mut board = loaded.board;
if settle(&mut board, now)
&& let Err(err) = self.store.save(&board)
{
eprintln!("tasu: could not save the board: {err}");
}
self.sync_mtime();
Loaded {
board,
damaged: loaded.damaged,
}
}
pub fn start_sync(&mut self) {
if let Some(sync) = &self.sync {
match sync.pull() {
Ok(()) => self.tracker.pull_queued(),
Err(err) => self.tracker.failed(&err),
}
}
}
fn sync_mtime(&mut self) {
self.last_mtime = self.store.mtime();
}
pub fn apply(&mut self, model: &mut Model, effects: Vec<Effect>) {
for effect in effects {
match effect {
Effect::Save => {
match self.store.save(&model.board) {
Ok(()) => {
model.ui.error = None;
model.ui.board_damage = None;
self.unsaved = false;
self.tracker.changed(Instant::now());
}
Err(err) => {
model.ui.error =
Some(Problem::new("could not save", format!("{err:#}")));
self.unsaved = true;
}
}
self.sync_mtime();
}
Effect::Quit => {
model.should_quit = true;
if self.unsaved {
match self.store.save(&model.board) {
Ok(()) => self.unsaved = false,
Err(err) => {
self.quit_error = Some(format!("could not save the board: {err}"));
}
}
}
}
}
}
}
pub fn poll_external(&mut self) -> Vec<Action> {
let mut actions = Vec::new();
if let Some(sync) = &self.sync {
match sync.poll_init() {
Ok(Some(Err(err))) | Err(err) => self.tracker.failed(&err),
Ok(_) => {}
}
let now = Instant::now();
loop {
match sync.poll() {
Ok(Some(outcome)) => {
if let Some(board) = self.tracker.on_outcome(outcome, now) {
actions.push(Action::Merge(board));
}
}
Ok(None) => break,
Err(err) => {
self.tracker.failed(&err);
break;
}
}
}
match self.tracker.due(now) {
Due::Nothing => {}
due => dispatch(&mut self.tracker, sync, due),
}
}
if let Some(action) = self.reload_if_changed() {
actions.push(action);
}
actions
}
fn reload_if_changed(&mut self) -> Option<Action> {
let current = self.store.mtime();
if current == self.last_mtime || current.is_none() {
return None;
}
self.last_mtime = current;
let loaded = self.store.load();
Some(Action::Reload {
board: loaded.board,
damaged: loaded.damaged.as_ref().map(Problem::from_damage),
})
}
}
fn dispatch(tracker: &mut SyncTracker, sync: &Sync, due: Due) {
if due == Due::PullThenPush {
if let Err(err) = sync.pull() {
tracker.failed(&err);
return;
}
tracker.pull_queued();
}
match sync.commit_push() {
Ok(()) => tracker.push_queued(),
Err(err) => tracker.failed(&err),
}
}