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};

/// 現在の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,
}

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

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

/// コミットの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(),
    }
}

/// リポジトリ情報
#[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からローカルブランチ一覧を取得
pub fn list_branches_from_repo(repo: &Repository) -> Result<Vec<String>> {
    let branches = repo.branches(Some(git2::BranchType::Local))?;
    let mut branch_names: Vec<String> = branches
        .filter_map(|b| b.ok())
        .filter_map(|(branch, _)| branch.name().ok().flatten().map(|s| s.to_string()))
        .collect();
    branch_names.sort();
    Ok(branch_names)
}

/// ブランチを切り替え
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<()> {
    let obj = repo
        .revparse_single(&format!("refs/heads/{}", branch_name))
        .context("ブランチが見つかりません")?;
    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<()> {
    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<()> {
    let head = repo.head()?.peel_to_commit()?;
    repo.reset_default(Some(&head.into_object()), [std::path::Path::new(path)])?;
    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
        )
    }))
}

/// コミット履歴を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>> {
    let mut revwalk = repo.revwalk()?;
    // TIME | TOPOLOGICAL で、同じ秒内のコミットもトポロジカル順で正しくソート
    revwalk.set_sorting(Sort::TIME | Sort::TOPOLOGICAL)?;
    revwalk.push_head()?;

    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
        };

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

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

        events.push(event);
    }

    Ok(events)
}

#[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());
    }
}