git_tailor/

app.rs

// Copyright 2026 Thomas Johannesson
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// TUI application state management

use anyhow::Result;
use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};

use crate::{
    CommitInfo,
    fragmap::{FragMap, SquashableScope},
    repo::ConflictState,
};

/// Semantic commands derived from keyboard input.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyCommand {
    MoveUp,
    MoveDown,
    PageUp,
    PageDown,
    ScrollLeft,
    ScrollRight,
    ToggleDetail,
    ShowHelp,
    Split,
    Squash,
    Fixup,
    Reword,
    Drop,
    Move,
    Mergetool,
    OpenEditor,
    Update,
    Quit,
    Confirm,
    /// Ctrl+C: quit immediately, aborting any in-progress rebase first.
    ForceQuit,
    SeparatorLeft,
    SeparatorRight,
    None,
}

/// Read the next terminal event.
///
/// Blocks until an event is available. Returns the event wrapped in Result
/// to handle potential I/O errors.
pub fn read_event() -> Result<Event> {
    Ok(event::read()?)
}

/// Result of a view module's `handle_key` function.
///
/// Pure state mutations (scroll, selection, mode transitions) are applied
/// directly to `AppState` inside the handler. Side effects that require git
/// operations or terminal access are returned here for `main.rs` to execute.
#[derive(Debug)]
pub enum AppAction {
    /// Fully handled, no side effects needed.
    Handled,
    /// The application should quit.
    Quit,
    /// Reload commits from the repository.
    ReloadCommits,
    /// Begin the split flow: get head_oid, count results, confirm if large.
    PrepareSplit {
        strategy: SplitStrategy,
        commit_oid: String,
    },
    /// Execute a split that has already been confirmed.
    ExecuteSplit {
        strategy: SplitStrategy,
        commit_oid: String,
        head_oid: String,
    },
    /// Begin the drop flow: get head_oid from repo, then show confirmation.
    PrepareDropConfirm {
        commit_oid: String,
        commit_summary: String,
    },
    /// Execute a confirmed drop.
    ExecuteDrop {
        commit_oid: String,
        head_oid: String,
    },
    /// Continue a rebase after the user resolved merge conflicts.
    RebaseContinue(ConflictState),
    /// Abort a rebase that hit conflicts.
    RebaseAbort(ConflictState),
    /// Launch the merge tool for conflicting files.
    RunMergetool {
        files: Vec<String>,
        conflict_state: ConflictState,
    },
    /// Open conflicting files in the configured editor.
    RunEditor {
        files: Vec<String>,
        conflict_state: ConflictState,
    },
    /// Start the reword flow: get head_oid, launch editor, rewrite commit.
    PrepareReword {
        commit_oid: String,
        current_message: String,
    },
    /// Start the squash/fixup flow: user picked source and target.
    /// When `is_fixup` is true the target's message is kept as-is (no editor).
    PrepareSquash {
        source_oid: String,
        target_oid: String,
        source_message: String,
        target_message: String,
        is_fixup: bool,
    },
    /// Execute a confirmed move: reorder the source commit to after insert_after_oid.
    ExecuteMove {
        source_oid: String,
        insert_after_oid: String,
    },
}

/// Split strategy options.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SplitStrategy {
    PerFile,
    PerHunk,
    PerHunkGroup,
}

impl SplitStrategy {
    pub const ALL: [SplitStrategy; 3] = [
        SplitStrategy::PerFile,
        SplitStrategy::PerHunk,
        SplitStrategy::PerHunkGroup,
    ];

    pub fn label(self) -> &'static str {
        match self {
            SplitStrategy::PerFile => "Per file",
            SplitStrategy::PerHunk => "Per hunk",
            SplitStrategy::PerHunkGroup => "Per hunk group",
        }
    }

    pub fn description(self) -> &'static str {
        match self {
            SplitStrategy::PerFile => "Create one commit per changed file",
            SplitStrategy::PerHunk => "Create one commit per diff hunk",
            SplitStrategy::PerHunkGroup => "Create one commit per hunk group",
        }
    }
}

