cargo-copter 0.3.0

// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

// Allow dead code and unused imports during development
// TODO: Remove these when the codebase stabilizes
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]

mod api;
mod bridge;
mod categorize;
mod cli;
mod compile;
mod config;
mod console_format;
mod docker;
mod download;
mod error_extract;
mod git;
mod manifest;
mod metadata;
mod report;
mod runner;
mod types;
mod ui;
mod version;

use std::fs;
use std::path::PathBuf;
use types::*;

fn main() {
    env_logger::init();

    // Parse CLI arguments
    let args = cli::CliArgs::parse_args();

    // Handle --docker flag: re-execute inside Docker container
    if args.docker {
        let original_args: Vec<String> = std::env::args().skip(1).collect();
        match docker::run_in_docker(&original_args) {
            Ok(status) => {
                std::process::exit(status.code().unwrap_or(1));
            }
            Err(e) => {
                ui::print_error(&e);
                std::process::exit(1);
            }
        }
    }

    // Validate arguments
    if let Err(e) = args.validate() {
        ui::print_error(&e);
        std::process::exit(1);
    }

    // Clean staging directory if requested
    if args.clean {
        let staging_dir = args.get_staging_dir();
        if staging_dir.exists() {
            match fs::remove_dir_all(&staging_dir) {
                Ok(_) => {
                    println!("Cleaned staging directory: {}", staging_dir.display());
                }
                Err(e) => {
                    eprintln!("Warning: Failed to clean staging directory: {}", e);
                }
            }
        }
    }

    // Set console width override if specified (for testing)
    if let Some(width) = args.console_width {
        console_format::set_console_width(width);
    }

    // Create report directory
    let report_dir = PathBuf::from("copter-report");
    if let Err(e) = fs::create_dir_all(&report_dir) {
        eprintln!("Warning: Failed to create report directory: {}", e);
    }
    // Append copter-report/ to .gitignore if it exists and doesn't already have it
    let gitignore_path = PathBuf::from(".gitignore");
    if gitignore_path.exists()
        && let Ok(content) = fs::read_to_string(&gitignore_path)
        && !content.lines().any(|line| line.trim() == "copter-report" || line.trim() == "copter-report/")
    {
        let entry = if content.ends_with('\n') { "copter-report/\n" } else { "\ncopter-report/\n" };
        let _ = fs::OpenOptions::new().append(true).open(&gitignore_path).and_then(|mut f| {
            use std::io::Write;
            f.write_all(entry.as_bytes())
        });
    }

    // Build test matrix
    let matrix = match config::build_test_matrix(&args) {
        Ok(m) => m,
        Err(e) => {
            ui::print_error(&format!("Configuration error: {}", e));
            std::process::exit(1);
        }
    };

    // Initialize table widths for console output (only needed for table format)
    let version_strs: Vec<String> = matrix.base_versions.iter().map(|v| v.crate_ref.version.display()).collect();
    let display_version = version_strs.first().map(|s| s.as_str()).unwrap_or("unknown");
    let force_versions = matrix.base_versions.iter().any(|v| v.override_mode == OverrideMode::Force);

    let simple_mode = args.simple;
    let base_crate = matrix.base_crate.clone();

    if simple_mode {
        // Simple output header with list of all dependents
        let dependent_names: Vec<String> = matrix
            .dependents
            .iter()
            .map(|d| format!("{}:{}", d.crate_ref.name, d.crate_ref.version.display()))
            .collect();
        report::print_simple_header(&matrix.base_crate, display_version, &dependent_names, &version_strs);
    } else {
        // Table output initialization and header
        report::init_table_widths(&version_strs, display_version, force_versions);

        let test_plan = format_test_plan_string(&matrix);
        let this_path = matrix.base_versions.iter().find_map(|v| match &v.crate_ref.source {
            CrateSource::Local { path } => Some(path.display().to_string()),
            _ => None,
        });
        report::print_table_header(
            &matrix.base_crate,
            display_version,
            matrix.dependents.len(),
            Some(&test_plan),
            this_path.as_deref(),
        );
    }

    // Run tests with streaming output
    let mut offered_rows = Vec::new();
    let mut prev_dependent: Option<String> = None;
    let mut prev_error: Option<String> = None;
    let report_dir_clone = report_dir.clone();
    let staging_dir = matrix.staging_dir.clone();

    // For simple mode: buffer results per dependent
    let mut current_dependent_results = report::DependentResults::default();

    let _test_results = match runner::run_tests(matrix.clone(), |result| {
        // Convert to OfferedRow immediately
        let row = bridge::test_result_to_offered_row(result);

        if simple_mode {
            // Simple output mode - buffer results until all versions for dependent are tested
            // Check if we've moved to a new dependent
            if current_dependent_results.dependent_name != row.primary.dependent_name
                || current_dependent_results.dependent_version != row.primary.dependent_version
            {
                // Print previous dependent's results if any
                if !current_dependent_results.dependent_name.is_empty() {
                    report::print_simple_dependent_result(&current_dependent_results, &base_crate, &report_dir_clone);
                }
                // Start new dependent
                current_dependent_results = report::DependentResults {
                    dependent_name: row.primary.dependent_name.clone(),
                    dependent_version: row.primary.dependent_version.clone(),
                    baseline: None,
                    offered_versions: Vec::new(),
                };
            }

            // Add to current dependent's results
            if row.offered.is_none() {
                current_dependent_results.baseline = Some(row.clone());
            } else {
                current_dependent_results.offered_versions.push(row.clone());
            }
        } else {
            // Table output mode
            // Print separator between different dependents
            if let Some(ref prev) = prev_dependent
                && *prev != row.primary.dependent_name
            {
                report::print_separator_line();
            }

            // Determine if this is the last row for this dependent
            // (We can't know this in streaming mode, so always pass false)
            let is_last = false;

            // Print the row immediately
            report::print_offered_row(&row, is_last, prev_error.as_deref(), args.error_lines);
        }

        // Write failure log for failed tests
        if !result.execution.is_success() {
            report::write_failure_log(&report_dir_clone, &staging_dir, result);
        }

        // Update tracking
        prev_error = report::extract_error_text(&row);
        prev_dependent = Some(row.primary.dependent_name.clone());

        // Save for later report generation
        offered_rows.push(row);
    }) {
        Ok(results) => results,
        Err(e) => {
            ui::print_error(&format!("Test execution failed: {}", e));
            std::process::exit(1);
        }
    };

    // Print final dependent's results in simple mode
    if simple_mode && !current_dependent_results.dependent_name.is_empty() {
        report::print_simple_dependent_result(&current_dependent_results, &base_crate, &report_dir);
    }

    // Write combined log file (for simple mode, also useful for table mode)
    let combined_log_path = report::write_combined_log(&report_dir, &offered_rows, &base_crate);

    if simple_mode {
        // Simple mode: print simple summary with regressions listed
        report::print_simple_summary(&offered_rows, &report_dir, &base_crate, &combined_log_path);
    } else {
        // Table mode: print table footer
        report::print_table_footer();
    }

    // Generate non-console reports (markdown, JSON) - always do this
    generate_non_console_reports(&offered_rows, &args, &matrix, &report_dir, simple_mode);

    // If using top-dependents and there were failures, suggest a targeted re-test
    if args.dependents.is_empty() && args.dependent_paths.is_empty() {
        suggest_failed_retest(&offered_rows, &args, &matrix);
    }

    // Determine exit code
    let summary = report::summarize_offered_rows(&offered_rows);
    let exit_code = if summary.regressed > 0 { -2 } else { 0 };

    std::process::exit(exit_code);
}

