pmat 2.93.1

//! Comprehensive CLI Functional Test Harness
//!
//! CRITICAL: This test harness verifies EVERY command and option works.
//! Without this, the entire project is dead in the water.
//!
//! Principles:
//! - Functional programming: pure functions, immutable data
//! - Exhaustive testing: every command, every option combination
//! - Real execution: actually run the binary, don't mock
//! - Output validation: verify output is sensible, not just "no error"

use std::collections::HashMap;
use std::path::PathBuf;
use std::process::Command;
use tempfile::TempDir;

/// Test result for a single command execution
#[derive(Debug, Clone)]
struct CommandResult {
    command: String,
    args: Vec<String>,
    success: bool,
    stdout: String,
    stderr: String,
    exit_code: i32,
    validation_errors: Vec<String>,
}

/// Validation function type
type Validator = fn(&str) -> Result<(), String>;

/// Test specification for a command
#[derive(Clone)]
struct CommandSpec {
    command: String,
    subcommand: Option<String>,
    args: Vec<String>,
    options: HashMap<String, String>,
    should_succeed: bool,
    output_validators: Vec<Validator>,
}

/// The main test harness
struct CliTestHarness {
    binary_path: PathBuf,
    test_dir: TempDir,
    results: Vec<CommandResult>,
}

impl CliTestHarness {
    fn new() -> Self {
        let binary_path = PathBuf::from(env!("CARGO_BIN_EXE_pmat"));
        let test_dir = TempDir::new().expect("Failed to create temp dir");

        Self {
            binary_path,
            test_dir,
            results: Vec::new(),
        }
    }

    /// Execute a command and validate output
    fn execute_command(&mut self, spec: CommandSpec) -> CommandResult {
        let mut cmd = Command::new(&self.binary_path);

        // Add command and subcommand
        cmd.arg(&spec.command);
        if let Some(subcmd) = &spec.subcommand {
            cmd.arg(subcmd);
        }

        // Add args
        for arg in &spec.args {
            cmd.arg(arg);
        }

        // Add options
        for (key, value) in &spec.options {
            cmd.arg(format!("--{}", key));
            if !value.is_empty() {
                cmd.arg(value);
            }
        }

        // Execute with timeout to prevent hanging
        let cmd_child = cmd.spawn().expect("Failed to spawn command");
        let output = match cmd_child.wait_with_output() {
            Ok(output) => output,
            Err(e) => panic!("Command failed to complete: {}", e),
        };

        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
        let exit_code = output.status.code().unwrap_or(-1);

        // Validate output
        let mut validation_errors = Vec::new();

        if spec.should_succeed && !output.status.success() {
            validation_errors.push(format!(
                "Command should succeed but failed with exit code {}",
                exit_code
            ));
        }

        // Run custom validators
        for validator in &spec.output_validators {
            if let Err(e) = validator(&stdout) {
                validation_errors.push(e);
            }
        }

        let result = CommandResult {
            command: format!(
                "{} {}",
                spec.command,
                spec.subcommand.as_ref().unwrap_or(&String::new())
            ),
            args: spec.args.clone(),
            success: output.status.success(),
            stdout: stdout.clone(),
            stderr: stderr.clone(),
            exit_code,
            validation_errors: validation_errors.clone(),
        };

        self.results.push(result.clone());
        result
    }

