selfware 0.2.2

//! Git tool tests
//!
//! Tests for GitStatus tool using temporary git repositories.
//! Note: GitDiff and GitCommit use current directory and are tested in integration tests.

use selfware::tools::{git::GitStatus, Tool};
use serde_json::json;
use std::fs;
use std::process::Command;
use tempfile::TempDir;

/// Create a temporary git repository for testing
fn create_test_repo() -> TempDir {
    let dir = TempDir::new().unwrap();

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

    // Configure git user for commits
    Command::new("git")
        .args(["config", "user.email", "test@example.com"])
        .current_dir(dir.path())
        .output()
        .expect("Failed to configure git email");

    Command::new("git")
        .args(["config", "user.name", "Test User"])
        .current_dir(dir.path())
        .output()
        .expect("Failed to configure git name");

    // Create initial commit
    fs::write(dir.path().join("README.md"), "# Test").unwrap();
    Command::new("git")
        .args(["add", "."])
        .current_dir(dir.path())
        .output()
        .expect("Failed to stage files");

    Command::new("git")
        .args(["commit", "-m", "Initial commit"])
        .current_dir(dir.path())
        .output()
        .expect("Failed to create initial commit");

    dir
}

// ==================== GitStatus Tests ====================

#[tokio::test]
async fn test_git_status_clean_repo() {
    let dir = create_test_repo();

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    let staged = result.get("staged").unwrap().as_array().unwrap();
    let unstaged = result.get("unstaged").unwrap().as_array().unwrap();
    let untracked = result.get("untracked").unwrap().as_array().unwrap();

    assert!(staged.is_empty());
    assert!(unstaged.is_empty());
    assert!(untracked.is_empty());
}

#[tokio::test]
async fn test_git_status_with_untracked() {
    let dir = create_test_repo();
    let new_file = dir.path().join("new_file.txt");
    fs::write(&new_file, "content").unwrap();

    // Verify file exists
    assert!(new_file.exists(), "New file should exist");

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();

    // GitStatus returns branch info and status arrays
    // Note: The current implementation may not include untracked files
    // depending on git2::StatusOptions defaults
    assert!(result.get("branch").is_some());
    assert!(result.get("untracked").is_some());
    assert!(result.get("staged").is_some());
    assert!(result.get("unstaged").is_some());
}

#[tokio::test]
async fn test_git_status_with_staged() {
    let dir = create_test_repo();
    fs::write(dir.path().join("staged.txt"), "content").unwrap();

    Command::new("git")
        .args(["add", "staged.txt"])
        .current_dir(dir.path())
        .output()
        .expect("Failed to stage file");

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    let staged = result.get("staged").unwrap().as_array().unwrap();

    assert!(!staged.is_empty(), "Expected staged files");
}

#[tokio::test]
async fn test_git_status_with_modified() {
    let dir = create_test_repo();
    fs::write(dir.path().join("README.md"), "# Modified").unwrap();

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    let unstaged = result.get("unstaged").unwrap().as_array().unwrap();

    assert!(!unstaged.is_empty(), "Expected modified files");
}

#[tokio::test]
async fn test_git_status_shows_branch() {
    let dir = create_test_repo();

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    let branch = result.get("branch").unwrap().as_str().unwrap();

    // Default branch could be main or master depending on git config
    assert!(
        branch == "main" || branch == "master",
        "Expected main or master, got: {}",
        branch
    );
}

#[tokio::test]
async fn test_git_status_not_a_repo() {
    let dir = TempDir::new().unwrap(); // Not initialized as git repo

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await;
    assert!(result.is_err());
}

// ==================== Tool Metadata Tests ====================

#[test]
fn test_git_status_metadata() {
    let tool = GitStatus;
    assert_eq!(tool.name(), "git_status");
    assert!(!tool.description().is_empty());
    let schema = tool.schema();
    assert!(schema.get("properties").is_some());
}

// ==================== Edge Cases ====================

