gitstack/

app.rs

use std::collections::HashMap;
use std::path::Path;

use git2::Repository;

use crate::compare::{BranchCompare, CompareTab};
use crate::config::{FilterPreset, FilterPresets};
use crate::event::GitEvent;
use crate::export::{
    export_heatmap_csv, export_heatmap_json, export_ownership_csv, export_ownership_json,
    export_stats_csv, export_stats_json, export_timeline_csv, export_timeline_json,
};
use crate::filter::FilterQuery;
use crate::git::{
    BlameLine, CommitDiff, FileHistoryEntry, FilePatch, FileStatus, RepoInfo, StashEntry,
};
use crate::related_files::RelatedFiles;
use crate::stats::{ActivityTimeline, CodeOwnership, FileHeatmap, RepoStats};
use crate::suggestion::CommitSuggestion;
use crate::topology::BranchTopology;

/// 入力モード
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum InputMode {
    #[default]
    Normal,
    Filter,
    BranchSelect,
    StatusView,
    CommitInput,
    TopologyView,
    StatsView,
    HeatmapView,
    FileHistoryView,
    TimelineView,
    BlameView,
    OwnershipView,
    StashView,
    PatchView,
    PresetSave,
    BranchCompareView,
    RelatedFilesView,
}

/// 表示モード
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum ViewMode {
    #[default]
    Normal, // 4行/コミット
    Compact, // 1行/コミット
}

/// レイアウトモード（画面幅に応じて自動切替）
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum LayoutMode {
    #[default]
    Single, // 従来の単一パネル
    SplitPanel, // 2ペイン分割
}

/// コミットタイプ（Conventional Commits）
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CommitType {
    Feat,
    Fix,
    Docs,
    Style,
    Refactor,
    Test,
    Chore,
    Perf,
}

impl CommitType {
    /// コミットメッセージのプレフィックスを取得
    pub fn prefix(&self) -> &'static str {
        match self {
            Self::Feat => "feat: ",
            Self::Fix => "fix: ",
            Self::Docs => "docs: ",
            Self::Style => "style: ",
            Self::Refactor => "refactor: ",
            Self::Test => "test: ",
            Self::Chore => "chore: ",
            Self::Perf => "perf: ",
        }
    }

    /// 対応するキーを取得
    pub fn key(&self) -> char {
        match self {
            Self::Feat => 'f',
            Self::Fix => 'x',
            Self::Docs => 'd',
            Self::Style => 's',
            Self::Refactor => 'r',
            Self::Test => 't',
            Self::Chore => 'c',
            Self::Perf => 'p',
        }
    }

    /// 全コミットタイプを取得
    pub fn all() -> &'static [CommitType] {
        &[
            Self::Feat,
            Self::Fix,
            Self::Docs,
            Self::Style,
            Self::Refactor,
            Self::Test,
            Self::Chore,
            Self::Perf,
        ]
    }

    /// 表示名を取得
    pub fn name(&self) -> &'static str {
        match self {
            Self::Feat => "feat",
            Self::Fix => "fix",
            Self::Docs => "docs",
            Self::Style => "style",
            Self::Refactor => "refactor",
            Self::Test => "test",
            Self::Chore => "chore",
            Self::Perf => "perf",
        }
    }
}

/// アプリケーション状態
pub struct App {
    /// アプリケーションが終了すべきかどうか
    pub should_quit: bool,
    /// リポジトリ情報
    pub repo_info: Option<RepoInfo>,
    /// キャッシュ済みリポジトリ（パフォーマンス最適化用）
    repo: Option<Repository>,
    /// 全イベント一覧
    all_events: Vec<GitEvent>,
    /// フィルタ後のイベントインデックス
    filtered_indices: Vec<usize>,
    /// 選択中のイベントインデックス（filtered_indices内）
    pub selected_index: usize,
    /// 詳細表示モード
    pub show_detail: bool,
    /// 入力モード
    pub input_mode: InputMode,
    /// フィルタ文字列
    pub filter_text: String,
    /// パース済みフィルタクエリ
    pub filter_query: FilterQuery,
    /// ファイルキャッシュ（コミットハッシュ -> ファイル一覧）
    file_cache: HashMap<String, Vec<String>>,
    /// ブランチ一覧
    pub branches: Vec<String>,
    /// ブランチ選択インデックス
    pub branch_selected_index: usize,
    /// ファイルステータス一覧
    pub file_statuses: Vec<FileStatus>,
    /// ステータス選択インデックス
    pub status_selected_index: usize,
    /// コミットメッセージ
    pub commit_message: String,
    /// 選択されたコミットタイプ
    pub commit_type: Option<CommitType>,
    /// ステータスメッセージ（操作結果表示用）
    pub status_message: Option<String>,
    /// バックグラウンド読み込み中フラグ
    pub is_loading: bool,
    /// ヘルプ表示フラグ
    pub show_help: bool,
    /// 現在のHEADのショートハッシュ（@キージャンプ用）
    head_hash: Option<String>,
    /// 表示モード（Normal/Compact/Grid）
    pub view_mode: ViewMode,
    /// トポロジーキャッシュ
    pub topology_cache: Option<BranchTopology>,
    /// トポロジービューの選択インデックス
    pub topology_selected_index: usize,
    /// トポロジービューのスクロールオフセット
    pub topology_scroll_offset: usize,

    // ===== 提案関連 =====
    /// コミット提案一覧
    pub commit_suggestions: Vec<CommitSuggestion>,
    /// 提案選択インデックス
    pub suggestion_selected_index: usize,

    // ===== 詳細ビュー関連 =====
    /// 詳細ビューのスクロールオフセット
    pub detail_scroll_offset: usize,
    /// 詳細ビューで選択中のファイルインデックス
    pub detail_selected_file: usize,
    /// 詳細ビューのdiffキャッシュ
    pub detail_diff_cache: Option<CommitDiff>,

    // ===== 統計ビュー関連 =====
    /// 統計情報キャッシュ
    pub stats_cache: Option<RepoStats>,
    /// 統計ビューで選択中の著者インデックス
    pub stats_selected_index: usize,
    /// 統計ビューのスクロールオフセット
    pub stats_scroll_offset: usize,

    // ===== ヒートマップビュー関連 =====
    /// ヒートマップキャッシュ
    pub heatmap_cache: Option<FileHeatmap>,
    /// ヒートマップビューで選択中のファイルインデックス
    pub heatmap_selected_index: usize,
    /// ヒートマップビューのスクロールオフセット
    pub heatmap_scroll_offset: usize,

    // ===== ファイル履歴ビュー関連 =====
    /// ファイル履歴キャッシュ
    pub file_history_cache: Option<Vec<FileHistoryEntry>>,
    /// ファイル履歴の対象ファイルパス
    pub file_history_path: Option<String>,
    /// ファイル履歴ビューで選択中のインデックス
    pub file_history_selected_index: usize,
    /// ファイル履歴ビューのスクロールオフセット
    pub file_history_scroll_offset: usize,

    // ===== タイムラインビュー関連 =====
    /// 活動タイムラインキャッシュ
    pub timeline_cache: Option<ActivityTimeline>,

    // ===== Blameビュー関連 =====
    /// Blameキャッシュ
    pub blame_cache: Option<Vec<BlameLine>>,
    /// Blame対象ファイルパス
    pub blame_path: Option<String>,
    /// Blameビューで選択中の行インデックス
    pub blame_selected_index: usize,
    /// Blameビューのスクロールオフセット
    pub blame_scroll_offset: usize,

    // ===== コードオーナーシップビュー関連 =====
    /// コードオーナーシップキャッシュ
    pub ownership_cache: Option<CodeOwnership>,
    /// コードオーナーシップビューで選択中のインデックス
    pub ownership_selected_index: usize,
    /// コードオーナーシップビューのスクロールオフセット
    pub ownership_scroll_offset: usize,

    // ===== Stashビュー関連 =====
    /// Stash一覧キャッシュ
    pub stash_cache: Option<Vec<StashEntry>>,
    /// Stashビューで選択中のインデックス
    pub stash_selected_index: usize,
    /// Stashビューのスクロールオフセット
    pub stash_scroll_offset: usize,

    // ===== パッチビュー関連 =====
    /// パッチキャッシュ
    pub patch_cache: Option<FilePatch>,
    /// パッチビューのスクロールオフセット
    pub patch_scroll_offset: usize,

    // ===== フィルタプリセット関連 =====
    /// フィルタプリセット
    pub filter_presets: FilterPresets,
    /// プリセット保存ダイアログ: 選択中のスロット (1-5)
    pub preset_save_slot: usize,
    /// プリセット保存ダイアログ: プリセット名入力
    pub preset_save_name: String,

    // ===== ブランチ比較ビュー関連 =====
    /// ブランチ比較キャッシュ
    pub branch_compare_cache: Option<BranchCompare>,
    /// 現在のタブ (Ahead/Behind)
    pub branch_compare_tab: CompareTab,
    /// 選択中のインデックス
    pub branch_compare_selected_index: usize,
    /// スクロールオフセット
    pub branch_compare_scroll_offset: usize,

    // ===== 関連コミット優先関連 =====
    /// 関連モードが有効かどうか
    pub relevance_mode: bool,
    /// ワーキングツリーの変更ファイル
    pub working_files: Vec<String>,
    /// 関連スコアキャッシュ（ハッシュ -> スコア）
    relevance_scores: HashMap<String, f32>,

    // ===== 関連ファイルビュー関連 =====
    /// 関連ファイルキャッシュ
    pub related_files_cache: Option<RelatedFiles>,
    /// 関連ファイルビューで選択中のインデックス
    pub related_files_selected_index: usize,
    /// 関連ファイルビューのスクロールオフセット
    pub related_files_scroll_offset: usize,

    // ===== 大画面2ペインレイアウト関連 =====
    /// 現在のレイアウトモード
    pub layout_mode: LayoutMode,
    /// 左パネルの比率（0-100）
    pub left_panel_ratio: u16,
}

