prodigy 0.4.4

//! Git operations abstraction layer
//!
//! Provides trait-based abstraction for git commands to enable
//! testing without actual git repository access.

use crate::subprocess::{ProcessCommandBuilder, SubprocessManager};
use anyhow::Result;
use async_trait::async_trait;
use std::path::Path;
use std::sync::Arc;
use tokio::sync::Mutex;

/// Trait for git operations
#[async_trait]
pub trait GitOperations: Send + Sync {
    /// Execute a git command with exclusive access
    async fn git_command(&self, args: &[&str], description: &str) -> Result<std::process::Output>;

    /// Execute a git command with exclusive access in a specific directory
    async fn git_command_in_dir(
        &self,
        args: &[&str],
        description: &str,
        working_dir: &Path,
    ) -> Result<std::process::Output>;

    /// Get the last commit message
    async fn get_last_commit_message(&self) -> Result<String>;

    /// Check git status
    async fn check_git_status(&self) -> Result<String>;

    /// Stage all changes
    async fn stage_all_changes(&self) -> Result<()>;

    /// Create a commit
    async fn create_commit(&self, message: &str) -> Result<()>;

    /// Check if we're in a git repository
    async fn is_git_repo(&self) -> bool;

    /// Create a worktree
    async fn create_worktree(&self, name: &str, path: &Path) -> Result<()>;

    /// Get current branch name
    async fn get_current_branch(&self) -> Result<String>;

    /// Switch to a branch
    async fn switch_branch(&self, branch: &str) -> Result<()>;
}

/// Real implementation of `GitOperations`
pub struct RealGitOperations {
    /// Mutex for thread-safe git operations
    git_mutex: Arc<Mutex<()>>,
    /// Subprocess manager for executing git commands
    subprocess: SubprocessManager,
}

impl RealGitOperations {
    /// Create a new `RealGitOperations` instance
    #[must_use]
    pub fn new() -> Self {
        Self {
            git_mutex: Arc::new(Mutex::new(())),
            subprocess: SubprocessManager::production(),
        }
    }

    /// Create a new instance with custom subprocess manager (for testing)
    #[cfg(test)]
    pub fn with_subprocess(subprocess: SubprocessManager) -> Self {
        Self {
            git_mutex: Arc::new(Mutex::new(())),
            subprocess,
        }
    }
}

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

#[async_trait]
impl GitOperations for RealGitOperations {
    async fn git_command(&self, args: &[&str], description: &str) -> Result<std::process::Output> {
        // Acquire the mutex to ensure exclusive access
        let _guard = self.git_mutex.lock().await;

        let command = ProcessCommandBuilder::new("git").args(args).build();

        let output = self
            .subprocess
            .runner()
            .run(command)
            .await
            .map_err(|e| anyhow::anyhow!("Failed to execute git {}: {}", description, e))?;

        if !output.status.success() {
            let stderr = &output.stderr;
            return Err(anyhow::anyhow!(
                "Git {} failed: {}",
                description,
                stderr.trim()
            ));
        }

        Ok(std::process::Output {
            status: std::process::ExitStatus::from_raw(output.status.code().unwrap_or(0)),
            stdout: output.stdout.into_bytes(),
            stderr: output.stderr.into_bytes(),
        })
    }

    async fn get_last_commit_message(&self) -> Result<String> {
        let output = self
            .git_command(&["log", "-1", "--pretty=format:%s"], "log")
            .await?;
        Ok(String::from_utf8_lossy(&output.stdout).to_string())
    }

    async fn check_git_status(&self) -> Result<String> {
        let output = self
            .git_command(&["status", "--porcelain"], "status")
            .await?;
        Ok(String::from_utf8_lossy(&output.stdout).to_string())
    }

    async fn stage_all_changes(&self) -> Result<()> {
        self.git_command(&["add", "."], "add").await?;
        Ok(())
    }

    async fn create_commit(&self, message: &str) -> Result<()> {
        self.git_command(&["commit", "-m", message], "commit")
            .await?;
        Ok(())
    }

    async fn is_git_repo(&self) -> bool {
        #[cfg(test)]
        let command = ProcessCommandBuilder::new("git")
            .args(["rev-parse", "--git-dir"])
            .suppress_stderr()
            .build();

        #[cfg(not(test))]
        let command = ProcessCommandBuilder::new("git")
            .args(["rev-parse", "--git-dir"])
            .build();

        self.subprocess
            .runner()
            .run(command)
            .await
            .map(|output| output.status.success())
            .unwrap_or(false)
    }

