gitstack/

git.rs

use std::time::SystemTime;

use anyhow::{Context, Result};
use chrono::{Local, TimeZone};
use git2::{Commit, Diff, Repository, Signature, Sort, Status, StatusOptions};

use crate::event::{GitEvent, GitEventKind};

/// パストラバーサル攻撃を防ぐためのパス検証
fn validate_path(path: &str) -> Result<()> {
    // ヌル文字チェック
    if path.contains('\0') {
        return Err(anyhow::anyhow!(
            "無効なパス: ヌル文字を含むことはできません"
        ));
    }

    // 親ディレクトリ参照チェック
    let normalized = std::path::Path::new(path);
    if normalized
        .components()
        .any(|c| matches!(c, std::path::Component::ParentDir))
    {
        return Err(anyhow::anyhow!(
            "無効なパス: 親ディレクトリ参照は許可されていません"
        ));
    }

    Ok(())
}

/// ブランチ名の検証
fn validate_branch_name(name: &str) -> Result<()> {
    if name.is_empty() {
        return Err(anyhow::anyhow!(
            "無効なブランチ名: 空文字列は許可されていません"
        ));
    }
    if name.contains('\0') {
        return Err(anyhow::anyhow!(
            "無効なブランチ名: ヌル文字を含むことはできません"
        ));
    }
    Ok(())
}

/// 現在のHEADのハッシュを取得
pub fn get_head_hash() -> Result<String> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_head_hash_from_repo(&repo)
}

/// RepositoryからHEADのハッシュを取得
pub fn get_head_hash_from_repo(repo: &Repository) -> Result<String> {
    let head = repo.head().context("HEADが見つかりません")?;
    let oid = head.target().context("HEADのターゲットが見つかりません")?;
    Ok(oid.to_string())
}

/// .git/indexファイルの更新時刻を取得（ワーキングツリー変更検知用）
pub fn get_index_mtime() -> Result<SystemTime> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_index_mtime_from_repo(&repo)
}

/// Repositoryから.git/indexの更新時刻を取得
pub fn get_index_mtime_from_repo(repo: &Repository) -> Result<SystemTime> {
    let git_dir = repo.path();
    let index_path = git_dir.join("index");
    let metadata = std::fs::metadata(&index_path).context("indexファイルが見つかりません")?;
    metadata.modified().context("更新時刻を取得できません")
}

/// git config user.name を取得
pub fn get_user_name() -> Option<String> {
    let repo = Repository::discover(".").ok()?;
    get_user_name_from_repo(&repo)
}

/// Repositoryからgit config user.nameを取得
pub fn get_user_name_from_repo(repo: &Repository) -> Option<String> {
    let config = repo.config().ok()?;
    config.get_string("user.name").ok()
}

/// ファイルのステータス種別
#[derive(Debug, Clone, PartialEq)]
pub enum FileStatusKind {
    /// ステージ済み（新規追加）
    StagedNew,
    /// ステージ済み（変更）
    StagedModified,
    /// ステージ済み（削除）
    StagedDeleted,
    /// 未ステージ（変更）
    Modified,
    /// 未ステージ（削除）
    Deleted,
    /// 未追跡
    Untracked,
}

impl FileStatusKind {
    /// ステージ済みかどうかを判定
    pub fn is_staged(&self) -> bool {
        matches!(
            self,
            FileStatusKind::StagedNew
                | FileStatusKind::StagedModified
                | FileStatusKind::StagedDeleted
        )
    }
}

/// ファイルステータス
#[derive(Debug, Clone)]
pub struct FileStatus {
    /// ファイルパス
    pub path: String,
    /// ステータス種別
    pub kind: FileStatusKind,
}

/// コミットのファイル変更統計
#[derive(Debug, Clone, Default)]
pub struct DiffStats {
    pub files_changed: usize,
    pub insertions: usize,
    pub deletions: usize,
}

/// ファイル変更のステータス
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum FileChangeStatus {
    /// 新規追加
    Added,
    /// 変更
    Modified,
    /// 削除
    Deleted,
    /// リネーム
    Renamed,
}

impl FileChangeStatus {
    /// 表示用の短縮文字を取得
    pub fn as_char(&self) -> char {
        match self {
            Self::Added => 'A',
            Self::Modified => 'M',
            Self::Deleted => 'D',
            Self::Renamed => 'R',
        }
    }
}

/// コミット内の個別ファイル変更
#[derive(Debug, Clone)]
pub struct FileChange {
    /// ファイルパス
    pub path: String,
    /// 変更ステータス
    pub status: FileChangeStatus,
    /// 追加行数
    pub insertions: usize,
    /// 削除行数
    pub deletions: usize,
}

/// コミットのdiff情報（統計 + ファイル一覧）
#[derive(Debug, Clone, Default)]
pub struct CommitDiff {
    /// 統計情報
    pub stats: DiffStats,
    /// ファイル変更一覧
    pub files: Vec<FileChange>,
}

/// コミットのdiff統計を取得
fn get_commit_diff_stats(repo: &Repository, commit: &Commit) -> DiffStats {
    let tree = match commit.tree() {
        Ok(t) => t,
        Err(_) => return DiffStats::default(),
    };

    let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

    let diff: Diff = match repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), None) {
        Ok(d) => d,
        Err(_) => return DiffStats::default(),
    };

    match diff.stats() {
        Ok(stats) => DiffStats {
            files_changed: stats.files_changed(),
            insertions: stats.insertions(),
            deletions: stats.deletions(),
        },
        Err(_) => DiffStats::default(),
    }
}

/// コミットの詳細なdiff情報を取得（統計 + ファイル一覧）
pub fn get_commit_diff(commit_hash: &str) -> Result<CommitDiff> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_commit_diff_from_repo(&repo, commit_hash)
}