/// Print test plan showing what will be tested
fn print_test_plan(matrix: &TestMatrix, args: &cli::CliArgs) {
    let deps_display: Vec<String> = matrix
        .dependents
        .iter()
        .take(5)
        .map(|d| {
            let version = d.crate_ref.version.display();
            if version == "latest" { d.crate_ref.name.clone() } else { format!("{}:{}", d.crate_ref.name, version) }
        })
        .collect();

    let more_deps = if matrix.dependents.len() > 5 {
        format!(" ... and {} more", matrix.dependents.len() - 5)
    } else {
        String::new()
    };

    let mut versions_display = vec!["baseline".to_string()];
    for version_spec in &matrix.base_versions {
        let version_str = version_spec.crate_ref.version.display();
        if version_spec.override_mode == OverrideMode::Force {
            versions_display.push(format!("{} [!]", version_str));
        } else {
            versions_display.push(version_str);
        }
    }

    let test_plan = format!(
        "  Dependents: {}{}\n  Versions:   {}",
        deps_display.join(", "),
        more_deps,
        versions_display.join(", ")
    );

    // Determine source path for display
    let this_path = matrix.base_versions.iter().find_map(|v| match &v.crate_ref.source {
        CrateSource::Local { path } => Some(path.display().to_string()),
        _ => None,
    });

    // Just print the test plan summary (table header printed separately during streaming)
    println!("Testing {} reverse dependencies of {}", matrix.dependents.len(), matrix.base_crate);
    println!("{}", test_plan);
    if let Some(path) = this_path {
        println!("  this = {} (your work-in-progress version)", path);
    }
    println!();
}