    async fn git_command_in_dir(
        &self,
        args: &[&str],
        description: &str,
        working_dir: &Path,
    ) -> Result<std::process::Output> {
        // Acquire the mutex to ensure exclusive access
        let _guard = self.git_mutex.lock().await;

        let command = ProcessCommandBuilder::new("git")
            .args(args)
            .current_dir(working_dir)
            .build();

        let output = self
            .subprocess
            .runner()
            .run(command)
            .await
            .map_err(|e| anyhow::anyhow!("Failed to execute git {}: {}", description, e))?;

        if !output.status.success() {
            let stderr = &output.stderr;
            return Err(anyhow::anyhow!(
                "Git {} failed: {}",
                description,
                stderr.trim()
            ));
        }

        Ok(std::process::Output {
            status: std::process::ExitStatus::from_raw(output.status.code().unwrap_or(0)),
            stdout: output.stdout.into_bytes(),
            stderr: output.stderr.into_bytes(),
        })
    }

    async fn create_worktree(&self, name: &str, path: &Path) -> Result<()> {
        let path_str = path
            .to_str()
            .ok_or_else(|| anyhow::anyhow!("Invalid path"))?;
        self.git_command(&["worktree", "add", path_str, "-b", name], "worktree add")
            .await?;
        Ok(())
    }

    async fn get_current_branch(&self) -> Result<String> {
        let output = self
            .git_command(&["rev-parse", "--abbrev-ref", "HEAD"], "get current branch")
            .await?;
        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
    }

    async fn switch_branch(&self, branch: &str) -> Result<()> {
        self.git_command(&["checkout", branch], "checkout").await?;
        Ok(())
    }
}

/// Mock implementation of `GitOperations` for testing
pub struct MockGitOperations {
    /// Predefined responses for git commands
    pub command_responses: Arc<Mutex<Vec<Result<std::process::Output>>>>,
    /// Predefined response for `is_git_repo`
    pub is_repo: bool,
    /// Track called commands for verification
    pub called_commands: Arc<Mutex<Vec<Vec<String>>>>,
}

use crate::abstractions::exit_status::ExitStatusExt;

impl MockGitOperations {
    /// Create a new `MockGitOperations` instance
    #[must_use]
    pub fn new() -> Self {
        Self {
            command_responses: Arc::new(Mutex::new(Vec::new())),
            is_repo: true,
            called_commands: Arc::new(Mutex::new(Vec::new())),
        }
    }

    /// Add a response for the next git command
    pub async fn add_response(&self, response: Result<std::process::Output>) {
        self.command_responses.lock().await.push(response);
    }

    /// Add a successful response with stdout content
    pub async fn add_success_response(&self, stdout: &str) {
        let output = std::process::Output {
            status: std::process::ExitStatus::from_raw(0),
            stdout: stdout.as_bytes().to_vec(),
            stderr: Vec::new(),
        };
        self.add_response(Ok(output)).await;
    }

    /// Add an error response
    pub async fn add_error_response(&self, error: &str) {
        let error_string = error.to_string();
        self.add_response(Err(anyhow::anyhow!(error_string))).await;
    }

    /// Get the list of called commands
    pub async fn get_called_commands(&self) -> Vec<Vec<String>> {
        self.called_commands.lock().await.clone()
    }
}

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

#[async_trait]
impl GitOperations for MockGitOperations {
    async fn git_command(&self, args: &[&str], _description: &str) -> Result<std::process::Output> {
        // Track the called command
        let cmd_vec: Vec<String> = args.iter().map(|s| (*s).to_string()).collect();
        self.called_commands.lock().await.push(cmd_vec);

        // Return the next predefined response
        let mut responses = self.command_responses.lock().await;
        if responses.is_empty() {
            return Err(anyhow::anyhow!("No mock response configured"));
        }
        responses.remove(0)
    }

    async fn get_last_commit_message(&self) -> Result<String> {
        let output = self
            .git_command(&["log", "-1", "--pretty=format:%s"], "log")
            .await?;
        Ok(String::from_utf8_lossy(&output.stdout).to_string())
    }

    async fn check_git_status(&self) -> Result<String> {
        let output = self
            .git_command(&["status", "--porcelain"], "status")
            .await?;
        Ok(String::from_utf8_lossy(&output.stdout).to_string())
    }

    async fn stage_all_changes(&self) -> Result<()> {
        self.git_command(&["add", "."], "add").await?;
        Ok(())
    }

    async fn create_commit(&self, message: &str) -> Result<()> {
        self.git_command(&["commit", "-m", message], "commit")
            .await?;
        Ok(())
    }

    async fn is_git_repo(&self) -> bool {
        self.is_repo
    }

    async fn create_worktree(&self, name: &str, path: &Path) -> Result<()> {
        let path_str = path
            .to_str()
            .ok_or_else(|| anyhow::anyhow!("Invalid path"))?;
        self.git_command(&["worktree", "add", path_str, "-b", name], "worktree add")
            .await?;
        Ok(())
    }

    async fn get_current_branch(&self) -> Result<String> {
        let output = self
            .git_command(&["rev-parse", "--abbrev-ref", "HEAD"], "get current branch")
            .await?;
        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
    }

    async fn switch_branch(&self, branch: &str) -> Result<()> {
        self.git_command(&["checkout", branch], "checkout").await?;
        Ok(())
    }

