void_graph/

app.rs

//! Main application for void-graph TUI.
//!
//! Adapted from [Serie](https://github.com/lusingander/serie) by lusingander.

use std::io::{self, Stdout};

use camino::Utf8Path;
use crossterm::{
    event::{DisableMouseCapture, EnableMouseCapture},
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use ratatui::{
    backend::CrosstermBackend,
    layout::{Constraint, Direction, Layout, Rect},
    style::{Modifier, Style},
    text::{Line, Span},
    widgets::{Block, Borders, Clear, Paragraph},
    Frame, Terminal,
};
use thiserror::Error;

use crate::{
    color::ColorTheme,
    event::{init as init_events, AppEvent, UserEvent},
    keybind::KeyBind,
    void_backend::{SortOrder, VoidCommit, VoidHead, VoidRef, VoidRepository},
    widget::{
        commit_detail::{CommitDetail, CommitDetailState},
        commit_list::{CommitList, CommitListState},
    },
};

/// Error type for application operations.
#[derive(Debug, Error)]
pub enum AppError {
    #[error("io error: {0}")]
    Io(#[from] io::Error),

    #[error("backend error: {0}")]
    Backend(#[from] crate::void_backend::VoidBackendError),
}

/// Result type for application operations.
pub type Result<T> = std::result::Result<T, AppError>;

/// Current view state of the application.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum AppView {
    /// Main commit list view
    List,
    /// Commit detail view
    Detail,
    /// Help overlay
    Help,
}

/// Run the void-graph application.
///
/// Opens the repository at `path` with a pre-loaded vault, loads commits,
/// and starts the TUI. The vault is constructed by the CLI caller which
/// handles identity loading and PIN prompting.
pub fn run(
    path: &Utf8Path,
    max_count: usize,
    order: SortOrder,
    vault: std::sync::Arc<void_core::crypto::KeyVault>,
) -> Result<()> {
    // Open repository
    let repo = VoidRepository::open(path, vault)?;

    // Load data
    let head = repo.head()?;
    let refs = repo.refs()?;

    // Start walk from ALL branch tips to see divergent branches
    let mut start_cids: Vec<_> = refs
        .iter()
        .filter(|r| r.kind == crate::void_backend::RefKind::Branch)
        .map(|r| r.target.clone())
        .collect();

    // Also include HEAD if detached
    if let Some(head_cid) = repo.resolve_head()? {
        if !start_cids.iter().any(|c| c == &head_cid) {
            start_cids.push(head_cid);
        }
    }

    if start_cids.is_empty() {
        return Ok(()); // Empty repo
    }

    let commits = repo.walk_commits(&start_cids, order, Some(max_count))?;

    if commits.is_empty() {
        return Ok(());
    }

    // Setup terminal
    enable_raw_mode()?;
    let mut stdout = io::stdout();
    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;
    terminal.clear()?;

    // Run the app and capture result
    let result = run_app(&mut terminal, commits, refs, head);

    // Cleanup terminal (always, even on error)
    disable_raw_mode()?;
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        DisableMouseCapture
    )?;
    terminal.show_cursor()?;

    result
}

/// Main application loop.
fn run_app(
    terminal: &mut Terminal<CrosstermBackend<Stdout>>,
    commits: Vec<VoidCommit>,
    refs: Vec<VoidRef>,
    head: Option<VoidHead>,
) -> Result<()> {
    // Initialize resources
    let theme = ColorTheme::default();
    let keybind = KeyBind::new(None);
    let (_tx, rx) = init_events();

    // Initialize state
    let mut list_state = CommitListState::new(commits.clone(), refs.clone(), head.clone());
    let mut detail_state = CommitDetailState::new();
    let mut app_view = AppView::List;

    // Track viewport height for navigation
    let mut viewport_height: usize = 20;

    // Main loop
    loop {
        // Render
        terminal.draw(|frame| {
            let area = frame.area();
            viewport_height = area.height.saturating_sub(2) as usize; // Account for borders

            match app_view {
                AppView::List => {
                    render_list_view(frame, area, &mut list_state, &theme);
                }
                AppView::Detail => {
                    render_detail_view(
                        frame,
                        area,
                        &mut list_state,
                        &mut detail_state,
                        &refs,
                        &theme,
                    );
                }
                AppView::Help => {
                    // Render list in background, then help overlay
                    render_list_view(frame, area, &mut list_state, &theme);
                    render_help_overlay(frame, area, &keybind, &theme);
                }
            }
        })?;

        // Handle events
        match rx.recv() {
            AppEvent::Key(key) => {
                if let Some(user_event) = keybind.get(&key) {
                    match handle_event(*user_event, &mut app_view, &mut list_state, &mut detail_state, viewport_height) {
                        EventResult::Continue => {}
                        EventResult::Quit => break,
                    }
                }
            }
            AppEvent::Resize(_, _) => {
                // Terminal will handle resize automatically
            }
            AppEvent::Quit => break,
            _ => {}
        }
    }

    Ok(())
}

/// Result of handling an event.
enum EventResult {
    Continue,
    Quit,
}

/// Handle a user event and return the result.
fn handle_event(
    event: UserEvent,
    view: &mut AppView,
    list_state: &mut CommitListState,
    detail_state: &mut CommitDetailState,
    viewport_height: usize,
) -> EventResult {
    match event {
        // Quit events
        UserEvent::Quit | UserEvent::ForceQuit => {
            return EventResult::Quit;
        }

        // Help toggle
        UserEvent::HelpToggle => {
            *view = match *view {
                AppView::Help => AppView::List,
                _ => AppView::Help,
            };
        }

        // Cancel/close - return to list from detail or help
        UserEvent::Cancel | UserEvent::Close => {
            if *view != AppView::List {
                *view = AppView::List;
            }
        }

        // Confirm - open detail view
        UserEvent::Confirm => {
            if *view == AppView::List && list_state.selected_commit().is_some() {
                detail_state.reset();
                *view = AppView::Detail;
            }
        }

        // Navigation events - always navigate list, detail view updates automatically
        UserEvent::NavigateDown => {
            list_state.select_next(viewport_height);
            if *view == AppView::Detail {
                detail_state.reset(); // Reset scroll for new commit
            }
        }
        UserEvent::NavigateUp => {
            list_state.select_prev();
            if *view == AppView::Detail {
                detail_state.reset();
            }
        }
        UserEvent::HalfPageDown => {
            list_state.scroll_down_half(viewport_height);
            if *view == AppView::Detail {
                detail_state.reset();
            }
        }
        UserEvent::HalfPageUp => {
            list_state.scroll_up_half(viewport_height);
            if *view == AppView::Detail {
                detail_state.reset();
            }
        }
        UserEvent::PageDown => {
            list_state.scroll_down_page(viewport_height);
            if *view == AppView::Detail {
                detail_state.reset();
            }
        }
        UserEvent::PageUp => {
            list_state.scroll_up_page(viewport_height);
            if *view == AppView::Detail {
                detail_state.reset();
            }
        }
        UserEvent::GoToTop => {
            list_state.select_first();
            if *view == AppView::Detail {
                detail_state.reset();
            }
        }
        UserEvent::GoToBottom => {
            list_state.select_last(viewport_height);
            if *view == AppView::Detail {
                detail_state.reset();
            }
        }

        // Scroll detail view content (only in detail view)
        UserEvent::ScrollDown => {
            if *view == AppView::Detail {
                detail_state.scroll_down();
            }
        }
        UserEvent::ScrollUp => {
            if *view == AppView::Detail {
                detail_state.scroll_up();
            }
        }

        // Unhandled events
        _ => {}
    }

    EventResult::Continue
}

/// Render the commit list view.
fn render_list_view(
    frame: &mut Frame,
    area: Rect,
    state: &mut CommitListState,
    theme: &ColorTheme,
) {
    let widget = CommitList::new(theme);
    frame.render_stateful_widget(widget, area, state);
}

/// Render the commit detail view.
fn render_detail_view(
    frame: &mut Frame,
    area: Rect,
    list_state: &mut CommitListState,
    detail_state: &mut CommitDetailState,
    refs: &[VoidRef],
    theme: &ColorTheme,
) {
    // Layout: split into list (left) and detail (right)
    let chunks = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(40), Constraint::Percentage(60)])
        .split(area);

    // Render list on the left
    let list_widget = CommitList::new(theme);
    frame.render_stateful_widget(list_widget, chunks[0], list_state);

    // Render detail on the right
    if let Some(commit) = list_state.selected_commit() {
        let commit_refs: Vec<&VoidRef> = refs
            .iter()
            .filter(|r| r.target == commit.cid)
            .collect();
        let detail_widget = CommitDetail::new(commit, commit_refs, theme);
        frame.render_stateful_widget(detail_widget, chunks[1], detail_state);
    }
}