/// Repositoryからコミットの詳細なdiff情報を取得
pub fn get_commit_diff_from_repo(repo: &Repository, commit_hash: &str) -> Result<CommitDiff> {
    use std::cell::RefCell;

    // コミットを解決
    let obj = repo
        .revparse_single(commit_hash)
        .context("コミットが見つかりません")?;
    let commit = obj.peel_to_commit().context("コミットに変換できません")?;

    let tree = commit.tree()?;
    let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

    let diff = repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), None)?;

    // 統計情報を取得
    let stats = match diff.stats() {
        Ok(s) => DiffStats {
            files_changed: s.files_changed(),
            insertions: s.insertions(),
            deletions: s.deletions(),
        },
        Err(_) => DiffStats::default(),
    };

    // ファイル変更一覧を構築（RefCellで内部可変性を使用）
    let files: RefCell<Vec<FileChange>> = RefCell::new(Vec::new());
    let file_stats: RefCell<std::collections::HashMap<String, (usize, usize)>> =
        RefCell::new(std::collections::HashMap::new());

    // 各ハンクを走査して行数を集計
    diff.foreach(
        &mut |delta, _| {
            let path = delta
                .new_file()
                .path()
                .or_else(|| delta.old_file().path())
                .and_then(|p| p.to_str())
                .unwrap_or("")
                .to_string();

            let status = match delta.status() {
                git2::Delta::Added => FileChangeStatus::Added,
                git2::Delta::Deleted => FileChangeStatus::Deleted,
                git2::Delta::Modified => FileChangeStatus::Modified,
                git2::Delta::Renamed => FileChangeStatus::Renamed,
                _ => FileChangeStatus::Modified,
            };

            files.borrow_mut().push(FileChange {
                path,
                status,
                insertions: 0,
                deletions: 0,
            });
            true
        },
        None,
        None,
        Some(&mut |delta, _hunk, line| {
            if let Some(path) = delta
                .new_file()
                .path()
                .or_else(|| delta.old_file().path())
                .and_then(|p| p.to_str())
            {
                let mut stats = file_stats.borrow_mut();
                let entry = stats.entry(path.to_string()).or_insert((0, 0));
                match line.origin() {
                    '+' => entry.0 += 1,
                    '-' => entry.1 += 1,
                    _ => {}
                }
            }
            true
        }),
    )?;

    // ファイルに行数統計を反映
    let mut files_vec = files.into_inner();
    let stats_map = file_stats.into_inner();
    for file in &mut files_vec {
        if let Some((ins, del)) = stats_map.get(&file.path) {
            file.insertions = *ins;
            file.deletions = *del;
        }
    }

    Ok(CommitDiff {
        stats,
        files: files_vec,
    })
}

/// リポジトリ情報
#[derive(Debug, Clone)]
pub struct RepoInfo {
    /// リポジトリ名
    pub name: String,
    /// 現在のブランチ名
    pub branch: String,
}

impl RepoInfo {
    /// カレントディレクトリからリポジトリ情報を取得
    pub fn from_current_dir() -> Result<Self> {
        let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
        Self::from_repo(&repo)
    }

    /// Repositoryからリポジトリ情報を取得
    pub fn from_repo(repo: &Repository) -> Result<Self> {
        let name = repo
            .workdir()
            .and_then(|p| p.file_name())
            .and_then(|n| n.to_str())
            .unwrap_or("unknown")
            .to_string();

        let branch = repo
            .head()
            .ok()
            .and_then(|h| h.shorthand().map(|s| s.to_string()))
            .unwrap_or_else(|| "HEAD".to_string());

        Ok(Self { name, branch })
    }
}

/// ローカルブランチ一覧を取得
pub fn list_branches() -> Result<Vec<String>> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    list_branches_from_repo(&repo)
}

/// Repositoryからローカルブランチ一覧を取得
/// 並び順: 現在のブランチ → main/master/develop → その他（アルファベット順）
pub fn list_branches_from_repo(repo: &Repository) -> Result<Vec<String>> {
    let branches = repo.branches(Some(git2::BranchType::Local))?;

    // 現在のブランチ名を取得
    let current_branch = repo
        .head()
        .ok()
        .and_then(|h| h.shorthand().map(|s| s.to_string()));

    // TODO: staleブランチ（リモートで削除済み）の除外は
    // git2での正確な検出が複雑なため、将来の課題とする
    let mut branch_names: Vec<String> = branches
        .filter_map(|b| b.ok())
        .filter_map(|(branch, _)| {
            let name = branch.name().ok().flatten()?.to_string();
            Some(name)
        })
        .collect();

    // 並び替え: 現在ブランチ → 優先ブランチ → その他（アルファベット順）
    sort_branches(&mut branch_names, current_branch.as_deref());

    Ok(branch_names)
}

/// ブランチ名を優先順位に従ってソート
/// 1. 現在のブランチ（最上部）
/// 2. main / master / develop（存在する場合）
/// 3. その他のブランチ（アルファベット順）
fn sort_branches(branches: &mut [String], current_branch: Option<&str>) {
    let priority_branches = ["main", "master", "develop"];

    branches.sort_by(|a, b| {
        let a_is_current = current_branch.is_some_and(|c| c == a);
        let b_is_current = current_branch.is_some_and(|c| c == b);

        // 現在のブランチを最優先
        if a_is_current && !b_is_current {
            return std::cmp::Ordering::Less;
        }
        if !a_is_current && b_is_current {
            return std::cmp::Ordering::Greater;
        }

        // 優先ブランチの順序を取得
        let a_priority = priority_branches.iter().position(|&p| p == a);
        let b_priority = priority_branches.iter().position(|&p| p == b);

        match (a_priority, b_priority) {
            (Some(ap), Some(bp)) => ap.cmp(&bp),
            (Some(_), None) => std::cmp::Ordering::Less,
            (None, Some(_)) => std::cmp::Ordering::Greater,
            (None, None) => a.cmp(b),
        }
    });
}

/// ブランチを切り替え
pub fn checkout_branch(branch_name: &str) -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    checkout_branch_in_repo(&repo, branch_name)
}

/// Repositoryでブランチを切り替え
pub fn checkout_branch_in_repo(repo: &Repository, branch_name: &str) -> Result<()> {
    validate_branch_name(branch_name)?;

    let obj = repo
        .revparse_single(&format!("refs/heads/{}", branch_name))
        .context(format!("ブランチ '{}' が見つかりません", branch_name))?;
    repo.checkout_tree(&obj, None)?;
    repo.set_head(&format!("refs/heads/{}", branch_name))?;
    Ok(())
}

/// ワーキングディレクトリのステータスを取得
pub fn get_status() -> Result<Vec<FileStatus>> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_status_from_repo(&repo)
}

