//! GitHub integration commands.
//!
//! Provides commands for GitHub Actions integration:
//! - `cortex github install` - Install GitHub Actions workflow
//! - `cortex github run` - Run GitHub agent in Actions context
//! - `cortex github status` - Check installation status

use crate::styled_output::{print_error, print_success, print_warning};
use anyhow::{Context, Result, bail};
use clap::Parser;
use std::path::PathBuf;

/// GitHub integration CLI.
#[derive(Debug, Parser)]
pub struct GitHubCli {
    #[command(subcommand)]
    pub subcommand: GitHubSubcommand,
}

/// GitHub subcommands.
#[derive(Debug, clap::Subcommand)]
pub enum GitHubSubcommand {
    /// Install GitHub Actions workflow for Cortex CI/CD automation.
    Install(InstallArgs),

    /// Run GitHub agent in Actions context.
    Run(RunArgs),

    /// Check GitHub Actions installation status.
    Status(StatusArgs),

    /// Uninstall/remove the Cortex GitHub workflow.
    Uninstall(UninstallArgs),

    /// Update the Cortex GitHub workflow to the latest version.
    Update(UpdateArgs),
}

/// Arguments for install command.
#[derive(Debug, Parser)]
pub struct InstallArgs {
    /// Path to the repository root (defaults to current directory).
    #[arg(short, long)]
    pub path: Option<PathBuf>,

    /// Force overwrite existing workflow file.
    #[arg(short, long)]
    pub force: bool,

    /// Include PR review automation in the workflow.
    /// When enabled, the agent will:
    ///   - Automatically review new and updated pull requests
    ///   - Analyze code changes for bugs, security issues, and best practices
    ///   - Suggest improvements with inline comments
    ///   - Respond to review comments and questions
    ///
    /// Triggered by: pull_request (opened, synchronize, reopened)
    #[arg(long, default_value_t = true)]
    pub pr_review: bool,

    /// Include issue automation.
    #[arg(long, default_value_t = true)]
    pub issue_automation: bool,

    /// Custom workflow name.
    #[arg(long, default_value = "Cortex")]
    pub workflow_name: String,
}

/// Arguments for run command.
#[derive(Debug, Parser)]
pub struct RunArgs {
    /// GitHub event type (issue_comment, pull_request, issues, etc.).
    #[arg(long, short)]
    pub event: String,

    /// GitHub token for API access.
    #[arg(long, short)]
    pub token: Option<String>,

    /// Path to the event payload JSON file.
    #[arg(long)]
    pub event_path: Option<PathBuf>,

    /// GitHub repository (owner/repo format).
    #[arg(long)]
    pub repository: Option<String>,

    /// GitHub run ID.
    #[arg(long)]
    pub run_id: Option<String>,

    /// Dry run mode - don't execute, just show what would happen.
    #[arg(long)]
    pub dry_run: bool,
}

/// Arguments for status command.
#[derive(Debug, Parser)]
pub struct StatusArgs {
    /// Path to the repository root (defaults to current directory).
    #[arg(short, long)]
    pub path: Option<PathBuf>,

    /// Output as JSON.
    #[arg(long)]
    pub json: bool,
}

/// Arguments for uninstall command.
#[derive(Debug, Parser)]
pub struct UninstallArgs {
    /// Path to the repository root (defaults to current directory).
    #[arg(short, long)]
    pub path: Option<PathBuf>,

    /// Workflow name to remove (defaults to "cortex").
    #[arg(long, default_value = "cortex")]
    pub workflow_name: String,

    /// Force removal without confirmation.
    #[arg(short, long)]
    pub force: bool,
}

/// Arguments for update command.
#[derive(Debug, Parser)]
pub struct UpdateArgs {
    /// Path to the repository root (defaults to current directory).
    #[arg(short, long)]
    pub path: Option<PathBuf>,

    /// Workflow name to update (defaults to "cortex").
    #[arg(long, default_value = "cortex")]
    pub workflow_name: String,

