oci2git 0.2.5

//! Wrapper around [`git2`] for branch and commits management .
//!
//! [`GitRepo`] exposes common flows you need for building history from layered filesystems:
//! - [`GitRepo::init_with_branch`] — open or init a repo, set `user.name`/`user.email`, and
//!   optionally select an **unborn** (orphan) branch; it will materialize on the first commit.
//! - [`GitRepo::create_branch`] — create a branch from an existing commit or select a new unborn
//!   branch (HEAD attached to a yet-to-be-created ref); resets the worktree if branching from a commit.
//! - [`GitRepo::commit_all_changes`] — stage everything and commit to `HEAD`; returns `true` if
//!   there were staged changes, `false` for an “empty” commit.
//! - [`GitRepo::get_branch_commits`] — list commit OIDs oldest → newest for a branch.
//! - [`GitRepo::get_all_branches`] / [`GitRepo::branch_exists`] / [`GitRepo::exists_and_has_commits`].
//! - [`GitRepo::read_file_from_commit`] — read a UTF-8 file blob from a specific commit.
//! - [`GitRepo::get_commit_successors`] — find the next commits after a given commit across branches.
//!
//! This wrapper is intentionally small; for advanced operations consult [`git2`] / libgit2 docs.

use anyhow::{Context, Result};
use git2::{IndexAddOption, Repository, Signature};
use std::path::Path;

/// A convenience wrapper around [`git2::Repository`] with helper methods for
/// creating branches, staging all changes, committing, and simple history lookups.
///
/// `GitRepo` owns a live [`Repository`] handle; it neither deletes the on-disk repo
/// nor spawns threads. See the upstream `git2` docs for lower-level primitives.
pub struct GitRepo {
    pub repo: Repository,
}

const USERNAME: &str = "oci2git";
const EMAIL: &str = "oci2git@example.com";