/// Repositoryからワーキングディレクトリのステータスを取得
pub fn get_status_from_repo(repo: &Repository) -> Result<Vec<FileStatus>> {
    let mut opts = StatusOptions::new();
    opts.include_untracked(true)
        .recurse_untracked_dirs(true)
        .include_ignored(false);

    let statuses = repo.statuses(Some(&mut opts))?;
    let mut result = Vec::new();

    for entry in statuses.iter() {
        let path = entry.path().unwrap_or("").to_string();
        let status = entry.status();

        // ステージ済みファイル
        if status.contains(Status::INDEX_NEW) {
            result.push(FileStatus {
                path: path.clone(),
                kind: FileStatusKind::StagedNew,
            });
        } else if status.contains(Status::INDEX_MODIFIED) {
            result.push(FileStatus {
                path: path.clone(),
                kind: FileStatusKind::StagedModified,
            });
        } else if status.contains(Status::INDEX_DELETED) {
            result.push(FileStatus {
                path: path.clone(),
                kind: FileStatusKind::StagedDeleted,
            });
        }

        // 未ステージファイル（ステージ済みと重複する場合もある）
        if status.contains(Status::WT_MODIFIED) {
            result.push(FileStatus {
                path: path.clone(),
                kind: FileStatusKind::Modified,
            });
        } else if status.contains(Status::WT_DELETED) {
            result.push(FileStatus {
                path: path.clone(),
                kind: FileStatusKind::Deleted,
            });
        } else if status.contains(Status::WT_NEW) {
            result.push(FileStatus {
                path,
                kind: FileStatusKind::Untracked,
            });
        }
    }

    Ok(result)
}

/// ファイルをステージング
pub fn stage_file(path: &str) -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    stage_file_in_repo(&repo, path)
}

/// Repositoryでファイルをステージング
pub fn stage_file_in_repo(repo: &Repository, path: &str) -> Result<()> {
    validate_path(path)?;

    let mut index = repo.index()?;
    let workdir = repo
        .workdir()
        .context("ワーキングディレクトリが見つかりません")?;
    let full_path = workdir.join(path);

    if full_path.exists() {
        index.add_path(std::path::Path::new(path))?;
    } else {
        // ファイルが削除された場合
        index.remove_path(std::path::Path::new(path))?;
    }
    index.write()?;
    Ok(())
}

/// ファイルをアンステージング
pub fn unstage_file(path: &str) -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    unstage_file_in_repo(&repo, path)
}

/// Repositoryでファイルをアンステージング
pub fn unstage_file_in_repo(repo: &Repository, path: &str) -> Result<()> {
    validate_path(path)?;

    let head = repo.head()?.peel_to_commit()?;
    repo.reset_default(Some(&head.into_object()), [std::path::Path::new(path)])?;
    Ok(())
}

/// 全ファイルをステージング
pub fn stage_all() -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    stage_all_in_repo(&repo)
}

/// Repositoryで全ファイルをステージング
pub fn stage_all_in_repo(repo: &Repository) -> Result<()> {
    let mut index = repo.index()?;
    index.add_all(["*"].iter(), git2::IndexAddOption::DEFAULT, None)?;
    index.write()?;
    Ok(())
}

/// 全ファイルをアンステージング
pub fn unstage_all() -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    unstage_all_in_repo(&repo)
}

/// Repositoryで全ファイルをアンステージング
pub fn unstage_all_in_repo(repo: &Repository) -> Result<()> {
    let head = repo.head()?.peel_to_commit()?;
    repo.reset(&head.into_object(), git2::ResetType::Mixed, None)?;
    Ok(())
}

/// コミットを作成
pub fn create_commit(message: &str) -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    create_commit_in_repo(&repo, message)
}

/// Repositoryでコミットを作成
pub fn create_commit_in_repo(repo: &Repository, message: &str) -> Result<()> {
    let sig = Signature::now("gitstack", "gitstack@local")?;
    let mut index = repo.index()?;
    let tree_id = index.write_tree()?;
    let tree = repo.find_tree(tree_id)?;
    let parent = repo.head()?.peel_to_commit()?;

    repo.commit(Some("HEAD"), &sig, &sig, message, &tree, &[&parent])?;
    Ok(())
}

/// リモートにプッシュ
pub fn push() -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    push_in_repo(&repo)
}

/// Repositoryでリモートにプッシュ
pub fn push_in_repo(repo: &Repository) -> Result<()> {
    let head = repo.head()?;
    let branch_name = head.shorthand().context("ブランチ名が取得できません")?;

    let mut remote = repo
        .find_remote("origin")
        .context("originリモートが見つかりません")?;
    let refspec = format!("refs/heads/{}:refs/heads/{}", branch_name, branch_name);

    remote.push(&[&refspec], None)?;
    Ok(())
}

/// リモートからフェッチ
pub fn fetch_remote() -> Result<()> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    fetch_remote_in_repo(&repo)
}

/// パスを指定してリモートからフェッチ（バックグラウンドスレッド用）
pub fn fetch_remote_at_path(repo_path: &std::path::Path) -> Result<()> {
    let repo = Repository::open(repo_path).context("リポジトリを開けません")?;
    fetch_remote_in_repo(&repo)
}

/// Repositoryでリモートからフェッチ
pub fn fetch_remote_in_repo(repo: &Repository) -> Result<()> {
    let mut remote = repo
        .find_remote("origin")
        .context("originリモートが見つかりません")?;

    // デフォルトのrefspecでフェッチ
    remote.fetch(&[] as &[&str], None, None)?;
    Ok(())
}

/// ステージ済みファイルがあるかどうか
pub fn has_staged_files() -> Result<bool> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    has_staged_files_in_repo(&repo)
}

/// Repositoryでステージ済みファイルがあるかどうか
pub fn has_staged_files_in_repo(repo: &Repository) -> Result<bool> {
    let statuses = get_status_from_repo(repo)?;
    Ok(statuses.iter().any(|s| {
        matches!(
            s.kind,
            FileStatusKind::StagedNew
                | FileStatusKind::StagedModified
                | FileStatusKind::StagedDeleted
        )
    }))
}

// ============================================================
// Diff/Patch 関連構造体と関数
// ============================================================