    /// Include PR review automation.
    #[arg(long, default_value_t = true)]
    pub pr_review: bool,

    /// Include issue automation.
    #[arg(long, default_value_t = true)]
    pub issue_automation: bool,
}

impl GitHubCli {
    /// Run the GitHub command.
    pub async fn run(self) -> Result<()> {
        match self.subcommand {
            GitHubSubcommand::Install(args) => run_install(args).await,
            GitHubSubcommand::Run(args) => run_github_agent(args).await,
            GitHubSubcommand::Status(args) => run_status(args).await,
            GitHubSubcommand::Uninstall(args) => run_uninstall(args).await,
            GitHubSubcommand::Update(args) => run_update(args).await,
        }
    }
}

/// Install GitHub Actions workflow.
async fn run_install(args: InstallArgs) -> Result<()> {
    use cortex_engine::github::{WorkflowConfig, generate_workflow};

    // Validate workflow name is not empty or whitespace-only
    if args.workflow_name.trim().is_empty() {
        bail!(
            "Workflow name cannot be empty.\n\
            Please provide a valid workflow name using --workflow-name or use the default value."
        );
    }

    let repo_path = args.path.unwrap_or_else(|| PathBuf::from("."));

    // Security: Reject paths containing directory traversal sequences
    let path_str = repo_path.to_string_lossy();
    if path_str.contains("..") {
        bail!(
            "Security error: Path contains directory traversal sequence (..): {}\n\
            Please provide a direct path without '..' components.",
            repo_path.display()
        );
    }

    // Validate that the target path exists and is a directory
    if !repo_path.exists() {
        bail!(
            "Target path does not exist: {}\n\
            Please ensure the directory exists or run from a valid repository root.",
            repo_path.display()
        );
    }

    if !repo_path.is_dir() {
        bail!(
            "Target path is not a directory: {}\n\
            Please provide a valid repository root directory.",
            repo_path.display()
        );
    }

    // Security: Canonicalize and verify the path is within expected bounds
    let canonical_path = repo_path.canonicalize().with_context(|| {
        format!(
            "Failed to resolve path: {}\nPlease ensure the path is accessible.",
            repo_path.display()
        )
    })?;

    let workflows_dir = canonical_path.join(".github").join("workflows");
    let workflow_file = workflows_dir.join(format!("{}.yml", args.workflow_name));

    // Check if workflow already exists
    if workflow_file.exists() && !args.force {
        bail!(
            "Workflow file already exists: {}\nUse --force to overwrite.",
            workflow_file.display()
        );
    }

    // Generate workflow configuration
    let config = WorkflowConfig {
        name: args.workflow_name.clone(),
        pr_review: args.pr_review,
        issue_automation: args.issue_automation,
    };

    let workflow_content = generate_workflow(&config);

    // Create directories if needed
    std::fs::create_dir_all(&workflows_dir)
        .with_context(|| format!("Failed to create directory: {}", workflows_dir.display()))?;

    // Write workflow file
    std::fs::write(&workflow_file, &workflow_content)
        .with_context(|| format!("Failed to write workflow file: {}", workflow_file.display()))?;

    println!("GitHub Actions workflow installed!");
    println!("   Location: {}", workflow_file.display());
    println!();
    println!("Next steps:");
    println!("  1. Add CORTEX_API_KEY to your repository secrets");
    println!("     Settings → Secrets and variables → Actions → New repository secret");
    println!();
    println!("  2. Commit and push the workflow file:");
    println!("     git add .github/workflows/{}.yml", args.workflow_name);
    println!("     git commit -m \"Add Cortex CI/CD automation\"");
    println!("     git push");
    println!();
    println!("Features enabled:");
    if args.pr_review {
        println!("  • PR review automation (triggered on pull_request events)");
    }
    if args.issue_automation {
        println!("  • Issue automation (triggered on issue_comment events)");
    }

    Ok(())
}