/// Application display mode.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AppMode {
    /// Commit list view with fragmap.
    CommitList,
    /// Detailed view of a single commit.
    CommitDetail,
    /// Split strategy selection dialog; carries the highlighted option index.
    SplitSelect { strategy_index: usize },
    /// Confirmation dialog for large splits (> SPLIT_CONFIRM_THRESHOLD commits).
    SplitConfirm(PendingSplit),
    /// Confirmation dialog before dropping a commit.
    DropConfirm(PendingDrop),
    /// Waiting for the user to resolve merge conflicts that arose during a
    /// rebase operation. Enter continues, Esc aborts the entire operation.
    RebaseConflict(Box<ConflictState>),
    /// Squash/fixup target selection: user picks which commit to squash the source into.
    /// When `is_fixup` is true the target's message is kept as-is (no editor).
    SquashSelect { source_index: usize, is_fixup: bool },
    /// Move commit selection: user picks where to insert the source commit.
    /// `insert_before` is the index in the commit list where the separator row
    /// appears; the commit will be moved to that position.
    MoveSelect {
        source_index: usize,
        insert_before: usize,
    },
    /// Help dialog overlay; carries the mode to return to when closed.
    Help(Box<AppMode>),
}

impl AppMode {
    /// For overlay modes, return the base view that should be rendered
    /// underneath. Returns `None` for base views (CommitList, CommitDetail).
    pub fn background(&self) -> Option<AppMode> {
        match self {
            AppMode::CommitList | AppMode::CommitDetail => None,
            AppMode::SquashSelect { .. } | AppMode::MoveSelect { .. } => None,
            AppMode::SplitSelect { .. }
            | AppMode::SplitConfirm(_)
            | AppMode::DropConfirm(_)
            | AppMode::RebaseConflict(_) => Some(AppMode::CommitList),
            AppMode::Help(prev) => Some(prev.as_ref().clone()),
        }
    }

    /// Parse a terminal event into a semantic key command for this mode.
    ///
    /// Most keys are mode-independent (arrows, Esc, Enter). Where a key has
    /// different meanings per mode (e.g. 'm' → Move in CommitList vs Mergetool
    /// in RebaseConflict), this method resolves the ambiguity.
    pub fn parse_key(&self, event: Event) -> KeyCommand {
        if let Event::Key(KeyEvent {
            code,
            modifiers,
            kind,
            ..
        }) = event
            && kind == event::KeyEventKind::Press
        {
            // Ctrl+C always force-quits regardless of mode.
            if code == KeyCode::Char('c') && modifiers.contains(KeyModifiers::CONTROL) {
                return KeyCommand::ForceQuit;
            }
            if modifiers.contains(KeyModifiers::CONTROL) {
                match code {
                    KeyCode::Left => return KeyCommand::SeparatorLeft,
                    KeyCode::Right => return KeyCommand::SeparatorRight,
                    _ => {}
                }
            }
            return match code {
                KeyCode::Up | KeyCode::Char('k') => KeyCommand::MoveUp,
                KeyCode::Down | KeyCode::Char('j') => KeyCommand::MoveDown,
                KeyCode::PageUp => KeyCommand::PageUp,
                KeyCode::PageDown => KeyCommand::PageDown,
                KeyCode::Left => KeyCommand::ScrollLeft,
                KeyCode::Right => KeyCommand::ScrollRight,
                KeyCode::Enter => KeyCommand::Confirm,
                KeyCode::Char('i') => KeyCommand::ToggleDetail,
                KeyCode::Char('h') => KeyCommand::ShowHelp,
                KeyCode::Char('p') => KeyCommand::Split,
                KeyCode::Char('s') => KeyCommand::Squash,
                KeyCode::Char('f') => KeyCommand::Fixup,
                KeyCode::Char('r') => KeyCommand::Reword,
                KeyCode::Char('d') => KeyCommand::Drop,
                KeyCode::Char('m') => match self {
                    AppMode::RebaseConflict(_) => KeyCommand::Mergetool,
                    _ => KeyCommand::Move,
                },
                KeyCode::Char('e') => match self {
                    AppMode::RebaseConflict(_) => KeyCommand::OpenEditor,
                    _ => KeyCommand::None,
                },
                KeyCode::Char('u') => KeyCommand::Update,
                KeyCode::Esc | KeyCode::Char('q') => KeyCommand::Quit,
                _ => KeyCommand::None,
            };
        }
        KeyCommand::None
    }
}

