heroforge-core 0.2.2

//! Git import builder for importing git repositories into heroforge.
//!
//! This module provides functionality to clone a git repository and import
//! its contents (without history) into a heroforge repository.
//!
//! # Overview
//!
//! The git import feature allows you to:
//! - Clone a git repository to a temporary location
//! - Checkout a specific branch, tag, or commit
//! - Import all files into a new heroforge repository
//! - Optionally filter files during import
//!
//! # Example
//!
//! ```no_run
//! use heroforge_core::Repository;
//!
//! let repo = Repository::init("imported.fossil")?;
//!
//! repo.git_import()
//!     .url("https://github.com/user/project.git")
//!     .branch("main")
//!     .message("Import from git repository")
//!     .author("developer")
//!     .execute()?;
//! # Ok::<(), heroforge_core::FossilError>(())
//! ```

use crate::error::{FossilError, Result};
use crate::repo::Repository;
use std::fs;
use std::path::Path;

/// Builder for importing a git repository into heroforge.
///
/// This builder clones a git repository and imports its contents
/// (without git history) into a heroforge repository as a single commit.
///
/// # Examples
///
/// ## Import from a branch
///
/// ```no_run
/// # use heroforge_core::Repository;
/// # let repo = Repository::init("project.fossil")?;
/// repo.git_import()
///     .url("https://github.com/user/project.git")
///     .branch("main")
///     .message("Initial import from git")
///     .author("developer")
///     .execute()?;
/// # Ok::<(), heroforge_core::FossilError>(())
/// ```
///
/// ## Import from a tag
///
/// ```no_run
/// # use heroforge_core::Repository;
/// # let repo = Repository::init("project.fossil")?;
/// repo.git_import()
///     .url("https://github.com/user/project.git")
///     .tag("v1.0.0")
///     .message("Import v1.0.0 release")
///     .author("developer")
///     .execute()?;
/// # Ok::<(), heroforge_core::FossilError>(())
/// ```
///
/// ## Import with file filtering
///
/// ```no_run
/// # use heroforge_core::Repository;
/// # let repo = Repository::init("project.fossil")?;
/// repo.git_import()
///     .url("https://github.com/user/project.git")
///     .branch("main")
///     .include_pattern("src/**/*.rs")
///     .include_pattern("Cargo.toml")
///     .exclude_pattern("**/test/**")
///     .message("Import source files only")
///     .author("developer")
///     .execute()?;
/// # Ok::<(), heroforge_core::FossilError>(())
/// ```
pub struct GitImportBuilder<'a> {
    repo: &'a Repository,
    git_url: Option<String>,
    branch: Option<String>,
    tag: Option<String>,
    commit: Option<String>,
    message: Option<String>,
    author: Option<String>,
    include_patterns: Vec<String>,
    exclude_patterns: Vec<String>,
    target_branch: Option<String>,
    parent_commit: Option<String>,
}

impl<'a> GitImportBuilder<'a> {
    pub(crate) fn new(repo: &'a Repository) -> Self {
        Self {
            repo,
            git_url: None,
            branch: None,
            tag: None,
            commit: None,
            message: None,
            author: None,
            include_patterns: Vec::new(),
            exclude_patterns: Vec::new(),
            target_branch: None,
            parent_commit: None,
        }
    }

    /// Set the git repository URL to clone.
    ///
    /// Supports HTTPS and SSH URLs.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use heroforge_core::Repository;
    /// # let repo = Repository::init("project.fossil")?;
    /// repo.git_import()
    ///     .url("https://github.com/user/project.git")
    ///     // ...
    /// # ;
    /// # Ok::<(), heroforge_core::FossilError>(())
    /// ```
    pub fn url(mut self, url: &str) -> Self {
        self.git_url = Some(url.to_string());
        self
    }

    /// Checkout a specific branch after cloning.
    ///
    /// If neither branch, tag, nor commit is specified, the default branch is used.
    pub fn branch(mut self, branch: &str) -> Self {
        self.branch = Some(branch.to_string());
        self
    }

    /// Checkout a specific tag after cloning.
    pub fn tag(mut self, tag: &str) -> Self {
        self.tag = Some(tag.to_string());
        self
    }

