forge-guard 0.2.0

//! `forge-guard report` — generate audit reports.

use crate::core::{AuditResult, ProjectConfig};
use crate::reports;

use super::ReportArgs;
use anyhow::{Context, Result};
use colored::*;

/// Generate audit reports from existing results or re-run.
pub fn run(args: &ReportArgs) -> Result<()> {
    let config = ProjectConfig::from_default_location();

    // Try to load existing audit result
    let result = if let Some(input_path) = &args.input {
        let content = std::fs::read_to_string(input_path).context("Failed to read input file")?;
        serde_json::from_str::<AuditResult>(&content)
            .context("Failed to parse audit result JSON")?
    } else {
        // Try loading from cache
        let cache_dir = config.project_root.join(".forge-guard-cache");
        let cache_file = cache_dir.join("last_audit.json");
        if cache_file.exists() {
            let content =
                std::fs::read_to_string(&cache_file).context("Failed to read cached audit")?;
            serde_json::from_str::<AuditResult>(&content)
                .context("Failed to parse cached audit result")?
        } else {
            anyhow::bail!(
                "No audit result found. Run `forge-guard audit` first or specify --input"
            );
        }
    };

    let output_dir = std::path::PathBuf::from(&config.report.output_dir);
    std::fs::create_dir_all(&output_dir)?;

    match args.format.to_lowercase().as_str() {
        "json" => {
            let output_path = args
                .output
                .clone()
                .unwrap_or_else(|| output_dir.join("audit.json"));
            reports::json::write_report(&result, &output_path)?;
            println!(
                "{} JSON report written to {}",
                "✅".green(),
                output_path.display()
            );
        }
        "markdown" | "md" => {
            let output_path = args
                .output
                .clone()
                .unwrap_or_else(|| output_dir.join("audit.md"));
            let md = reports::markdown::generate_report(&result)?;
            std::fs::write(&output_path, md)?;
            println!(
                "{} Markdown report written to {}",
                "✅".green(),
                output_path.display()
            );
        }
        "html" => {
            let output_path = args
                .output
                .clone()
                .unwrap_or_else(|| output_dir.join("audit.html"));
            let html = reports::html::generate_report(&result)?;
            std::fs::write(&output_path, html)?;
            println!(
                "{} HTML report written to {}",
                "✅".green(),
                output_path.display()
            );
        }
        other => {
            anyhow::bail!(
                "Unsupported format: {}. Use 'json', 'markdown', or 'html'.",
                other
            );
        }
    }

    if args.shared.json {
        println!("{}", serde_json::to_string_pretty(&result)?);
    }

    Ok(())
}

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

    #[test]
    fn test_report_arg_defaults() {
        let args = ReportArgs {
            shared: super::super::SharedFlags {
                chain: "ethereum".into(),
                project: std::path::PathBuf::from("."),
                json: false,
                markdown: false,
                html: false,
                strict: false,
                offline: false,
                production: false,
                report: false,
                parallelism: 4,
            },
            input: None,
            format: "markdown".into(),
            output: None,
            exploit_paths: false,
            summary: false,
        };
        assert!(args.input.is_none());
        assert_eq!(args.format, "markdown");
        assert!(args.output.is_none());
        assert!(!args.exploit_paths);
        assert!(!args.summary);
    }

    #[test]
    fn test_report_with_json_format() {
        let args = ReportArgs {
            shared: super::super::SharedFlags::default(),
            input: Some(std::path::PathBuf::from("audit.json")),
            format: "json".into(),
            output: Some(std::path::PathBuf::from("report.json")),
            exploit_paths: true,
            summary: false,
        };
        assert_eq!(args.format, "json");
        assert!(args.input.is_some());
        assert!(args.exploit_paths);
    }

    #[test]
    fn test_report_format_lowercasing() {
        // Test the format matching logic used in run()
        let format_upper = "MARKDOWN";
        let format_lower = format_upper.to_lowercase();
        assert_eq!(format_lower, "markdown");
        assert!(matches!(format_lower.as_str(), "json" | "markdown" | "md"));

        let format_json = "JSON";
        assert_eq!(format_json.to_lowercase(), "json");

        let format_md = "MD";
        assert_eq!(format_md.to_lowercase(), "md");
    }

    #[test]
    fn test_report_html_format() {
        let args = ReportArgs {
            shared: super::super::SharedFlags::default(),
            input: None,
            format: "html".into(),
            output: Some(std::path::PathBuf::from("report.html")),
            exploit_paths: false,
            summary: false,
        };
        assert_eq!(args.format, "html");
        assert!(args.output.is_some());
    }

    #[test]
    fn test_report_unsupported_format() {
        let format = "pdf";
        assert!(!matches!(format, "json" | "markdown" | "md" | "html"));
    }

    #[test]
    fn test_report_output_dir_from_config() {
        let config = ProjectConfig::default();
        assert_eq!(config.report.output_dir, "reports");
    }
}