termato/src/main.rs

use std::{
  io::{self, stdout},
  sync::mpsc,
  thread,
  time::Duration,
};

use crossterm::{
  ExecutableCommand,
  event::{self, Event, KeyCode, KeyModifiers},
  terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{
  Terminal,
  backend::CrosstermBackend,
  layout::Alignment,
  style::{Color, Style},
  widgets::Paragraph,
};

const SECONDS_PER_MIN: i64 = 60;

#[derive(Debug, PartialEq, Clone)]
enum TimerState {
  Work,
  Break,
  Paused,
}

struct Termato {
  work_mins: i64,
  break_mins: i64,
  state: TimerState,
  prior_state: TimerState,
  is_running: bool,
  duration_in_secs: i64,
  time_remaining_in_sec: i64,
}

impl Termato {
  fn new(work_mins: i64, break_mins: i64) -> Self {
    Termato {
      work_mins,
      break_mins,
      state: TimerState::Work,
      prior_state: TimerState::Work,
      is_running: false,
      duration_in_secs: work_mins * SECONDS_PER_MIN,
      time_remaining_in_sec: break_mins * SECONDS_PER_MIN,
    }
  }

  fn toggle_running(&mut self) {
    if self.is_running {
      self.prior_state = self.state.clone();
      self.state = TimerState::Paused;
      self.is_running = false;
    } else {
      self.state = self.prior_state.clone();
      self.is_running = true;
    }
  }

  fn toggle_mode(&mut self) {
    let is_on_break = self.state == TimerState::Break
      || (self.state == TimerState::Paused && self.prior_state == TimerState::Break);

    if is_on_break {
      self.state = TimerState::Work;
      self.prior_state = TimerState::Work;
      self.duration_in_secs = self.work_mins * SECONDS_PER_MIN;
    } else {
      self.state = TimerState::Break;
      self.prior_state = TimerState::Break;
      self.duration_in_secs = self.break_mins * SECONDS_PER_MIN;
    }

    self.time_remaining_in_sec = self.duration_in_secs;
  }

  fn tick(&mut self) {
    if self.is_running && self.time_remaining_in_sec > 0 {
      self.time_remaining_in_sec -= 1;

      if self.time_remaining_in_sec == 0 {
        self.toggle_mode();
      }
    }
  }
}

fn main() -> Result<(), io::Error> {
  enable_raw_mode()?;
  stdout().execute(EnterAlternateScreen)?;
  let backend = CrosstermBackend::new(stdout());
  let mut terminal = Terminal::new(backend)?;

  let mut termato = Termato::new(1, 1);

  let (tx, rx) = mpsc::channel();
  thread::spawn(move || {
    loop {
      thread::sleep(Duration::from_secs(1));
      if tx.send(()).is_err() {
        break;
      }
    }
  });

  loop {
    terminal.draw(|f| {
      let size = f.area();
      let minutes = termato.time_remaining_in_sec / SECONDS_PER_MIN;
      let seconds = termato.time_remaining_in_sec % SECONDS_PER_MIN;
      let time_str = format!("{:02}:{:02}", minutes, seconds);

      let paragraph = Paragraph::new(time_str)
        .style(Style::default().fg(Color::White))
        .alignment(Alignment::Center);

      f.render_widget(paragraph, size);
    })?;

    if event::poll(Duration::from_millis(100))?
      && let Event::Key(key) = event::read()?
      && key.kind == event::KeyEventKind::Press
    {
      match key.code {
        KeyCode::Char('q') | KeyCode::Char('Q') => break,
        KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => break,
        KeyCode::Char(' ') => termato.toggle_running(),
        _ => {}
      }
    }

    if rx.try_recv().is_ok() {
      termato.tick();
    }
  }

  disable_raw_mode()?;
  stdout().execute(LeaveAlternateScreen)?;
  Ok(())
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn termato_when_called_it_should_return_expected_starting_state() {
    let result = Termato::new(1, 1);

    assert_eq!(result.work_mins, 1);
    assert_eq!(result.break_mins, 1);
    assert_eq!(result.state, TimerState::Work);
    assert_eq!(result.prior_state, TimerState::Work);
    assert!(!result.is_running);
    assert_eq!(result.duration_in_secs, 60);
    assert_eq!(result.time_remaining_in_sec, 60);
  }

  #[test]
  fn termato_tick_when_called_and_not_running_it_should_do_nothing() {
    let mut termato = Termato::new(1, 1);

    termato.tick();

    assert_eq!(termato.time_remaining_in_sec, 60);
  }

  #[test]
  fn termato_tick_when_called_and_no_time_remaining_it_should_do_nothing() {
    let mut termato = Termato::new(1, 1);
    termato.is_running = true;
    termato.time_remaining_in_sec = 0;

    termato.tick();

    assert_eq!(termato.time_remaining_in_sec, 0);
  }

  #[test]
  fn termato_tick_when_running_and_time_reamining_it_should_reduce_remaining_by_one() {
    let mut termato = Termato::new(1, 1);
    termato.is_running = true;

    termato.tick();

    assert_eq!(termato.time_remaining_in_sec, 59);
  }

  #[test]
  fn termato_tick_when_running_on_work_and_time_remaining_reaches_zero_it_should_toggle_to_break() {
    let mut termato = Termato::new(1, 2);
    termato.is_running = true;
    termato.time_remaining_in_sec = 1;

    termato.tick();

    assert_eq!(termato.state, TimerState::Break);
    assert_eq!(termato.prior_state, TimerState::Break);
    assert_eq!(termato.duration_in_secs, 120);
    assert_eq!(termato.time_remaining_in_sec, 120);
  }

  #[test]
  fn termato_tick_when_running_on_break_and_time_remaining_reaches_zero_it_should_toggle_to_work() {
    let mut termato = Termato::new(2, 1);
    termato.state = TimerState::Break;
    termato.is_running = true;
    termato.time_remaining_in_sec = 1;

    termato.tick();

    assert_eq!(termato.state, TimerState::Work);
    assert_eq!(termato.prior_state, TimerState::Work);
    assert_eq!(termato.duration_in_secs, 120);
    assert_eq!(termato.time_remaining_in_sec, 120);
  }

  #[test]
  fn termato_toggle_mode_when_paused_and_previous_state_is_break_it_should_toggle_to_work() {
    let mut termato = Termato::new(2, 1);
    termato.state = TimerState::Paused;
    termato.prior_state = TimerState::Break;

    termato.toggle_mode();

    assert_eq!(termato.state, TimerState::Work);
    assert_eq!(termato.prior_state, TimerState::Work);
    assert_eq!(termato.duration_in_secs, 120);
    assert_eq!(termato.time_remaining_in_sec, 120);
  }

  #[test]
  fn termato_toggle_running_when_called_and_already_running_it_should_pause() {
    let mut termato = Termato::new(1, 1);
    termato.is_running = true;

    termato.toggle_running();

    assert_eq!(termato.state, TimerState::Paused);
    assert_eq!(termato.prior_state, TimerState::Work);
    assert!(!termato.is_running)
  }

  #[test]
  fn termato_toggle_running_when_called_and_already_paused_it_should_run() {
    let mut termato = Termato::new(1, 1);

    termato.toggle_running();

    assert_eq!(termato.state, TimerState::Work);
    assert_eq!(termato.prior_state, TimerState::Work);
    assert!(termato.is_running)
  }
}