/// Render the help overlay.
fn render_help_overlay(
    frame: &mut Frame,
    area: Rect,
    keybind: &KeyBind,
    theme: &ColorTheme,
) {
    // Calculate centered popup area
    let popup_width = 60.min(area.width.saturating_sub(4));
    let popup_height = 20.min(area.height.saturating_sub(4));
    let popup_x = (area.width.saturating_sub(popup_width)) / 2;
    let popup_y = (area.height.saturating_sub(popup_height)) / 2;
    let popup_area = Rect::new(popup_x, popup_y, popup_width, popup_height);

    // Clear the popup area
    frame.render_widget(Clear, popup_area);

    // Build help content
    let help_items = [
        (UserEvent::NavigateDown, "Move down"),
        (UserEvent::NavigateUp, "Move up"),
        (UserEvent::HalfPageDown, "Half page down"),
        (UserEvent::HalfPageUp, "Half page up"),
        (UserEvent::PageDown, "Page down"),
        (UserEvent::PageUp, "Page up"),
        (UserEvent::GoToTop, "Go to top"),
        (UserEvent::GoToBottom, "Go to bottom"),
        (UserEvent::Confirm, "View details"),
        (UserEvent::Cancel, "Close/back"),
        (UserEvent::HelpToggle, "Toggle help"),
        (UserEvent::Quit, "Quit"),
    ];

    let mut lines: Vec<Line> = Vec::new();
    for (event, description) in help_items {
        let keys = keybind.keys_for_event(event);
        let key_str = if keys.is_empty() {
            "(unbound)".to_string()
        } else {
            keys.join(", ")
        };

        lines.push(Line::from(vec![
            Span::styled(
                format!("{:>15}", key_str),
                Style::default()
                    .fg(theme.help_key_fg)
                    .add_modifier(Modifier::BOLD),
            ),
            Span::raw("  "),
            Span::raw(description),
        ]));
    }

    let help_paragraph = Paragraph::new(lines)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .title(" Help ")
                .title_style(Style::default().fg(theme.help_block_title_fg)),
        )
        .style(Style::default().fg(theme.fg).bg(theme.bg));

    frame.render_widget(help_paragraph, popup_area);
}