    /// Generate test report
    fn generate_report(&self) -> String {
        let total = self.results.len();
        let passed = self
            .results
            .iter()
            .filter(|r| r.validation_errors.is_empty())
            .count();
        let failed = total - passed;

        let mut report = "# CLI Functional Test Report\n\n".to_string();
        report.push_str(&format!("Total Commands Tested: {}\n", total));
        report.push_str(&format!("✅ Passed: {}\n", passed));
        report.push_str(&format!("❌ Failed: {}\n\n", failed));

        if failed > 0 {
            report.push_str("## Failed Commands\n\n");
            for result in &self.results {
                if !result.validation_errors.is_empty() {
                    report.push_str(&format!("### Command: `{}`\n", result.command));
                    report.push_str(&format!("Args: {:?}\n", result.args));
                    report.push_str(&format!("Exit Code: {}\n", result.exit_code));
                    report.push_str("Errors:\n");
                    for error in &result.validation_errors {
                        report.push_str(&format!("- {}\n", error));
                    }
                    if !result.stderr.is_empty() {
                        report.push_str(&format!("Stderr:\n```\n{}\n```\n", result.stderr));
                    }
                    report.push('\n');
                }
            }
        }

        report.push_str("## Working Commands\n\n");
        for result in &self.results {
            if result.validation_errors.is_empty() {
                report.push_str(&format!("✅ `pmat {}`", result.command));
                if !result.args.is_empty() {
                    report.push_str(&format!(" {}", result.args.join(" ")));
                }
                report.push('\n');
            }
        }

        report
    }
}

// Validator functions
fn validate_help_has_usage(output: &str) -> Result<(), String> {
    if output.contains("Usage:") {
        Ok(())
    } else {
        Err("Help output missing 'Usage:' section".to_string())
    }
}

fn validate_help_has_commands(output: &str) -> Result<(), String> {
    if output.contains("Commands:") {
        Ok(())
    } else {
        Err("Help output missing 'Commands:' section".to_string())
    }
}

fn validate_has_version(output: &str) -> Result<(), String> {
    if output.contains("pmat") {
        Ok(())
    } else {
        Err("Version output doesn't contain 'pmat'".to_string())
    }
}

fn validate_complexity_output(output: &str) -> Result<(), String> {
    if output.contains("Complexity Analysis") || output.contains("Files analyzed") {
        Ok(())
    } else {
        Err("Complexity output missing expected sections".to_string())
    }
}

fn validate_satd_output(output: &str) -> Result<(), String> {
    if output.contains("SATD Analysis") || output.contains("Files analyzed") {
        Ok(())
    } else {
        Err("SATD output missing expected sections".to_string())
    }
}

fn validate_dead_code_output(output: &str) -> Result<(), String> {
    if output.contains("Dead Code Analysis") || output.contains("Files analyzed") {
        Ok(())
    } else {
        Err("Dead code output missing expected sections".to_string())
    }
}

fn validate_quality_gate_output(output: &str) -> Result<(), String> {
    if output.contains("Quality Gate") || output.contains("Checking") {
        Ok(())
    } else {
        Err("Quality gate output missing expected sections".to_string())
    }
}

/// Create all command specifications to test
fn generate_command_specs() -> Vec<CommandSpec> {
    let mut specs = Vec::new();

    // Help commands - these MUST work
    specs.push(CommandSpec {
        command: "--help".to_string(),
        subcommand: None,
        args: vec![],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![validate_help_has_usage, validate_help_has_commands],
    });

    // Version command
    specs.push(CommandSpec {
        command: "--version".to_string(),
        subcommand: None,
        args: vec![],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![validate_has_version],
    });

    // Analyze complexity - various forms
    specs.push(CommandSpec {
        command: "analyze".to_string(),
        subcommand: Some("complexity".to_string()),
        args: vec![],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![validate_complexity_output],
    });

    // Analyze complexity with file
    specs.push(CommandSpec {
        command: "analyze".to_string(),
        subcommand: Some("complexity".to_string()),
        args: vec![],
        options: {
            let mut opts = HashMap::new();
            opts.insert("file".to_string(), "src/lib.rs".to_string());
            opts
        },
        should_succeed: true,
        output_validators: vec![],
    });

    // Analyze SATD
    specs.push(CommandSpec {
        command: "analyze".to_string(),
        subcommand: Some("satd".to_string()),
        args: vec![],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![validate_satd_output],
    });

    // Analyze dead-code - FIXED: Should no longer hang
    specs.push(CommandSpec {
        command: "analyze".to_string(),
        subcommand: Some("dead-code".to_string()),
        args: vec![],
        options: {
            let mut opts = HashMap::new();
            opts.insert("path".to_string(), ".".to_string());
            opts
        },
        should_succeed: true,
        output_validators: vec![validate_dead_code_output],
    });

    // Quality gate
    specs.push(CommandSpec {
        command: "quality-gate".to_string(),
        subcommand: None,
        args: vec![],
        options: HashMap::new(),
        should_succeed: true, // Should succeed even if quality fails
        output_validators: vec![validate_quality_gate_output],
    });

    // Demo command
    specs.push(CommandSpec {
        command: "demo".to_string(),
        subcommand: None,
        args: vec!["--help".to_string()],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![],
    });

    // Agent command
    specs.push(CommandSpec {
        command: "agent".to_string(),
        subcommand: None,
        args: vec!["--help".to_string()],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![],
    });

    // TDG analysis
    specs.push(CommandSpec {
        command: "analyze".to_string(),
        subcommand: Some("tdg".to_string()),
        args: vec![],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![],
    });

    // Context generation
    specs.push(CommandSpec {
        command: "context".to_string(),
        subcommand: None,
        args: vec![],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![],
    });

    // Refactor commands
    specs.push(CommandSpec {
        command: "refactor".to_string(),
        subcommand: None,
        args: vec!["--help".to_string()],
        options: HashMap::new(),
        should_succeed: true,
        output_validators: vec![],
    });

    specs
}