    async fn git_command_in_dir(
        &self,
        args: &[&str],
        description: &str,
        _working_dir: &Path,
    ) -> Result<std::process::Output> {
        // For mocks, just delegate to git_command since we don't actually run commands
        self.git_command(args, description).await
    }
}

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

    #[tokio::test]
    async fn test_mock_git_operations() {
        let mock = MockGitOperations::new();

        // Add responses
        mock.add_success_response("test commit message").await;
        mock.add_success_response("M  src/main.rs\nA  src/new.rs")
            .await;

        // Test get_last_commit_message
        let msg = mock.get_last_commit_message().await.unwrap();
        assert_eq!(msg, "test commit message");

        // Test check_git_status
        let status = mock.check_git_status().await.unwrap();
        assert!(status.contains("M  src/main.rs"));

        // Verify called commands
        let commands = mock.get_called_commands().await;
        assert_eq!(commands.len(), 2);
        assert_eq!(commands[0], vec!["log", "-1", "--pretty=format:%s"]);
        assert_eq!(commands[1], vec!["status", "--porcelain"]);
    }

    #[tokio::test]
    async fn test_mock_git_error() {
        let mock = MockGitOperations::new();

        // Add error response
        mock.add_error_response("fatal: not a git repository").await;

        // Test error handling
        let result = mock.get_last_commit_message().await;
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("not a git repository"));
    }

    #[tokio::test]
    async fn test_real_git_operations_is_git_repo() {
        use crate::subprocess::builder::ProcessCommandBuilder;
        use crate::subprocess::SubprocessManager;
        use std::process::Command;
        use tempfile::TempDir;

        // Create a temporary directory with a git repo
        let temp_dir = TempDir::new().unwrap();

        // Initialize git repo
        let output = Command::new("git")
            .args(["init"])
            .current_dir(temp_dir.path())
            .output()
            .expect("Failed to run git init");

        assert!(output.status.success(), "Git init should succeed");

        // Create a subprocess manager that runs commands in the temp directory
        let subprocess = SubprocessManager::production();

        // Test if it's a git repo by running git rev-parse in that directory
        let command = ProcessCommandBuilder::new("git")
            .args(["rev-parse", "--git-dir"])
            .current_dir(temp_dir.path())
            .suppress_stderr()
            .build();

        let result = subprocess.runner().run(command).await;

        assert!(
            result.is_ok() && result.unwrap().status.success(),
            "Should detect git repository in {}",
            temp_dir.path().display()
        );
    }
}

#[cfg(test)]
mod real_git_tests {
    use super::*;
    use tempfile::TempDir;

    #[tokio::test]
    async fn test_git_command_success() {
        let git_ops = RealGitOperations::new();

        // Test successful command execution
        let result = git_ops.git_command(&["--version"], "version check").await;
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.status.success());
        let stdout = String::from_utf8_lossy(&output.stdout);
        assert!(stdout.contains("git version"));
    }

    #[tokio::test]
    async fn test_git_command_failure() {
        let git_ops = RealGitOperations::new();

        // Test failed command execution
        let result = git_ops
            .git_command(&["invalid-command"], "invalid command")
            .await;
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("Git invalid command failed"));
    }

    #[tokio::test]
    async fn test_stage_all_changes_and_commit() {
        let git_ops = RealGitOperations::new();

        // Only run if in a git repo
        if !git_ops.is_git_repo().await {
            return;
        }

        // Create a test file in a temp directory
        let temp_dir = TempDir::new().unwrap();
        let test_file = temp_dir.path().join("test.txt");
        std::fs::write(&test_file, "test content").unwrap();

        // Note: Full integration testing would require a test git repo
        // This is a partial test to verify the methods don't panic
        let _ = git_ops.check_git_status().await;
    }

    #[tokio::test]
    async fn test_get_current_branch() {
        let git_ops = RealGitOperations::new();

        // This test may run in environments where we're not in a git repo
        // (e.g., when tests change directories). Skip if not in a git repo.
        if !git_ops.is_git_repo().await {
            return;
        }

        let result = git_ops.get_current_branch().await;

        match result {
            Ok(branch) => {
                // Branch name should not be empty
                assert!(!branch.is_empty());
            }
            Err(e) => {
                let error_msg = e.to_string();
                // Accept errors that indicate we're not in a git repo
                // (can happen if test environment changes between is_git_repo check and this call)
                if error_msg.contains("not a git repository") {
                    return;
                }
                // Accept errors related to working directory issues
                if error_msg.contains("Unable to read current working directory") {
                    return;
                }
                // Also accept detached HEAD state
                assert!(
                    error_msg.contains("HEAD") || error_msg.contains("detached"),
                    "Unexpected error: {error_msg}"
                );
            }
        }
    }

    #[tokio::test]
    async fn test_create_worktree_invalid_path() {
        let git_ops = RealGitOperations::new();

        if git_ops.is_git_repo().await {
            let invalid_path = Path::new("/\0invalid");
            let result = git_ops.create_worktree("test-branch", invalid_path).await;
            assert!(result.is_err());
        }
    }
}