/// Diffの1行分のデータ
#[derive(Debug, Clone)]
pub struct DiffLine {
    /// 行の種類（'+': 追加, '-': 削除, ' ': 変更なし）
    pub origin: char,
    /// 行の内容
    pub content: String,
    /// 旧ファイルの行番号（削除行・コンテキスト行で有効）
    pub old_lineno: Option<u32>,
    /// 新ファイルの行番号（追加行・コンテキスト行で有効）
    pub new_lineno: Option<u32>,
}

/// ファイルのパッチ情報
#[derive(Debug, Clone)]
pub struct FilePatch {
    /// ファイルパス
    pub path: String,
    /// パッチの行一覧
    pub lines: Vec<DiffLine>,
}

/// 特定コミットの特定ファイルのパッチを取得
pub fn get_file_patch(commit_hash: &str, file_path: &str) -> Result<FilePatch> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_file_patch_from_repo(&repo, commit_hash, file_path)
}

/// Repositoryから特定コミットの特定ファイルのパッチを取得
pub fn get_file_patch_from_repo(
    repo: &Repository,
    commit_hash: &str,
    file_path: &str,
) -> Result<FilePatch> {
    validate_path(file_path)?;

    use std::cell::RefCell;

    // コミットを解決
    let obj = repo
        .revparse_single(commit_hash)
        .context("コミットが見つかりません")?;
    let commit = obj.peel_to_commit().context("コミットに変換できません")?;

    let tree = commit.tree()?;
    let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

    // コンテキスト行を含めるためのオプション
    let mut diff_opts = git2::DiffOptions::new();
    diff_opts.context_lines(3);

    let diff = repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), Some(&mut diff_opts))?;

    let lines: RefCell<Vec<DiffLine>> = RefCell::new(Vec::new());
    let path_obj = std::path::Path::new(file_path);

    diff.foreach(
        &mut |_delta, _| true, // ファイルコールバック
        None,                  // バイナリコールバック
        Some(&mut |delta, _hunk| {
            // 対象ファイルのみ処理
            let new_path = delta.new_file().path();
            let old_path = delta.old_file().path();
            new_path == Some(path_obj) || old_path == Some(path_obj)
        }),
        Some(&mut |delta, _hunk, line| {
            // 対象ファイルのみ処理
            let new_path = delta.new_file().path();
            let old_path = delta.old_file().path();
            if new_path != Some(path_obj) && old_path != Some(path_obj) {
                return true;
            }

            let origin = line.origin();
            let content = String::from_utf8_lossy(line.content()).to_string();
            // 末尾の改行を除去
            let content = content.trim_end_matches('\n').to_string();

            let old_lineno = line.old_lineno();
            let new_lineno = line.new_lineno();

            lines.borrow_mut().push(DiffLine {
                origin,
                content,
                old_lineno,
                new_lineno,
            });

            true
        }),
    )?;

    Ok(FilePatch {
        path: file_path.to_string(),
        lines: lines.into_inner(),
    })
}

/// コミットの変更ファイル一覧を取得
pub fn get_commit_files(commit_hash: &str) -> Result<Vec<String>> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_commit_files_from_repo(&repo, commit_hash)
}

/// Repositoryからコミットの変更ファイル一覧を取得
pub fn get_commit_files_from_repo(repo: &Repository, commit_hash: &str) -> Result<Vec<String>> {
    // コミットを解決
    let obj = repo
        .revparse_single(commit_hash)
        .context("コミットが見つかりません")?;
    let commit = obj.peel_to_commit().context("コミットに変換できません")?;

    let tree = commit.tree()?;
    let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

    let diff = repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), None)?;

    let mut files = Vec::new();
    diff.foreach(
        &mut |delta, _| {
            if let Some(path) = delta.new_file().path() {
                if let Some(path_str) = path.to_str() {
                    files.push(path_str.to_string());
                }
            }
            true
        },
        None,
        None,
        None,
    )?;

    Ok(files)
}

/// コミット履歴をGitEventとして取得
pub fn load_events(limit: usize) -> Result<Vec<GitEvent>> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    load_events_from_repo(&repo, limit)
}

/// Repositoryからコミット履歴をGitEventとして取得
pub fn load_events_from_repo(repo: &Repository, limit: usize) -> Result<Vec<GitEvent>> {
    // 全ブランチのHEADコミットを収集（ラベル付け用）
    let mut branch_heads: std::collections::HashMap<String, Vec<String>> =
        std::collections::HashMap::new();

    if let Ok(branches) = repo.branches(Some(git2::BranchType::Local)) {
        for (branch, _) in branches.flatten() {
            if let (Some(name), Ok(commit)) =
                (branch.name().ok().flatten(), branch.get().peel_to_commit())
            {
                let short_hash = commit.id().to_string()[..7].to_string();
                branch_heads
                    .entry(short_hash)
                    .or_default()
                    .push(name.to_string());
            }
        }
    }

    let mut revwalk = repo.revwalk()?;
    // TIME | TOPOLOGICAL で、同じ秒内のコミットもトポロジカル順で正しくソート
    revwalk.set_sorting(Sort::TIME | Sort::TOPOLOGICAL)?;
    // 全ローカルブランチのコミットを取得
    revwalk.push_glob("refs/heads/*")?;

    let mut events = Vec::new();

    for oid in revwalk.take(limit) {
        let oid = oid?;
        let commit = repo.find_commit(oid)?;

        let short_hash = oid.to_string()[..7].to_string();
        let message = commit
            .message()
            .unwrap_or("")
            .lines()
            .next()
            .unwrap_or("")
            .to_string();
        let author = commit.author().name().unwrap_or("unknown").to_string();
        let timestamp = Local
            .timestamp_opt(commit.time().seconds(), 0)
            .single()
            .unwrap_or_else(Local::now);

        // マージコミットかどうかを判定（親が2つ以上）
        let kind = if commit.parent_count() > 1 {
            GitEventKind::Merge
        } else {
            GitEventKind::Commit
        };

        // 親コミットのハッシュを取得
        let parent_hashes: Vec<String> = (0..commit.parent_count())
            .filter_map(|i| commit.parent_id(i).ok())
            .map(|oid| oid.to_string()[..7].to_string())
            .collect();

        // diff統計を取得
        let diff_stats = get_commit_diff_stats(repo, &commit);

        // ブランチラベルを取得
        let labels = branch_heads.get(&short_hash).cloned().unwrap_or_default();

        let event = match kind {
            GitEventKind::Merge => GitEvent::merge(short_hash, message, author, timestamp)
                .with_parents(parent_hashes)
                .with_labels(labels),
            _ => GitEvent::commit(
                short_hash,
                message,
                author,
                timestamp,
                diff_stats.insertions,
                diff_stats.deletions,
            )
            .with_parents(parent_hashes)
            .with_labels(labels),
        };

        events.push(event);
    }

    Ok(events)
}

