use super::Clock;
use super::pacing::Core;
pub const EVENT_MS: f64 = 250.0;
pub const LOOK_MS: f64 = 100.0;
pub(crate) fn memory_state(core: Option<&impl Core>) -> Option<String> {
core.map(|c| match c.memory_changes() {
Ok(n) => format!("{n:016X}"),
Err(e) => format!("error: {e}"),
})
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Watch {
pub on: bool,
last: Option<String>,
at: Option<f64>,
told: Option<f64>,
cycles: u64,
pub force: bool,
pub due: Option<f64>,
pub looks: u64,
pub spent_ms: f64,
}
impl Watch {
pub fn subscribe(&mut self, on: bool, core: Option<&impl Core>) {
self.on = on;
self.last = memory_state(core);
self.at = None;
self.told = None;
self.force = false;
self.due = None;
if let Some(c) = core {
self.cycles = c.cycles();
}
}
pub fn poll(&mut self, core: Option<&impl Core>, quiet: bool, clock: &dyn Clock) -> bool {
let Some(core) = core else {
return false;
};
if !self.on || self.due.is_some() || !quiet {
return false;
}
let cycles = core.cycles();
if cycles == self.cycles && !self.force {
return false;
}
let now = clock.now_ms();
let due = [
self.at.map(|t| t + LOOK_MS),
self.told.map(|t| t + EVENT_MS),
]
.into_iter()
.flatten()
.fold(f64::NEG_INFINITY, f64::max);
if due > now {
self.due = Some(due);
return false;
}
self.at = Some(now);
self.cycles = cycles;
self.force = false;
let state = memory_state(Some(core));
self.looks += 1;
self.spent_ms += clock.now_ms() - now;
if state != self.last {
self.last = state;
self.told = Some(now);
return true;
}
false
}
}