/// Run GitHub agent in Actions context.
async fn run_github_agent(args: RunArgs) -> Result<()> {
    use cortex_engine::github::{GitHubEvent, parse_event};

    let token = args.token.ok_or_else(|| {
        anyhow::anyhow!("GitHub token required. Set GITHUB_TOKEN env var or use --token")
    })?;

    let repository = args.repository.ok_or_else(|| {
        anyhow::anyhow!(
            "GitHub repository required. Set GITHUB_REPOSITORY env var or use --repository"
        )
    })?;

    // Parse the event payload
    let event_path = args.event_path.ok_or_else(|| {
        anyhow::anyhow!(
            "Event payload path required. Set GITHUB_EVENT_PATH env var or use --event-path"
        )
    })?;

    let event_content = std::fs::read_to_string(&event_path)
        .with_context(|| format!("Failed to read event file: {}", event_path.display()))?;

    let event = parse_event(&args.event, &event_content)
        .with_context(|| format!("Failed to parse {} event", args.event))?;

    println!("Cortex GitHub Agent");
    println!("{}", "=".repeat(40));
    println!("Repository: {}", repository);
    println!("Event type: {}", args.event);
    if let Some(ref run_id) = args.run_id {
        println!("Run ID: {}", run_id);
    }
    println!();

    if args.dry_run {
        println!("Dry run mode - not executing");
        println!();
        print_event_summary(&event);
        return Ok(());
    }

    // Execute the appropriate agent based on event type
    match event {
        GitHubEvent::IssueComment(comment) => {
            handle_issue_comment(&token, &repository, &comment).await?;
        }
        GitHubEvent::PullRequest(pr) => {
            handle_pull_request(&token, &repository, &pr).await?;
        }
        GitHubEvent::PullRequestReview(review) => {
            handle_pull_request_review(&token, &repository, &review).await?;
        }
        GitHubEvent::Issues(issue) => {
            handle_issue(&token, &repository, &issue).await?;
        }
        GitHubEvent::Unknown(event_type) => {
            eprintln!(
                "\x1b[1;33mWarning:\x1b[0m Unknown event type: {}",
                event_type
            );
            println!(
                "   Supported events: issue_comment, pull_request, pull_request_review, issues"
            );
        }
    }

    Ok(())
}

/// Print event summary for dry run mode.
fn print_event_summary(event: &cortex_engine::github::GitHubEvent) {
    use cortex_engine::github::GitHubEvent;

    match event {
        GitHubEvent::IssueComment(comment) => {
            println!("Event: Issue Comment");
            println!("  Action: {}", comment.action);
            println!("  Issue #: {}", comment.issue_number);
            println!("  Author: {}", comment.author);
            println!(
                "  Body preview: {}...",
                comment.body.chars().take(100).collect::<String>()
            );
        }
        GitHubEvent::PullRequest(pr) => {
            println!("Event: Pull Request");
            println!("  Action: {}", pr.action);
            println!("  PR #: {}", pr.number);
            println!("  Title: {}", pr.title);
            println!("  Author: {}", pr.author);
            println!("  Base: {} ← Head: {}", pr.base_branch, pr.head_branch);
        }
        GitHubEvent::PullRequestReview(review) => {
            println!("Event: Pull Request Review");
            println!("  Action: {}", review.action);
            println!("  PR #: {}", review.pr_number);
            println!("  Reviewer: {}", review.reviewer);
            println!("  State: {}", review.state);
        }
        GitHubEvent::Issues(issue) => {
            println!("Event: Issue");
            println!("  Action: {}", issue.action);
            println!("  Issue #: {}", issue.number);
            println!("  Title: {}", issue.title);
            println!("  Author: {}", issue.author);
        }
        GitHubEvent::Unknown(event_type) => {
            println!("Event: Unknown ({})", event_type);
        }
    }
}