/// Data retained while the user is shown the large-split confirmation dialog.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PendingSplit {
    pub strategy: SplitStrategy,
    pub commit_oid: String,
    pub head_oid: String,
    pub count: usize,
}

/// Data retained while the user is shown the drop confirmation dialog.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PendingDrop {
    pub commit_oid: String,
    pub commit_summary: String,
    pub head_oid: String,
}

/// Application state for the TUI.
///
/// Manages the overall state of the interactive terminal interface,
/// including quit flag and commit list state.
pub struct AppState {
    pub should_quit: bool,
    pub commits: Vec<CommitInfo>,
    pub selection_index: usize,
    pub reverse: bool,
    /// Show all hunk-group columns without deduplication (--full flag).
    pub full_fragmap: bool,
    /// Controls what the squashable connector symbol means in the fragmap.
    pub squashable_scope: SquashableScope,
    /// The reference OID (merge-base) used when the session started.
    /// Stored here so 'u' update can rescan from HEAD down to the same base.
    pub reference_oid: String,
    /// Optional fragmap visualization data.
    /// None if fragmap computation failed or was not performed.
    pub fragmap: Option<FragMap>,
    /// Horizontal scroll offset for the fragmap grid.
    pub fragmap_scroll_offset: usize,
    /// Current display mode.
    pub mode: AppMode,
    /// Vertical scroll offset for the detail view.
    pub detail_scroll_offset: usize,
    /// Maximum vertical scroll offset for the detail view (updated during render).
    pub max_detail_scroll: usize,
    /// Horizontal scroll offset for the detail view.
    pub detail_h_scroll_offset: usize,
    /// Maximum horizontal scroll offset for the detail view (updated during render).
    pub max_detail_h_scroll: usize,
    /// Visible height of the commit list area (updated during render).
    pub commit_list_visible_height: usize,
    /// Visible height of the detail view area (updated during render).
    pub detail_visible_height: usize,
    /// Transient status message shown in the footer (cleared on next keypress).
    pub status_message: Option<String>,
    /// Whether the current status message represents an error (red) or success (green).
    pub status_is_error: bool,
    /// User-controlled offset for the vertical separator bar (positive = right, negative = left).
    pub separator_offset: i16,
}

impl AppState {
    /// Create a new AppState with default values.
    pub fn new() -> Self {
        Self {
            should_quit: false,
            commits: Vec::new(),
            selection_index: 0,
            reverse: false,
            full_fragmap: false,
            squashable_scope: SquashableScope::Group,
            reference_oid: String::new(),
            fragmap: None,
            fragmap_scroll_offset: 0,
            mode: AppMode::CommitList,
            detail_scroll_offset: 0,
            max_detail_scroll: 0,
            detail_h_scroll_offset: 0,
            max_detail_h_scroll: 0,
            commit_list_visible_height: 0,
            detail_visible_height: 0,
            status_message: None,
            status_is_error: false,
            separator_offset: 0,
        }
    }

    /// Create a new AppState with the given commits, selecting the last one (HEAD).
    pub fn with_commits(commits: Vec<CommitInfo>) -> Self {
        let selection_index = commits.len().saturating_sub(1);
        Self {
            should_quit: false,
            commits,
            selection_index,
            reverse: false,
            full_fragmap: false,
            squashable_scope: SquashableScope::Group,
            reference_oid: String::new(),
            fragmap: None,
            fragmap_scroll_offset: 0,
            mode: AppMode::CommitList,
            detail_scroll_offset: 0,
            max_detail_scroll: 0,
            detail_h_scroll_offset: 0,
            max_detail_h_scroll: 0,
            commit_list_visible_height: 0,
            detail_visible_height: 0,
            status_message: None,
            status_is_error: false,
            separator_offset: 0,
        }
    }

    /// Move selection up (decrement index) with lower bound check.
    /// Does nothing if already at top or commits list is empty.
    pub fn move_up(&mut self) {
        if self.selection_index > 0 {
            self.selection_index -= 1;
        }
    }

    /// Move selection down (increment index) with upper bound check.
    /// Does nothing if already at bottom or commits list is empty.
    pub fn move_down(&mut self) {
        if !self.commits.is_empty() && self.selection_index < self.commits.len() - 1 {
            self.selection_index += 1;
        }
    }

