xorcist 0.1.3

//! Keyboard event handlers.

use anyhow::{Context, Result};
use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
use tui_input::backend::crossterm::EventHandler;

use crate::app::{App, InputMode, View};

/// Handle key events in log view.
pub fn handle_log_keys(app: &mut App, key: KeyEvent) -> Result<()> {
    // Track if we need to check for loading more entries
    let mut check_load_more = false;

    match key.code {
        KeyCode::Char('q') | KeyCode::Esc => {
            app.quit();
        }
        KeyCode::Char('j') | KeyCode::Down => {
            app.select_next();
            check_load_more = true;
        }
        KeyCode::Char('k') | KeyCode::Up => {
            app.select_previous();
        }
        KeyCode::Char('g') | KeyCode::Home => {
            app.select_first();
        }
        KeyCode::Char('G') | KeyCode::End => {
            app.select_last();
            check_load_more = true;
        }
        KeyCode::Enter => {
            app.open_detail().context("failed to open detail view")?;
        }
        KeyCode::Char('d') if key.modifiers.contains(KeyModifiers::CONTROL) => {
            app.page_down(10);
            check_load_more = true;
        }
        KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::CONTROL) => {
            app.page_up(10);
        }
        KeyCode::PageDown => {
            app.page_down(10);
            check_load_more = true;
        }
        KeyCode::PageUp => {
            app.page_up(10);
        }
        // jj commands with confirmation
        KeyCode::Char('a') => {
            // jj abandon (with confirmation)
            app.show_abandon_confirm();
        }
        KeyCode::Char('s') => {
            // jj squash (with confirmation)
            app.show_squash_confirm();
        }
        KeyCode::Char('f') => {
            // jj git fetch (no confirmation - read-only operation)
            app.execute_git_fetch()
                .context("failed to execute jj git fetch")?;
        }
        KeyCode::Char('p') => {
            // jj git push (with confirmation)
            app.show_push_confirm();
        }
        KeyCode::Char('u') => {
            // jj undo (with confirmation)
            app.show_undo_confirm();
        }
        // Phase1 jj command keys
        KeyCode::Char('n') => {
            // jj new (without message)
            app.execute_new().context("failed to execute jj new")?;
        }
        KeyCode::Char('N') => {
            // jj new -m (with message input)
            app.start_input_mode(InputMode::NewWithMessage);
        }
        KeyCode::Char('e') => {
            // jj edit
            app.execute_edit().context("failed to execute jj edit")?;
        }
        KeyCode::Char('d') => {
            // jj describe -m (input mode)
            app.start_input_mode(InputMode::Describe);
        }
        KeyCode::Char('b') => {
            // jj bookmark set (input mode)
            app.start_input_mode(InputMode::BookmarkSet);
        }
        KeyCode::Char('r') => {
            // jj rebase -d (input mode)
            app.start_input_mode(InputMode::RebaseDestination);
        }
        _ => {}
    }

    // Mark that we should check for loading more entries
    if check_load_more {
        app.request_load_more_check();
    }

    Ok(())
}

/// Handle key events in input mode.
pub fn handle_input_keys(app: &mut App, key: KeyEvent, event: &Event) -> Result<()> {
    match key.code {
        KeyCode::Enter => {
            app.submit_input().context("failed to submit input")?;
        }
        KeyCode::Esc => {
            app.cancel_input_mode();
        }
        _ => {
            // Pass other keys to tui-input
            app.input.handle_event(event);
        }
    }
    Ok(())
}

/// Handle key events in modal dialog.
pub fn handle_modal_keys(app: &mut App, key: KeyEvent) -> Result<()> {
    match key.code {
        KeyCode::Char('y') | KeyCode::Char('Y') => {
            app.confirm_action().context("failed to execute action")?;
        }
        KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
            app.close_modal();
        }
        _ => {}
    }
    Ok(())
}

/// Handle key events in detail view.
pub fn handle_detail_keys(app: &mut App, key: KeyEvent) -> Result<()> {
    match key.code {
        KeyCode::Char('q') | KeyCode::Esc => {
            app.close_detail();
        }
        KeyCode::Char('j') | KeyCode::Down => {
            app.detail_scroll_down(1);
        }
        KeyCode::Char('k') | KeyCode::Up => {
            app.detail_scroll_up(1);
        }
        KeyCode::Char('d') if key.modifiers.contains(KeyModifiers::CONTROL) => {
            app.detail_scroll_down(10);
        }
        KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::CONTROL) => {
            app.detail_scroll_up(10);
        }
        KeyCode::PageDown => {
            app.detail_scroll_down(10);
        }
        KeyCode::PageUp => {
            app.detail_scroll_up(10);
        }
        // Open diff view with 'd' key
        KeyCode::Char('d') => {
            app.open_diff_view().context("failed to open diff view")?;
        }
        _ => {}
    }
    Ok(())
}

/// Handle key events in diff view.
pub fn handle_diff_keys(app: &mut App, key: KeyEvent) -> Result<()> {
    match key.code {
        KeyCode::Char('q') | KeyCode::Esc => {
            app.close_diff();
        }
        KeyCode::Char('j') | KeyCode::Down => {
            app.diff_select_next();
            app.refresh_diff_text().context("failed to refresh diff")?;
        }
        KeyCode::Char('k') | KeyCode::Up => {
            app.diff_select_previous();
            app.refresh_diff_text().context("failed to refresh diff")?;
        }
        KeyCode::Char('d') if key.modifiers.contains(KeyModifiers::CONTROL) => {
            app.diff_scroll_down(10);
        }
        KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::CONTROL) => {
            app.diff_scroll_up(10);
        }
        KeyCode::PageDown => {
            app.diff_scroll_down(10);
        }
        KeyCode::PageUp => {
            app.diff_scroll_up(10);
        }
        // Horizontal scrolling for diff text
        KeyCode::Right => {
            app.diff_scroll_right(8);
        }
        KeyCode::Left => {
            app.diff_scroll_left(8);
        }
        _ => {}
    }
    Ok(())
}

/// Dispatch key event to appropriate handler based on app state.
///
/// Returns `true` if the event was fully handled (e.g., help toggle),
/// meaning the caller should `continue` the event loop.
pub fn dispatch_key_event(app: &mut App, key: KeyEvent, event: &Event) -> Result<bool> {
    // Input mode takes highest priority, including over help toggles.
    if app.is_input_mode() {
        handle_input_keys(app, key, event)?;
        return Ok(false);
    }

    // Modal dialogs take second priority, including over help toggles.
    if app.is_modal_open() {
        handle_modal_keys(app, key)?;
        return Ok(false);
    }

    // Help belongs to active-view handling, after input and modal priority.
    // While shown, only Esc and ? close it; all other keys are consumed so they
    // cannot fall through to active-view commands.
    if app.show_help {
        match key.code {
            KeyCode::Esc | KeyCode::Char('?') => app.close_help(),
            _ => {}
        }
        return Ok(true);
    }

    if key.code == KeyCode::Char('?') {
        app.toggle_help();
        return Ok(true);
    }

    match app.view {
        View::Log => handle_log_keys(app, key)?,
        View::Detail => handle_detail_keys(app, key)?,
        View::Diff => handle_diff_keys(app, key)?,
    }

    Ok(false)
}