/// Handle issue comment events.
async fn handle_issue_comment(
    token: &str,
    repository: &str,
    comment: &cortex_engine::github::IssueCommentEvent,
) -> Result<()> {
    use cortex_engine::github::GitHubClient;

    println!("Processing issue comment on #{}", comment.issue_number);
    println!("   Author: {}", comment.author);
    println!("   Action: {}", comment.action);

    // Only process new comments (not edits or deletions)
    if comment.action != "created" {
        println!("   Skipping: action is '{}'", comment.action);
        return Ok(());
    }

    // Check if comment mentions cortex or starts with /cortex
    let is_cortex_mention = comment.body.contains("@cortex")
        || comment.body.starts_with("/cortex")
        || comment.body.to_lowercase().contains("cortex help");

    if !is_cortex_mention {
        println!("   Skipping: no Cortex mention detected");
        return Ok(());
    }

    println!("   Cortex command detected!");

    // Initialize GitHub client
    let client = GitHubClient::new(token, repository)?;

    // Parse the command from the comment
    let command = parse_cortex_command(&comment.body);

    // Add reaction to show we're processing
    client.add_reaction(comment.comment_id, "eyes").await?;

    // Process the command
    let response = match command.as_str() {
        "help" => get_help_message(),
        "review" => {
            if comment.is_pull_request {
                "Starting code review... (not yet implemented)".to_string()
            } else {
                "This command is only available on pull requests.".to_string()
            }
        }
        "fix" => "Analyzing and suggesting fixes... (not yet implemented)".to_string(),
        _ => format!(
            "Unknown command: `{}`\n\nUse `/cortex help` to see available commands.",
            command
        ),
    };

    // Post response comment
    client
        .create_comment(comment.issue_number, &response)
        .await?;

    // Add success reaction
    client.add_reaction(comment.comment_id, "rocket").await?;

    println!("   Response posted");

    Ok(())
}

/// Handle pull request events.
async fn handle_pull_request(
    token: &str,
    repository: &str,
    pr: &cortex_engine::github::PullRequestEvent,
) -> Result<()> {
    use cortex_engine::github::GitHubClient;

    println!("🔀 Processing pull request #{}", pr.number);
    println!("   Title: {}", pr.title);
    println!("   Action: {}", pr.action);
    println!("   Author: {}", pr.author);

    // Only process opened or synchronized PRs
    if !matches!(pr.action.as_str(), "opened" | "synchronize" | "reopened") {
        println!("   Skipping: action is '{}'", pr.action);
        return Ok(());
    }

    let client = GitHubClient::new(token, repository)?;

    // Auto-review on PR open (if enabled)
    if pr.action == "opened" {
        println!("   New PR opened - preparing welcome message");

        let welcome_message = format!(
            "👋 Thanks for opening this PR, @{}!\n\n\
            I'm Cortex, your AI coding assistant. I can help with:\n\
            - `/cortex review` - Get a code review\n\
            - `/cortex help` - See all available commands\n\n\
            I'll analyze this PR automatically when ready.",
            pr.author
        );

        client.create_comment(pr.number, &welcome_message).await?;
    }

    // For synchronize events (new commits pushed)
    if pr.action == "synchronize" {
        println!("   New commits pushed to PR");
        // Could trigger re-review here
    }

    Ok(())
}

/// Handle pull request review events.
async fn handle_pull_request_review(
    _token: &str,
    _repository: &str,
    review: &cortex_engine::github::PullRequestReviewEvent,
) -> Result<()> {
    println!("Processing PR review on #{}", review.pr_number);
    println!("   Reviewer: {}", review.reviewer);
    println!("   State: {}", review.state);
    println!("   Action: {}", review.action);

    // Could respond to review requests here
    println!("   Note: PR review events not yet implemented");

    Ok(())
}