    /// Scroll fragmap grid left.
    pub fn scroll_fragmap_left(&mut self) {
        if self.fragmap_scroll_offset > 0 {
            self.fragmap_scroll_offset -= 1;
        }
    }

    /// Scroll fragmap grid right.
    pub fn scroll_fragmap_right(&mut self) {
        self.fragmap_scroll_offset += 1;
    }

    /// Scroll detail view up (decrease offset).
    pub fn scroll_detail_up(&mut self) {
        if self.detail_scroll_offset > 0 {
            self.detail_scroll_offset -= 1;
        }
    }

    /// Scroll detail view down (increase offset).
    pub fn scroll_detail_down(&mut self) {
        if self.detail_scroll_offset < self.max_detail_scroll {
            self.detail_scroll_offset += 1;
        }
    }

    /// Scroll detail view left (decrease horizontal offset).
    pub fn scroll_detail_left(&mut self) {
        if self.detail_h_scroll_offset > 0 {
            self.detail_h_scroll_offset -= 1;
        }
    }

    /// Scroll detail view right (increase horizontal offset).
    pub fn scroll_detail_right(&mut self) {
        if self.detail_h_scroll_offset < self.max_detail_h_scroll {
            self.detail_h_scroll_offset += 1;
        }
    }

    /// Scroll commit list up by one page (visible_height lines).
    pub fn page_up(&mut self, visible_height: usize) {
        let page_size = visible_height.saturating_sub(1).max(1); // Keep at least one line overlap
        self.selection_index = self.selection_index.saturating_sub(page_size);
    }

    /// Scroll commit list down by one page (visible_height lines).
    pub fn page_down(&mut self, visible_height: usize) {
        if self.commits.is_empty() {
            return;
        }
        let page_size = visible_height.saturating_sub(1).max(1); // Keep at least one line overlap
        let new_index = self.selection_index.saturating_add(page_size);
        self.selection_index = new_index.min(self.commits.len() - 1);
    }

    /// Scroll detail view up by one page (visible_height lines).
    pub fn scroll_detail_page_up(&mut self, visible_height: usize) {
        let page_size = visible_height.saturating_sub(1).max(1);
        self.detail_scroll_offset = self.detail_scroll_offset.saturating_sub(page_size);
    }

    /// Scroll detail view down by one page (visible_height lines).
    pub fn scroll_detail_page_down(&mut self, visible_height: usize) {
        let page_size = visible_height.saturating_sub(1).max(1);
        let new_offset = self.detail_scroll_offset.saturating_add(page_size);
        self.detail_scroll_offset = new_offset.min(self.max_detail_scroll);
    }

    /// Enter the large-split confirmation dialog.
    pub fn enter_split_confirm(
        &mut self,
        strategy: SplitStrategy,
        commit_oid: String,
        head_oid: String,
        count: usize,
    ) {
        self.mode = AppMode::SplitConfirm(PendingSplit {
            strategy,
            commit_oid,
            head_oid,
            count,
        });
    }

    /// Cancel the large-split confirmation and return to CommitList.
    pub fn cancel_split_confirm(&mut self) {
        self.mode = AppMode::CommitList;
    }

    /// Enter the drop confirmation dialog.
    pub fn enter_drop_confirm(
        &mut self,
        commit_oid: String,
        commit_summary: String,
        head_oid: String,
    ) {
        self.mode = AppMode::DropConfirm(PendingDrop {
            commit_oid,
            commit_summary,
            head_oid,
        });
    }

    /// Cancel the drop confirmation and return to CommitList.
    pub fn cancel_drop_confirm(&mut self) {
        self.mode = AppMode::CommitList;
    }

    /// Enter the rebase-conflict resolution dialog.
    pub fn enter_rebase_conflict(&mut self, state: ConflictState) {
        self.mode = AppMode::RebaseConflict(Box::new(state));
    }

    /// Enter split strategy selection mode.
    /// Only allowed for real commits (not staged/unstaged synthetic rows).
    pub fn enter_split_select(&mut self) {
        if let Some(commit) = self.commits.get(self.selection_index)
            && (commit.oid == "staged" || commit.oid == "unstaged")
        {
            self.set_error_message("Cannot split staged/unstaged changes");
            return;
        }
        self.mode = AppMode::SplitSelect { strategy_index: 0 };
    }