impl App {
    pub fn new() -> Self {
        Self {
            should_quit: false,
            repo_info: None,
            repo: None,
            all_events: Vec::new(),
            filtered_indices: Vec::new(),
            selected_index: 0,
            show_detail: false,
            input_mode: InputMode::Normal,
            filter_text: String::new(),
            filter_query: FilterQuery::default(),
            file_cache: HashMap::new(),
            branches: Vec::new(),
            branch_selected_index: 0,
            file_statuses: Vec::new(),
            status_selected_index: 0,
            commit_message: String::new(),
            commit_type: None,
            status_message: None,
            is_loading: false,
            show_help: false,
            head_hash: None,
            view_mode: ViewMode::default(),
            topology_cache: None,
            topology_selected_index: 0,
            topology_scroll_offset: 0,
            // 提案関連
            commit_suggestions: Vec::new(),
            suggestion_selected_index: 0,
            // 詳細ビュー関連
            detail_scroll_offset: 0,
            detail_selected_file: 0,
            detail_diff_cache: None,
            // 統計ビュー関連
            stats_cache: None,
            stats_selected_index: 0,
            stats_scroll_offset: 0,
            // ヒートマップビュー関連
            heatmap_cache: None,
            heatmap_selected_index: 0,
            heatmap_scroll_offset: 0,
            // ファイル履歴ビュー関連
            file_history_cache: None,
            file_history_path: None,
            file_history_selected_index: 0,
            file_history_scroll_offset: 0,
            // タイムラインビュー関連
            timeline_cache: None,
            // Blameビュー関連
            blame_cache: None,
            blame_path: None,
            blame_selected_index: 0,
            blame_scroll_offset: 0,
            // コードオーナーシップビュー関連
            ownership_cache: None,
            ownership_selected_index: 0,
            ownership_scroll_offset: 0,
            // Stashビュー関連
            stash_cache: None,
            stash_selected_index: 0,
            stash_scroll_offset: 0,
            // パッチビュー関連
            patch_cache: None,
            patch_scroll_offset: 0,
            // フィルタプリセット関連
            filter_presets: FilterPresets::load(),
            preset_save_slot: 1,
            preset_save_name: String::new(),
            // ブランチ比較ビュー関連
            branch_compare_cache: None,
            branch_compare_tab: CompareTab::default(),
            branch_compare_selected_index: 0,
            branch_compare_scroll_offset: 0,
            // 関連コミット優先関連
            relevance_mode: false,
            working_files: Vec::new(),
            relevance_scores: HashMap::new(),
            // 関連ファイルビュー関連
            related_files_cache: None,
            related_files_selected_index: 0,
            related_files_scroll_offset: 0,
            // 大画面2ペインレイアウト関連
            layout_mode: LayoutMode::default(),
            left_panel_ratio: 65,
        }
    }

    /// リポジトリ情報とイベントを設定
    pub fn load(&mut self, repo_info: RepoInfo, events: Vec<GitEvent>) {
        self.repo_info = Some(repo_info);
        self.filtered_indices = (0..events.len()).collect();
        self.all_events = events;
        self.selected_index = 0;
        self.filter_text.clear();
    }

    /// キャッシュ用リポジトリを設定
    pub fn set_repo(&mut self, repo: Repository) {
        self.repo = Some(repo);
    }

    /// キャッシュ済みリポジトリの参照を取得
    pub fn get_repo(&self) -> Option<&Repository> {
        self.repo.as_ref()
    }

    /// HEADハッシュを設定（@キージャンプ用）
    pub fn set_head_hash(&mut self, hash: String) {
        // フルハッシュの場合は7文字に切り詰め
        self.head_hash = Some(if hash.len() > 7 {
            hash[..7].to_string()
        } else {
            hash
        });
    }

    /// HEADハッシュを取得
    pub fn head_hash(&self) -> Option<&str> {
        self.head_hash.as_deref()
    }

    /// フィルタ後のイベント一覧を取得
    pub fn events(&self) -> Vec<&GitEvent> {
        self.filtered_indices
            .iter()
            .filter_map(|&i| self.all_events.get(i))
            .collect()
    }

    /// 全イベントの参照を取得
    pub fn all_events(&self) -> &[GitEvent] {
        &self.all_events
    }

    /// フィルタ後のイベント数を取得
    pub fn event_count(&self) -> usize {
        self.filtered_indices.len()
    }

    /// qキーで終了
    pub fn quit(&mut self) {
        self.should_quit = true;
    }

    /// 選択を上に移動
    pub fn move_up(&mut self) {
        if self.selected_index > 0 {
            self.selected_index -= 1;
        }
    }

    /// 選択を下に移動
    pub fn move_down(&mut self) {
        if !self.filtered_indices.is_empty()
            && self.selected_index < self.filtered_indices.len() - 1
        {
            self.selected_index += 1;
        }
    }

    /// 先頭に移動 (gg)
    pub fn move_to_top(&mut self) {
        self.selected_index = 0;
    }

    /// HEADにジャンプ (@キー)
    /// フィルタ中でもHEADの位置に移動
    pub fn jump_to_head(&mut self) {
        // HEADのハッシュがない場合は先頭にジャンプ
        let Some(head_hash) = &self.head_hash else {
            self.selected_index = 0;
            return;
        };

        // all_events内でHEADのインデックスを探す
        let head_index = self
            .all_events
            .iter()
            .position(|e| e.short_hash == *head_hash);

        let Some(head_idx) = head_index else {
            // HEADが見つからない場合は先頭にジャンプ
            self.selected_index = 0;
            return;
        };

        // フィルタ結果内でHEADの位置を探す
        if let Some(pos) = self.filtered_indices.iter().position(|&i| i == head_idx) {
            self.selected_index = pos;
        }
        // HEADがフィルタに含まれていない場合は何もしない
    }

    /// 末尾に移動 (G)
    pub fn move_to_bottom(&mut self) {
        if !self.filtered_indices.is_empty() {
            self.selected_index = self.filtered_indices.len() - 1;
        }
    }

    /// ページダウン (Ctrl+d)
    pub fn page_down(&mut self, page_size: usize) {
        if !self.filtered_indices.is_empty() {
            let max_index = self.filtered_indices.len() - 1;
            self.selected_index = (self.selected_index + page_size).min(max_index);
        }
    }

    /// ページアップ (Ctrl+u)
    pub fn page_up(&mut self, page_size: usize) {
        self.selected_index = self.selected_index.saturating_sub(page_size);
    }

    /// ヘルプ表示を切り替え
    pub fn toggle_help(&mut self) {
        self.show_help = !self.show_help;
    }

    /// ヘルプを閉じる
    pub fn close_help(&mut self) {
        self.show_help = false;
    }

    /// 表示モードをトグル切り替え（Normal ↔ Compact）
    pub fn cycle_view_mode(&mut self) {
        self.view_mode = match self.view_mode {
            ViewMode::Normal => ViewMode::Compact,
            ViewMode::Compact => ViewMode::Normal,
        };
    }

    /// 有効なレイアウトモードを取得（画面幅に応じて自動決定）
    ///
    /// 画面幅がSPLIT_PANEL_THRESHOLDを超え、かつlayout_modeがSplitPanelの場合に
    /// 2ペインモードが有効になる。
    pub fn effective_layout_mode(&self, width: u16) -> LayoutMode {
        const SPLIT_PANEL_THRESHOLD: u16 = 120;
        if width >= SPLIT_PANEL_THRESHOLD && self.layout_mode == LayoutMode::SplitPanel {
            LayoutMode::SplitPanel
        } else {
            LayoutMode::Single
        }
    }

    /// 2ペインモード時に詳細パネル用のdiffを更新
    ///
    /// 選択中のコミットが変わった場合にdiffキャッシュをクリアする
    pub fn update_detail_for_split_panel(&mut self) {
        // 2ペインモードでは常にdiffを更新する必要がある
        // show_detailがfalseでも、選択が変わればキャッシュをクリア
        self.detail_diff_cache = None;
        self.detail_scroll_offset = 0;
        self.detail_selected_file = 0;
    }

    /// レイアウトモードをトグル切り替え（Single ↔ SplitPanel）
    pub fn toggle_layout_mode(&mut self) {
        self.layout_mode = match self.layout_mode {
            LayoutMode::Single => LayoutMode::SplitPanel,
            LayoutMode::SplitPanel => LayoutMode::Single,
        };
    }

    /// 左パネルの比率を調整
    ///
    /// delta: 調整値（正で拡大、負で縮小）
    /// 比率は40%から85%の範囲に制限
    pub fn adjust_panel_ratio(&mut self, delta: i16) {
        let new_ratio = (self.left_panel_ratio as i16 + delta).clamp(40, 85) as u16;
        self.left_panel_ratio = new_ratio;
    }

    /// 次のラベル付きコミットにジャンプ (] キー)
    pub fn jump_to_next_label(&mut self) {
        // フィルタ後のイベント内で、現在位置より後のラベル付きイベントを探す
        for i in (self.selected_index + 1)..self.filtered_indices.len() {
            if let Some(&event_idx) = self.filtered_indices.get(i) {
                if let Some(event) = self.all_events.get(event_idx) {
                    if event.has_labels() {
                        self.selected_index = i;
                        return;
                    }
                }
            }
        }
        // 見つからない場合は何もしない
    }

    /// 前のラベル付きコミットにジャンプ ([ キー)
    pub fn jump_to_prev_label(&mut self) {
        // フィルタ後のイベント内で、現在位置より前のラベル付きイベントを探す
        if self.selected_index == 0 {
            return;
        }
        for i in (0..self.selected_index).rev() {
            if let Some(&event_idx) = self.filtered_indices.get(i) {
                if let Some(event) = self.all_events.get(event_idx) {
                    if event.has_labels() {
                        self.selected_index = i;
                        return;
                    }
                }
            }
        }
        // 見つからない場合は何もしない
    }

    /// 選択中のイベントを取得
    pub fn selected_event(&self) -> Option<&GitEvent> {
        self.filtered_indices
            .get(self.selected_index)
            .and_then(|&i| self.all_events.get(i))
    }

    /// 詳細表示を開く
    pub fn open_detail(&mut self) {
        if self.selected_event().is_some() {
            self.show_detail = true;
            self.detail_scroll_offset = 0;
            self.detail_selected_file = 0;
            self.detail_diff_cache = None;
        }
    }

    /// 詳細表示を閉じる
    pub fn close_detail(&mut self) {
        self.show_detail = false;
        self.detail_diff_cache = None;
    }

    /// 詳細ビューでdiffをキャッシュ
    pub fn set_detail_diff(&mut self, diff: CommitDiff) {
        self.detail_diff_cache = Some(diff);
    }

    /// 詳細ビューでファイル選択を上に移動
    pub fn detail_move_up(&mut self) {
        if self.detail_selected_file > 0 {
            self.detail_selected_file -= 1;
            // スクロールオフセットを調整
            if self.detail_selected_file < self.detail_scroll_offset {
                self.detail_scroll_offset = self.detail_selected_file;
            }
        }
    }

    /// 詳細ビューでファイル選択を下に移動
    pub fn detail_move_down(&mut self) {
        if let Some(ref diff) = self.detail_diff_cache {
            if !diff.files.is_empty() && self.detail_selected_file < diff.files.len() - 1 {
                self.detail_selected_file += 1;
            }
        }
    }