/// Handle issue events.
async fn handle_issue(
    token: &str,
    repository: &str,
    issue: &cortex_engine::github::IssueEvent,
) -> Result<()> {
    use cortex_engine::github::GitHubClient;

    println!("Processing issue #{}", issue.number);
    println!("   Title: {}", issue.title);
    println!("   Action: {}", issue.action);

    // Only greet on new issues
    if issue.action != "opened" {
        println!("   Skipping: action is '{}'", issue.action);
        return Ok(());
    }

    let client = GitHubClient::new(token, repository)?;

    // Check if issue mentions cortex
    let is_cortex_related = issue.title.to_lowercase().contains("Cortex")
        || issue.body.to_lowercase().contains("Cortex")
        || issue
            .labels
            .iter()
            .any(|l| l.to_lowercase().contains("Cortex"));

    if is_cortex_related {
        let greeting = format!(
            "👋 Thanks for opening this issue, @{}!\n\n\
            I'm Cortex, your AI coding assistant. I'll analyze this issue and provide suggestions.\n\n\
            In the meantime, you can use `/cortex help` to see what I can do.",
            issue.author
        );

        client.create_comment(issue.number, &greeting).await?;
    }

    Ok(())
}

/// Parse a cortex command from comment text.
fn parse_cortex_command(text: &str) -> String {
    // Look for /cortex <command> pattern
    if let Some(pos) = text.find("/cortex") {
        let after_cortex = &text[pos + 7..];
        let command = after_cortex.split_whitespace().next().unwrap_or("help");
        return command.to_string();
    }

    // Look for @cortex <command> pattern
    if let Some(pos) = text.find("@cortex") {
        let after_cortex = &text[pos + 7..];
        let command = after_cortex.split_whitespace().next().unwrap_or("help");
        return command.to_string();
    }

    "help".to_string()
}