// ============================================================
// キャッシュ対応版関数（パフォーマンス最適化用）
// Option<&Repository>を受け取り、Noneの場合はフォールバックでdiscover()を使用
// ============================================================

/// HEADのハッシュを取得（キャッシュ対応版）
pub fn get_head_hash_cached(repo: Option<&Repository>) -> Result<String> {
    match repo {
        Some(r) => get_head_hash_from_repo(r),
        None => get_head_hash(),
    }
}

/// インデックスの更新時刻を取得（キャッシュ対応版）
pub fn get_index_mtime_cached(repo: Option<&Repository>) -> Result<SystemTime> {
    match repo {
        Some(r) => get_index_mtime_from_repo(r),
        None => get_index_mtime(),
    }
}

/// ワーキングディレクトリのステータスを取得（キャッシュ対応版）
pub fn get_status_cached(repo: Option<&Repository>) -> Result<Vec<FileStatus>> {
    match repo {
        Some(r) => get_status_from_repo(r),
        None => get_status(),
    }
}

/// ローカルブランチ一覧を取得（キャッシュ対応版）
pub fn list_branches_cached(repo: Option<&Repository>) -> Result<Vec<String>> {
    match repo {
        Some(r) => list_branches_from_repo(r),
        None => list_branches(),
    }
}

/// リポジトリ情報を取得（キャッシュ対応版）
pub fn get_repo_info_cached(repo: Option<&Repository>) -> Result<RepoInfo> {
    match repo {
        Some(r) => RepoInfo::from_repo(r),
        None => RepoInfo::from_current_dir(),
    }
}

/// Blameの1行分のデータ
#[derive(Debug, Clone)]
pub struct BlameLine {
    /// コミットハッシュ（短縮）
    pub hash: String,
    /// 著者名
    pub author: String,
    /// コミット日時
    pub date: chrono::DateTime<Local>,
    /// 行番号（1始まり）
    pub line_number: usize,
    /// 行の内容
    pub content: String,
}

/// ファイル履歴のエントリ
#[derive(Debug, Clone)]
pub struct FileHistoryEntry {
    /// コミットハッシュ（短縮）
    pub hash: String,
    /// 著者名
    pub author: String,
    /// コミット日時
    pub date: chrono::DateTime<Local>,
    /// コミットメッセージ（1行目）
    pub message: String,
    /// 追加行数
    pub insertions: usize,
    /// 削除行数
    pub deletions: usize,
}

/// 特定ファイルの変更履歴を取得
pub fn get_file_history(path: &str) -> Result<Vec<FileHistoryEntry>> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_file_history_from_repo(&repo, path)
}

/// Repositoryから特定ファイルの変更履歴を取得
pub fn get_file_history_from_repo(repo: &Repository, path: &str) -> Result<Vec<FileHistoryEntry>> {
    use std::cell::RefCell;

    let mut revwalk = repo.revwalk()?;
    revwalk.set_sorting(Sort::TIME | Sort::TOPOLOGICAL)?;
    revwalk.push_head()?;

    let mut entries = Vec::new();
    let path_obj = std::path::Path::new(path);

    for oid in revwalk {
        let oid = oid?;
        let commit = repo.find_commit(oid)?;

        let tree = commit.tree()?;
        let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

        // diffを取得してパスが含まれているかチェック
        let diff = repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), None)?;

        let found: RefCell<bool> = RefCell::new(false);
        let insertions: RefCell<usize> = RefCell::new(0);
        let deletions: RefCell<usize> = RefCell::new(0);

        diff.foreach(
            &mut |delta, _| {
                let new_path = delta.new_file().path();
                let old_path = delta.old_file().path();
                if new_path == Some(path_obj) || old_path == Some(path_obj) {
                    *found.borrow_mut() = true;
                }
                true
            },
            None,
            None,
            Some(&mut |delta, _hunk, line| {
                let new_path = delta.new_file().path();
                let old_path = delta.old_file().path();
                if new_path == Some(path_obj) || old_path == Some(path_obj) {
                    match line.origin() {
                        '+' => *insertions.borrow_mut() += 1,
                        '-' => *deletions.borrow_mut() += 1,
                        _ => {}
                    }
                }
                true
            }),
        )?;

        if *found.borrow() {
            let short_hash = oid.to_string()[..7].to_string();
            let message = commit
                .message()
                .unwrap_or("")
                .lines()
                .next()
                .unwrap_or("")
                .to_string();
            let author = commit.author().name().unwrap_or("unknown").to_string();
            let timestamp = Local
                .timestamp_opt(commit.time().seconds(), 0)
                .single()
                .unwrap_or_else(Local::now);

            entries.push(FileHistoryEntry {
                hash: short_hash,
                author,
                date: timestamp,
                message,
                insertions: *insertions.borrow(),
                deletions: *deletions.borrow(),
            });
        }

        // 最大100件まで
        if entries.len() >= 100 {
            break;
        }
    }

    Ok(entries)
}

/// ファイルのblame情報を取得
pub fn get_blame(path: &str) -> Result<Vec<BlameLine>> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    get_blame_from_repo(&repo, path)
}