#[tokio::test]
async fn test_git_status_with_multiple_changes() {
    let dir = create_test_repo();

    // Create file to stage
    fs::write(dir.path().join("staged.txt"), "staged").unwrap();
    Command::new("git")
        .args(["add", "staged.txt"])
        .current_dir(dir.path())
        .output()
        .expect("Failed to stage file");

    // Modify existing file
    fs::write(dir.path().join("README.md"), "modified").unwrap();

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();

    let staged = result.get("staged").unwrap().as_array().unwrap();
    let unstaged = result.get("unstaged").unwrap().as_array().unwrap();

    assert!(!staged.is_empty(), "Should have staged files: {:?}", result);
    assert!(
        !unstaged.is_empty(),
        "Should have unstaged files: {:?}",
        result
    );
}

#[tokio::test]
async fn test_git_status_default_path() {
    // Test with no repo_path (defaults to current directory)
    // This is the main project repo
    let tool = GitStatus;
    let args = json!({});

    let result = tool.execute(args).await.unwrap();
    // Should succeed since we're in the selfware repo
    assert!(result.get("branch").is_some());
}

// ==================== GitDiff Tests ====================

use selfware::tools::git::GitDiff;

#[tokio::test]
async fn test_git_diff_no_changes() {
    let dir = create_test_repo();

    let tool = GitDiff;
    let args = json!({
        "path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    assert!(!result["has_changes"].as_bool().unwrap());
    assert_eq!(result["diff"].as_str().unwrap(), "");
}

#[tokio::test]
async fn test_git_diff_with_changes() {
    let dir = create_test_repo();
    fs::write(dir.path().join("README.md"), "# Changed content").unwrap();

    let tool = GitDiff;
    let args = json!({
        "path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    assert!(result["has_changes"].as_bool().unwrap());
    let diff = result["diff"].as_str().unwrap();
    assert!(diff.contains("Changed content") || diff.contains("README"));
}

#[tokio::test]
async fn test_git_diff_staged() {
    let dir = create_test_repo();
    fs::write(dir.path().join("staged.txt"), "staged content").unwrap();

    Command::new("git")
        .args(["add", "staged.txt"])
        .current_dir(dir.path())
        .output()
        .expect("Failed to stage file");

    let tool = GitDiff;
    let args = json!({
        "path": dir.path().to_str().unwrap(),
        "staged": true
    });

    let result = tool.execute(args).await.unwrap();
    assert!(result["has_changes"].as_bool().unwrap());
}

#[tokio::test]
async fn test_git_diff_default_not_staged() {
    let dir = create_test_repo();
    fs::write(dir.path().join("new.txt"), "new content").unwrap();

    Command::new("git")
        .args(["add", "new.txt"])
        .current_dir(dir.path())
        .output()
        .expect("Failed to stage file");

    let tool = GitDiff;
    // Without staged=true, should show working tree diff (empty since we staged)
    let args = json!({
        "path": dir.path().to_str().unwrap(),
        "staged": false
    });

    let result = tool.execute(args).await.unwrap();
    // Working tree has no unstaged changes
    assert!(!result["has_changes"].as_bool().unwrap());
}

// ==================== GitCommit Tests ====================
// Note: GitCommit and GitCheckpoint use current directory
// Testing them requires changing cwd which is problematic in tests
// These tools are better tested in integration tests

use selfware::tools::git::GitCommit;

#[tokio::test]
async fn test_git_commit_specific_files() {
    let dir = create_test_repo();
    fs::write(dir.path().join("file1.txt"), "content1").unwrap();

    // Use git -C to run in specific directory
    Command::new("git")
        .args(["-C", dir.path().to_str().unwrap(), "add", "file1.txt"])
        .output()
        .expect("Failed to stage file");

    Command::new("git")
        .args(["-C", dir.path().to_str().unwrap(), "commit", "-m", "Test"])
        .output()
        .expect("Failed to commit");

    // Verify commit was made
    let log = Command::new("git")
        .args(["-C", dir.path().to_str().unwrap(), "log", "--oneline", "-1"])
        .output()
        .expect("Failed to get log");

    let log_str = String::from_utf8_lossy(&log.stdout);
    assert!(log_str.contains("Test"));
}

// ==================== GitCheckpoint Tests ====================

use selfware::tools::git::GitCheckpoint;

#[test]
fn test_git_diff_metadata() {
    let tool = GitDiff;
    assert_eq!(tool.name(), "git_diff");
    assert!(tool.description().contains("diff"));
    let schema = tool.schema();
    assert!(schema["properties"]["staged"].is_object());
}

#[test]
fn test_git_commit_metadata() {
    let tool = GitCommit;
    assert_eq!(tool.name(), "git_commit");
    assert!(tool.description().contains("commit"));
    let schema = tool.schema();
    assert!(schema["properties"]["message"].is_object());
    assert!(schema["required"]
        .as_array()
        .unwrap()
        .contains(&json!("message")));
}

#[test]
fn test_git_checkpoint_metadata() {
    let tool = GitCheckpoint;
    assert_eq!(tool.name(), "git_checkpoint");
    assert!(tool.description().contains("checkpoint"));
    let schema = tool.schema();
    assert!(schema["properties"]["tag"].is_object());
    assert!(schema["properties"]["auto_branch"].is_object());
}

// ==================== GitStatus Additional Tests ====================

#[tokio::test]
async fn test_git_status_with_deleted_file() {
    let dir = create_test_repo();

    // Delete the README.md file
    fs::remove_file(dir.path().join("README.md")).unwrap();

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    let unstaged = result.get("unstaged").unwrap().as_array().unwrap();

    // Should detect the deleted file
    assert!(
        !unstaged.is_empty(),
        "Should detect deleted file: {:?}",
        result
    );
}

#[tokio::test]
async fn test_git_status_with_index_deleted() {
    let dir = create_test_repo();

    // Stage a deletion
    Command::new("git")
        .args(["-C", dir.path().to_str().unwrap(), "rm", "README.md"])
        .output()
        .expect("Failed to stage deletion");

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();
    let staged = result.get("staged").unwrap().as_array().unwrap();

    // Should detect the staged deletion
    assert!(
        !staged.is_empty(),
        "Should detect staged deletion: {:?}",
        result
    );
}

#[tokio::test]
async fn test_git_status_staged_and_unstaged() {
    let dir = create_test_repo();

    // Create staged file
    fs::write(dir.path().join("staged.txt"), "staged").unwrap();
    Command::new("git")
        .args(["-C", dir.path().to_str().unwrap(), "add", "staged.txt"])
        .output()
        .expect("Failed to stage file");

    // Modify tracked file (unstaged)
    fs::write(dir.path().join("README.md"), "modified").unwrap();

    let tool = GitStatus;
    let args = json!({
        "repo_path": dir.path().to_str().unwrap()
    });

    let result = tool.execute(args).await.unwrap();

    let staged = result.get("staged").unwrap().as_array().unwrap();
    let unstaged = result.get("unstaged").unwrap().as_array().unwrap();

    assert!(!staged.is_empty(), "Should have staged files");
    assert!(!unstaged.is_empty(), "Should have unstaged files");

    // Verify untracked array exists (may or may not contain files based on StatusOptions)
    assert!(
        result.get("untracked").is_some(),
        "Should have untracked array"
    );
}

// ==================== GitDiff Additional Tests ====================

#[tokio::test]
async fn test_git_diff_not_a_repo() {
    let dir = TempDir::new().unwrap(); // Not a git repo

    let tool = GitDiff;
    let args = json!({
        "path": dir.path().to_str().unwrap()
    });

    // Should still return (git diff handles non-repo gracefully with error in stderr)
    let result = tool.execute(args).await;
    assert!(result.is_ok()); // Returns empty diff with has_changes: false
}

#[tokio::test]
async fn test_git_diff_multiple_files_changed() {
    let dir = create_test_repo();

    // Modify multiple files
    fs::write(dir.path().join("README.md"), "modified readme").unwrap();
    fs::write(dir.path().join("file2.txt"), "new file").unwrap();

    // Add and modify file2
    Command::new("git")
        .args(["-C", dir.path().to_str().unwrap(), "add", "file2.txt"])
        .output()
        .expect("Failed to add file2");

    Command::new("git")
        .args([
            "-C",
            dir.path().to_str().unwrap(),
            "commit",
            "-m",
            "add file2",
        ])
        .output()
        .expect("Failed to commit");

    fs::write(dir.path().join("file2.txt"), "modified file2").unwrap();

    let tool = GitDiff;
    let args = json!({
        "path": dir.path().to_str().unwrap(),
        "staged": false
    });

    let result = tool.execute(args).await.unwrap();
    assert!(result["has_changes"].as_bool().unwrap());

    let diff = result["diff"].as_str().unwrap();
    assert!(diff.contains("README") || diff.contains("file2"));
}

#[tokio::test]
async fn test_git_diff_staged_vs_unstaged() {
    let dir = create_test_repo();

    // Create a staged change
    fs::write(dir.path().join("staged.txt"), "staged content").unwrap();
    Command::new("git")
        .args(["-C", dir.path().to_str().unwrap(), "add", "staged.txt"])
        .output()
        .expect("Failed to stage");

    // Create an unstaged change to a different file
    fs::write(dir.path().join("README.md"), "unstaged change").unwrap();

    let tool = GitDiff;

    // Check staged diff
    let staged_args = json!({
        "path": dir.path().to_str().unwrap(),
        "staged": true
    });
    let staged_result = tool.execute(staged_args).await.unwrap();
    assert!(staged_result["has_changes"].as_bool().unwrap());
    let staged_diff = staged_result["diff"].as_str().unwrap();
    assert!(staged_diff.contains("staged.txt") || staged_diff.contains("staged content"));

    // Check unstaged diff
    let unstaged_args = json!({
        "path": dir.path().to_str().unwrap(),
        "staged": false
    });
    let unstaged_result = tool.execute(unstaged_args).await.unwrap();
    assert!(unstaged_result["has_changes"].as_bool().unwrap());
    let unstaged_diff = unstaged_result["diff"].as_str().unwrap();
    assert!(unstaged_diff.contains("README") || unstaged_diff.contains("unstaged"));
}

// ==================== GitCommit Additional Tests ====================

#[tokio::test]
async fn test_git_commit_empty_files_array() {
    let dir = create_test_repo();

    // Create a file to commit
    fs::write(dir.path().join("newfile.txt"), "content").unwrap();

    // Run commit tool with empty files (should stage all)
    let tool = GitCommit;

    // We can't actually test GitCommit easily because it operates on current dir
    // But we can test the schema
    let schema = tool.schema();
    let files_schema = &schema["properties"]["files"];
    assert_eq!(files_schema["type"], "array");
}

// ==================== GitCheckpoint Additional Tests ====================

#[tokio::test]
async fn test_git_checkpoint_creates_tagged_commit() {
    // Test the schema requirements
    let tool = GitCheckpoint;
    let schema = tool.schema();

    let required = schema["required"].as_array().unwrap();
    assert!(required.contains(&json!("message")));

    let tag_prop = &schema["properties"]["tag"];
    assert_eq!(tag_prop["type"], "string");
}

#[test]
fn test_git_checkpoint_auto_branch_default() {
    let tool = GitCheckpoint;
    let schema = tool.schema();

    let auto_branch = &schema["properties"]["auto_branch"];
    assert_eq!(auto_branch["default"], true);
}

// ==================== Schema Validation Tests ====================

#[test]
fn test_all_git_tools_have_object_schema() {
    let tools: Vec<Box<dyn Tool>> = vec![
        Box::new(GitStatus),
        Box::new(GitDiff),
        Box::new(GitCommit),
        Box::new(GitCheckpoint),
    ];

    for tool in tools {
        let schema = tool.schema();
        assert_eq!(
            schema["type"],
            "object",
            "Tool {} should have object schema",
            tool.name()
        );
        assert!(
            schema.get("properties").is_some(),
            "Tool {} should have properties",
            tool.name()
        );
    }
}

#[test]
fn test_git_tools_have_descriptions() {
    let tools: Vec<Box<dyn Tool>> = vec![
        Box::new(GitStatus),
        Box::new(GitDiff),
        Box::new(GitCommit),
        Box::new(GitCheckpoint),
    ];

    for tool in tools {
        assert!(
            !tool.description().is_empty(),
            "Tool {} should have description",
            tool.name()
        );
    }
}