#[test]
fn test_all_cli_commands_work() {
    let mut harness = CliTestHarness::new();
    let specs = generate_command_specs();

    println!("Testing {} command variations...", specs.len());

    let mut failed = 0;
    for spec in specs {
        let result = harness.execute_command(spec.clone());
        if !result.validation_errors.is_empty() {
            failed += 1;
            eprintln!(
                "❌ Failed: {} {}",
                spec.command,
                spec.subcommand.unwrap_or_default()
            );
            for error in &result.validation_errors {
                eprintln!("   {}", error);
            }
        } else {
            println!(
                "✅ Passed: {} {}",
                spec.command,
                spec.subcommand.unwrap_or_default()
            );
        }
    }

    // Generate report
    let report = harness.generate_report();
    std::fs::write("cli_test_report.md", &report).expect("Failed to write report");

    if failed > 0 {
        panic!(
            "{} commands failed! See cli_test_report.md for details",
            failed
        );
    }
}

#[test]
fn test_help_is_actually_helpful() {
    let output = Command::new(env!("CARGO_BIN_EXE_pmat"))
        .arg("--help")
        .output()
        .expect("Failed to run help");

    let help_text = String::from_utf8_lossy(&output.stdout);

    // Help should show actual examples
    assert!(help_text.contains("Usage:"), "Help should show usage");
    assert!(help_text.contains("Commands:"), "Help should list commands");

    // Help should be organized
    assert!(help_text.contains("analyze"), "Should show analyze command");
    assert!(
        help_text.contains("quality-gate"),
        "Should show quality-gate command"
    );
}

#[test]
fn test_analyze_complexity_actually_finds_files() {
    let output = Command::new(env!("CARGO_BIN_EXE_pmat"))
        .arg("analyze")
        .arg("complexity")
        .arg("--project-path")
        .arg(".")
        .output()
        .expect("Failed to run complexity analysis");

    let stdout = String::from_utf8_lossy(&output.stdout);

    // Should actually find some files
    assert!(
        !stdout.contains("Files analyzed: 0"),
        "Complexity analysis should find files, but got:\n{}",
        stdout
    );
}

#[test]
fn test_error_messages_are_helpful() {
    // Test invalid command
    let output = Command::new(env!("CARGO_BIN_EXE_pmat"))
        .arg("agent")
        .arg("analyze") // This is wrong - should be separate commands
        .output()
        .expect("Failed to run command");

    let stderr = String::from_utf8_lossy(&output.stderr);

    // Error should suggest correct usage
    assert!(
        stderr.contains("unrecognized") || stderr.contains("error"),
        "Should show clear error message"
    );

    // Ideally should suggest: "Did you mean 'pmat analyze'?"
    // This is what we need to add!
}