use std::sync::mpsc;
use std::sync::mpsc::Receiver;
use std::sync::mpsc::TryRecvError;
use std::thread;
use std::time::Duration;
use std::time::Instant;
use ratatui::layout::Rect;
use ratatui::widgets::ListState;
use crate::diff;
use crate::diff::DiffView;
use crate::git::DiffSection;
use crate::git::GitResult;
use crate::git::Repo;
use crate::theme::Theme;
use crate::types::FileEntry;
use crate::types::FileGroup;
const AUTO_REFRESH: Duration = Duration::from_secs(3);
const MESSAGE_TTL: Duration = Duration::from_secs(6);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mode {
Normal,
Input,
Confirm(Confirm),
Help,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Confirm {
Revert,
Remove,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MessageKind {
Info,
Success,
Error,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ListRow {
Header(FileGroup, usize),
File(usize),
}
#[derive(Debug, Clone)]
pub struct Message {
pub kind: MessageKind,
pub text: String,
at: Instant,
}
pub struct App {
repo: Repo,
pub theme: Theme,
pub branch: String,
pub files: Vec<FileEntry>,
pub selected: usize,
pub list_state: ListState,
pub diff: DiffView,
diff_source: Option<(String, Vec<DiffSection>)>,
pub diff_scroll: usize,
pub diff_hscroll: usize,
pub mode: Mode,
pub commit_input: String,
pub message: Option<Message>,
pub files_area: Rect,
pub diff_area: Rect,
pub should_quit: bool,
push_rx: Option<Receiver<GitResult<String>>>,
last_refresh: Instant,
}
impl App {
pub fn new(repo: Repo, theme: Theme) -> Self {
let mut app = App {
repo,
theme,
branch: String::new(),
files: vec![],
selected: 0,
list_state: ListState::default(),
diff: DiffView::default(),
diff_source: None,
diff_scroll: 0,
diff_hscroll: 0,
mode: Mode::Normal,
commit_input: String::new(),
message: None,
files_area: Rect::default(),
diff_area: Rect::default(),
should_quit: false,
push_rx: None,
last_refresh: Instant::now(),
};
app.refresh();
app
}
pub fn selected_file(&self) -> Option<&FileEntry> {
self.files.get(self.selected)
}
pub fn is_pushing(&self) -> bool {
self.push_rx.is_some()
}
pub fn diff_height(&self) -> usize {
usize::from(self.diff_area.height.saturating_sub(2)).max(1)
}
pub fn refresh(&mut self) {
self.last_refresh = Instant::now();
let previous = self.selected_file().map(|f| f.path.clone());
let status = match self.repo.status() {
Ok(status) => status,
Err(e) => {
self.set_message(MessageKind::Error, e);
return;
}
};
self.branch = status.branch;
self.files = status.files;
self.files.sort_by_key(FileEntry::group);
if self.files.is_empty() {
self.selected = 0;
self.diff = DiffView::default();
self.diff_source = None;
self.diff_scroll = 0;
self.list_state.select(None);
return;
}
if let Some(pos) = previous
.as_ref()
.and_then(|p| self.files.iter().position(|f| &f.path == p))
{
self.selected = pos;
} else {
self.selected = self.selected.min(self.files.len() - 1);
}
self.list_state.select(Some(self.row_of(self.selected)));
let same_file = previous.as_deref() == self.selected_file().map(|f| f.path.as_str());
if !same_file {
self.diff_scroll = 0;
self.diff_hscroll = 0;
}
self.load_diff();
}
fn load_diff(&mut self) {
let Some(file) = self.selected_file() else {
self.diff = DiffView::default();
self.diff_source = None;
return;
};
match self.repo.diff(file) {
Ok(sections) => {
let source = (file.path.clone(), sections);
if self.diff_source.as_ref() != Some(&source) {
self.diff = diff::build(&source.1, &source.0, &self.theme);
self.diff_source = Some(source);
}
}
Err(e) => {
self.diff = DiffView::error(&e);
self.diff_source = None;
}
}
self.clamp_scroll();
}
pub fn tick(&mut self) {
if let Some(rx) = &self.push_rx {
match rx.try_recv() {
Ok(result) => {
self.push_rx = None;
self.report(result);
self.refresh();
}
Err(TryRecvError::Disconnected) => {
self.push_rx = None;
self.set_message(MessageKind::Error, "push thread stopped unexpectedly");
}
Err(TryRecvError::Empty) => {}
}
}
if self
.message
.as_ref()
.is_some_and(|m| m.kind != MessageKind::Info && m.at.elapsed() > MESSAGE_TTL)
{
self.message = None;
}
if self.mode != Mode::Input && self.last_refresh.elapsed() >= AUTO_REFRESH {
self.refresh();
}
}
fn select(&mut self, index: usize) {
if self.files.is_empty() || index == self.selected && self.diff_source.is_some() {
return;
}
self.selected = index.min(self.files.len() - 1);
self.list_state.select(Some(self.row_of(self.selected)));
self.diff_scroll = 0;
self.diff_hscroll = 0;
self.load_diff();
}
pub fn next(&mut self) {
if !self.files.is_empty() {
self.select((self.selected + 1) % self.files.len());
}
}
pub fn prev(&mut self) {
if !self.files.is_empty() {
let len = self.files.len();
self.select((self.selected + len - 1) % len);
}
}
pub fn first(&mut self) {
self.select(0);
}
pub fn last(&mut self) {
self.select(self.files.len().saturating_sub(1));
}
pub fn list_rows(&self) -> Vec<ListRow> {
let mut rows = Vec::with_capacity(self.files.len() + 2);
let mut current = None;
for (i, file) in self.files.iter().enumerate() {
let group = file.group();
if current != Some(group) {
current = Some(group);
let count = self.files[i..]
.iter()
.take_while(|f| f.group() == group)
.count();
rows.push(ListRow::Header(group, count));
}
rows.push(ListRow::File(i));
}
rows
}
pub fn row_of(&self, index: usize) -> usize {
let staged = self
.files
.iter()
.take_while(|f| f.group() == FileGroup::Staged)
.count();
index + 1 + usize::from(staged > 0 && index >= staged)
}
pub fn click_file(&mut self, row: u16) {
let inner_top = self.files_area.y + 1;
if row < inner_top || row >= self.files_area.bottom().saturating_sub(1) {
return;
}
let index = self.list_state.offset() + usize::from(row - inner_top);
if let Some(ListRow::File(file)) = self.list_rows().get(index) {
self.select(*file);
}
}
fn with_selected<F>(&mut self, action: F)
where
F: FnOnce(&Repo, &FileEntry) -> GitResult<String>,
{
let Some(file) = self.selected_file().cloned() else {
return;
};
let result = action(&self.repo, &file);
self.report(result);
self.refresh();
}
fn report(&mut self, result: GitResult<String>) {
match result {
Ok(msg) if msg.is_empty() => self.message = None,
Ok(msg) => self.set_message(MessageKind::Success, msg),
Err(e) => self.set_message(MessageKind::Error, e),
}
}
pub fn set_message(&mut self, kind: MessageKind, text: impl Into<String>) {
self.message = Some(Message {
kind,
text: text.into(),
at: Instant::now(),
});
}
pub fn clear_message(&mut self) {
if !self.is_pushing() {
self.message = None;
}
}
pub fn toggle_stage(&mut self) {
self.with_selected(|repo, file| repo.toggle_stage(file).map(|()| String::new()));
}
pub fn stage_all(&mut self) {
let result = self
.repo
.stage_all()
.map(|()| "staged all changes".to_string());
self.report(result);
self.refresh();
}
pub fn unstage_all(&mut self) {
let result = self
.repo
.unstage_all()
.map(|()| "unstaged all changes".to_string());
self.report(result);
self.refresh();
}
pub fn ask_confirm(&mut self, action: Confirm) {
if self.selected_file().is_some() {
self.mode = Mode::Confirm(action);
}
}
pub fn confirm(&mut self) {
let Mode::Confirm(action) = self.mode else {
return;
};
self.mode = Mode::Normal;
match action {
Confirm::Revert => self.with_selected(|repo, file| repo.revert(file)),
Confirm::Remove => self.with_selected(|repo, file| repo.remove(file)),
}
}
pub fn cancel(&mut self) {
self.mode = Mode::Normal;
}
pub fn manual_refresh(&mut self) {
self.refresh();
if self.message.is_none() {
self.set_message(MessageKind::Info, "refreshed");
}
}
fn max_scroll(&self) -> usize {
self.diff.rows.len().saturating_sub(self.diff_height())
}
fn clamp_scroll(&mut self) {
self.diff_scroll = self.diff_scroll.min(self.max_scroll());
}
pub fn scroll_by(&mut self, delta: isize) {
self.diff_scroll = self.diff_scroll.saturating_add_signed(delta);
self.clamp_scroll();
}
pub fn scroll_down(&mut self) {
self.scroll_by((self.diff_height() / 2).max(1) as isize);
}
pub fn scroll_up(&mut self) {
self.scroll_by(-((self.diff_height() / 2).max(1) as isize));
}
pub fn page_down(&mut self) {
self.scroll_by(self.diff_height().saturating_sub(1).max(1) as isize);
}
pub fn page_up(&mut self) {
self.scroll_by(-(self.diff_height().saturating_sub(1).max(1) as isize));
}
pub fn scroll_top(&mut self) {
self.diff_scroll = 0;
}
pub fn scroll_bottom(&mut self) {
self.diff_scroll = self.max_scroll();
}
pub fn hscroll_by(&mut self, delta: isize) {
let code_width =
usize::from(self.diff_area.width.saturating_sub(2)).saturating_sub(self.diff.gutter_width());
let max = self.diff.max_width.saturating_sub(code_width);
self.diff_hscroll = self.diff_hscroll.saturating_add_signed(delta).min(max);
}
pub fn enter_input_mode(&mut self) {
self.mode = Mode::Input;
}
pub fn exit_input_mode(&mut self) {
self.mode = Mode::Normal;
}
pub fn insert_text(&mut self, text: &str) {
for c in text.chars() {
match c {
'\n' | '\r' | '\t' => {
if !self.commit_input.ends_with(' ') && !self.commit_input.is_empty() {
self.commit_input.push(' ');
}
}
c if c.is_control() => {}
c => self.commit_input.push(c),
}
}
}
pub fn delete_word(&mut self) {
delete_last_word(&mut self.commit_input);
}
pub fn push(&mut self) {
if self.is_pushing() {
return;
}
let (tx, rx) = mpsc::channel();
let repo = self.repo.clone();
thread::spawn(move || {
let _ = tx.send(repo.push());
});
self.push_rx = Some(rx);
self.set_message(MessageKind::Info, "pushing…");
}
pub fn commit(&mut self) {
match self.repo.commit(&self.commit_input) {
Ok(msg) => {
self.commit_input.clear();
self.mode = Mode::Normal;
self.set_message(MessageKind::Success, msg);
}
Err(e) => self.set_message(MessageKind::Error, e),
}
self.refresh();
}
}
pub fn delete_last_word(text: &mut String) {
let trimmed = text.trim_end_matches(' ').len();
text.truncate(trimmed);
let cut = text.rfind(' ').map_or(0, |i| i + 1);
text.truncate(cut);
}