mod detail;
mod list;
mod run;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::mpsc::Sender;
use std::time::{Duration, Instant};
use crossterm::event::KeyEvent;
use crate::cache::Run;
use crate::cache::models::{Problem, ReviewCard, VerifyResult};
use crate::filters::{ProblemFilters, ProgressStats, progress};
use crate::helper::Difficulty;
use crate::srs::Grade;
use crate::tui::input::Input;
use crate::{Cache, Result};
pub use run::run;
pub(crate) const LIST_ROWS_MARGIN: u16 = 9;
const DETAIL_ROWS_MARGIN: u16 = 3;
const DETAIL_MARGIN: u16 = 4;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DeckState {
pub due_fids: Vec<i32>,
pub tracked: i32,
}
pub enum Msg {
Key(KeyEvent),
Resize(u16, u16),
ProblemsLoaded(Result<Vec<Problem>>),
TagIdsLoaded {
generation: u64,
res: Result<Vec<String>>,
},
QuestionLoaded {
generation: u64,
fid: i32,
res: Result<String>,
},
DailyLoaded(Result<i32>),
CodeFileReady {
fid: i32,
res: Result<String>,
},
ExecDone {
generation: u64,
fid: i32,
kind: Run,
res: Result<Box<VerifyResult>>,
},
DueLoaded(Result<DeckState>),
ReviewGraded {
fid: i32,
grade: Grade,
res: Result<ReviewCard>,
},
Tick,
}
const SPINNER_INTERVAL: Duration = Duration::from_millis(150);
const SPINNER_FRAMES: [&str; 10] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
pub(crate) struct ExecInFlight {
pub(crate) kind: Run,
pub(crate) fid: i32,
started: Instant,
frame: usize,
}
impl ExecInFlight {
pub(crate) fn label(&self) -> String {
let verb = match self.kind {
Run::Test => "testing",
Run::Submit => "submitting",
};
format!(
"{} {verb} #{} · {:.1}s",
SPINNER_FRAMES[self.frame % SPINNER_FRAMES.len()],
self.fid,
self.started.elapsed().as_secs_f32()
)
}
}
pub(crate) struct ExecOutcome {
pub(crate) kind: Run,
pub(crate) text: String,
pub(crate) accepted: bool,
pub(crate) scroll: usize,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(crate) enum Mode {
List,
Detail,
Help,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(crate) enum PromptKind {
Search,
Tag,
}
pub(crate) struct Prompt {
pub(crate) kind: PromptKind,
pub(crate) input: Input,
}
pub(crate) struct SetChoice {
pub(crate) slug: String,
pub(crate) name: String,
pub(crate) count: usize,
}
pub struct Options {
pub rt: tokio::runtime::Handle,
pub cache: Cache,
pub filters: ProblemFilters,
}
struct Backend {
rt: tokio::runtime::Handle,
cache: Cache,
tx: Sender<Msg>,
suspended: Arc<AtomicBool>,
}
impl Backend {
fn load_problems(&self) {
let cache = self.cache.clone();
let tx = self.tx.clone();
self.rt.spawn(async move {
let res = crate::cmd::populated_problems(&cache).await;
let _ = tx.send(Msg::ProblemsLoaded(res));
});
}
fn load_question(&self, fid: i32, generation: u64) {
let cache = self.cache.clone();
let tx = self.tx.clone();
self.rt.spawn(async move {
let res = cache
.get_question(fid)
.await
.map(|question| question.desc());
let _ = tx.send(Msg::QuestionLoaded {
generation,
fid,
res,
});
});
}
fn load_daily(&self) {
let cache = self.cache.clone();
let tx = self.tx.clone();
self.rt.spawn(async move {
let _ = tx.send(Msg::DailyLoaded(cache.get_daily_problem_id().await));
});
}
fn prepare_code_file(&self, fid: i32) {
let cache = self.cache.clone();
let tx = self.tx.clone();
self.rt.spawn(async move {
let res = crate::scaffold::ensure_code_file(
&cache,
fid,
None,
crate::scaffold::Announce::Silent,
crate::scaffold::Existing::Keep,
)
.await;
let _ = tx.send(Msg::CodeFileReady { fid, res });
});
}
fn exec(&self, fid: i32, kind: Run, generation: u64) {
let cache = self.cache.clone();
let tx = self.tx.clone();
let run = kind.clone();
self.rt.spawn(async move {
let res = cache
.exec_problem(fid, run.clone(), None)
.await
.map(Box::new);
let _ = tx.send(Msg::ExecDone {
generation,
fid,
kind: run,
res,
});
});
}
fn load_due(&self) {
let cache = self.cache.clone();
let tx = self.tx.clone();
self.rt.spawn(async move {
let res = cache
.due_review_fids(crate::srs::today())
.and_then(|due_fids| {
cache.review_count().map(|tracked| DeckState {
due_fids,
tracked: tracked as i32,
})
});
let _ = tx.send(Msg::DueLoaded(res));
});
}
fn grade(&self, fid: i32, grade: Grade) {
let cache = self.cache.clone();
let tx = self.tx.clone();
self.rt.spawn(async move {
let res = cache.grade_review(fid, grade, crate::srs::today());
let _ = tx.send(Msg::ReviewGraded { fid, grade, res });
});
}
fn schedule_tick(&self) {
let tx = self.tx.clone();
self.rt.spawn(async move {
tokio::time::sleep(SPINNER_INTERVAL).await;
let _ = tx.send(Msg::Tick);
});
}
fn load_tag_ids(&self, tag: String, generation: u64) {
let cache = self.cache.clone();
let tx = self.tx.clone();
self.rt.spawn(async move {
let res = cache.get_tagged_questions(&tag).await;
let _ = tx.send(Msg::TagIdsLoaded { generation, res });
});
}
}
pub struct Model {
backend: Option<Backend>,
pub(crate) all: Vec<Problem>,
pub(crate) filtered: Vec<Problem>,
pub(crate) filters: ProblemFilters,
pub(crate) search: String,
pub(crate) unsolved_only: bool,
pub(crate) due: HashSet<i32>,
pub(crate) due_only: bool,
pub(crate) deck_tracked: i32,
pub(crate) tag: Option<String>,
pub(crate) prompt: Option<Prompt>,
pub(crate) picker: Option<usize>,
pub(crate) sets: Vec<SetChoice>,
tag_gen: u64,
pub(crate) mode: Mode,
pub(crate) detail_fid: Option<i32>,
pub(crate) detail_scroll: usize,
pub(crate) descriptions: HashMap<i32, String>,
desc_gen: u64,
pub(crate) daily_fid: Option<i32>,
daily_jump_pending: bool,
pub(crate) exec: Option<ExecInFlight>,
pub(crate) outcome: Option<ExecOutcome>,
exec_gen: u64,
pub(crate) confirm_submit: Option<i32>,
editor_request: Option<String>,
pub(crate) cursor: usize,
pub(crate) row_offset: usize,
pub(crate) goto_pending: bool,
pub(crate) loading: bool,
pub(crate) status: String,
pub(crate) width: u16,
pub(crate) height: u16,
quit: bool,
}
impl Model {
fn new(opts: Options, tx: Sender<Msg>, suspended: Arc<AtomicBool>) -> Self {
Self {
backend: Some(Backend {
rt: opts.rt,
cache: opts.cache,
tx,
suspended,
}),
all: Vec::new(),
filtered: Vec::new(),
filters: opts.filters,
search: String::new(),
unsolved_only: false,
due: HashSet::new(),
due_only: false,
deck_tracked: 0,
tag: None,
prompt: None,
picker: None,
sets: Vec::new(),
tag_gen: 0,
mode: Mode::List,
detail_fid: None,
detail_scroll: 0,
descriptions: HashMap::new(),
desc_gen: 0,
daily_fid: None,
daily_jump_pending: false,
exec: None,
outcome: None,
exec_gen: 0,
confirm_submit: None,
editor_request: None,
cursor: 0,
row_offset: 0,
goto_pending: false,
loading: true,
status: String::new(),
width: 0,
height: 0,
quit: false,
}
}
fn init(&mut self) {
if let Some(backend) = &self.backend {
backend.load_problems();
backend.load_daily();
backend.load_due();
}
}
pub(crate) fn handle(&mut self, msg: Msg) {
match msg {
Msg::Key(k) => match self.mode {
Mode::List => list::update(self, k),
Mode::Detail => detail::update(self, k),
Mode::Help => detail::update_help(self, k),
},
Msg::Resize(w, h) => {
self.width = w;
self.height = h;
}
Msg::ProblemsLoaded(res) => {
self.loading = false;
match res {
Ok(problems) => {
self.all = problems;
self.apply_filters();
}
Err(e) => self.status = e.to_string(),
}
}
Msg::QuestionLoaded {
generation,
fid,
res,
} => {
if generation != self.desc_gen {
return;
}
match res {
Ok(desc) => {
self.descriptions.insert(fid, desc);
self.status.clear();
}
Err(e) => self.status = e.to_string(),
}
}
Msg::DailyLoaded(res) => match res {
Ok(fid) => {
self.daily_fid = Some(fid);
if std::mem::take(&mut self.daily_jump_pending) {
self.open_daily();
}
}
Err(e) => {
if std::mem::take(&mut self.daily_jump_pending) {
self.status = e.to_string();
}
}
},
Msg::CodeFileReady { fid, res } => match res {
Ok(path) => {
self.status.clear();
self.editor_request = Some(path);
}
Err(e) => self.status = format!("Could not prepare the file for #{fid}: {e}"),
},
Msg::ExecDone {
generation,
fid,
kind,
res,
} => {
if generation != self.exec_gen {
return;
}
self.exec = None;
match res {
Ok(result) => {
if let (Run::Submit, Some(backend)) = (&kind, &self.backend) {
backend.load_due();
}
let accepted = result.is_accepted();
if accepted {
self.mark_solved(fid);
}
self.status.clear();
self.outcome = Some(ExecOutcome {
kind,
text: result.to_string(),
accepted,
scroll: 0,
});
}
Err(e) => self.status = e.to_string(),
}
}
Msg::DueLoaded(res) => match res {
Ok(deck) => {
self.deck_tracked = deck.tracked;
self.due = deck.due_fids.into_iter().collect();
self.apply_filters();
}
Err(e) => self.status = e.to_string(),
},
Msg::ReviewGraded { fid, grade, res } => match res {
Ok(card) => {
self.status = format!(
"#{fid} graded {} — back in {} days",
grade.as_str(),
card.interval_days
);
if let Some(backend) = &self.backend {
backend.load_due();
}
}
Err(e) => self.status = e.to_string(),
},
Msg::Tick => {
if let Some(exec) = &mut self.exec {
exec.frame += 1;
if let Some(backend) = &self.backend {
backend.schedule_tick();
}
}
}
Msg::TagIdsLoaded { generation, res } => {
if generation != self.tag_gen {
return;
}
match res {
Ok(ids) => {
self.filters.tag_ids = Some(ids);
self.apply_filters();
}
Err(e) => {
self.tag = None;
self.status = e.to_string();
}
}
}
}
}
pub(crate) fn apply_filters(&mut self) {
self.filters.query = self.unsolved_only.then(|| "D".to_string());
self.filters.due_fids = self.due_only.then(|| self.due.iter().copied().collect());
let mut ps = self.all.clone();
match crate::filters::apply(&mut ps, &self.filters) {
Ok(()) => {
ps.retain(|p| crate::tui::search::matches(p, &self.search));
self.filtered = ps;
self.status.clear();
}
Err(e) => {
self.filtered = Vec::new();
self.status = e.to_string();
}
}
self.clamp_cursor();
}
pub(crate) fn open_prompt(&mut self, kind: PromptKind) {
self.prompt = Some(Prompt {
kind,
input: Input::default(),
});
}
pub(crate) fn cycle_difficulty(&mut self) {
self.filters.difficulty = match self.filters.difficulty {
None => Some(Difficulty::Easy),
Some(Difficulty::Easy) => Some(Difficulty::Medium),
Some(Difficulty::Medium) => Some(Difficulty::Hard),
Some(Difficulty::Hard) => None,
};
self.apply_filters();
}
pub(crate) fn toggle_unsolved(&mut self) {
self.unsolved_only = !self.unsolved_only;
self.apply_filters();
}
pub(crate) fn toggle_due(&mut self) {
self.due_only = !self.due_only;
self.apply_filters();
}
pub(crate) fn grade_detail(&mut self, grade: Grade) {
let Some(fid) = self.detail_fid else { return };
self.status = format!("Grading #{fid} {}…", grade.as_str());
if let Some(backend) = &self.backend {
backend.grade(fid, grade);
}
}
pub(crate) fn is_due(&self, fid: i32) -> bool {
self.due.contains(&fid)
}
pub(crate) fn due_listed(&self) -> i32 {
self.filtered.iter().filter(|p| self.is_due(p.fid)).count() as i32
}
pub(crate) fn request_tag(&mut self, tag: String) {
if tag.trim().is_empty() {
return;
}
self.tag_gen += 1;
self.tag = Some(tag.clone());
self.status = format!("Looking up problems tagged {tag}…");
if let Some(backend) = &self.backend {
backend.load_tag_ids(tag, self.tag_gen);
}
}
pub(crate) fn open_picker(&mut self) {
if self.sets.is_empty() {
match crate::sets::all() {
Ok(sets) => {
self.sets = sets
.into_iter()
.map(|set| SetChoice {
slug: set.slug,
name: set.name,
count: set.problems.len(),
})
.collect();
}
Err(e) => {
self.status = e.to_string();
return;
}
}
}
let active = self
.sets
.iter()
.position(|choice| Some(&choice.slug) == self.filters.set.as_ref());
self.picker = Some(active.unwrap_or(0));
}
pub(crate) fn choose_set(&mut self) {
if let Some(i) = self.picker.take() {
self.filters.set = self.sets.get(i).map(|choice| choice.slug.clone());
self.apply_filters();
}
}
pub(crate) fn clear_filters(&mut self) {
self.filters = ProblemFilters::default();
self.search.clear();
self.unsolved_only = false;
self.due_only = false;
self.tag = None;
self.tag_gen += 1;
self.apply_filters();
}
pub(crate) fn selected(&self) -> Option<&Problem> {
self.filtered.get(self.cursor)
}
pub(crate) fn open_detail(&mut self) {
let Some(problem) = self.selected() else {
return;
};
let fid = problem.fid;
self.mode = Mode::Detail;
self.detail_fid = Some(fid);
self.detail_scroll = 0;
if self.descriptions.contains_key(&fid) {
return;
}
self.desc_gen += 1;
self.status = format!("Fetching problem {fid}…");
if let Some(backend) = &self.backend {
backend.load_question(fid, self.desc_gen);
}
}
pub(crate) fn detail_text(&self) -> Option<&str> {
self.detail_fid
.and_then(|fid| self.descriptions.get(&fid))
.map(String::as_str)
}
pub(crate) fn detail_problem(&self) -> Option<&Problem> {
let fid = self.detail_fid?;
self.filtered
.iter()
.chain(self.all.iter())
.find(|p| p.fid == fid)
}
pub(crate) fn back_to_list(&mut self) {
self.mode = Mode::List;
}
pub(crate) fn open_help(&mut self) {
self.mode = Mode::Help;
}
pub(crate) fn request_daily(&mut self) {
match self.daily_fid {
Some(_) => self.open_daily(),
None => {
self.daily_jump_pending = true;
self.status = "Looking up today's challenge…".to_string();
if let Some(backend) = &self.backend {
backend.load_daily();
}
}
}
}
fn open_daily(&mut self) {
let Some(fid) = self.daily_fid else { return };
if !self.filtered.iter().any(|p| p.fid == fid) {
if !self.all.iter().any(|p| p.fid == fid) {
self.status = format!(
"Today's challenge is problem {fid}, which is not in the cache yet — \
run `leetctl data -u`."
);
return;
}
self.clear_filters();
}
if let Some(i) = self.filtered.iter().position(|p| p.fid == fid) {
self.cursor = i;
self.open_detail();
}
}
pub(crate) fn request_editor(&mut self) {
let Some(fid) = self.detail_fid.or_else(|| self.selected().map(|p| p.fid)) else {
return;
};
self.status = format!("Preparing the solution file for #{fid}…");
if let Some(backend) = &self.backend {
backend.prepare_code_file(fid);
}
}
pub(crate) fn take_editor_request(&mut self) -> Option<String> {
self.editor_request.take()
}
pub(crate) fn editor_command(
&self,
path: String,
) -> Option<(crate::scaffold::EditorCommand, Arc<AtomicBool>)> {
let backend = self.backend.as_ref()?;
match crate::scaffold::editor_command(&backend.cache.0.conf, path) {
Ok(command) => Some((command, backend.suspended.clone())),
Err(_) => None,
}
}
pub(crate) fn start_exec(&mut self, kind: Run) {
let Some(fid) = self.detail_fid else { return };
if self.exec.is_some() {
self.status = "A run is already in flight.".to_string();
return;
}
self.outcome = None;
self.exec_gen += 1;
self.exec = Some(ExecInFlight {
kind: kind.clone(),
fid,
started: Instant::now(),
frame: 0,
});
if let Some(backend) = &self.backend {
backend.exec(fid, kind, self.exec_gen);
backend.schedule_tick();
}
}
pub(crate) fn ask_to_submit(&mut self) {
if let Some(fid) = self.detail_fid {
self.confirm_submit = Some(fid);
}
}
pub(crate) fn confirm_submit(&mut self) {
if self.confirm_submit.take().is_some() {
self.start_exec(Run::Submit);
}
}
pub(crate) fn cancel_submit(&mut self) {
self.confirm_submit = None;
}
pub(crate) fn dismiss_outcome(&mut self) {
self.outcome = None;
}
pub(crate) fn scroll_outcome(&mut self, delta: isize) {
let rows = self.rows_height();
let Some(outcome) = &mut self.outcome else {
return;
};
let last = outcome.text.lines().count().saturating_sub(rows) as isize;
outcome.scroll = (outcome.scroll as isize + delta).clamp(0, last.max(0)) as usize;
}
fn mark_solved(&mut self, fid: i32) {
for problem in self.all.iter_mut().chain(self.filtered.iter_mut()) {
if problem.fid == fid {
problem.status = "ac".to_string();
}
}
}
pub(crate) fn has_filters(&self) -> bool {
self.filters.set.is_some()
|| self.filters.difficulty.is_some()
|| self.filters.keyword.is_some()
|| self.filters.tag_ids.is_some()
|| self.unsolved_only
|| self.due_only
|| !self.search.is_empty()
|| self.tag.is_some()
}
pub(crate) fn stats(&self) -> ProgressStats {
progress(&self.filtered)
}
pub(crate) fn detail_lines(&self) -> Vec<String> {
let width = self.width.saturating_sub(DETAIL_MARGIN) as usize;
self.detail_text()
.map(|text| crate::tui::wrap::wrap(text, width))
.unwrap_or_default()
}
pub(crate) fn detail_last_scroll(&self) -> usize {
self.detail_lines()
.len()
.saturating_sub(self.detail_rows_height())
}
pub(crate) fn rows_height(&self) -> usize {
self.height.saturating_sub(LIST_ROWS_MARGIN) as usize
}
pub(crate) fn detail_rows_height(&self) -> usize {
self.height.saturating_sub(DETAIL_ROWS_MARGIN) as usize
}
fn clamp_cursor(&mut self) {
self.cursor = self.cursor.min(self.filtered.len().saturating_sub(1));
}
pub(crate) fn ensure_cursor_visible(&mut self) {
let rows = self.rows_height();
if rows == 0 {
return;
}
if self.cursor < self.row_offset {
self.row_offset = self.cursor;
} else if self.cursor >= self.row_offset + rows {
self.row_offset = self.cursor + 1 - rows;
}
let last_offset = self.filtered.len().saturating_sub(rows);
self.row_offset = self.row_offset.min(last_offset);
}
pub(crate) fn quit(&mut self) {
self.quit = true;
}
fn should_quit(&self) -> bool {
self.quit
}
}
#[cfg(test)]
pub(crate) fn test_model() -> Model {
Model {
backend: None,
all: Vec::new(),
filtered: Vec::new(),
filters: ProblemFilters::default(),
search: String::new(),
unsolved_only: false,
due: HashSet::new(),
due_only: false,
deck_tracked: 0,
tag: None,
prompt: None,
picker: None,
sets: Vec::new(),
tag_gen: 0,
mode: Mode::List,
detail_fid: None,
detail_scroll: 0,
descriptions: HashMap::new(),
desc_gen: 0,
daily_fid: None,
daily_jump_pending: false,
exec: None,
outcome: None,
exec_gen: 0,
confirm_submit: None,
editor_request: None,
cursor: 0,
row_offset: 0,
goto_pending: false,
loading: false,
status: String::new(),
width: 100,
height: 30,
quit: false,
}
}