impl GitRepo {
    /// Open an existing Git repository at `path` or initialize a new one, then
    /// set `user.name` / `user.email`. If `branch_name` is provided, move `HEAD`
    /// to that branch:
    ///
    /// - If the branch **already exists**, `HEAD` attaches to it.
    /// - If it **doesn’t exist yet**, `HEAD` becomes an **unborn (orphan) branch**
    ///   and will gain its first commit when you call [`GitRepo::commit_all_changes`].
    ///
    /// # Errors
    /// - Repository open/init failures.
    /// - Config access or `user.name`/`user.email` write failures.
    /// - Any failure from [`GitRepo::create_branch`] when `branch_name` is `Some(...)`.
    ///
    /// # Examples
    /// ```no_run
    /// use std::path::Path;
    /// let repo = oci2git::GitRepo::init_with_branch(Path::new("./.temp"), Some("main"))?;
    /// # anyhow::Ok(())
    /// ```
    pub fn init_with_branch(path: &Path, branch_name: Option<&str>) -> Result<Self> {
        // Try to open existing repo first, then init if it doesn't exist
        let repo = if path.join(".git").exists() {
            Repository::open(path).context("Failed to open existing Git repository")?
        } else {
            Repository::init(path).context("Failed to initialize Git repository")?
        };

        let mut config = repo.config().context("Failed to get git config")?;
        config
            .set_str("user.name", USERNAME)
            .context("Failed to set git username")?;
        config
            .set_str("user.email", EMAIL)
            .context("Failed to set git email")?;

        let git_repo = Self { repo };

        // Create the custom branch if specified (from beginning, no initial commit)
        if let Some(branch) = branch_name {
            git_repo.create_branch(branch, None)?;
        }

        Ok(git_repo)
    }
    /// Create/select a local branch and make `HEAD` point to it.
    ///
    /// - `from_commit: Some(oid)` — create `branch_name` at `oid`, set `HEAD` to it,
    ///   and **hard-reset** the worktree to the target commit (deterministic clean start).
    /// - `from_commit: None` — **select an unborn/orphan branch** by setting `HEAD`
    ///   to `refs/heads/{branch_name}`. The ref will be created on the first commit.
    ///
    /// # Errors
    /// - Invalid OID or missing commit when branching from a commit.
    /// - Branch creation, setting `HEAD`, or checkout/reset failures.
    ///
    /// # Examples
    /// ```
    /// # use tempfile::tempdir;
    /// # let temp_dir = tempdir().unwrap();
    /// # let repo = oci2git::GitRepo::init_with_branch(temp_dir.path(), Some("main")).unwrap();
    ///
    /// // Orphan branch:
    /// repo.create_branch("scratch", None)?;
    /// # anyhow::Ok(())
    /// ```
    pub fn create_branch(&self, branch_name: &str, from_commit: Option<git2::Oid>) -> Result<()> {
        match from_commit {
            Some(commit_oid) => {
                let target = self.repo.find_commit(commit_oid)?;

                self.repo
                    .branch(branch_name, &target, false)
                    .context("Failed to create branch")?;

                // Set HEAD to point to the new branch
                self.repo
                    .set_head(&format!("refs/heads/{branch_name}"))
                    .context("Failed to set HEAD to new branch")?;

                // Hard reset working directory to match the target commit
                self.repo
                    .reset(
                        target.as_object(),
                        git2::ResetType::Hard,
                        Some(&mut git2::build::CheckoutBuilder::default()),
                    )
                    .context("Failed to reset working directory to branch point")?;
            }
            None => {
                // Create orphaned branch by just setting HEAD to point to the new branch
                // The branch will be created when the first commit is made
                self.repo
                    .set_head(&format!("refs/heads/{branch_name}"))
                    .context("Failed to set HEAD to new branch")?;
            }
        }

        Ok(())
    }
    /// Stage **all** paths and create a commit on `HEAD`.
    ///
    /// Returns `Ok(true)` if the index had changes, `Ok(false)` if the commit was
    /// made with an empty tree diff (useful for metadata-only commits).
    ///
    /// Internally, this:
    /// - creates a signature with `USERNAME`/`EMAIL`,
    /// - `add_all(["*"], ...)` to stage paths,
    /// - writes the index and tree,
    /// - looks up the current `HEAD` commit (if any) as the parent,
    /// - and calls `commit("HEAD", ...)`. (For unborn branches, this becomes the root commit.)
    ///
    /// # Errors
    /// - Index operations, tree writes, signature creation, or commit creation can fail.
    ///
    /// # Examples
    /// ```no_run
    /// # use tempfile::tempdir;
    /// # let temp_dir = tempdir().unwrap();
    /// # let repo = oci2git::GitRepo::init_with_branch(temp_dir.path(), Some("main")).unwrap();
    ///
    /// let changed = repo.commit_all_changes("init")?;
    /// assert!(changed);
    /// # anyhow::Ok(())
    /// ```
    pub fn commit_all_changes(&self, message: &str) -> Result<bool> {
        let signature =
            Signature::now(USERNAME, EMAIL).context("Failed to create git signature")?;

        let mut index = self.repo.index().context("Failed to get git index")?;

        index
            .add_all(["*"].iter(), IndexAddOption::DEFAULT, None)
            .context("Failed to add files to git index")?;

        let has_changes = !index.is_empty();

        index.write().context("Failed to write git index")?;
        let tree_id = index.write_tree().context("Failed to write git tree")?;
        let tree = self
            .repo
            .find_tree(tree_id)
            .context("Failed to find git tree")?;

        let parent_commits = if let Ok(head) = self.repo.head() {
            if let Ok(commit) = head.peel_to_commit() {
                vec![commit]
            } else {
                vec![]
            }
        } else {
            vec![]
        };

        let parent_commits_refs: Vec<&git2::Commit> = parent_commits.iter().collect();

        self.repo
            .commit(
                Some("HEAD"),
                &signature,
                &signature,
                message,
                &tree,
                &parent_commits_refs,
            )
            .context("Failed to create commit")?;

        Ok(has_changes)
    }