    /// 詳細ビューのスクロール調整（表示可能行数を考慮）
    pub fn detail_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        // 選択行が表示範囲外になったらスクロール
        if self.detail_selected_file >= self.detail_scroll_offset + visible_lines {
            self.detail_scroll_offset = self.detail_selected_file - visible_lines + 1;
        }
    }

    /// フィルタモードを開始
    pub fn start_filter(&mut self) {
        self.input_mode = InputMode::Filter;
    }

    /// フィルタモードを終了
    pub fn end_filter(&mut self) {
        self.input_mode = InputMode::Normal;
    }

    /// フィルタ文字を追加
    pub fn filter_push(&mut self, c: char) {
        self.filter_text.push(c);
        self.apply_filter();
        self.update_filter_status();
    }

    /// フィルタ文字を削除
    pub fn filter_pop(&mut self) {
        self.filter_text.pop();
        self.apply_filter();
        self.update_filter_status();
    }

    /// フィルタをクリア
    pub fn filter_clear(&mut self) {
        self.filter_text.clear();
        self.apply_filter();
        self.status_message = None;
    }

    /// フィルタ適用後のステータスメッセージを更新
    fn update_filter_status(&mut self) {
        let total = self.all_events.len();
        let filtered = self.filtered_indices.len();
        if !self.filter_text.is_empty() {
            self.status_message = Some(format!("{}/{} commits matched", filtered, total));
        }
    }

    /// フィルタを適用
    fn apply_filter(&mut self) {
        // フィルタクエリをパース
        self.filter_query = FilterQuery::parse(&self.filter_text);

        if self.filter_query.is_empty() {
            self.filtered_indices = (0..self.all_events.len()).collect();
        } else {
            // ハッシュ範囲フィルタがある場合は範囲インデックスを計算
            let hash_range_indices = self.calculate_hash_range_indices();

            self.filtered_indices = self
                .all_events
                .iter()
                .enumerate()
                .filter(|(i, e)| {
                    // ハッシュ範囲フィルタの判定
                    if let Some((start_idx, end_idx)) = hash_range_indices {
                        // all_eventsは新しい順なので、start_idx <= i <= end_idx が範囲内
                        if *i < start_idx || *i > end_idx {
                            return false;
                        }
                    }

                    let files = self.file_cache.get(&e.short_hash).map(|v| v.as_slice());
                    self.filter_query.matches(e, files)
                })
                .map(|(i, _)| i)
                .collect();
        }
        // 選択インデックスを調整
        if self.selected_index >= self.filtered_indices.len() {
            self.selected_index = self.filtered_indices.len().saturating_sub(1);
        }
    }

    /// ハッシュ範囲のインデックスを計算
    ///
    /// all_eventsは時系列の新しい順なので、
    /// 開始ハッシュ(より新しい)のインデックス <= 終了ハッシュ(より古い)のインデックス となる
    /// 返り値: Some((開始インデックス, 終了インデックス)) または None
    fn calculate_hash_range_indices(&self) -> Option<(usize, usize)> {
        let (start_hash, end_hash) = self.filter_query.hash_range.as_ref()?;

        // 開始ハッシュのインデックスを検索（部分一致）
        let start_idx = self
            .all_events
            .iter()
            .position(|e| e.short_hash.starts_with(start_hash))?;

        // 終了ハッシュのインデックスを検索（部分一致）
        let end_idx = self
            .all_events
            .iter()
            .position(|e| e.short_hash.starts_with(end_hash))?;

        // all_eventsは新しい順なので、開始(より新しい)が先、終了(より古い)が後
        // start_idx < end_idx となるはず
        if start_idx <= end_idx {
            Some((start_idx, end_idx))
        } else {
            // 逆順の場合は入れ替え
            Some((end_idx, start_idx))
        }
    }

    /// ファイルキャッシュをプリロード（ファイルフィルタ有効時）
    /// 注意: UIブロッキングを防ぐため、最新N件のみキャッシュする
    pub fn preload_file_cache(&mut self, get_files: impl Fn(&str) -> Option<Vec<String>>) {
        if !self.filter_query.has_file_filter() {
            return;
        }

        // UIブロッキングを防ぐため、キャッシュするコミット数を制限
        const MAX_PRELOAD_COMMITS: usize = 200;

        for event in self.all_events.iter().take(MAX_PRELOAD_COMMITS) {
            if !self.file_cache.contains_key(&event.short_hash) {
                if let Some(files) = get_files(&event.short_hash) {
                    self.file_cache.insert(event.short_hash.clone(), files);
                }
            }
        }
    }

    /// ファイルキャッシュをクリア
    pub fn clear_file_cache(&mut self) {
        self.file_cache.clear();
    }

    /// ファイルキャッシュが空かどうか
    pub fn file_cache_is_empty(&self) -> bool {
        self.file_cache.is_empty()
    }

    /// フィルタを再適用（キャッシュ更新後に使用）
    pub fn reapply_filter(&mut self) {
        self.apply_filter();
    }

    /// リポジトリ名を取得
    pub fn repo_name(&self) -> &str {
        self.repo_info
            .as_ref()
            .map(|r| r.name.as_str())
            .unwrap_or("unknown")
    }

    /// ブランチ名を取得
    pub fn branch_name(&self) -> &str {
        self.repo_info
            .as_ref()
            .map(|r| r.branch.as_str())
            .unwrap_or("unknown")
    }

    /// ブランチ選択モードを開始
    pub fn start_branch_select(&mut self, branches: Vec<String>) {
        self.branches = branches;
        // 現在のブランチを選択状態にする
        let current = self.branch_name().to_string();
        self.branch_selected_index = self
            .branches
            .iter()
            .position(|b| b == &current)
            .unwrap_or(0);
        self.input_mode = InputMode::BranchSelect;
    }

    /// ブランチ選択モードを終了
    pub fn end_branch_select(&mut self) {
        self.input_mode = InputMode::Normal;
        self.branches.clear();
    }

    /// ブランチ選択を上に移動
    pub fn branch_move_up(&mut self) {
        if self.branch_selected_index > 0 {
            self.branch_selected_index -= 1;
        }
    }

    /// ブランチ選択を下に移動
    pub fn branch_move_down(&mut self) {
        if !self.branches.is_empty() && self.branch_selected_index < self.branches.len() - 1 {
            self.branch_selected_index += 1;
        }
    }

    /// 選択中のブランチ名を取得
    pub fn selected_branch(&self) -> Option<&str> {
        self.branches
            .get(self.branch_selected_index)
            .map(|s| s.as_str())
    }

    /// ブランチ切り替え後にリポジトリ情報を更新
    pub fn update_branch(&mut self, branch: String) {
        if let Some(ref mut info) = self.repo_info {
            info.branch = branch;
        }
    }

    /// イベント一覧を置き換え
    pub fn all_events_replace(&mut self, events: Vec<GitEvent>) {
        self.all_events = events;
        self.selected_index = 0;
    }

    /// フィルタインデックスをリセット
    pub fn filtered_indices_reset(&mut self, count: usize) {
        self.filtered_indices = (0..count).collect();
        self.selected_index = 0;
    }

    /// ステータスビューモードを開始
    pub fn start_status_view(&mut self, statuses: Vec<FileStatus>) {
        self.file_statuses = statuses;
        self.status_selected_index = 0;
        self.status_message = None;
        self.input_mode = InputMode::StatusView;
    }

    /// ステータスビューモードを終了
    pub fn end_status_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.file_statuses.clear();
        self.status_message = None;
    }

    /// ステータス選択を上に移動
    pub fn status_move_up(&mut self) {
        if self.status_selected_index > 0 {
            self.status_selected_index -= 1;
        }
    }

    /// ステータス選択を下に移動
    pub fn status_move_down(&mut self) {
        if !self.file_statuses.is_empty()
            && self.status_selected_index < self.file_statuses.len() - 1
        {
            self.status_selected_index += 1;
        }
    }

    /// 選択中のファイルステータスを取得
    pub fn selected_file_status(&self) -> Option<&FileStatus> {
        self.file_statuses.get(self.status_selected_index)
    }

    /// ファイルステータス一覧を更新
    pub fn update_file_statuses(&mut self, statuses: Vec<FileStatus>) {
        self.file_statuses = statuses;
        if self.status_selected_index >= self.file_statuses.len() {
            self.status_selected_index = self.file_statuses.len().saturating_sub(1);
        }
    }

    /// ステータスメッセージを設定
    pub fn set_status_message(&mut self, msg: String) {
        self.status_message = Some(msg);
    }

    /// コミット入力モードを開始
    pub fn start_commit_input(&mut self) {
        self.commit_message.clear();
        self.commit_type = None;
        self.input_mode = InputMode::CommitInput;
    }

    /// コミット入力モードを終了
    pub fn end_commit_input(&mut self) {
        self.commit_type = None;
        self.input_mode = InputMode::StatusView;
    }

    /// コミットタイプを選択
    pub fn select_commit_type(&mut self, commit_type: CommitType) {
        self.commit_type = Some(commit_type);
        self.commit_message = commit_type.prefix().to_string();
    }

    /// コミットメッセージに文字を追加
    pub fn commit_message_push(&mut self, c: char) {
        self.commit_message.push(c);
    }

    /// コミットメッセージから文字を削除
    pub fn commit_message_pop(&mut self) {
        self.commit_message.pop();
        // プレフィックスが消えたらタイプもクリア
        if let Some(commit_type) = self.commit_type {
            if !self
                .commit_message
                .starts_with(commit_type.prefix().trim_end())
            {
                self.commit_type = None;
            }
        }
    }

    /// コミットメッセージをクリア
    pub fn commit_message_clear(&mut self) {
        self.commit_message.clear();
        self.commit_type = None;
    }

    /// 読み込み中状態を開始
    pub fn start_loading(&mut self) {
        self.is_loading = true;
    }

    /// 読み込み中状態を終了
    pub fn finish_loading(&mut self) {
        self.is_loading = false;
    }

    /// イベントを追加（バックグラウンド読み込み用）
    pub fn append_events(&mut self, mut events: Vec<GitEvent>) {
        let current_len = self.all_events.len();
        self.all_events.append(&mut events);
        // フィルタが適用されていなければインデックスを追加
        if self.filter_text.is_empty() {
            let new_indices: Vec<usize> = (current_len..self.all_events.len()).collect();
            self.filtered_indices.extend(new_indices);
        } else {
            // フィルタ適用中なら再適用
            self.apply_filter();
        }
    }

    // ===== トポロジービュー関連 =====

    /// トポロジービューを開始
    pub fn start_topology_view(&mut self, topology: BranchTopology) {
        self.topology_cache = Some(topology);
        self.topology_selected_index = 0;
        self.topology_scroll_offset = 0;
        self.input_mode = InputMode::TopologyView;
    }

    /// トポロジービューを終了
    pub fn end_topology_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.topology_cache = None;
    }

    /// トポロジー選択を上に移動
    pub fn topology_move_up(&mut self) {
        if self.topology_selected_index > 0 {
            self.topology_selected_index -= 1;
            // スクロールオフセットを調整
            if self.topology_selected_index < self.topology_scroll_offset {
                self.topology_scroll_offset = self.topology_selected_index;
            }
        }
    }

    /// トポロジー選択を下に移動
    pub fn topology_move_down(&mut self) {
        if let Some(ref topology) = self.topology_cache {
            if self.topology_selected_index < topology.branches.len().saturating_sub(1) {
                self.topology_selected_index += 1;
            }
        }
    }

    /// トポロジービューの表示可能行数を設定してスクロールを調整
    pub fn topology_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        // 選択行が表示範囲外になったらスクロール
        if self.topology_selected_index >= self.topology_scroll_offset + visible_lines {
            self.topology_scroll_offset = self.topology_selected_index - visible_lines + 1;
        }
    }

    /// 選択中のトポロジーブランチ名を取得
    pub fn selected_topology_branch(&self) -> Option<&str> {
        self.topology_cache.as_ref().and_then(|t| {
            t.branches
                .get(self.topology_selected_index)
                .map(|b| b.name.as_str())
        })
    }

    /// フィルタクエリの説明を取得
    pub fn filter_description(&self) -> String {
        self.filter_query.description()
    }

    // ===== 提案関連 =====

    /// コミット提案を生成
    pub fn generate_commit_suggestions(&mut self) {
        use crate::suggestion::generate_suggestions;

        let staged: Vec<FileStatus> = self
            .file_statuses
            .iter()
            .filter(|s| s.kind.is_staged())
            .cloned()
            .collect();
        self.commit_suggestions = generate_suggestions(&staged);
        self.suggestion_selected_index = 0;
    }

    /// 提案を適用
    pub fn apply_suggestion(&mut self, index: usize) {
        if let Some(suggestion) = self.commit_suggestions.get(index) {
            self.commit_type = Some(suggestion.commit_type);
            self.commit_message = suggestion.full_message();
        }
    }

    /// 提案選択を上に移動
    pub fn suggestion_move_up(&mut self) {
        if self.suggestion_selected_index > 0 {
            self.suggestion_selected_index -= 1;
        }
    }

    /// 提案選択を下に移動
    pub fn suggestion_move_down(&mut self) {
        if !self.commit_suggestions.is_empty()
            && self.suggestion_selected_index < self.commit_suggestions.len() - 1
        {
            self.suggestion_selected_index += 1;
        }
    }

    // ===== 統計ビュー関連 =====

    /// 統計ビューを開始
    pub fn start_stats_view(&mut self, stats: RepoStats) {
        self.stats_cache = Some(stats);
        self.stats_selected_index = 0;
        self.stats_scroll_offset = 0;
        self.input_mode = InputMode::StatsView;
    }

    /// 統計ビューを終了
    pub fn end_stats_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.stats_cache = None;
    }

    /// 統計情報をエクスポート
    pub fn export_stats(&mut self) -> Option<String> {
        if let Some(ref stats) = self.stats_cache {
            let csv_path = Path::new("gitstack_stats.csv");
            let json_path = Path::new("gitstack_stats.json");

            let mut results = Vec::new();

            if let Err(e) = export_stats_csv(stats, csv_path) {
                results.push(format!("CSV error: {}", e));
            } else {
                results.push(format!("CSV: {}", csv_path.display()));
            }

            if let Err(e) = export_stats_json(stats, json_path) {
                results.push(format!("JSON error: {}", e));
            } else {
                results.push(format!("JSON: {}", json_path.display()));
            }

            let message = format!("Exported: {}", results.join(", "));
            self.status_message = Some(message.clone());
            Some(message)
        } else {
            None
        }
    }

    /// 統計ビューで選択を上に移動
    pub fn stats_move_up(&mut self) {
        if self.stats_selected_index > 0 {
            self.stats_selected_index -= 1;
            // スクロールオフセットを調整
            if self.stats_selected_index < self.stats_scroll_offset {
                self.stats_scroll_offset = self.stats_selected_index;
            }
        }
    }

    /// 統計ビューで選択を下に移動
    pub fn stats_move_down(&mut self) {
        if let Some(ref stats) = self.stats_cache {
            if !stats.authors.is_empty() && self.stats_selected_index < stats.authors.len() - 1 {
                self.stats_selected_index += 1;
            }
        }
    }

    /// 統計ビューのスクロール調整
    pub fn stats_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        if self.stats_selected_index >= self.stats_scroll_offset + visible_lines {
            self.stats_scroll_offset = self.stats_selected_index - visible_lines + 1;
        }
    }

    /// 選択中の著者名を取得
    pub fn selected_author(&self) -> Option<&str> {
        self.stats_cache.as_ref().and_then(|s| {
            s.authors
                .get(self.stats_selected_index)
                .map(|a| a.name.as_str())
        })
    }

    /// 著者でフィルタを適用
    pub fn filter_by_author(&mut self, author: &str) {
        self.filter_text = format!("/author:{}", author);
        self.reapply_filter();
    }

    // ===== ヒートマップビュー関連 =====

    /// ヒートマップビューを開始
    pub fn start_heatmap_view(&mut self, heatmap: FileHeatmap) {
        self.heatmap_cache = Some(heatmap);
        self.heatmap_selected_index = 0;
        self.heatmap_scroll_offset = 0;
        self.input_mode = InputMode::HeatmapView;
    }

    /// ヒートマップビューを終了
    pub fn end_heatmap_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.heatmap_cache = None;
    }

    /// ヒートマップをエクスポート
    pub fn export_heatmap(&mut self) -> Option<String> {
        if let Some(ref heatmap) = self.heatmap_cache {
            let csv_path = Path::new("gitstack_heatmap.csv");
            let json_path = Path::new("gitstack_heatmap.json");

            let mut results = Vec::new();

            if let Err(e) = export_heatmap_csv(heatmap, csv_path) {
                results.push(format!("CSV error: {}", e));
            } else {
                results.push(format!("CSV: {}", csv_path.display()));
            }

            if let Err(e) = export_heatmap_json(heatmap, json_path) {
                results.push(format!("JSON error: {}", e));
            } else {
                results.push(format!("JSON: {}", json_path.display()));
            }

            let message = format!("Exported: {}", results.join(", "));
            self.status_message = Some(message.clone());
            Some(message)
        } else {
            None
        }
    }

    /// ヒートマップの集約レベルを次へ切り替え（+キー）
    pub fn heatmap_increase_aggregation(&mut self) {
        if let Some(ref heatmap) = self.heatmap_cache.clone() {
            let new_level = heatmap.aggregation_level.next();
            self.heatmap_cache = Some(heatmap.with_aggregation(new_level));
            self.heatmap_selected_index = 0;
            self.heatmap_scroll_offset = 0;
            self.status_message = Some(format!("Aggregation: {}", new_level.display_name()));
        }
    }

    /// ヒートマップの集約レベルを前へ切り替え（-キー）
    pub fn heatmap_decrease_aggregation(&mut self) {
        if let Some(ref heatmap) = self.heatmap_cache.clone() {
            let new_level = heatmap.aggregation_level.prev();
            self.heatmap_cache = Some(heatmap.with_aggregation(new_level));
            self.heatmap_selected_index = 0;
            self.heatmap_scroll_offset = 0;
            self.status_message = Some(format!("Aggregation: {}", new_level.display_name()));
        }
    }

    /// ヒートマップビューで選択を上に移動
    pub fn heatmap_move_up(&mut self) {
        if self.heatmap_selected_index > 0 {
            self.heatmap_selected_index -= 1;
            // スクロールオフセットを調整
            if self.heatmap_selected_index < self.heatmap_scroll_offset {
                self.heatmap_scroll_offset = self.heatmap_selected_index;
            }
        }
    }

    /// ヒートマップビューで選択を下に移動
    pub fn heatmap_move_down(&mut self) {
        if let Some(ref heatmap) = self.heatmap_cache {
            if !heatmap.files.is_empty() && self.heatmap_selected_index < heatmap.files.len() - 1 {
                self.heatmap_selected_index += 1;
            }
        }
    }

    /// ヒートマップビューのスクロール調整
    pub fn heatmap_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        if self.heatmap_selected_index >= self.heatmap_scroll_offset + visible_lines {
            self.heatmap_scroll_offset = self.heatmap_selected_index - visible_lines + 1;
        }
    }

    /// 選択中のファイルパスを取得
    pub fn selected_heatmap_file(&self) -> Option<&str> {
        self.heatmap_cache.as_ref().and_then(|h| {
            h.files
                .get(self.heatmap_selected_index)
                .map(|f| f.path.as_str())
        })
    }

    /// ファイルでフィルタを適用
    pub fn filter_by_file(&mut self, file_path: &str) {
        self.filter_text = format!("/file:{}", file_path);
        self.reapply_filter();
    }

    // ===== ファイル履歴ビュー関連 =====

    /// ファイル履歴ビューを開始
    pub fn start_file_history_view(&mut self, path: String, history: Vec<FileHistoryEntry>) {
        self.file_history_path = Some(path);
        self.file_history_cache = Some(history);
        self.file_history_selected_index = 0;
        self.file_history_scroll_offset = 0;
        self.input_mode = InputMode::FileHistoryView;
    }

    /// ファイル履歴ビューを終了
    pub fn end_file_history_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.file_history_cache = None;
        self.file_history_path = None;
    }

    /// ファイル履歴ビューで選択を上に移動
    pub fn file_history_move_up(&mut self) {
        if self.file_history_selected_index > 0 {
            self.file_history_selected_index -= 1;
            // スクロールオフセットを調整
            if self.file_history_selected_index < self.file_history_scroll_offset {
                self.file_history_scroll_offset = self.file_history_selected_index;
            }
        }
    }

    /// ファイル履歴ビューで選択を下に移動
    pub fn file_history_move_down(&mut self) {
        if let Some(ref history) = self.file_history_cache {
            if !history.is_empty() && self.file_history_selected_index < history.len() - 1 {
                self.file_history_selected_index += 1;
            }
        }
    }

    /// ファイル履歴ビューのスクロール調整
    pub fn file_history_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        if self.file_history_selected_index >= self.file_history_scroll_offset + visible_lines {
            self.file_history_scroll_offset = self.file_history_selected_index - visible_lines + 1;
        }
    }

    /// 選択中のファイル履歴エントリを取得
    pub fn selected_file_history(&self) -> Option<&FileHistoryEntry> {
        self.file_history_cache
            .as_ref()
            .and_then(|h| h.get(self.file_history_selected_index))
    }

    // ===== タイムラインビュー関連 =====

    /// タイムラインビューを開始
    pub fn start_timeline_view(&mut self, timeline: ActivityTimeline) {
        self.timeline_cache = Some(timeline);
        self.input_mode = InputMode::TimelineView;
    }

    /// タイムラインビューを終了
    pub fn end_timeline_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.timeline_cache = None;
    }

    /// タイムラインをエクスポート
    pub fn export_timeline(&mut self) -> Option<String> {
        if let Some(ref timeline) = self.timeline_cache {
            let csv_path = Path::new("gitstack_timeline.csv");
            let json_path = Path::new("gitstack_timeline.json");

            let mut results = Vec::new();

            if let Err(e) = export_timeline_csv(timeline, csv_path) {
                results.push(format!("CSV error: {}", e));
            } else {
                results.push(format!("CSV: {}", csv_path.display()));
            }

            if let Err(e) = export_timeline_json(timeline, json_path) {
                results.push(format!("JSON error: {}", e));
            } else {
                results.push(format!("JSON: {}", json_path.display()));
            }

            let message = format!("Exported: {}", results.join(", "));
            self.status_message = Some(message.clone());
            Some(message)
        } else {
            None
        }
    }

    // ===== Blameビュー関連 =====

    /// Blameビューを開始
    pub fn start_blame_view(&mut self, path: String, blame: Vec<BlameLine>) {
        self.blame_path = Some(path);
        self.blame_cache = Some(blame);
        self.blame_selected_index = 0;
        self.blame_scroll_offset = 0;
        self.input_mode = InputMode::BlameView;
    }

    /// Blameビューを終了
    pub fn end_blame_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.blame_cache = None;
        self.blame_path = None;
    }

    /// Blameビューで選択を上に移動
    pub fn blame_move_up(&mut self) {
        if self.blame_selected_index > 0 {
            self.blame_selected_index -= 1;
            // スクロールオフセットを調整
            if self.blame_selected_index < self.blame_scroll_offset {
                self.blame_scroll_offset = self.blame_selected_index;
            }
        }
    }

    /// Blameビューで選択を下に移動
    pub fn blame_move_down(&mut self) {
        if let Some(ref blame) = self.blame_cache {
            if !blame.is_empty() && self.blame_selected_index < blame.len() - 1 {
                self.blame_selected_index += 1;
            }
        }
    }

    /// Blameビューのスクロール調整
    pub fn blame_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        if self.blame_selected_index >= self.blame_scroll_offset + visible_lines {
            self.blame_scroll_offset = self.blame_selected_index - visible_lines + 1;
        }
    }

    /// 選択中のBlame行を取得
    pub fn selected_blame_line(&self) -> Option<&BlameLine> {
        self.blame_cache
            .as_ref()
            .and_then(|b| b.get(self.blame_selected_index))
    }

    // ===== コードオーナーシップビュー関連 =====

    /// コードオーナーシップビューを開始
    pub fn start_ownership_view(&mut self, ownership: CodeOwnership) {
        self.ownership_cache = Some(ownership);
        self.ownership_selected_index = 0;
        self.ownership_scroll_offset = 0;
        self.input_mode = InputMode::OwnershipView;
    }

    /// コードオーナーシップビューを終了
    pub fn end_ownership_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.ownership_cache = None;
    }

    /// コードオーナーシップをエクスポート
    pub fn export_ownership(&mut self) -> Option<String> {
        if let Some(ref ownership) = self.ownership_cache {
            let csv_path = Path::new("gitstack_ownership.csv");
            let json_path = Path::new("gitstack_ownership.json");

            let mut results = Vec::new();

            if let Err(e) = export_ownership_csv(ownership, csv_path) {
                results.push(format!("CSV error: {}", e));
            } else {
                results.push(format!("CSV: {}", csv_path.display()));
            }

            if let Err(e) = export_ownership_json(ownership, json_path) {
                results.push(format!("JSON error: {}", e));
            } else {
                results.push(format!("JSON: {}", json_path.display()));
            }

            let message = format!("Exported: {}", results.join(", "));
            self.status_message = Some(message.clone());
            Some(message)
        } else {
            None
        }
    }

    /// コードオーナーシップビューで選択を上に移動
    pub fn ownership_move_up(&mut self) {
        if self.ownership_selected_index > 0 {
            self.ownership_selected_index -= 1;
            // スクロールオフセットを調整
            if self.ownership_selected_index < self.ownership_scroll_offset {
                self.ownership_scroll_offset = self.ownership_selected_index;
            }
        }
    }

    /// コードオーナーシップビューで選択を下に移動
    pub fn ownership_move_down(&mut self) {
        if let Some(ref ownership) = self.ownership_cache {
            if !ownership.entries.is_empty()
                && self.ownership_selected_index < ownership.entries.len() - 1
            {
                self.ownership_selected_index += 1;
            }
        }
    }

    /// コードオーナーシップビューのスクロール調整
    pub fn ownership_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        if self.ownership_selected_index >= self.ownership_scroll_offset + visible_lines {
            self.ownership_scroll_offset = self.ownership_selected_index - visible_lines + 1;
        }
    }

    /// 選択中のオーナーシップエントリを取得
    pub fn selected_ownership_entry(&self) -> Option<&crate::stats::CodeOwnershipEntry> {
        self.ownership_cache
            .as_ref()
            .and_then(|o| o.entries.get(self.ownership_selected_index))
    }

    // ===== Stashビュー関連メソッド =====

    /// Stashビューを開始
    pub fn start_stash_view(&mut self, stashes: Vec<StashEntry>) {
        self.stash_cache = Some(stashes);
        self.stash_selected_index = 0;
        self.stash_scroll_offset = 0;
        self.input_mode = InputMode::StashView;
    }

    /// Stashビューを終了
    pub fn end_stash_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.stash_cache = None;
    }

    /// Stashビューで選択を上に移動
    pub fn stash_move_up(&mut self) {
        if self.stash_selected_index > 0 {
            self.stash_selected_index -= 1;
            // スクロールオフセットを調整
            if self.stash_selected_index < self.stash_scroll_offset {
                self.stash_scroll_offset = self.stash_selected_index;
            }
        }
    }

    /// Stashビューで選択を下に移動
    pub fn stash_move_down(&mut self) {
        if let Some(ref stashes) = self.stash_cache {
            if !stashes.is_empty() && self.stash_selected_index < stashes.len() - 1 {
                self.stash_selected_index += 1;
            }
        }
    }

    /// Stashビューのスクロール調整
    pub fn stash_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        if self.stash_selected_index >= self.stash_scroll_offset + visible_lines {
            self.stash_scroll_offset = self.stash_selected_index - visible_lines + 1;
        }
    }

    /// 選択中のStashエントリを取得
    pub fn selected_stash_entry(&self) -> Option<&StashEntry> {
        self.stash_cache
            .as_ref()
            .and_then(|s| s.get(self.stash_selected_index))
    }

    /// Stash一覧を更新
    pub fn update_stash_cache(&mut self, stashes: Vec<StashEntry>) {
        let prev_len = self.stash_cache.as_ref().map(|s| s.len()).unwrap_or(0);
        self.stash_cache = Some(stashes);
        // 選択インデックスを調整（削除後など）
        if let Some(ref stashes) = self.stash_cache {
            if !stashes.is_empty() && self.stash_selected_index >= stashes.len() {
                self.stash_selected_index = stashes.len() - 1;
            }
            // 空になった場合はインデックスを0に
            if stashes.is_empty() {
                self.stash_selected_index = 0;
            }
        }
        let _ = prev_len; // suppress unused warning
    }

    // ===== パッチビュー関連メソッド =====

    /// パッチビューを開始
    pub fn start_patch_view(&mut self, patch: FilePatch) {
        self.patch_cache = Some(patch);
        self.patch_scroll_offset = 0;
        self.input_mode = InputMode::PatchView;
    }

    /// パッチビューを終了
    pub fn end_patch_view(&mut self) {
        self.input_mode = InputMode::Normal;
        self.show_detail = true; // 詳細ビューに戻る
        self.patch_cache = None;
    }

    /// パッチビューで上にスクロール
    pub fn patch_scroll_up(&mut self) {
        if self.patch_scroll_offset > 0 {
            self.patch_scroll_offset -= 1;
        }
    }

    /// パッチビューで下にスクロール
    pub fn patch_scroll_down(&mut self, visible_lines: usize) {
        if let Some(ref patch) = self.patch_cache {
            let max_scroll = patch.lines.len().saturating_sub(visible_lines);
            if self.patch_scroll_offset < max_scroll {
                self.patch_scroll_offset += 1;
            }
        }
    }

    // ===== フィルタプリセット関連 =====

    /// フィルタプリセットを適用（1-5キー）
    pub fn apply_preset(&mut self, slot: usize) {
        if let Some(preset) = self.filter_presets.get(slot) {
            let query = preset.query.clone();
            let name = preset.name.clone();
            self.filter_text = query;
            self.apply_filter();
            self.set_status_message(format!("Preset {}: {}", slot, name));
        }
    }

    /// プリセット保存ダイアログを開始（Ctrl+S）
    pub fn start_preset_save(&mut self) {
        if self.filter_text.is_empty() {
            self.set_status_message("No filter to save".to_string());
            return;
        }
        // 空きスロットまたはスロット1を選択
        self.preset_save_slot = self.filter_presets.next_empty_slot().unwrap_or(1);
        self.preset_save_name.clear();
        self.input_mode = InputMode::PresetSave;
    }

    /// プリセット保存ダイアログを終了
    pub fn end_preset_save(&mut self) {
        self.input_mode = InputMode::Filter;
        self.preset_save_name.clear();
    }

    /// プリセット保存: スロット選択を上に移動
    pub fn preset_slot_up(&mut self) {
        if self.preset_save_slot > 1 {
            self.preset_save_slot -= 1;
        }
    }

    /// プリセット保存: スロット選択を下に移動
    pub fn preset_slot_down(&mut self) {
        if self.preset_save_slot < 5 {
            self.preset_save_slot += 1;
        }
    }

    /// プリセット保存: 名前入力に文字を追加
    pub fn preset_name_push(&mut self, c: char) {
        self.preset_save_name.push(c);
    }

    /// プリセット保存: 名前入力から文字を削除
    pub fn preset_name_pop(&mut self) {
        self.preset_save_name.pop();
    }

    /// プリセットを保存
    pub fn save_preset(&mut self) -> bool {
        if self.filter_text.is_empty() {
            return false;
        }

        let name = if self.preset_save_name.is_empty() {
            format!("Preset {}", self.preset_save_slot)
        } else {
            self.preset_save_name.clone()
        };

        self.filter_presets.set(
            self.preset_save_slot,
            FilterPreset {
                name: name.clone(),
                query: self.filter_text.clone(),
            },
        );

        if self.filter_presets.save().is_ok() {
            self.set_status_message(format!("Saved to slot {}: {}", self.preset_save_slot, name));
            true
        } else {
            self.set_status_message("Failed to save preset".to_string());
            false
        }
    }

    /// プリセットを削除
    pub fn delete_preset(&mut self, slot: usize) {
        match slot {
            1 => self.filter_presets.slot1 = None,
            2 => self.filter_presets.slot2 = None,
            3 => self.filter_presets.slot3 = None,
            4 => self.filter_presets.slot4 = None,
            5 => self.filter_presets.slot5 = None,
            _ => return,
        }
        if self.filter_presets.save().is_ok() {
            self.set_status_message(format!("Deleted preset {}", slot));
        }
    }

    // ===== ブランチ比較ビュー関連 =====

    /// ブランチ比較ビューを開始
    pub fn start_branch_compare_view(&mut self, compare: BranchCompare) {
        self.branch_compare_cache = Some(compare);
        self.branch_compare_tab = CompareTab::Ahead;
        self.branch_compare_selected_index = 0;
        self.branch_compare_scroll_offset = 0;
        self.input_mode = InputMode::BranchCompareView;
    }

    /// ブランチ比較ビューを終了
    pub fn end_branch_compare_view(&mut self) {
        self.branch_compare_cache = None;
        self.input_mode = InputMode::TopologyView;
    }

    /// タブを切り替え
    pub fn branch_compare_toggle_tab(&mut self) {
        self.branch_compare_tab = self.branch_compare_tab.toggle();
        self.branch_compare_selected_index = 0;
        self.branch_compare_scroll_offset = 0;
    }

    /// 選択を上に移動
    pub fn branch_compare_move_up(&mut self) {
        if self.branch_compare_selected_index > 0 {
            self.branch_compare_selected_index -= 1;
            if self.branch_compare_selected_index < self.branch_compare_scroll_offset {
                self.branch_compare_scroll_offset = self.branch_compare_selected_index;
            }
        }
    }

    /// 選択を下に移動
    pub fn branch_compare_move_down(&mut self) {
        if let Some(ref compare) = self.branch_compare_cache {
            let count = match self.branch_compare_tab {
                CompareTab::Ahead => compare.ahead_commits.len(),
                CompareTab::Behind => compare.behind_commits.len(),
            };
            if count > 0 && self.branch_compare_selected_index < count - 1 {
                self.branch_compare_selected_index += 1;
            }
        }
    }

    /// スクロールを調整
    pub fn branch_compare_adjust_scroll(&mut self, visible_lines: usize) {
        if visible_lines == 0 {
            return;
        }
        if self.branch_compare_selected_index >= self.branch_compare_scroll_offset + visible_lines {
            self.branch_compare_scroll_offset =
                self.branch_compare_selected_index - visible_lines + 1;
        }
    }

    /// 現在選択中のコミットを取得
    pub fn selected_branch_compare_commit(&self) -> Option<&crate::compare::CompareCommit> {
        let compare = self.branch_compare_cache.as_ref()?;
        let commits = match self.branch_compare_tab {
            CompareTab::Ahead => &compare.ahead_commits,
            CompareTab::Behind => &compare.behind_commits,
        };
        commits.get(self.branch_compare_selected_index)
    }

    // ===== 関連コミット優先関連 =====

    /// 関連モードをトグル
    pub fn toggle_relevance_mode(&mut self) {
        self.relevance_mode = !self.relevance_mode;
        if self.relevance_mode {
            self.apply_relevance_sort();
        } else {
            // 通常モードに戻す場合はフィルタを再適用
            self.reapply_filter();
        }
    }

    /// ワーキングファイルを設定
    pub fn set_working_files(&mut self, files: Vec<String>) {
        self.working_files = files;
        // 関連モードが有効な場合は再ソート
        if self.relevance_mode {
            self.apply_relevance_sort();
        }
    }

    /// 関連スコアを計算してソート適用
    pub fn apply_relevance_sort(&mut self) {
        if self.working_files.is_empty() {
            self.set_status_message("No working files to compare".to_string());
            self.relevance_mode = false;
            return;
        }

        // 関連スコアを計算
        let events: Vec<&GitEvent> = self.all_events.iter().collect();
        let scores = crate::relevance::calculate_relevance(&self.working_files, &events, |hash| {
            self.file_cache.get(hash).cloned()
        });

        // スコアをキャッシュ
        self.relevance_scores.clear();
        for score in &scores {
            self.relevance_scores
                .insert(score.hash.clone(), score.score);
        }

        // スコアでソート（スコアが高い順、スコアがないものは後ろ）
        self.filtered_indices.sort_by(|&a, &b| {
            let score_a = self
                .all_events
                .get(a)
                .and_then(|e| self.relevance_scores.get(&e.short_hash))
                .copied()
                .unwrap_or(-1.0);
            let score_b = self
                .all_events
                .get(b)
                .and_then(|e| self.relevance_scores.get(&e.short_hash))
                .copied()
                .unwrap_or(-1.0);
            score_b
                .partial_cmp(&score_a)
                .unwrap_or(std::cmp::Ordering::Equal)
        });

        self.selected_index = 0;
        let related_count = scores.len();
        self.set_status_message(format!("Relevance mode: {} related commits", related_count));
    }

    /// 指定したハッシュの関連スコアを取得
    pub fn get_relevance_score(&self, hash: &str) -> Option<f32> {
        self.relevance_scores.get(hash).copied()
    }

    /// 関連モードが有効かどうか
    pub fn is_relevance_mode(&self) -> bool {
        self.relevance_mode
    }

    // ===== 関連ファイルビュー関連 =====

    /// 関連ファイルビューを開始
    pub fn start_related_files_view(&mut self, related_files: RelatedFiles) {
        self.related_files_cache = Some(related_files);
        self.related_files_selected_index = 0;
        self.related_files_scroll_offset = 0;
        self.input_mode = InputMode::RelatedFilesView;
    }

    /// 関連ファイルビューを終了
    pub fn close_related_files_view(&mut self) {
        self.related_files_cache = None;
        self.input_mode = InputMode::Normal;
        self.open_detail(); // 詳細ビューに戻る
    }

    /// 関連ファイルビューで下に移動
    pub fn related_files_move_down(&mut self) {
        if let Some(ref related) = self.related_files_cache {
            if self.related_files_selected_index < related.related.len().saturating_sub(1) {
                self.related_files_selected_index += 1;
            }
        }
    }

    /// 関連ファイルビューで上に移動
    pub fn related_files_move_up(&mut self) {
        if self.related_files_selected_index > 0 {
            self.related_files_selected_index -= 1;
        }
    }

    /// 関連ファイルビューのスクロールを調整
    pub fn related_files_adjust_scroll(&mut self, visible_lines: usize) {
        if self.related_files_selected_index >= self.related_files_scroll_offset + visible_lines {
            self.related_files_scroll_offset =
                self.related_files_selected_index - visible_lines + 1;
        } else if self.related_files_selected_index < self.related_files_scroll_offset {
            self.related_files_scroll_offset = self.related_files_selected_index;
        }
    }
}

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

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

    fn create_test_event(message: &str) -> GitEvent {
        GitEvent::commit(
            "abc1234".to_string(),
            message.to_string(),
            "author".to_string(),
            Local::now(),
            0,
            0,
        )
    }

    fn create_test_repo_info() -> RepoInfo {
        RepoInfo {
            name: "test-repo".to_string(),
            branch: "main".to_string(),
        }
    }

    #[test]
    fn test_app_new_initializes_with_should_quit_false() {
        let app = App::new();
        assert!(!app.should_quit);
    }

    #[test]
    fn test_app_new_initializes_with_empty_events() {
        let app = App::new();
        assert!(app.events().is_empty());
    }

    #[test]
    fn test_app_new_initializes_with_no_repo_info() {
        let app = App::new();
        assert!(app.repo_info.is_none());
    }

    #[test]
    fn test_app_quit_sets_should_quit_to_true() {
        let mut app = App::new();
        app.quit();
        assert!(app.should_quit);
    }

    #[test]
    fn test_app_default_is_same_as_new() {
        let app1 = App::new();
        let app2 = App::default();
        assert_eq!(app1.should_quit, app2.should_quit);
    }

    #[test]
    fn test_app_load_sets_repo_info() {
        let mut app = App::new();
        let repo_info = create_test_repo_info();
        app.load(repo_info, vec![]);
        assert!(app.repo_info.is_some());
        assert_eq!(app.repo_name(), "test-repo");
    }

    #[test]
    fn test_app_load_sets_events() {
        let mut app = App::new();
        let events = vec![create_test_event("commit 1"), create_test_event("commit 2")];
        app.load(create_test_repo_info(), events);
        assert_eq!(app.event_count(), 2);
    }

    #[test]
    fn test_app_load_resets_selected_index() {
        let mut app = App::new();
        app.selected_index = 5;
        app.load(create_test_repo_info(), vec![create_test_event("commit")]);
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_move_down_increments_selected_index() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![create_test_event("1"), create_test_event("2")],
        );
        app.move_down();
        assert_eq!(app.selected_index, 1);
    }

    #[test]
    fn test_app_move_down_does_not_exceed_events_length() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![create_test_event("1"), create_test_event("2")],
        );
        app.move_down();
        app.move_down();
        app.move_down();
        assert_eq!(app.selected_index, 1);
    }

    #[test]
    fn test_app_move_up_decrements_selected_index() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![create_test_event("1"), create_test_event("2")],
        );
        app.selected_index = 1;
        app.move_up();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_move_up_does_not_go_below_zero() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("1")]);
        app.move_up();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_selected_event_returns_correct_event() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![create_test_event("first"), create_test_event("second")],
        );
        app.selected_index = 1;
        let event = app.selected_event().unwrap();
        assert_eq!(event.message, "second");
    }

    #[test]
    fn test_app_selected_event_returns_none_when_empty() {
        let app = App::new();
        assert!(app.selected_event().is_none());
    }

    #[test]
    fn test_app_repo_name_returns_unknown_when_no_repo() {
        let app = App::new();
        assert_eq!(app.repo_name(), "unknown");
    }

    #[test]
    fn test_app_branch_name_returns_unknown_when_no_repo() {
        let app = App::new();
        assert_eq!(app.branch_name(), "unknown");
    }

    #[test]
    fn test_app_new_initializes_with_show_detail_false() {
        let app = App::new();
        assert!(!app.show_detail);
    }

    #[test]
    fn test_app_open_detail_sets_show_detail_true() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("commit")]);
        app.open_detail();
        assert!(app.show_detail);
    }

    #[test]
    fn test_app_open_detail_does_nothing_when_no_events() {
        let mut app = App::new();
        app.open_detail();
        assert!(!app.show_detail);
    }

    #[test]
    fn test_app_close_detail_sets_show_detail_false() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("commit")]);
        app.open_detail();
        app.close_detail();
        assert!(!app.show_detail);
    }

    #[test]
    fn test_app_new_initializes_with_normal_mode() {
        let app = App::new();
        assert_eq!(app.input_mode, InputMode::Normal);
    }

    #[test]
    fn test_app_start_filter_sets_filter_mode() {
        let mut app = App::new();
        app.start_filter();
        assert_eq!(app.input_mode, InputMode::Filter);
    }

    #[test]
    fn test_app_end_filter_sets_normal_mode() {
        let mut app = App::new();
        app.start_filter();
        app.end_filter();
        assert_eq!(app.input_mode, InputMode::Normal);
    }

    #[test]
    fn test_app_filter_push_adds_character() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("test")]);
        app.filter_push('a');
        assert_eq!(app.filter_text, "a");
    }

    #[test]
    fn test_app_filter_pop_removes_character() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("test")]);
        app.filter_push('a');
        app.filter_push('b');
        app.filter_pop();
        assert_eq!(app.filter_text, "a");
    }

    #[test]
    fn test_app_filter_clear_removes_all() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("test")]);
        app.filter_push('a');
        app.filter_push('b');
        app.filter_clear();
        assert_eq!(app.filter_text, "");
    }

    #[test]
    fn test_app_filter_filters_by_message() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("feat: add feature"),
                create_test_event("fix: bug fix"),
                create_test_event("feat: another feature"),
            ],
        );
        app.filter_push('f');
        app.filter_push('i');
        app.filter_push('x');
        assert_eq!(app.event_count(), 1);
    }

    #[test]
    fn test_app_filter_is_case_insensitive() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![create_test_event("FEAT: Add Feature")],
        );
        app.filter_push('f');
        app.filter_push('e');
        app.filter_push('a');
        app.filter_push('t');
        assert_eq!(app.event_count(), 1);
    }

    #[test]
    fn test_app_filter_resets_selected_index() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("first"),
                create_test_event("second"),
                create_test_event("third"),
            ],
        );
        app.selected_index = 2;
        app.filter_push('f');
        app.filter_push('i');
        app.filter_push('r');
        // "first"のみマッチ、selected_indexは0に調整
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_start_branch_select_sets_mode() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]);
        app.start_branch_select(vec!["main".to_string(), "develop".to_string()]);
        assert_eq!(app.input_mode, InputMode::BranchSelect);
    }

    #[test]
    fn test_app_start_branch_select_sets_branches() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]);
        app.start_branch_select(vec!["main".to_string(), "develop".to_string()]);
        assert_eq!(app.branches.len(), 2);
    }

    #[test]
    fn test_app_start_branch_select_selects_current_branch() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]); // main branch
        app.start_branch_select(vec!["develop".to_string(), "main".to_string()]);
        assert_eq!(app.branch_selected_index, 1);
    }

    #[test]
    fn test_app_end_branch_select_clears_branches() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]);
        app.start_branch_select(vec!["main".to_string()]);
        app.end_branch_select();
        assert!(app.branches.is_empty());
        assert_eq!(app.input_mode, InputMode::Normal);
    }

    #[test]
    fn test_app_branch_move_down_increments_index() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]);
        app.start_branch_select(vec!["a".to_string(), "b".to_string(), "c".to_string()]);
        app.branch_selected_index = 0;
        app.branch_move_down();
        assert_eq!(app.branch_selected_index, 1);
    }

    #[test]
    fn test_app_branch_move_up_decrements_index() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]);
        app.start_branch_select(vec!["a".to_string(), "b".to_string(), "c".to_string()]);
        app.branch_selected_index = 2;
        app.branch_move_up();
        assert_eq!(app.branch_selected_index, 1);
    }

    #[test]
    fn test_app_selected_branch_returns_correct_branch() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]);
        app.start_branch_select(vec!["a".to_string(), "b".to_string(), "c".to_string()]);
        app.branch_selected_index = 1;
        assert_eq!(app.selected_branch(), Some("b"));
    }

    #[test]
    fn test_app_update_branch_changes_repo_info() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![]);
        app.update_branch("new-branch".to_string());
        assert_eq!(app.branch_name(), "new-branch");
    }

    fn create_test_file_status() -> FileStatus {
        use crate::git::FileStatusKind;
        FileStatus {
            path: "test.txt".to_string(),
            kind: FileStatusKind::Modified,
        }
    }

    #[test]
    fn test_app_start_status_view_sets_mode() {
        let mut app = App::new();
        app.start_status_view(vec![create_test_file_status()]);
        assert_eq!(app.input_mode, InputMode::StatusView);
    }

    #[test]
    fn test_app_start_status_view_sets_statuses() {
        let mut app = App::new();
        app.start_status_view(vec![create_test_file_status(), create_test_file_status()]);
        assert_eq!(app.file_statuses.len(), 2);
    }

    #[test]
    fn test_app_end_status_view_clears_statuses() {
        let mut app = App::new();
        app.start_status_view(vec![create_test_file_status()]);
        app.end_status_view();
        assert!(app.file_statuses.is_empty());
        assert_eq!(app.input_mode, InputMode::Normal);
    }

    #[test]
    fn test_app_status_move_down_increments_index() {
        let mut app = App::new();
        app.start_status_view(vec![create_test_file_status(), create_test_file_status()]);
        app.status_move_down();
        assert_eq!(app.status_selected_index, 1);
    }

    #[test]
    fn test_app_status_move_up_decrements_index() {
        let mut app = App::new();
        app.start_status_view(vec![create_test_file_status(), create_test_file_status()]);
        app.status_selected_index = 1;
        app.status_move_up();
        assert_eq!(app.status_selected_index, 0);
    }

    #[test]
    fn test_app_selected_file_status_returns_correct_status() {
        let mut app = App::new();
        app.start_status_view(vec![create_test_file_status()]);
        let status = app.selected_file_status().unwrap();
        assert_eq!(status.path, "test.txt");
    }

    #[test]
    fn test_app_start_commit_input_sets_mode() {
        let mut app = App::new();
        app.start_commit_input();
        assert_eq!(app.input_mode, InputMode::CommitInput);
    }

    #[test]
    fn test_app_commit_message_push_adds_character() {
        let mut app = App::new();
        app.commit_message_push('t');
        app.commit_message_push('e');
        app.commit_message_push('s');
        app.commit_message_push('t');
        assert_eq!(app.commit_message, "test");
    }

    #[test]
    fn test_app_commit_message_pop_removes_character() {
        let mut app = App::new();
        app.commit_message_push('a');
        app.commit_message_push('b');
        app.commit_message_pop();
        assert_eq!(app.commit_message, "a");
    }

    #[test]
    fn test_app_set_status_message_sets_message() {
        let mut app = App::new();
        app.set_status_message("Success".to_string());
        assert_eq!(app.status_message, Some("Success".to_string()));
    }

    #[test]
    fn test_app_new_initializes_with_is_loading_false() {
        let app = App::new();
        assert!(!app.is_loading);
    }

    #[test]
    fn test_app_start_loading_sets_is_loading_true() {
        let mut app = App::new();
        app.start_loading();
        assert!(app.is_loading);
    }

    #[test]
    fn test_app_finish_loading_sets_is_loading_false() {
        let mut app = App::new();
        app.start_loading();
        app.finish_loading();
        assert!(!app.is_loading);
    }

    #[test]
    fn test_app_append_events_adds_to_existing() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("first")]);
        assert_eq!(app.event_count(), 1);

        app.append_events(vec![
            create_test_event("second"),
            create_test_event("third"),
        ]);
        assert_eq!(app.event_count(), 3);
    }

    #[test]
    fn test_app_append_events_updates_filtered_indices() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("first")]);
        app.append_events(vec![create_test_event("second")]);

        // フィルタなしなら全てのイベントが表示される
        assert_eq!(app.events().len(), 2);
    }

    // ===== Vim風ナビゲーションのテスト =====

    #[test]
    fn test_app_move_to_top_sets_selected_index_to_zero() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("1"),
                create_test_event("2"),
                create_test_event("3"),
            ],
        );
        app.selected_index = 2;
        app.move_to_top();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_move_to_top_works_when_already_at_top() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("1")]);
        app.selected_index = 0;
        app.move_to_top();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_move_to_bottom_sets_selected_index_to_last() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("1"),
                create_test_event("2"),
                create_test_event("3"),
            ],
        );
        app.selected_index = 0;
        app.move_to_bottom();
        assert_eq!(app.selected_index, 2);
    }

    #[test]
    fn test_app_move_to_bottom_does_nothing_when_empty() {
        let mut app = App::new();
        app.move_to_bottom();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_page_down_moves_by_page_size() {
        let mut app = App::new();
        let events: Vec<_> = (0..20)
            .map(|i| create_test_event(&format!("{}", i)))
            .collect();
        app.load(create_test_repo_info(), events);
        app.selected_index = 0;
        app.page_down(10);
        assert_eq!(app.selected_index, 10);
    }

    #[test]
    fn test_app_page_down_stops_at_last_index() {
        let mut app = App::new();
        let events: Vec<_> = (0..5)
            .map(|i| create_test_event(&format!("{}", i)))
            .collect();
        app.load(create_test_repo_info(), events);
        app.selected_index = 0;
        app.page_down(10);
        assert_eq!(app.selected_index, 4);
    }

    #[test]
    fn test_app_page_down_does_nothing_when_empty() {
        let mut app = App::new();
        app.page_down(10);
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_page_up_moves_by_page_size() {
        let mut app = App::new();
        let events: Vec<_> = (0..20)
            .map(|i| create_test_event(&format!("{}", i)))
            .collect();
        app.load(create_test_repo_info(), events);
        app.selected_index = 15;
        app.page_up(10);
        assert_eq!(app.selected_index, 5);
    }

    #[test]
    fn test_app_page_up_stops_at_zero() {
        let mut app = App::new();
        let events: Vec<_> = (0..5)
            .map(|i| create_test_event(&format!("{}", i)))
            .collect();
        app.load(create_test_repo_info(), events);
        app.selected_index = 3;
        app.page_up(10);
        assert_eq!(app.selected_index, 0);
    }

    // ===== ヘルプ表示のテスト =====

    #[test]
    fn test_app_new_initializes_with_show_help_false() {
        let app = App::new();
        assert!(!app.show_help);
    }

    #[test]
    fn test_app_toggle_help_sets_show_help_true() {
        let mut app = App::new();
        app.toggle_help();
        assert!(app.show_help);
    }

    #[test]
    fn test_app_toggle_help_toggles_show_help() {
        let mut app = App::new();
        app.toggle_help();
        assert!(app.show_help);
        app.toggle_help();
        assert!(!app.show_help);
    }

    #[test]
    fn test_app_close_help_sets_show_help_false() {
        let mut app = App::new();
        app.show_help = true;
        app.close_help();
        assert!(!app.show_help);
    }

    #[test]
    fn test_app_close_help_does_nothing_when_already_closed() {
        let mut app = App::new();
        app.close_help();
        assert!(!app.show_help);
    }

    // ===== jump_to_head のテスト =====

    #[test]
    fn test_app_jump_to_head_moves_to_head_event() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("1"),
                create_test_event("2"),
                create_test_event("3"),
            ],
        );
        // HEADは最初のイベント（abc1234）
        app.set_head_hash("abc1234".to_string());
        app.selected_index = 2;
        app.jump_to_head();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_jump_to_head_works_when_already_at_head() {
        let mut app = App::new();
        app.load(create_test_repo_info(), vec![create_test_event("1")]);
        app.set_head_hash("abc1234".to_string());
        app.selected_index = 0;
        app.jump_to_head();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_jump_to_head_finds_head_in_filtered_results() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("HEAD commit"),
                create_test_event("other"),
                create_test_event("HEAD related"),
            ],
        );
        // HEADは最初のイベント
        app.set_head_hash("abc1234".to_string());
        // "HEAD"でフィルタ → [0, 2]がマッチ
        app.filter_push('H');
        app.filter_push('E');
        app.filter_push('A');
        app.filter_push('D');
        // selected_indexをフィルタ結果内で最後(2番目)に設定
        app.selected_index = 1;
        // HEADにジャンプ → インデックス0はフィルタ結果の0番目
        app.jump_to_head();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_jump_to_head_does_nothing_when_head_not_in_filter() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("first"),
                create_test_event("match me"),
                create_test_event("another match me"),
            ],
        );
        // HEADは最初のイベント
        app.set_head_hash("abc1234".to_string());
        // "match"でフィルタ → [1, 2]がマッチ、HEADの0は含まれない
        app.filter_push('m');
        app.filter_push('a');
        app.filter_push('t');
        app.filter_push('c');
        app.filter_push('h');
        app.selected_index = 1;
        // HEADにジャンプ → インデックス0はフィルタ結果に含まれないので移動しない
        app.jump_to_head();
        assert_eq!(app.selected_index, 1);
    }

    #[test]
    fn test_app_jump_to_head_without_head_hash_goes_to_first() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("1"),
                create_test_event("2"),
                create_test_event("3"),
            ],
        );
        // head_hashが設定されていない場合は先頭にジャンプ
        app.selected_index = 2;
        app.jump_to_head();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_set_head_hash_truncates_long_hash() {
        let mut app = App::new();
        app.set_head_hash("abcdef1234567890".to_string());
        assert_eq!(app.head_hash, Some("abcdef1".to_string()));
    }

    #[test]
    fn test_app_set_head_hash_keeps_short_hash() {
        let mut app = App::new();
        app.set_head_hash("abc1234".to_string());
        assert_eq!(app.head_hash, Some("abc1234".to_string()));
    }

    // ===== 表示モードのテスト =====

    #[test]
    fn test_app_new_initializes_with_normal_view_mode() {
        let app = App::new();
        assert_eq!(app.view_mode, ViewMode::Normal);
    }

    #[test]
    fn test_app_cycle_view_mode_normal_to_compact() {
        let mut app = App::new();
        app.cycle_view_mode();
        assert_eq!(app.view_mode, ViewMode::Compact);
    }

    #[test]
    fn test_app_cycle_view_mode_toggle() {
        let mut app = App::new();
        assert_eq!(app.view_mode, ViewMode::Normal);
        app.cycle_view_mode();
        assert_eq!(app.view_mode, ViewMode::Compact);
        app.cycle_view_mode();
        assert_eq!(app.view_mode, ViewMode::Normal);
    }

    // ===== ラベルジャンプのテスト =====

    fn create_labeled_event(message: &str, labels: Vec<&str>) -> GitEvent {
        let mut event = GitEvent::commit(
            "abc1234".to_string(),
            message.to_string(),
            "author".to_string(),
            Local::now(),
            0,
            0,
        );
        event.branch_labels = labels.into_iter().map(|s| s.to_string()).collect();
        event
    }

    #[test]
    fn test_app_jump_to_next_label_finds_label() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("no label 1"),
                create_test_event("no label 2"),
                create_labeled_event("with label", vec!["main"]),
                create_test_event("no label 3"),
            ],
        );
        app.selected_index = 0;
        app.jump_to_next_label();
        assert_eq!(app.selected_index, 2);
    }

    #[test]
    fn test_app_jump_to_next_label_no_label_found() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("no label 1"),
                create_test_event("no label 2"),
                create_test_event("no label 3"),
            ],
        );
        app.selected_index = 0;
        app.jump_to_next_label();
        assert_eq!(app.selected_index, 0); // 変わらない
    }

    #[test]
    fn test_app_jump_to_prev_label_finds_label() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_labeled_event("with label", vec!["main"]),
                create_test_event("no label 1"),
                create_test_event("no label 2"),
                create_test_event("no label 3"),
            ],
        );
        app.selected_index = 3;
        app.jump_to_prev_label();
        assert_eq!(app.selected_index, 0);
    }

    #[test]
    fn test_app_jump_to_prev_label_no_label_found() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_test_event("no label 1"),
                create_test_event("no label 2"),
                create_test_event("no label 3"),
            ],
        );
        app.selected_index = 2;
        app.jump_to_prev_label();
        assert_eq!(app.selected_index, 2); // 変わらない
    }

    #[test]
    fn test_app_jump_to_prev_label_at_start() {
        let mut app = App::new();
        app.load(
            create_test_repo_info(),
            vec![
                create_labeled_event("with label", vec!["main"]),
                create_test_event("no label"),
            ],
        );
        app.selected_index = 0;
        app.jump_to_prev_label();
        assert_eq!(app.selected_index, 0); // 変わらない（開始位置）
    }

    // ===== CommitType のテスト =====

    #[test]
    fn test_commit_type_prefix_feat() {
        assert_eq!(CommitType::Feat.prefix(), "feat: ");
    }

    #[test]
    fn test_commit_type_prefix_fix() {
        assert_eq!(CommitType::Fix.prefix(), "fix: ");
    }

    #[test]
    fn test_commit_type_prefix_all_types() {
        assert_eq!(CommitType::Docs.prefix(), "docs: ");
        assert_eq!(CommitType::Style.prefix(), "style: ");
        assert_eq!(CommitType::Refactor.prefix(), "refactor: ");
        assert_eq!(CommitType::Test.prefix(), "test: ");
        assert_eq!(CommitType::Chore.prefix(), "chore: ");
        assert_eq!(CommitType::Perf.prefix(), "perf: ");
    }

    #[test]
    fn test_commit_type_key_feat() {
        assert_eq!(CommitType::Feat.key(), 'f');
    }

    #[test]
    fn test_commit_type_key_fix() {
        assert_eq!(CommitType::Fix.key(), 'x');
    }

    #[test]
    fn test_commit_type_key_all_types() {
        assert_eq!(CommitType::Docs.key(), 'd');
        assert_eq!(CommitType::Style.key(), 's');
        assert_eq!(CommitType::Refactor.key(), 'r');
        assert_eq!(CommitType::Test.key(), 't');
        assert_eq!(CommitType::Chore.key(), 'c');
        assert_eq!(CommitType::Perf.key(), 'p');
    }

    #[test]
    fn test_commit_type_all_returns_8_types() {
        assert_eq!(CommitType::all().len(), 8);
    }

    #[test]
    fn test_select_commit_type_sets_prefix() {
        let mut app = App::new();
        app.select_commit_type(CommitType::Feat);
        assert_eq!(app.commit_message, "feat: ");
        assert_eq!(app.commit_type, Some(CommitType::Feat));
    }

    #[test]
    fn test_select_commit_type_fix() {
        let mut app = App::new();
        app.select_commit_type(CommitType::Fix);
        assert_eq!(app.commit_message, "fix: ");
        assert_eq!(app.commit_type, Some(CommitType::Fix));
    }

    #[test]
    fn test_commit_message_pop_clears_type_when_prefix_removed() {
        let mut app = App::new();
        app.select_commit_type(CommitType::Feat);
        // "feat: " を消していく
        for _ in 0..6 {
            app.commit_message_pop();
        }
        assert_eq!(app.commit_type, None);
    }

    #[test]
    fn test_commit_message_clear_clears_type() {
        let mut app = App::new();
        app.select_commit_type(CommitType::Feat);
        app.commit_message_clear();
        assert_eq!(app.commit_type, None);
        assert_eq!(app.commit_message, "");
    }

    #[test]
    fn test_start_commit_input_clears_type() {
        let mut app = App::new();
        app.commit_type = Some(CommitType::Feat);
        app.start_commit_input();
        assert_eq!(app.commit_type, None);
    }

    #[test]
    fn test_end_commit_input_clears_type() {
        let mut app = App::new();
        app.start_commit_input();
        app.select_commit_type(CommitType::Feat);
        app.end_commit_input();
        assert_eq!(app.commit_type, None);
    }

    // ===== 提案関連のテスト =====

    #[test]
    fn test_app_new_initializes_with_empty_suggestions() {
        let app = App::new();
        assert!(app.commit_suggestions.is_empty());
        assert_eq!(app.suggestion_selected_index, 0);
    }

    #[test]
    fn test_suggestion_move_down_increments_index() {
        let mut app = App::new();
        app.commit_suggestions = vec![
            crate::suggestion::CommitSuggestion {
                commit_type: CommitType::Feat,
                scope: None,
                message: "test1".to_string(),
                confidence: 0.8,
            },
            crate::suggestion::CommitSuggestion {
                commit_type: CommitType::Fix,
                scope: None,
                message: "test2".to_string(),
                confidence: 0.6,
            },
        ];
        app.suggestion_move_down();
        assert_eq!(app.suggestion_selected_index, 1);
    }

    #[test]
    fn test_suggestion_move_up_decrements_index() {
        let mut app = App::new();
        app.commit_suggestions = vec![
            crate::suggestion::CommitSuggestion {
                commit_type: CommitType::Feat,
                scope: None,
                message: "test1".to_string(),
                confidence: 0.8,
            },
            crate::suggestion::CommitSuggestion {
                commit_type: CommitType::Fix,
                scope: None,
                message: "test2".to_string(),
                confidence: 0.6,
            },
        ];
        app.suggestion_selected_index = 1;
        app.suggestion_move_up();
        assert_eq!(app.suggestion_selected_index, 0);
    }

    #[test]
    fn test_apply_suggestion_sets_message_and_type() {
        let mut app = App::new();
        app.commit_suggestions = vec![crate::suggestion::CommitSuggestion {
            commit_type: CommitType::Feat,
            scope: Some("auth".to_string()),
            message: "add login".to_string(),
            confidence: 0.8,
        }];
        app.apply_suggestion(0);
        assert_eq!(app.commit_type, Some(CommitType::Feat));
        assert_eq!(app.commit_message, "feat(auth): add login");
    }

    #[test]
    fn test_apply_suggestion_invalid_index_does_nothing() {
        let mut app = App::new();
        app.apply_suggestion(0);
        assert_eq!(app.commit_type, None);
        assert!(app.commit_message.is_empty());
    }

    // ===== LayoutMode関連のテスト =====

    #[test]
    fn test_layout_mode_default_is_single() {
        let app = App::new();
        assert_eq!(app.layout_mode, LayoutMode::Single);
    }

    #[test]
    fn test_toggle_layout_mode_single_to_split() {
        let mut app = App::new();
        assert_eq!(app.layout_mode, LayoutMode::Single);
        app.toggle_layout_mode();
        assert_eq!(app.layout_mode, LayoutMode::SplitPanel);
    }

    #[test]
    fn test_toggle_layout_mode_split_to_single() {
        let mut app = App::new();
        app.layout_mode = LayoutMode::SplitPanel;
        app.toggle_layout_mode();
        assert_eq!(app.layout_mode, LayoutMode::Single);
    }

    #[test]
    fn test_effective_layout_mode_single_when_narrow() {
        let mut app = App::new();
        app.layout_mode = LayoutMode::SplitPanel;
        // 幅119以下はSingleになる
        assert_eq!(app.effective_layout_mode(119), LayoutMode::Single);
        assert_eq!(app.effective_layout_mode(100), LayoutMode::Single);
        assert_eq!(app.effective_layout_mode(80), LayoutMode::Single);
    }

    #[test]
    fn test_effective_layout_mode_split_when_wide() {
        let mut app = App::new();
        app.layout_mode = LayoutMode::SplitPanel;
        // 幅120以上はSplitPanelになる
        assert_eq!(app.effective_layout_mode(120), LayoutMode::SplitPanel);
        assert_eq!(app.effective_layout_mode(150), LayoutMode::SplitPanel);
        assert_eq!(app.effective_layout_mode(200), LayoutMode::SplitPanel);
    }

    #[test]
    fn test_effective_layout_mode_single_when_mode_is_single() {
        let app = App::new();
        // モードがSingleなら幅に関係なくSingle
        assert_eq!(app.effective_layout_mode(200), LayoutMode::Single);
    }

    #[test]
    fn test_left_panel_ratio_default() {
        let app = App::new();
        assert_eq!(app.left_panel_ratio, 65);
    }

    #[test]
    fn test_adjust_panel_ratio_increase() {
        let mut app = App::new();
        app.adjust_panel_ratio(5);
        assert_eq!(app.left_panel_ratio, 70);
    }

    #[test]
    fn test_adjust_panel_ratio_decrease() {
        let mut app = App::new();
        app.adjust_panel_ratio(-5);
        assert_eq!(app.left_panel_ratio, 60);
    }

    #[test]
    fn test_adjust_panel_ratio_max_clamp() {
        let mut app = App::new();
        app.left_panel_ratio = 80;
        app.adjust_panel_ratio(10); // 80 + 10 = 90 -> 85に制限
        assert_eq!(app.left_panel_ratio, 85);
    }

    #[test]
    fn test_adjust_panel_ratio_min_clamp() {
        let mut app = App::new();
        app.left_panel_ratio = 45;
        app.adjust_panel_ratio(-10); // 45 - 10 = 35 -> 40に制限
        assert_eq!(app.left_panel_ratio, 40);
    }

    #[test]
    fn test_update_detail_for_split_panel_clears_cache() {
        let mut app = App::new();
        app.detail_scroll_offset = 5;
        app.detail_selected_file = 3;
        app.update_detail_for_split_panel();
        assert_eq!(app.detail_scroll_offset, 0);
        assert_eq!(app.detail_selected_file, 0);
        assert!(app.detail_diff_cache.is_none());
    }
}