    /// Checkout a specific commit hash after cloning.
    pub fn commit_hash(mut self, hash: &str) -> Self {
        self.commit = Some(hash.to_string());
        self
    }

    /// Set the commit message for the import.
    pub fn message(mut self, msg: &str) -> Self {
        self.message = Some(msg.to_string());
        self
    }

    /// Set the author for the import commit.
    pub fn author(mut self, author: &str) -> Self {
        self.author = Some(author.to_string());
        self
    }

    /// Add a glob pattern to include files.
    ///
    /// If no include patterns are specified, all files are included.
    /// If any include patterns are specified, only matching files are included.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use heroforge_core::Repository;
    /// # let repo = Repository::init("project.fossil")?;
    /// repo.git_import()
    ///     .url("https://github.com/user/project.git")
    ///     .branch("main")
    ///     .include_pattern("**/*.rs")
    ///     .include_pattern("**/*.toml")
    ///     .message("Import Rust files only")
    ///     .author("developer")
    ///     .execute()?;
    /// # Ok::<(), heroforge_core::FossilError>(())
    /// ```
    pub fn include_pattern(mut self, pattern: &str) -> Self {
        self.include_patterns.push(pattern.to_string());
        self
    }

    /// Add a glob pattern to exclude files.
    ///
    /// Exclude patterns are applied after include patterns.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use heroforge_core::Repository;
    /// # let repo = Repository::init("project.fossil")?;
    /// repo.git_import()
    ///     .url("https://github.com/user/project.git")
    ///     .branch("main")
    ///     .exclude_pattern("**/test/**")
    ///     .exclude_pattern("**/*.md")
    ///     .message("Import without tests and docs")
    ///     .author("developer")
    ///     .execute()?;
    /// # Ok::<(), heroforge_core::FossilError>(())
    /// ```
    pub fn exclude_pattern(mut self, pattern: &str) -> Self {
        self.exclude_patterns.push(pattern.to_string());
        self
    }

    /// Set the target branch in the heroforge repository.
    ///
    /// If not specified, commits to trunk.
    pub fn to_branch(mut self, branch: &str) -> Self {
        self.target_branch = Some(branch.to_string());
        self
    }

    /// Set the parent commit for the import.
    ///
    /// If not specified, creates an initial commit or uses trunk tip.
    pub fn parent(mut self, hash: &str) -> Self {
        self.parent_commit = Some(hash.to_string());
        self
    }

    /// Execute the git import operation.
    ///
    /// This will:
    /// 1. Clone the git repository to a temporary directory
    /// 2. Checkout the specified branch/tag/commit
    /// 3. Collect all files (applying include/exclude filters)
    /// 4. Create a commit in the heroforge repository
    ///
    /// Returns the hash of the created commit.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - No git URL was specified
    /// - No commit message was specified
    /// - No author was specified
    /// - Git clone or checkout fails
    /// - File reading fails
    pub fn execute(self) -> Result<String> {
        use herolib_os::git::GitTree;

        let git_url = self.git_url.clone().ok_or_else(|| {
            FossilError::InvalidArtifact("git URL is required for git import".to_string())
        })?;

        let message = self.message.clone().ok_or_else(|| {
            FossilError::InvalidArtifact("commit message is required for git import".to_string())
        })?;

        let author = self.author.clone().ok_or_else(|| {
            FossilError::InvalidArtifact("author is required for git import".to_string())
        })?;

        // Create a temporary directory for the clone
        let temp_base =
            std::env::temp_dir().join(format!("heroforge_git_import_{}", uuid::Uuid::new_v4()));
        fs::create_dir_all(&temp_base)?;

        // Use herolib-os's GitTree for cloning
        let git_tree = GitTree::new(temp_base.to_string_lossy().as_ref()).map_err(|e| {
            let _ = fs::remove_dir_all(&temp_base);
            FossilError::InvalidArtifact(format!("Failed to create git tree: {}", e))
        })?;

        // Clone the repository with optional branch
        let branch_ref = self
            .branch
            .as_deref()
            .or(self.tag.as_deref())
            .or(self.commit.as_deref());

        let clone_result = if let Some(branch) = branch_ref {
            git_tree.clone_repo(&git_url).branch(branch).execute()
        } else {
            git_tree.clone_repo(&git_url).execute()
        };

        let cloned_path = clone_result.map_err(|e| {
            let _ = fs::remove_dir_all(&temp_base);
            FossilError::InvalidArtifact(format!("Failed to clone git repository: {}", e))
        })?;

        // Collect files from the cloned repository
        let cloned_dir = Path::new(&cloned_path);
        let files = self.collect_files(cloned_dir).map_err(|e| {
            let _ = fs::remove_dir_all(&temp_base);
            e
        })?;

        // Clean up the temp directory
        let _ = fs::remove_dir_all(&temp_base);

        if files.is_empty() {
            return Err(FossilError::InvalidArtifact(
                "No files found to import (check include/exclude patterns)".to_string(),
            ));
        }

        // Determine parent commit
        let parent = if let Some(ref p) = self.parent_commit {
            Some(p.clone())
        } else {
            // Try to get trunk tip, if it exists
            self.repo
                .branch_tip_internal("trunk")
                .ok()
                .map(|tip| tip.hash)
        };

        // Create the commit
        let files_refs: Vec<(&str, &[u8])> = files
            .iter()
            .map(|(path, content)| (path.as_str(), content.as_slice()))
            .collect();

        self.repo.commit_internal(
            &files_refs,
            &message,
            &author,
            parent.as_deref(),
            self.target_branch.as_deref(),
        )
    }