/// Repositoryからファイルのblame情報を取得
pub fn get_blame_from_repo(repo: &Repository, path: &str) -> Result<Vec<BlameLine>> {
    validate_path(path)?;

    let blame = repo
        .blame_file(std::path::Path::new(path), None)
        .context("Blameの取得に失敗しました")?;

    let mut lines = Vec::new();

    // ファイルの内容を読み込む
    let workdir = repo
        .workdir()
        .context("ワーキングディレクトリが見つかりません")?;
    let file_path = workdir.join(path);
    let content = std::fs::read_to_string(&file_path).unwrap_or_default();
    let file_lines: Vec<&str> = content.lines().collect();

    for (line_idx, hunk) in blame.iter().enumerate() {
        let oid = hunk.final_commit_id();
        let short_hash = oid.to_string()[..7.min(oid.to_string().len())].to_string();

        // コミット情報を取得
        let (author, date) = if let Ok(commit) = repo.find_commit(oid) {
            let author_name = commit.author().name().unwrap_or("unknown").to_string();
            let timestamp = Local
                .timestamp_opt(commit.time().seconds(), 0)
                .single()
                .unwrap_or_else(Local::now);
            (author_name, timestamp)
        } else {
            ("unknown".to_string(), Local::now())
        };

        let line_content = file_lines.get(line_idx).unwrap_or(&"").to_string();

        lines.push(BlameLine {
            hash: short_hash,
            author,
            date,
            line_number: line_idx + 1,
            content: line_content,
        });
    }

    Ok(lines)
}

// ============================================================
// Stash 関連関数
// ============================================================

use git2::Oid;

/// Stashエントリ
#[derive(Debug, Clone)]
pub struct StashEntry {
    /// インデックス（0始まり）
    pub index: usize,
    /// メッセージ
    pub message: String,
}

/// Stash一覧を取得
pub fn get_stash_list() -> Result<Vec<StashEntry>> {
    let mut repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    let mut entries = Vec::new();

    repo.stash_foreach(|index, message, _oid| {
        entries.push(StashEntry {
            index,
            message: message.to_string(),
        });
        true // 全エントリを走査
    })?;

    Ok(entries)
}

/// 現在の変更をStashに保存
pub fn stash_save(message: &str) -> Result<Oid> {
    let mut repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    let sig = repo
        .signature()
        .or_else(|_| Signature::now("gitstack", "gitstack@local"))?;

    let stash_id = repo.stash_save(&sig, message, None)?;
    Ok(stash_id)
}

/// Stashを適用（削除しない）
pub fn stash_apply(index: usize) -> Result<()> {
    let mut repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    repo.stash_apply(index, None)?;
    Ok(())
}

/// Stashをpop（適用して削除）
pub fn stash_pop(index: usize) -> Result<()> {
    let mut repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    repo.stash_pop(index, None)?;
    Ok(())
}

/// Stashを削除
pub fn stash_drop(index: usize) -> Result<()> {
    let mut repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    repo.stash_drop(index)?;
    Ok(())
}

/// 2つのブランチを比較
pub fn compare_branches(base: &str, target: &str) -> Result<crate::compare::BranchCompare> {
    let repo = Repository::discover(".").context("Gitリポジトリが見つかりません")?;
    compare_branches_from_repo(&repo, base, target)
}

/// Repositoryから2つのブランチを比較
pub fn compare_branches_from_repo(
    repo: &Repository,
    base: &str,
    target: &str,
) -> Result<crate::compare::BranchCompare> {
    use crate::compare::BranchCompare;

    // ブランチのコミットを取得
    let base_obj = repo
        .revparse_single(base)
        .context(format!("ブランチ '{}' が見つかりません", base))?;
    let target_obj = repo
        .revparse_single(target)
        .context(format!("ブランチ '{}' が見つかりません", target))?;

    let base_commit = base_obj.peel_to_commit()?;
    let target_commit = target_obj.peel_to_commit()?;

    // マージベースを計算
    let merge_base_oid = repo
        .merge_base(base_commit.id(), target_commit.id())
        .context("マージベースが見つかりません")?;
    let merge_base = merge_base_oid.to_string()[..7].to_string();

    // aheadコミット（target にあって base にない）
    let ahead_commits = get_commits_between(repo, merge_base_oid, target_commit.id())?;

    // behindコミット（base にあって target にない）
    let behind_commits = get_commits_between(repo, merge_base_oid, base_commit.id())?;

    Ok(BranchCompare {
        base_branch: base.to_string(),
        target_branch: target.to_string(),
        ahead_commits,
        behind_commits,
        merge_base,
    })
}