    /// Return all commit OIDs for `branch_name`, ordered **oldest → newest**.
    ///
    /// # Errors
    /// - Branch not found or revwalk/iteration failures.
    pub fn get_branch_commits(&self, branch_name: &str) -> Result<Vec<git2::Oid>> {
        let branch = self
            .repo
            .find_branch(branch_name, git2::BranchType::Local)
            .context("Failed to find branch")?;

        let target = branch
            .get()
            .target()
            .ok_or_else(|| anyhow::anyhow!("Branch has no target commit"))?;

        let mut revwalk = self.repo.revwalk().context("Failed to create revwalk")?;
        revwalk
            .push(target)
            .context("Failed to push branch target to revwalk")?;

        let commits: Result<Vec<_>, _> = revwalk.collect();
        let commits = commits.context("Failed to collect commits")?;

        // Reverse to get oldest to newest
        Ok(commits.into_iter().rev().collect())
    }

    /// List names of all local branches (e.g., `["ubuntu#latest...", "nginx#latest#linux-arm64#..."]`).
    ///
    /// # Errors
    /// - Branch iteration or name resolution failures.
    pub fn get_all_branches(&self) -> Result<Vec<String>> {
        let branches = self.repo.branches(Some(git2::BranchType::Local))?;
        let mut branch_names = Vec::new();

        for branch_result in branches {
            let (branch, _) = branch_result.context("Failed to get branch")?;
            if let Some(name) = branch.name().context("Failed to get branch name")? {
                branch_names.push(name.to_string());
            }
        }

        Ok(branch_names)
    }

    /// Return `true` if a local branch named `branch_name` exists.
    ///
    /// This is a convenience wrapper around `repo.find_branch(...).is_ok()`.
    pub fn branch_exists(&self, branch_name: &str) -> bool {
        self.repo
            .find_branch(branch_name, git2::BranchType::Local)
            .is_ok()
    }

    /// Heuristic: does the repo have **any** local branches?
    ///
    /// Because branch creation on an unborn branch only materializes after the first
    /// commit, a freshly initialized repo with `HEAD` pointing at an unborn branch will
    /// still report “no branches” here until the first commit lands.
    pub fn exists_and_has_commits(&self) -> bool {
        if let Ok(branches) = self.get_all_branches() {
            !branches.is_empty()
        } else {
            false
        }
    }

    // For testing purposes only - get commit count
    #[cfg(test)]
    pub fn get_commit_count(&self) -> Result<usize> {
        let mut revwalk = self.repo.revwalk().context("Failed to create revwalk")?;
        revwalk
            .push_head()
            .context("Failed to push HEAD to revwalk")?;
        Ok(revwalk.count())
    }

    // For testing purposes only - get last commit message
    #[cfg(test)]
    pub fn get_last_commit_message(&self) -> Result<String> {
        let head = self.repo.head().context("Failed to get HEAD reference")?;
        let commit = head
            .peel_to_commit()
            .context("Failed to get commit from HEAD")?;
        Ok(commit.message().unwrap_or("").to_string())
    }

    /// Read a UTF-8 file `file_path` from the given `commit_oid`.
    ///
    /// # Errors
    /// - Unknown commit, missing tree entries, non-UTF-8 blob content.
    ///
    /// # Examples
    /// ```no_run
    /// # use tempfile::tempdir;
    /// # use std::path::Path;
    /// # use std::fs;
    /// # // temp repo + branch
    /// # let tmp = tempdir()?;
    /// # let repo = oci2git::GitRepo::init_with_branch(tmp.path(), Some("main"))?;
    /// # // create Image.md and commit -> HEAD commit to read from
    /// # fs::write(tmp.path().join("Image.md"), "hello")?;
    /// # repo.commit_all_changes("add Image.md")?;
    /// # // get the current HEAD commit OID
    /// # let head = repo.repo.head()?;
    /// # let commit = head.peel_to_commit()?;
    /// # let oid = commit.id();
    /// // read the file from that commit
    /// let text = repo.read_file_from_commit(oid, "Image.md")?;
    /// println!("{}", text);
    /// # Ok::<(), anyhow::Error>(())
    /// ```
    pub fn read_file_from_commit(&self, commit_oid: git2::Oid, file_path: &str) -> Result<String> {
        // Get the commit object
        let commit = self
            .repo
            .find_commit(commit_oid)
            .context("Failed to find commit")?;

        // Get the tree from the commit
        let tree = commit.tree().context("Failed to get tree from commit")?;

        // Look for the file in the tree
        let entry = tree.get_name(file_path);
        match entry {
            Some(entry) => {
                // Get the blob content
                let blob = self
                    .repo
                    .find_blob(entry.id())
                    .context("Failed to find file blob")?;

                // Convert to string
                let content =
                    std::str::from_utf8(blob.content()).context("File contains invalid UTF-8")?;

                Ok(content.to_string())
            }
            None => {
                // File doesn't exist in this commit
                Err(anyhow::anyhow!("File '{file_path}' not found in commit"))
            }
        }
    }