    /// Enter squash target selection mode.
    /// Only allowed for real commits (not staged/unstaged synthetic rows).
    pub fn enter_squash_select(&mut self) {
        self.enter_squash_or_fixup_select(false);
    }

    /// Enter fixup target selection mode (same UI as squash, keeps target msg).
    pub fn enter_fixup_select(&mut self) {
        self.enter_squash_or_fixup_select(true);
    }

    fn enter_squash_or_fixup_select(&mut self, is_fixup: bool) {
        let label = if is_fixup { "fixup" } else { "squash" };
        if let Some(commit) = self.commits.get(self.selection_index)
            && (commit.oid == "staged" || commit.oid == "unstaged")
        {
            self.set_error_message(format!("Cannot {label} staged/unstaged changes"));
            return;
        }
        let real_count = self
            .commits
            .iter()
            .filter(|c| c.oid != "staged" && c.oid != "unstaged")
            .count();
        if real_count < 2 {
            self.set_error_message(format!(
                "Nothing to {label} — only one commit on the branch"
            ));
            return;
        }
        self.mode = AppMode::SquashSelect {
            source_index: self.selection_index,
            is_fixup,
        };
    }

    /// Cancel squash selection and return to CommitList.
    pub fn cancel_squash_select(&mut self) {
        self.mode = AppMode::CommitList;
    }

    /// Enter move commit selection mode.
    /// The insertion cursor starts one position before the source (i.e. one
    /// slot earlier in the commit list, which visually means "above" in
    /// chronological order).
    pub fn enter_move_select(&mut self) {
        if let Some(commit) = self.commits.get(self.selection_index)
            && (commit.oid == "staged" || commit.oid == "unstaged")
        {
            self.set_error_message("Cannot move staged/unstaged changes");
            return;
        }

        // Count real (non-synthetic) commits; moving requires at least 2.
        let real_count = self
            .commits
            .iter()
            .filter(|c| c.oid != "staged" && c.oid != "unstaged")
            .count();
        if real_count < 2 {
            self.set_error_message("Nothing to move — only one commit on the branch");
            return;
        }

        let source = self.selection_index;
        let max = self.commits.len();
        // Pick the first valid (non-no-op) position. No-ops are source and
        // source + 1, so try source - 1 first, then scan forward.
        let insert_before = if source > 0 {
            source - 1
        } else {
            // source == 0 → first valid position is 2 (skip 0 and 1)
            2.min(max)
        };
        self.mode = AppMode::MoveSelect {
            source_index: source,
            insert_before,
        };
    }

    /// Cancel move selection and return to CommitList.
    pub fn cancel_move_select(&mut self) {
        self.mode = AppMode::CommitList;
    }

    /// Set a success status message (shown with green background).
    pub fn set_success_message(&mut self, msg: impl Into<String>) {
        self.status_message = Some(msg.into());
        self.status_is_error = false;
    }

    /// Set an error status message (shown with red background).
    pub fn set_error_message(&mut self, msg: impl Into<String>) {
        self.status_message = Some(msg.into());
        self.status_is_error = true;
    }

    /// Clear the transient status message.
    pub fn clear_status_message(&mut self) {
        self.status_message = None;
        self.status_is_error = false;
    }

    /// Move split strategy selection up.
    pub fn split_select_up(&mut self) {
        if let AppMode::SplitSelect { strategy_index } = &mut self.mode
            && *strategy_index > 0
        {
            *strategy_index -= 1;
        }
    }

    /// Move split strategy selection down.
    pub fn split_select_down(&mut self) {
        if let AppMode::SplitSelect { strategy_index } = &mut self.mode
            && *strategy_index < SplitStrategy::ALL.len() - 1
        {
            *strategy_index += 1;
        }
    }

    /// Get the currently selected split strategy.
    pub fn selected_split_strategy(&self) -> SplitStrategy {
        if let AppMode::SplitSelect { strategy_index } = self.mode {
            SplitStrategy::ALL[strategy_index]
        } else {
            SplitStrategy::ALL[0]
        }
    }