/// Generate non-console reports (markdown, JSON) and comparison table
fn generate_non_console_reports(
    rows: &[OfferedRow],
    _args: &cli::CliArgs,
    matrix: &TestMatrix,
    report_dir: &std::path::Path,
    simple_mode: bool,
) {
    // Export markdown report
    let markdown_path = report_dir.join("report.md");
    let test_plan = format_test_plan_string(matrix);
    let this_path = matrix.base_versions.iter().find_map(|v| match &v.crate_ref.source {
        CrateSource::Local { path } => Some(path.display().to_string()),
        _ => None,
    });

    if let Err(e) = report::export_markdown_table_report(
        rows,
        &markdown_path,
        &matrix.base_crate,
        &matrix.base_versions.first().map(|v| v.crate_ref.version.display()).unwrap_or_else(|| "unknown".to_string()),
        matrix.dependents.len(),
        Some(&test_plan),
        this_path.as_deref(),
    ) {
        eprintln!("Warning: Failed to save markdown report: {}", e);
    }

    // Export JSON report
    let json_path = report_dir.join("report.json");
    if let Err(e) = report::export_json_report(
        rows,
        &json_path,
        &matrix.base_crate,
        &matrix.base_versions.first().map(|v| v.crate_ref.version.display()).unwrap_or_else(|| "unknown".to_string()),
        matrix.dependents.len(),
    ) {
        eprintln!("Warning: Failed to save JSON report: {}", e);
    }

    if !simple_mode {
        // Print comparison table (only for table mode - simple mode has its own summary)
        let comparison_stats = report::generate_comparison_table(rows);
        report::print_comparison_table(&comparison_stats);
    }

    // Print compatibility report (table mode only — simple mode has its own summary)
    if !simple_mode {
        let compat_report = report::build_compatibility_report(rows, &matrix.base_crate);
        report::print_compatibility_report(&compat_report, report_dir);
    }
}

/// Format test plan as a string
fn format_test_plan_string(matrix: &TestMatrix) -> String {
    let deps_display: Vec<String> = matrix
        .dependents
        .iter()
        .take(5)
        .map(|d| {
            let version = d.crate_ref.version.display();
            if version == "latest" { d.crate_ref.name.clone() } else { format!("{}:{}", d.crate_ref.name, version) }
        })
        .collect();

    let more_deps = if matrix.dependents.len() > 5 {
        format!(" ... and {} more", matrix.dependents.len() - 5)
    } else {
        String::new()
    };

    let mut versions_display = vec!["baseline".to_string()];
    for version_spec in &matrix.base_versions {
        let version_str = version_spec.crate_ref.version.display();
        if version_spec.override_mode == OverrideMode::Force {
            versions_display.push(format!("{} [!]", version_str));
        } else {
            versions_display.push(version_str);
        }
    }

    format!("  Dependents: {}{}\n  Versions:   {}", deps_display.join(", "), more_deps, versions_display.join(", "))
}

/// Suggest a command to re-test only the failed dependents
fn suggest_failed_retest(rows: &[OfferedRow], args: &cli::CliArgs, matrix: &TestMatrix) {
    // Collect dependents that had any failures
    let mut failed_dependents: std::collections::HashSet<String> = std::collections::HashSet::new();

    for row in rows {
        // Check if this dependent had any failures (regression or baseline failed)
        let failed = match row.baseline_passed {
            Some(true) => !row.test.all_passed(), // Regression: baseline passed, offered failed
            Some(false) => true,                  // Baseline already broken
            None => !row.test.all_passed(),       // This IS the baseline and it failed
        };

        if failed {
            failed_dependents.insert(row.primary.dependent_name.clone());
        }
    }

    // If there are failures and some passed, suggest a focused re-test
    if !failed_dependents.is_empty() && failed_dependents.len() < matrix.dependents.len() {
        println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!("💡 To re-test only the {} failed dependent(s):", failed_dependents.len());
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

        // Build the command
        let mut cmd = String::from("cargo-copter");

        // Add path or crate argument
        if let Some(ref path) = args.path {
            cmd.push_str(&format!(" --path {}", path.display()));
        } else if let Some(ref crate_name) = args.crate_name {
            cmd.push_str(&format!(" --crate {}", crate_name));
        }

        // Add test-versions if specified
        if !args.test_versions.is_empty() {
            cmd.push_str(" --test-versions");
            for v in &args.test_versions {
                cmd.push_str(&format!(" {}", v));
            }
        }

        // Add force-versions if specified
        if !args.force_versions.is_empty() {
            cmd.push_str(" --force-versions");
            for v in &args.force_versions {
                cmd.push_str(&format!(" {}", v));
            }
        }

        // Add the failed dependents
        cmd.push_str(" --dependents");
        let mut sorted_failed: Vec<_> = failed_dependents.iter().collect();
        sorted_failed.sort();
        for dep in sorted_failed {
            cmd.push_str(&format!(" {}", dep));
        }

        // Add other relevant flags
        if args.skip_normal_testing {
            cmd.push_str(" --skip-normal-testing");
        }
        if args.error_lines != 10 {
            cmd.push_str(&format!(" --error-lines {}", args.error_lines));
        }

        println!("  {}\n", cmd);
    }
}