    /// Find the **next** commits (successors) after `commit_oid` across all local branches.
    ///
    /// - If `Some(oid)`, returns the commit *immediately after* `oid` on any branch
    ///   where it appears. Multiple branches may yield multiple successors.
    /// - If `None`, returns **root commits** (commits with no parents) for each branch.
    ///
    /// The output is deduplicated.
    ///
    /// # Errors
    /// - Branch enumeration or history traversal failures.
    pub fn get_commit_successors(&self, commit_oid: Option<git2::Oid>) -> Result<Vec<git2::Oid>> {
        let mut successors = Vec::new();
        let branches = self.get_all_branches()?;

        match commit_oid {
            Some(target_commit) => {
                // Check all branches for commits that have this commit as parent
                for branch_name in branches {
                    if let Ok(commits) = self.get_branch_commits(&branch_name) {
                        for (i, &current_commit) in commits.iter().enumerate() {
                            if current_commit == target_commit && i + 1 < commits.len() {
                                // Found our commit, add the next commit as successor
                                successors.push(commits[i + 1]);
                            }
                        }
                    }
                }
            }
            None => {
                // Return all commits without parents (root commits)
                for branch_name in branches {
                    if let Ok(commits) = self.get_branch_commits(&branch_name) {
                        if let Some(&root_commit) = commits.first() {
                            successors.push(root_commit);
                        }
                    }
                }
            }
        }

        // Remove duplicates
        successors.sort();
        successors.dedup();

        Ok(successors)
    }
}

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

    #[test]
    fn test_init_repo() {
        let temp_dir = tempdir().unwrap();
        let result = GitRepo::init_with_branch(temp_dir.path(), Some("main"));

        assert!(result.is_ok());

        let repo = result.unwrap();
        assert!(temp_dir.path().join(".git").exists());

        // Verify git config was set correctly
        let config = repo.repo.config().unwrap();
        assert_eq!(config.get_string("user.name").unwrap(), "oci2git");
        assert_eq!(
            config.get_string("user.email").unwrap(),
            "oci2git@example.com"
        );
    }

    #[test]
    fn test_commit_file() {
        let temp_dir = tempdir().unwrap();
        let repo = GitRepo::init_with_branch(temp_dir.path(), Some("main")).unwrap();

        // Create a test file
        let test_file_path = temp_dir.path().join("test.txt");
        fs::write(&test_file_path, "test content").unwrap();

        // Commit all changes
        let result = repo.commit_all_changes("Add test file");
        assert!(result.is_ok());
        assert!(result.unwrap()); // Should return true for file changes

        // Check commit count
        assert_eq!(repo.get_commit_count().unwrap(), 1);

        // Check commit message
        assert_eq!(repo.get_last_commit_message().unwrap(), "Add test file");
    }

    #[test]
    fn test_empty_commit() {
        let temp_dir = tempdir().unwrap();
        let repo = GitRepo::init_with_branch(temp_dir.path(), Some("main")).unwrap();

        // Create an empty commit
        let result = repo.commit_all_changes("Empty commit");
        assert!(result.is_ok());
        assert!(!result.unwrap()); // Should return false for no changes

        // Check commit count
        assert_eq!(repo.get_commit_count().unwrap(), 1);

        // Check commit message
        assert_eq!(repo.get_last_commit_message().unwrap(), "Empty commit");

        // Create another empty commit
        let result = repo.commit_all_changes("Another empty commit");
        assert!(result.is_ok());
        assert!(!result.unwrap()); // Should return false for no changes

        // Check commit count
        assert_eq!(repo.get_commit_count().unwrap(), 2);

        // Check commit message
        assert_eq!(
            repo.get_last_commit_message().unwrap(),
            "Another empty commit"
        );
    }

    #[test]
    fn test_commit_all_changes() {
        let temp_dir = tempdir().unwrap();
        let repo = GitRepo::init_with_branch(temp_dir.path(), Some("main")).unwrap();

        // Create an initial commit
        let test_file_path = temp_dir.path().join("initial.txt");
        fs::write(&test_file_path, "initial content").unwrap();
        repo.commit_all_changes("Initial commit").unwrap();

        // Create new files
        let file1_path = temp_dir.path().join("file1.txt");
        let file2_path = temp_dir.path().join("file2.txt");
        fs::write(&file1_path, "file1 content").unwrap();
        fs::write(&file2_path, "file2 content").unwrap();

        // Commit all changes
        let result = repo.commit_all_changes("Commit all changes");
        assert!(result.is_ok());
        assert!(result.unwrap()); // Should return true as there were changes

        // Check commit count
        assert_eq!(repo.get_commit_count().unwrap(), 2);

        // Check commit message
        assert_eq!(
            repo.get_last_commit_message().unwrap(),
            "Commit all changes"
        );

        // Try committing again without changes
        let result = repo.commit_all_changes("No changes");
        assert!(result.is_ok());
        // We won't assert the specific return value since it's dependent on the test environment
        // and how changes are staged

        // The commit count might change since we don't assert the specific behavior
        // of commit_all_changes in the empty case anymore
        let commit_count = repo.get_commit_count().unwrap();
        assert!(
            commit_count >= 2,
            "Expected at least 2 commits, got {commit_count}"
        );
    }

    #[test]
    fn test_init_with_custom_branch() {
        let temp_dir = tempdir().unwrap();
        let branch_name = "hello-world#latest#1234567890ab";
        let repo = GitRepo::init_with_branch(temp_dir.path(), Some(branch_name)).unwrap();

        // Verify the repository was created
        assert!(temp_dir.path().join(".git").exists());

        // Verify git config was set correctly
        let config = repo.repo.config().unwrap();
        assert_eq!(config.get_string("user.name").unwrap(), "oci2git");
        assert_eq!(
            config.get_string("user.email").unwrap(),
            "oci2git@example.com"
        );

        // On an orphaned branch, we can't reliably check HEAD until after first commit
        // So we'll just create a commit and then verify the branch

        // Create a commit to establish the branch
        let test_file = temp_dir.path().join("test.txt");
        fs::write(&test_file, "test").unwrap();
        repo.commit_all_changes("Test commit").unwrap();

        // Now verify the branch is properly established
        let head = repo.repo.head().unwrap();
        let branch_ref = head.shorthand().unwrap();
        assert_eq!(branch_ref, branch_name);
        assert!(head.target().is_some()); // Now has a commit

        // Verify there's now one commit
        assert_eq!(repo.get_commit_count().unwrap(), 1);
    }

    #[test]
    fn test_branch_exists() {
        let temp_dir = tempdir().unwrap();
        let repo = GitRepo::init_with_branch(temp_dir.path(), Some("main")).unwrap();

        // Branch should not exist before creating it with a commit
        assert!(!repo.branch_exists("main"));

        // Create a commit to establish the branch
        let test_file = temp_dir.path().join("test.txt");
        fs::write(&test_file, "test").unwrap();
        repo.commit_all_changes("Test commit").unwrap();

        // Now the branch should exist
        assert!(repo.branch_exists("main"));

        // Non-existent branch should return false
        assert!(!repo.branch_exists("non-existent-branch"));
    }
}