/// Get help message for Cortex commands.
fn get_help_message() -> String {
    r#"## Cortex Commands

| Command | Description |
|---------|-------------|
| `/cortex help` | Show this help message |
| `/cortex review` | Request a code review (PRs only) |
| `/cortex fix` | Suggest fixes for issues |
| `/cortex explain` | Explain the code changes |
| `/cortex test` | Suggest tests for changes |

### Tips
- Mention `@cortex` anywhere in your comment to get my attention
- I automatically review new pull requests when configured
- Use labels like `cortex:review` to trigger specific actions

[Learn more](https://docs.cortex.foundation/github)"#
        .to_string()
}

/// Check GitHub Actions installation status.
async fn run_status(args: StatusArgs) -> Result<()> {
    let repo_path = args.path.unwrap_or_else(|| PathBuf::from("."));

    let mut status = InstallationStatus::default();

    // Check for workflow files
    let workflows_dir = repo_path.join(".github").join("workflows");
    if workflows_dir.exists() {
        for entry in std::fs::read_dir(&workflows_dir)? {
            let entry = entry?;
            let path = entry.path();
            if path.extension().is_some_and(|e| e == "yml" || e == "yaml") {
                let content = std::fs::read_to_string(&path)?;
                if content.contains("Cortex") {
                    status.workflow_installed = true;
                    status.workflow_path = Some(path.clone());

                    // Check workflow features
                    if content.contains("issue_comment") {
                        status.features.push("issue_comment".to_string());
                    }
                    if content.contains("pull_request") {
                        status.features.push("pull_request".to_string());
                    }
                    if content.contains("issues") {
                        status.features.push("issues".to_string());
                    }
                    break;
                }
            }
        }
    }

    // Check for .github directory
    status.github_dir_exists = repo_path.join(".github").exists();

    // Check if we're in a git repo
    status.is_git_repo = repo_path.join(".git").exists();

    if args.json {
        let json = serde_json::to_string_pretty(&status)?;
        println!("{}", json);
        // Return non-zero exit code if workflow is not installed
        if !status.workflow_installed {
            std::process::exit(1);
        }
        return Ok(());
    }

    println!("GitHub Actions Status");
    println!("{}", "=".repeat(40));
    println!();

    if !status.is_git_repo {
        print_warning("Not a git repository.");
        println!("   Run this command from a git repository root.");
        std::process::exit(1);
    }

    if !status.github_dir_exists {
        print_error(".github directory not found.");
        println!("   Run `cortex github install` to set up GitHub Actions.");
        std::process::exit(1);
    }

    if status.workflow_installed {
        print_success("Cortex workflow is installed.");
        if let Some(ref path) = status.workflow_path {
            println!("   Path: {}", path.display());
        }
        println!();
        println!("Features enabled:");
        for feature in &status.features {
            println!("  • {}", feature);
        }
    } else {
        print_error("Cortex workflow not found.");
        println!("   Run `cortex github install` to set up GitHub Actions.");
        std::process::exit(1);
    }

    Ok(())
}

/// Uninstall/remove GitHub Actions workflow.
async fn run_uninstall(args: UninstallArgs) -> Result<()> {
    use std::io::{self, Write};

    let repo_path = args.path.unwrap_or_else(|| PathBuf::from("."));

    // Validate path exists
    if !repo_path.exists() {
        bail!("Path does not exist: {}", repo_path.display());
    }

    // Check for workflow files
    let workflows_dir = repo_path.join(".github").join("workflows");

    // Try multiple possible workflow file names
    let possible_names = vec![
        format!("{}.yml", args.workflow_name),
        format!("{}.yaml", args.workflow_name),
    ];

    let mut found_workflow: Option<PathBuf> = None;
    for name in &possible_names {
        let path = workflows_dir.join(name);
        if path.exists() {
            // Verify it's a Cortex workflow
            if let Ok(content) = std::fs::read_to_string(&path)
                && (content.contains("Cortex") || content.contains("cortex"))
            {
                found_workflow = Some(path);
                break;
            }
        }
    }

    let workflow_path = match found_workflow {
        Some(p) => p,
        None => {
            bail!(
                "Cortex workflow '{}' not found in {}.\n\
                Use `cortex github status` to check installation status.",
                args.workflow_name,
                workflows_dir.display()
            );
        }
    };

    // Confirm removal unless --force
    if !args.force {
        print!(
            "Remove Cortex workflow '{}'? [y/N]: ",
            workflow_path.display()
        );
        io::stdout().flush()?;

        let mut input = String::new();
        io::stdin().read_line(&mut input)?;

        if !input.trim().eq_ignore_ascii_case("y") {
            println!("Cancelled.");
            return Ok(());
        }
    }

    // Remove the workflow file
    std::fs::remove_file(&workflow_path)
        .with_context(|| format!("Failed to remove workflow: {}", workflow_path.display()))?;

    println!("Cortex workflow removed successfully!");
    println!("   Removed: {}", workflow_path.display());
    println!();
    println!(
        "Note: You may also want to remove the CORTEX_API_KEY secret from your repository settings."
    );

    Ok(())
}

/// Update GitHub Actions workflow to latest version.
async fn run_update(args: UpdateArgs) -> Result<()> {
    use cortex_engine::github::{WorkflowConfig, generate_workflow};

    let repo_path = args.path.unwrap_or_else(|| PathBuf::from("."));

    // Validate path exists
    if !repo_path.exists() {
        bail!("Path does not exist: {}", repo_path.display());
    }

    let workflows_dir = repo_path.join(".github").join("workflows");

    // Try to find existing workflow
    let possible_names = vec![
        format!("{}.yml", args.workflow_name),
        format!("{}.yaml", args.workflow_name),
    ];

    let mut existing_path: Option<PathBuf> = None;
    for name in &possible_names {
        let path = workflows_dir.join(name);
        if path.exists() {
            existing_path = Some(path);
            break;
        }
    }

    let workflow_file = match existing_path {
        Some(p) => p,
        None => {
            bail!(
                "Cortex workflow '{}' not found. Use `cortex github install` first.",
                args.workflow_name
            );
        }
    };

    // Generate updated workflow
    let config = WorkflowConfig {
        name: args.workflow_name.clone(),
        pr_review: args.pr_review,
        issue_automation: args.issue_automation,
    };

    let workflow_content = generate_workflow(&config);

    // Write updated workflow
    std::fs::write(&workflow_file, &workflow_content)
        .with_context(|| format!("Failed to write workflow file: {}", workflow_file.display()))?;

    println!("Cortex workflow updated successfully!");
    println!("   Path: {}", workflow_file.display());
    println!();
    println!("Features enabled:");
    if args.pr_review {
        println!("  • PR review automation");
    }
    if args.issue_automation {
        println!("  • Issue automation");
    }
    println!();
    println!("Next steps:");
    println!("  1. Commit and push the updated workflow:");
    println!("     git add {}", workflow_file.display());
    println!("     git commit -m \"Update Cortex workflow\"");
    println!("     git push");

    Ok(())
}

/// Installation status information.
#[derive(Debug, Default, serde::Serialize)]
struct InstallationStatus {
    is_git_repo: bool,
    github_dir_exists: bool,
    workflow_installed: bool,
    workflow_path: Option<PathBuf>,
    features: Vec<String>,
}

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

    #[test]
    fn test_parse_cortex_command() {
        assert_eq!(parse_cortex_command("/cortex help"), "help");
        assert_eq!(parse_cortex_command("/cortex review"), "review");
        assert_eq!(parse_cortex_command("@cortex fix"), "fix");
        assert_eq!(parse_cortex_command("Please @cortex help me"), "help");
        assert_eq!(parse_cortex_command("No command here"), "help");
    }

    #[test]
    fn test_get_help_message() {
        let help = get_help_message();
        assert!(help.contains("/cortex help"));
        assert!(help.contains("/cortex review"));
    }

    #[tokio::test]
    async fn test_install_validates_path_exists() {
        let args = InstallArgs {
            path: Some(PathBuf::from("/nonexistent/path/that/does/not/exist")),
            force: false,
            pr_review: true,
            issue_automation: true,
            workflow_name: "test".to_string(),
        };

        let result = run_install(args).await;
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(
            err.to_string().contains("Target path does not exist"),
            "Expected 'Target path does not exist' error, got: {}",
            err
        );
    }

    #[tokio::test]
    async fn test_install_validates_path_is_directory() {
        use std::io::Write;

        // Create a temporary file to test with
        let temp_dir = std::env::temp_dir();
        let temp_file = temp_dir.join(format!("cortex_test_file_{}", std::process::id()));

        // Create the file
        let mut file = std::fs::File::create(&temp_file).expect("Failed to create temp file");
        file.write_all(b"test content")
            .expect("Failed to write to temp file");
        drop(file);

        let args = InstallArgs {
            path: Some(temp_file.clone()),
            force: false,
            pr_review: true,
            issue_automation: true,
            workflow_name: "test".to_string(),
        };

        let result = run_install(args).await;

        // Clean up
        let _ = std::fs::remove_file(&temp_file);

        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(
            err.to_string().contains("Target path is not a directory"),
            "Expected 'Target path is not a directory' error, got: {}",
            err
        );
    }

    #[tokio::test]
    async fn test_install_accepts_valid_directory() {
        // Create a temporary directory
        let temp_dir = std::env::temp_dir().join(format!("cortex_test_dir_{}", std::process::id()));
        std::fs::create_dir_all(&temp_dir).expect("Failed to create temp dir");

        let args = InstallArgs {
            path: Some(temp_dir.clone()),
            force: false,
            pr_review: true,
            issue_automation: true,
            workflow_name: "test-workflow".to_string(),
        };

        let result = run_install(args).await;

        // Clean up
        let workflow_path = temp_dir
            .join(".github")
            .join("workflows")
            .join("test-workflow.yml");
        let _ = std::fs::remove_file(&workflow_path);
        let _ = std::fs::remove_dir_all(&temp_dir);

        assert!(
            result.is_ok(),
            "Expected successful install to valid directory, got error: {:?}",
            result
        );
    }
}