/// 2つのコミット間のコミット一覧を取得（from は含まず、to は含む）
fn get_commits_between(
    repo: &Repository,
    from: git2::Oid,
    to: git2::Oid,
) -> Result<Vec<crate::compare::CompareCommit>> {
    use crate::compare::CompareCommit;

    if from == to {
        return Ok(Vec::new());
    }

    let mut revwalk = repo.revwalk()?;
    revwalk.push(to)?;
    revwalk.hide(from)?;
    revwalk.set_sorting(Sort::TOPOLOGICAL | Sort::TIME)?;

    let mut commits = Vec::new();
    for oid_result in revwalk {
        let oid = oid_result?;
        let commit = repo.find_commit(oid)?;

        let message = commit
            .message()
            .unwrap_or("")
            .lines()
            .next()
            .unwrap_or("")
            .to_string();
        let author = commit.author().name().unwrap_or("Unknown").to_string();
        let date = Local.timestamp_opt(commit.time().seconds(), 0).unwrap();

        commits.push(CompareCommit {
            hash: oid.to_string()[..7].to_string(),
            message,
            author,
            date,
        });
    }

    Ok(commits)
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use std::path::Path;
    use tempfile::TempDir;

    fn init_test_repo() -> (TempDir, Repository) {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let repo = Repository::init(temp_dir.path()).expect("Failed to init repo");

        // 初期コミットを作成
        let sig = git2::Signature::now("Test Author", "test@example.com").unwrap();
        let tree_id = {
            let mut index = repo.index().unwrap();
            let test_file = temp_dir.path().join("test.txt");
            fs::write(&test_file, "test content").unwrap();
            index.add_path(Path::new("test.txt")).unwrap();
            index.write().unwrap();
            index.write_tree().unwrap()
        };
        {
            let tree = repo.find_tree(tree_id).unwrap();
            repo.commit(Some("HEAD"), &sig, &sig, "Initial commit", &tree, &[])
                .unwrap();
        }

        (temp_dir, repo)
    }

    #[test]
    fn test_repo_info_from_repo_gets_name() {
        let (_temp_dir, repo) = init_test_repo();
        let info = RepoInfo::from_repo(&repo).unwrap();
        assert!(!info.name.is_empty());
    }

    #[test]
    fn test_repo_info_from_repo_gets_branch() {
        let (_temp_dir, repo) = init_test_repo();
        let info = RepoInfo::from_repo(&repo).unwrap();
        // 初期ブランチはmasterまたはmain
        assert!(info.branch == "master" || info.branch == "main");
    }

    #[test]
    fn test_load_events_from_repo_returns_events() {
        let (_temp_dir, repo) = init_test_repo();
        let events = load_events_from_repo(&repo, 10).unwrap();
        assert!(!events.is_empty());
    }

    #[test]
    fn test_load_events_from_repo_first_event_is_initial_commit() {
        let (_temp_dir, repo) = init_test_repo();
        let events = load_events_from_repo(&repo, 10).unwrap();
        assert_eq!(events[0].message, "Initial commit");
    }

    #[test]
    fn test_load_events_from_repo_respects_limit() {
        let (temp_dir, repo) = init_test_repo();

        // 追加のコミットを作成
        let sig = git2::Signature::now("Test Author", "test@example.com").unwrap();
        for i in 1..=5 {
            let test_file = temp_dir.path().join(format!("file{}.txt", i));
            fs::write(&test_file, format!("content {}", i)).unwrap();
            let mut index = repo.index().unwrap();
            index
                .add_path(Path::new(&format!("file{}.txt", i)))
                .unwrap();
            index.write().unwrap();
            let tree_id = index.write_tree().unwrap();
            let tree = repo.find_tree(tree_id).unwrap();
            let parent = repo.head().unwrap().peel_to_commit().unwrap();
            repo.commit(
                Some("HEAD"),
                &sig,
                &sig,
                &format!("Commit {}", i),
                &tree,
                &[&parent],
            )
            .unwrap();
        }

        let events = load_events_from_repo(&repo, 3).unwrap();
        assert_eq!(events.len(), 3);
    }

    #[test]
    fn test_load_events_from_repo_returns_commits_in_order() {
        let (temp_dir, repo) = init_test_repo();

        // 追加のコミットを作成
        let sig = git2::Signature::now("Test Author", "test@example.com").unwrap();
        for i in 1..=3 {
            let test_file = temp_dir.path().join(format!("file{}.txt", i));
            fs::write(&test_file, format!("content {}", i)).unwrap();
            let mut index = repo.index().unwrap();
            index
                .add_path(Path::new(&format!("file{}.txt", i)))
                .unwrap();
            index.write().unwrap();
            let tree_id = index.write_tree().unwrap();
            let tree = repo.find_tree(tree_id).unwrap();
            let parent = repo.head().unwrap().peel_to_commit().unwrap();
            repo.commit(
                Some("HEAD"),
                &sig,
                &sig,
                &format!("Commit {}", i),
                &tree,
                &[&parent],
            )
            .unwrap();
        }

        let events = load_events_from_repo(&repo, 10).unwrap();
        // 4つのコミットがある
        assert_eq!(events.len(), 4);
        // 最新のコミット(Commit 3)が含まれている
        assert!(events.iter().any(|e| e.message == "Commit 3"));
        // Initial commitが含まれている
        assert!(events.iter().any(|e| e.message == "Initial commit"));
    }

    #[test]
    fn test_load_events_from_repo_event_has_short_hash() {
        let (_temp_dir, repo) = init_test_repo();
        let events = load_events_from_repo(&repo, 10).unwrap();
        assert_eq!(events[0].short_hash.len(), 7);
    }

    #[test]
    fn test_load_events_from_repo_event_has_author() {
        let (_temp_dir, repo) = init_test_repo();
        let events = load_events_from_repo(&repo, 10).unwrap();
        assert_eq!(events[0].author, "Test Author");
    }

    #[test]
    fn test_load_events_from_repo_event_has_file_stats() {
        let (_temp_dir, repo) = init_test_repo();
        let events = load_events_from_repo(&repo, 10).unwrap();
        // Initial commitは1ファイル追加（test content = 12文字 + 改行なし）
        assert!(events[0].files_added > 0);
    }

    #[test]
    fn test_get_commit_diff_stats_returns_stats() {
        let (_temp_dir, repo) = init_test_repo();
        let commit = repo.head().unwrap().peel_to_commit().unwrap();
        let stats = get_commit_diff_stats(&repo, &commit);
        // Initial commitは1ファイル、1行追加
        assert!(stats.files_changed > 0 || stats.insertions > 0);
    }

    #[test]
    fn test_list_branches_from_repo_returns_branches() {
        let (_temp_dir, repo) = init_test_repo();
        let branches = list_branches_from_repo(&repo).unwrap();
        assert!(!branches.is_empty());
    }

    #[test]
    fn test_list_branches_from_repo_includes_current_branch() {
        let (_temp_dir, repo) = init_test_repo();
        let branches = list_branches_from_repo(&repo).unwrap();
        // 初期ブランチはmasterまたはmain
        assert!(branches.contains(&"master".to_string()) || branches.contains(&"main".to_string()));
    }

    #[test]
    fn test_checkout_branch_in_repo_switches_branch() {
        let (_temp_dir, repo) = init_test_repo();

        // 新しいブランチを作成
        {
            let head = repo.head().unwrap().peel_to_commit().unwrap();
            repo.branch("test-branch", &head, false).unwrap();
        }

        // ブランチを切り替え
        checkout_branch_in_repo(&repo, "test-branch").unwrap();

        // 現在のブランチを確認
        let info = RepoInfo::from_repo(&repo).unwrap();
        assert_eq!(info.branch, "test-branch");
    }

    #[test]
    fn test_get_status_from_repo_empty_on_clean() {
        let (_temp_dir, repo) = init_test_repo();
        let statuses = get_status_from_repo(&repo).unwrap();
        assert!(statuses.is_empty());
    }

    #[test]
    fn test_get_status_from_repo_detects_modified() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("test.txt"), "modified content").unwrap();

        let statuses = get_status_from_repo(&repo).unwrap();
        assert!(statuses.iter().any(|s| s.kind == FileStatusKind::Modified));
    }

    #[test]
    fn test_get_status_from_repo_detects_untracked() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("new_file.txt"), "new content").unwrap();

        let statuses = get_status_from_repo(&repo).unwrap();
        assert!(statuses.iter().any(|s| s.kind == FileStatusKind::Untracked));
    }

    #[test]
    fn test_stage_file_in_repo_stages_file() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("new_file.txt"), "new content").unwrap();

        stage_file_in_repo(&repo, "new_file.txt").unwrap();

        let statuses = get_status_from_repo(&repo).unwrap();
        assert!(statuses.iter().any(|s| s.kind == FileStatusKind::StagedNew));
    }

    #[test]
    fn test_unstage_file_in_repo_unstages_file() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("new_file.txt"), "new content").unwrap();

        stage_file_in_repo(&repo, "new_file.txt").unwrap();
        unstage_file_in_repo(&repo, "new_file.txt").unwrap();

        let statuses = get_status_from_repo(&repo).unwrap();
        assert!(!statuses.iter().any(|s| s.kind == FileStatusKind::StagedNew));
        assert!(statuses.iter().any(|s| s.kind == FileStatusKind::Untracked));
    }

    #[test]
    fn test_create_commit_in_repo_creates_commit() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("new_file.txt"), "new content").unwrap();
        stage_file_in_repo(&repo, "new_file.txt").unwrap();

        create_commit_in_repo(&repo, "Test commit").unwrap();

        let events = load_events_from_repo(&repo, 10).unwrap();
        assert!(events.iter().any(|e| e.message == "Test commit"));
    }

    #[test]
    fn test_has_staged_files_in_repo_returns_false_when_empty() {
        let (_temp_dir, repo) = init_test_repo();
        assert!(!has_staged_files_in_repo(&repo).unwrap());
    }

    #[test]
    fn test_has_staged_files_in_repo_returns_true_when_staged() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("new_file.txt"), "new content").unwrap();
        stage_file_in_repo(&repo, "new_file.txt").unwrap();

        assert!(has_staged_files_in_repo(&repo).unwrap());
    }

    #[test]
    fn test_stage_all_in_repo_stages_all_files() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("file1.txt"), "content1").unwrap();
        fs::write(temp_dir.path().join("file2.txt"), "content2").unwrap();

        stage_all_in_repo(&repo).unwrap();

        let statuses = get_status_from_repo(&repo).unwrap();
        let staged_count = statuses
            .iter()
            .filter(|s| matches!(s.kind, FileStatusKind::StagedNew))
            .count();
        assert_eq!(staged_count, 2);
    }

    #[test]
    fn test_unstage_all_in_repo_unstages_all_files() {
        let (temp_dir, repo) = init_test_repo();
        fs::write(temp_dir.path().join("file1.txt"), "content1").unwrap();
        fs::write(temp_dir.path().join("file2.txt"), "content2").unwrap();
        stage_all_in_repo(&repo).unwrap();

        unstage_all_in_repo(&repo).unwrap();

        let statuses = get_status_from_repo(&repo).unwrap();
        let staged_count = statuses
            .iter()
            .filter(|s| {
                matches!(
                    s.kind,
                    FileStatusKind::StagedNew
                        | FileStatusKind::StagedModified
                        | FileStatusKind::StagedDeleted
                )
            })
            .count();
        assert_eq!(staged_count, 0);
    }

    #[test]
    fn test_sort_branches_current_first() {
        let mut branches = vec![
            "develop".to_string(),
            "feature/foo".to_string(),
            "main".to_string(),
        ];
        sort_branches(&mut branches, Some("feature/foo"));
        assert_eq!(branches[0], "feature/foo"); // 現在のブランチが最初
    }

    #[test]
    fn test_sort_branches_priority_order() {
        let mut branches = vec![
            "develop".to_string(),
            "feature/foo".to_string(),
            "main".to_string(),
            "master".to_string(),
        ];
        sort_branches(&mut branches, None);
        // main → master → develop → feature/foo の順
        assert_eq!(branches[0], "main");
        assert_eq!(branches[1], "master");
        assert_eq!(branches[2], "develop");
        assert_eq!(branches[3], "feature/foo");
    }

    #[test]
    fn test_sort_branches_current_takes_precedence_over_priority() {
        let mut branches = vec![
            "develop".to_string(),
            "main".to_string(),
            "feature/foo".to_string(),
        ];
        sort_branches(&mut branches, Some("develop"));
        // develop（現在）→ main → feature/foo の順
        assert_eq!(branches[0], "develop");
        assert_eq!(branches[1], "main");
        assert_eq!(branches[2], "feature/foo");
    }

    #[test]
    fn test_sort_branches_alphabetical_for_non_priority() {
        let mut branches = vec![
            "feature/xyz".to_string(),
            "feature/abc".to_string(),
            "bugfix/123".to_string(),
        ];
        sort_branches(&mut branches, None);
        // アルファベット順
        assert_eq!(branches[0], "bugfix/123");
        assert_eq!(branches[1], "feature/abc");
        assert_eq!(branches[2], "feature/xyz");
    }

    #[test]
    fn test_list_branches_from_repo_current_branch_first() {
        let (_temp_dir, repo) = init_test_repo();

        // 追加のブランチを作成
        {
            let head = repo.head().unwrap().peel_to_commit().unwrap();
            repo.branch("develop", &head, false).unwrap();
            repo.branch("feature/test", &head, false).unwrap();
        }

        let branches = list_branches_from_repo(&repo).unwrap();
        // 現在のブランチ（master または main）が最初
        let current = repo.head().unwrap().shorthand().unwrap().to_string();
        assert_eq!(branches[0], current);
    }

    #[test]
    fn test_validate_path_rejects_parent_dir() {
        assert!(validate_path("../etc/passwd").is_err());
        assert!(validate_path("foo/../bar").is_err());
    }

    #[test]
    fn test_validate_path_rejects_null_char() {
        assert!(validate_path("foo\0bar").is_err());
    }

    #[test]
    fn test_validate_path_accepts_valid_paths() {
        assert!(validate_path("src/main.rs").is_ok());
        assert!(validate_path("file.txt").is_ok());
    }

    #[test]
    fn test_validate_branch_name_rejects_empty() {
        assert!(validate_branch_name("").is_err());
    }

    #[test]
    fn test_validate_branch_name_rejects_null_char() {
        assert!(validate_branch_name("main\0").is_err());
    }

    #[test]
    fn test_validate_branch_name_accepts_valid() {
        assert!(validate_branch_name("main").is_ok());
        assert!(validate_branch_name("feature/new-feature").is_ok());
    }
}