561 lines
17 KiB
Rust
561 lines
17 KiB
Rust
use anyhow::Result;
|
|
use serde::{Serialize, Serializer};
|
|
use shellexpand;
|
|
use std::collections::HashMap;
|
|
use std::io::{stdout, Write};
|
|
use std::rc::Rc;
|
|
use std::time::{Duration, Instant}; // <--- Add this
|
|
mod constants;
|
|
mod window;
|
|
|
|
use ratatui::{
|
|
crossterm::{
|
|
event::{self, Event, KeyCode},
|
|
execute,
|
|
terminal::{
|
|
disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen, SetTitle,
|
|
},
|
|
ExecutableCommand,
|
|
},
|
|
prelude::*,
|
|
style::Color,
|
|
widgets::*,
|
|
};
|
|
|
|
#[derive(PartialEq)]
|
|
enum State {
|
|
InputIntention,
|
|
InputDuration,
|
|
InProgress,
|
|
Paused,
|
|
End,
|
|
ShouldQuit,
|
|
}
|
|
|
|
fn serialize_duration<S>(duration: &Duration, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
serializer.serialize_u64(duration.as_secs())
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct SessionResult {
|
|
intention: String,
|
|
#[serde(serialize_with = "serialize_duration")]
|
|
duration: Duration,
|
|
session_ratings: Vec<SessionRating>,
|
|
rating: u8,
|
|
rating_f64: f64,
|
|
}
|
|
|
|
impl SessionResult {
|
|
fn rate(&mut self) {
|
|
let mut rating = 0_f64;
|
|
let total_duration = self
|
|
.session_ratings
|
|
.iter()
|
|
.map(|r| r.duration)
|
|
.fold(Duration::ZERO, |acc, dur| acc.saturating_add(dur));
|
|
|
|
for session_rating in &self.session_ratings {
|
|
let ratio: f64 = session_rating.duration.as_secs_f64() / total_duration.as_secs_f64();
|
|
rating += (session_rating.rating as f64) * ratio;
|
|
}
|
|
|
|
self.rating_f64 = rating;
|
|
|
|
if rating > 2.5 {
|
|
self.rating = 3;
|
|
} else if rating > 2.0 {
|
|
self.rating = 2;
|
|
} else if rating > 1.0 {
|
|
self.rating = 1;
|
|
} else {
|
|
self.rating = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize)]
|
|
struct SessionRating {
|
|
window_title: Rc<String>,
|
|
duration: Duration,
|
|
rating: u8,
|
|
}
|
|
|
|
struct App {
|
|
state: State,
|
|
user_intention: String,
|
|
user_duration_str: String,
|
|
user_duration: Duration,
|
|
current_window_title: Rc<String>,
|
|
current_window_time: Instant,
|
|
session_start: Instant,
|
|
session_stats: HashMap<Rc<String>, Duration>,
|
|
session_remaining: Duration,
|
|
session_ratings: Vec<SessionRating>,
|
|
session_ratings_index: usize,
|
|
session_results: Vec<SessionResult>,
|
|
last_tick_50ms: Instant,
|
|
last_tick_1s: Instant,
|
|
}
|
|
|
|
fn save_session(session: &SessionResult) {
|
|
let path = shellexpand::tilde(constants::HISTORY_FILE).to_string();
|
|
|
|
// 1. Open file in append mode, create if missing
|
|
let file = std::fs::OpenOptions::new()
|
|
.create(true)
|
|
.append(true)
|
|
.open(path);
|
|
|
|
if let Ok(mut f) = file {
|
|
// 2. Serialize to JSON
|
|
if let Ok(json) = serde_json::to_string(session) {
|
|
// 3. Write newline appended
|
|
let _ = writeln!(f, "{}", json);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
fn new() -> Self {
|
|
let window_title = window::get_title_clean();
|
|
|
|
App {
|
|
state: State::InputIntention,
|
|
user_intention: String::new(),
|
|
user_duration_str: constants::DEFAULT_DURATION.to_string(),
|
|
user_duration: Duration::ZERO,
|
|
current_window_title: window_title.into(),
|
|
current_window_time: Instant::now(),
|
|
session_start: Instant::now(),
|
|
session_stats: HashMap::new(),
|
|
session_remaining: Duration::ZERO,
|
|
session_ratings: Vec::new(),
|
|
session_ratings_index: 0,
|
|
session_results: Vec::new(),
|
|
last_tick_50ms: Instant::now(),
|
|
last_tick_1s: Instant::now(),
|
|
}
|
|
}
|
|
|
|
fn handle_ticks(&mut self) {
|
|
if self.last_tick_50ms.elapsed() >= Duration::from_millis(50) {
|
|
self.tick_50ms();
|
|
}
|
|
if self.last_tick_1s.elapsed() >= Duration::from_secs(1) {
|
|
self.tick_1s();
|
|
}
|
|
}
|
|
|
|
fn to_in_progress(&mut self) {
|
|
if self.user_intention.len() == 0 || self.user_duration == Duration::ZERO {
|
|
return;
|
|
}
|
|
self.state = State::InProgress;
|
|
self.current_window_time = Instant::now();
|
|
self.session_start = self.current_window_time;
|
|
self.session_stats = HashMap::new();
|
|
self.session_ratings_index = 0;
|
|
}
|
|
|
|
fn to_end(&mut self) {
|
|
self.state = State::End;
|
|
self.session_ratings = session_stats_as_vec(&self.session_stats);
|
|
}
|
|
|
|
fn cleanup(&self) {
|
|
let path = shellexpand::tilde(constants::STATUS_FILE).to_string();
|
|
let _ = std::fs::remove_file(path);
|
|
}
|
|
|
|
fn write_status(&self) {
|
|
let status = match self.state {
|
|
State::InputIntention | State::InputDuration => constants::STATUS_CONFIGURE.to_string(),
|
|
State::InProgress => format!(
|
|
"🎯 {} - {}",
|
|
self.user_intention,
|
|
duration_as_str(&self.session_remaining)
|
|
),
|
|
State::Paused => format!(
|
|
"{} - {}",
|
|
constants::STATUS_PAUSED,
|
|
duration_as_str(&self.session_remaining)
|
|
),
|
|
State::End => constants::STATUS_RATE_SESSION.to_string(),
|
|
State::ShouldQuit => constants::STATUS_QUIT.to_string(),
|
|
};
|
|
|
|
let path = shellexpand::tilde(constants::STATUS_FILE).to_string();
|
|
if let Ok(mut file) = std::fs::OpenOptions::new()
|
|
.write(true)
|
|
.create(true)
|
|
.truncate(true)
|
|
.open(&path)
|
|
{
|
|
let _ = file.write_all(status.as_bytes());
|
|
}
|
|
}
|
|
|
|
fn tick_50ms(&mut self) {
|
|
match self.state {
|
|
State::InputIntention | State::InputDuration => {
|
|
if let Ok(user_duration_mins) = self.user_duration_str.parse::<u64>() {
|
|
self.user_duration = Duration::from_secs(user_duration_mins * 60);
|
|
} else {
|
|
self.user_duration = Duration::ZERO;
|
|
}
|
|
|
|
window::minimize_other(&constants::APP_TITLE);
|
|
}
|
|
State::InProgress => {
|
|
let elapsed = self.session_start.elapsed();
|
|
self.session_remaining = self.user_duration.saturating_sub(elapsed);
|
|
update_session_stats(self);
|
|
|
|
if self.session_remaining.is_zero() {
|
|
self.to_end();
|
|
}
|
|
}
|
|
State::ShouldQuit => {}
|
|
State::Paused => {
|
|
window::minimize_other(&constants::APP_TITLE);
|
|
update_session_stats(self);
|
|
}
|
|
State::End => {
|
|
window::minimize_other(&constants::APP_TITLE);
|
|
}
|
|
}
|
|
|
|
self.last_tick_50ms = Instant::now();
|
|
}
|
|
|
|
fn tick_1s(&mut self) {
|
|
self.last_tick_1s = Instant::now();
|
|
self.write_status();
|
|
|
|
if self.state == State::Paused {
|
|
self.user_duration = self.user_duration.saturating_add(Duration::from_secs(1));
|
|
}
|
|
}
|
|
|
|
fn timeout(&self) -> Duration {
|
|
Duration::from_millis(50).saturating_sub(self.last_tick_50ms.elapsed())
|
|
}
|
|
|
|
fn get_session_results(&self) -> Vec<Line<'_>> {
|
|
self.session_results
|
|
.iter()
|
|
.map(|r| {
|
|
Line::from(Span::styled(
|
|
format!("{} {}", duration_as_str(&r.duration), r.intention,),
|
|
match r.rating {
|
|
2 => Style::new().fg(Color::LightYellow),
|
|
3 => Style::new().fg(Color::LightGreen),
|
|
_ => Style::new().fg(Color::LightRed),
|
|
},
|
|
))
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn get_session_stats(&self) -> Vec<Line<'_>> {
|
|
let mut zero_encountered = if self.state != State::End {
|
|
true
|
|
} else {
|
|
false
|
|
};
|
|
|
|
self.session_ratings
|
|
.iter()
|
|
.map(|s| {
|
|
Line::from(Span::styled(
|
|
format!("{}: {}", duration_as_str(&s.duration), s.window_title),
|
|
match s.rating {
|
|
0 if !zero_encountered => {
|
|
zero_encountered = true;
|
|
Style::new().fg(Color::LightBlue)
|
|
}
|
|
0 if zero_encountered => Style::new(),
|
|
1 => Style::new().fg(Color::LightRed),
|
|
2 => Style::new().fg(Color::LightYellow),
|
|
3 => Style::new().fg(Color::LightGreen),
|
|
_ => Style::new().fg(Color::LightBlue),
|
|
},
|
|
))
|
|
})
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
fn duration_as_str(duration: &Duration) -> String {
|
|
format!(
|
|
"{:3}:{:02}",
|
|
duration.as_secs() / 60,
|
|
duration.as_secs() % 60
|
|
)
|
|
}
|
|
|
|
fn session_stats_as_vec(session_stats: &HashMap<Rc<String>, Duration>) -> Vec<SessionRating> {
|
|
let mut stats: Vec<_> = session_stats
|
|
.iter()
|
|
.filter(|(_, duration)| duration.as_secs() > 30)
|
|
.map(|(title, duration)| SessionRating {
|
|
window_title: title.clone(),
|
|
duration: duration.clone(),
|
|
rating: 0,
|
|
})
|
|
.collect();
|
|
stats.sort_by(|a, b| b.duration.cmp(&a.duration));
|
|
stats
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
enable_raw_mode()?;
|
|
stdout().execute(EnterAlternateScreen)?;
|
|
execute!(stdout(), SetTitle(constants::APP_TITLE))?;
|
|
let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
|
|
let mut app = App::new();
|
|
|
|
while app.state != State::ShouldQuit {
|
|
terminal.draw(|frame| ui(frame, &app))?;
|
|
handle_events(&mut app)?;
|
|
app.handle_ticks();
|
|
}
|
|
|
|
app.cleanup();
|
|
disable_raw_mode()?;
|
|
stdout().execute(LeaveAlternateScreen)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_events(app: &mut App) -> Result<()> {
|
|
if !event::poll(app.timeout())? {
|
|
return Ok(());
|
|
}
|
|
|
|
let Event::Key(key) = event::read()? else {
|
|
return Ok(());
|
|
};
|
|
|
|
if key.kind != event::KeyEventKind::Press {
|
|
return Ok(());
|
|
}
|
|
|
|
if key.code == KeyCode::Esc {
|
|
app.state = State::ShouldQuit;
|
|
}
|
|
|
|
match app.state {
|
|
State::InputIntention => match key.code {
|
|
KeyCode::Enter => app.state = State::InputDuration,
|
|
KeyCode::Tab => app.state = State::InputDuration,
|
|
KeyCode::Backspace => {
|
|
let _ = app.user_intention.pop();
|
|
}
|
|
KeyCode::Char(c) => {
|
|
app.user_intention.push(c);
|
|
}
|
|
_ => {}
|
|
},
|
|
State::InputDuration => match key.code {
|
|
KeyCode::Enter => app.to_in_progress(),
|
|
KeyCode::Tab => app.state = State::InputIntention,
|
|
KeyCode::Backspace => {
|
|
let _ = app.user_duration_str.pop();
|
|
}
|
|
KeyCode::Char(c) if c.is_ascii_digit() => {
|
|
app.user_duration_str.push(c);
|
|
}
|
|
_ => {}
|
|
},
|
|
State::InProgress => match key.code {
|
|
KeyCode::Char('q') => {
|
|
app.to_end();
|
|
}
|
|
KeyCode::Char('p') => {
|
|
app.state = State::Paused;
|
|
}
|
|
KeyCode::Char('a') => {
|
|
app.user_duration = app.user_duration.saturating_add(Duration::from_secs(60));
|
|
}
|
|
KeyCode::Char('x') => {
|
|
app.user_duration = app.user_duration.saturating_sub(Duration::from_secs(60));
|
|
}
|
|
_ => {}
|
|
},
|
|
State::Paused => {
|
|
if key.code == KeyCode::Char('p') {
|
|
app.state = State::InProgress;
|
|
}
|
|
}
|
|
State::ShouldQuit => (),
|
|
State::End => {
|
|
let code = match key.code {
|
|
KeyCode::Char('1') => 1,
|
|
KeyCode::Char('2') => 2,
|
|
KeyCode::Char('3') => 3,
|
|
_ => 0,
|
|
};
|
|
|
|
if app.session_ratings_index < app.session_ratings.len() && code != 0 {
|
|
app.session_ratings[app.session_ratings_index].rating = code;
|
|
app.session_ratings_index += 1;
|
|
}
|
|
|
|
if app.session_ratings_index >= app.session_ratings.len() {
|
|
app.state = State::InputIntention;
|
|
let mut session_result = SessionResult {
|
|
intention: app.user_intention.clone(),
|
|
duration: app.session_start.elapsed(),
|
|
session_ratings: std::mem::take(&mut app.session_ratings),
|
|
rating: 0,
|
|
rating_f64: 0.0,
|
|
};
|
|
session_result.rate();
|
|
save_session(&session_result);
|
|
app.session_results.push(session_result);
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn update_session_stats(app: &mut App) {
|
|
let window_title = if app.state == State::Paused {
|
|
constants::PAUSED.to_string().into()
|
|
} else {
|
|
window::get_title_clean().into()
|
|
};
|
|
|
|
let delta = app.current_window_time.elapsed();
|
|
if app.current_window_title != window_title || (delta > Duration::from_secs(1)) {
|
|
let entry = app
|
|
.session_stats
|
|
.entry(app.current_window_title.clone())
|
|
.or_insert_with(|| Duration::default());
|
|
*entry += app.current_window_time.elapsed();
|
|
app.current_window_time = Instant::now();
|
|
app.current_window_title = window_title;
|
|
app.session_ratings = session_stats_as_vec(&app.session_stats);
|
|
}
|
|
}
|
|
|
|
fn ui(frame: &mut Frame, app: &App) {
|
|
let layout = Layout::vertical([
|
|
Constraint::Min(3),
|
|
Constraint::Min(3),
|
|
Constraint::Percentage(100),
|
|
Constraint::Min(3),
|
|
]);
|
|
let [layout_intention, layout_duration, layout_titles, layout_status] =
|
|
layout.areas(frame.size());
|
|
|
|
let border_type_intention = if app.state == State::InputIntention {
|
|
BorderType::Thick
|
|
} else {
|
|
BorderType::Plain
|
|
};
|
|
let input_intention = Line::from(Span::raw(&app.user_intention));
|
|
frame.render_widget(
|
|
Paragraph::new(input_intention).block(
|
|
Block::bordered()
|
|
.border_type(border_type_intention)
|
|
.title(constants::INTENTION_TITLE),
|
|
),
|
|
layout_intention,
|
|
);
|
|
|
|
let input_duration: Vec<Line> = match app.state {
|
|
State::InProgress | State::Paused => {
|
|
let s = duration_as_str(&app.session_remaining);
|
|
vec![Line::from(Span::raw(s))]
|
|
}
|
|
_ => {
|
|
vec![Line::from(Span::raw(&app.user_duration_str))]
|
|
}
|
|
};
|
|
let border_type_duration = if app.state == State::InputDuration {
|
|
BorderType::Thick
|
|
} else {
|
|
BorderType::Plain
|
|
};
|
|
frame.render_widget(
|
|
Paragraph::new(input_duration).block(
|
|
Block::bordered()
|
|
.border_type(border_type_duration)
|
|
.title(constants::DURATION_TITLE),
|
|
),
|
|
layout_duration,
|
|
);
|
|
|
|
if app.state == State::InputIntention || app.state == State::InputDuration {
|
|
let results = app.get_session_results();
|
|
frame.render_widget(
|
|
Paragraph::new(results)
|
|
.block(Block::bordered().title(constants::PREVIOUS_SESSIONS_TITLE)),
|
|
layout_titles,
|
|
);
|
|
} else {
|
|
let stats = app.get_session_stats();
|
|
frame.render_widget(
|
|
Paragraph::new(stats).block(Block::bordered().title(constants::SESSION_STATS_TITLE)),
|
|
layout_titles,
|
|
);
|
|
}
|
|
|
|
let mut spans: Vec<Span> = Vec::new();
|
|
if app.user_intention.len() == 0 {
|
|
let span = Span::styled(
|
|
constants::PROVIDE_INTENTION,
|
|
Style::new().fg(Color::LightRed),
|
|
);
|
|
spans.push(span);
|
|
}
|
|
|
|
if app.user_duration.is_zero() {
|
|
let span = Span::styled(
|
|
constants::PROVIDE_VALID_DURATION,
|
|
Style::new().fg(Color::LightRed),
|
|
);
|
|
spans.push(span);
|
|
}
|
|
|
|
match app.state {
|
|
State::InputIntention | State::InputDuration => {
|
|
if spans.len() == 0 {
|
|
let span = Span::styled(
|
|
constants::READY_TO_START,
|
|
Style::new().fg(Color::LightGreen),
|
|
);
|
|
spans.push(span);
|
|
}
|
|
}
|
|
State::InProgress => {
|
|
let span = Span::styled(
|
|
constants::SESSION_IN_PROGRESS,
|
|
Style::new().fg(Color::LightGreen),
|
|
);
|
|
spans.push(span);
|
|
}
|
|
State::Paused => {
|
|
let span = Span::styled(constants::SESSION_PAUSED, Style::new().fg(Color::LightBlue));
|
|
spans.push(span);
|
|
}
|
|
State::ShouldQuit => {}
|
|
State::End => {
|
|
let span = Span::styled(constants::RATE_TITLES, Style::new().fg(Color::LightBlue));
|
|
spans.push(span);
|
|
}
|
|
}
|
|
|
|
let input_status: Vec<Line> = vec![Line::from(spans)];
|
|
frame.render_widget(
|
|
Paragraph::new(input_status).block(Block::bordered().title(constants::STATUS_TITLE)),
|
|
layout_status,
|
|
);
|
|
}
|