    /// Collect files from a directory, applying include/exclude filters.
    fn collect_files(&self, dir: &Path) -> Result<Vec<(String, Vec<u8>)>> {
        let mut files = Vec::new();

        // Compile include patterns
        let include_patterns: Vec<glob::Pattern> = self
            .include_patterns
            .iter()
            .filter_map(|p| glob::Pattern::new(p).ok())
            .collect();

        // Compile exclude patterns
        let exclude_patterns: Vec<glob::Pattern> = self
            .exclude_patterns
            .iter()
            .filter_map(|p| glob::Pattern::new(p).ok())
            .collect();

        // Always exclude .git directory
        let git_exclude = glob::Pattern::new(".git/**").unwrap();
        let git_dir_exclude = glob::Pattern::new(".git").unwrap();

        self.collect_files_recursive(
            dir,
            dir,
            &include_patterns,
            &exclude_patterns,
            &git_exclude,
            &git_dir_exclude,
            &mut files,
        )?;

        Ok(files)
    }

    fn collect_files_recursive(
        &self,
        base_dir: &Path,
        current_dir: &Path,
        include_patterns: &[glob::Pattern],
        exclude_patterns: &[glob::Pattern],
        git_exclude: &glob::Pattern,
        git_dir_exclude: &glob::Pattern,
        files: &mut Vec<(String, Vec<u8>)>,
    ) -> Result<()> {
        let entries = fs::read_dir(current_dir)?;

        for entry in entries {
            let entry = entry?;

            let path = entry.path();
            let relative_path = path
                .strip_prefix(base_dir)
                .unwrap_or(&path)
                .to_string_lossy()
                .to_string();

            // Skip .git directory
            if git_exclude.matches(&relative_path) || git_dir_exclude.matches(&relative_path) {
                continue;
            }

            if path.is_dir() {
                self.collect_files_recursive(
                    base_dir,
                    &path,
                    include_patterns,
                    exclude_patterns,
                    git_exclude,
                    git_dir_exclude,
                    files,
                )?;
            } else if path.is_file() {
                // Check include patterns (if any specified)
                let included = if include_patterns.is_empty() {
                    true
                } else {
                    include_patterns.iter().any(|p| p.matches(&relative_path))
                };

                // Check exclude patterns
                let excluded = exclude_patterns.iter().any(|p| p.matches(&relative_path));

                if included && !excluded {
                    let content = fs::read(&path)?;

                    // Normalize path separators
                    let normalized_path = relative_path.replace('\\', "/");
                    files.push((normalized_path, content));
                }
            }
        }

        Ok(())
    }
}

/// Result of a git import operation.
#[derive(Debug)]
pub struct GitImportResult {
    /// Hash of the created commit.
    pub commit_hash: String,
    /// Number of files imported.
    pub files_imported: usize,
    /// Total size of imported files in bytes.
    pub total_size: usize,
}