    /// Toggle between CommitList and CommitDetail modes.
    pub fn toggle_detail_view(&mut self) {
        let new_mode = match &self.mode {
            AppMode::CommitList => AppMode::CommitDetail,
            AppMode::CommitDetail => AppMode::CommitList,
            AppMode::Help(_)
            | AppMode::SplitSelect { .. }
            | AppMode::SplitConfirm(_)
            | AppMode::DropConfirm(_)
            | AppMode::RebaseConflict(_)
            | AppMode::SquashSelect { .. }
            | AppMode::MoveSelect { .. } => return,
        };
        self.mode = new_mode;
        self.detail_scroll_offset = 0;
    }

    /// Show help dialog, saving current mode to return to later.
    pub fn show_help(&mut self) {
        if !matches!(self.mode, AppMode::Help(_)) {
            let current = std::mem::replace(&mut self.mode, AppMode::CommitList);
            self.mode = AppMode::Help(Box::new(current));
        }
    }

    /// Close help dialog and return to previous mode.
    pub fn close_help(&mut self) {
        if matches!(self.mode, AppMode::Help(_)) {
            let prev = std::mem::replace(&mut self.mode, AppMode::CommitList);
            if let AppMode::Help(prev_mode) = prev {
                self.mode = *prev_mode;
            }
        }
    }

    /// Toggle help dialog on/off.
    pub fn toggle_help(&mut self) {
        if matches!(self.mode, AppMode::Help(_)) {
            self.close_help();
        } else {
            self.show_help();
        }
    }
}

impl Default for AppState {
    fn default() -> Self {
        Self::new()
    }
}

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

    fn create_test_commit(oid: &str, summary: &str) -> CommitInfo {
        CommitInfo {
            oid: oid.to_string(),
            summary: summary.to_string(),
            author: Some("Test Author".to_string()),
            date: Some("2024-01-01".to_string()),
            parent_oids: vec![],
            message: summary.to_string(),
            author_email: Some("test@example.com".to_string()),
            author_date: Some(time::OffsetDateTime::from_unix_timestamp(1704110400).unwrap()),
            committer: Some("Test Committer".to_string()),
            committer_email: Some("committer@example.com".to_string()),
            commit_date: Some(time::OffsetDateTime::from_unix_timestamp(1704110400).unwrap()),
        }
    }

    #[test]
    fn test_move_up_with_empty_list() {
        let mut app = AppState::new();
        assert_eq!(app.selection_index, 0);
        app.move_up();
        assert_eq!(app.selection_index, 0);
    }

    #[test]
    fn test_move_up_at_top() {
        let mut app = AppState::new();
        app.commits = vec![
            create_test_commit("abc123", "First"),
            create_test_commit("def456", "Second"),
        ];
        app.selection_index = 0;
        app.move_up();
        assert_eq!(app.selection_index, 0);
    }

    #[test]
    fn test_move_up_from_middle() {
        let mut app = AppState::new();
        app.commits = vec![
            create_test_commit("abc123", "First"),
            create_test_commit("def456", "Second"),
            create_test_commit("ghi789", "Third"),
        ];
        app.selection_index = 2;
        app.move_up();
        assert_eq!(app.selection_index, 1);
        app.move_up();
        assert_eq!(app.selection_index, 0);
    }

    #[test]
    fn test_move_down_with_empty_list() {
        let mut app = AppState::new();
        assert_eq!(app.selection_index, 0);
        app.move_down();
        assert_eq!(app.selection_index, 0);
    }

    #[test]
    fn test_move_down_at_bottom() {
        let mut app = AppState::new();
        app.commits = vec![
            create_test_commit("abc123", "First"),
            create_test_commit("def456", "Second"),
        ];
        app.selection_index = 1;
        app.move_down();
        assert_eq!(app.selection_index, 1);
    }

    #[test]
    fn test_move_down_from_middle() {
        let mut app = AppState::new();
        app.commits = vec![
            create_test_commit("abc123", "First"),
            create_test_commit("def456", "Second"),
            create_test_commit("ghi789", "Third"),
        ];
        app.selection_index = 0;
        app.move_down();
        assert_eq!(app.selection_index, 1);
        app.move_down();
        assert_eq!(app.selection_index, 2);
    }
}