schema_risk/

output.rs

//! Terminal output renderer – pretty-prints analysis results to stdout.

use crate::drift::DriftReport;
use crate::graph::{SchemaEdge, SchemaGraph, SchemaNode};
use crate::impact::ImpactReport;
use crate::locks::{LockMode, MigrationTimeline};
use crate::parser::ParsedStatement;
use crate::recommendation::{FixSeverity, FixSuggestion};
use crate::types::{DetectedOperation, MigrationReport, RiskLevel};
use colored::Colorize;
use petgraph::visit::EdgeRef;

// ─────────────────────────────────────────────
// Colours
// ─────────────────────────────────────────────

fn risk_color(level: RiskLevel) -> colored::ColoredString {
    match level {
        RiskLevel::Low => level.to_string().green().bold(),
        RiskLevel::Medium => level.to_string().yellow().bold(),
        RiskLevel::High => level.to_string().truecolor(255, 140, 0).bold(),
        RiskLevel::Critical => level.to_string().red().bold(),
    }
}

// ─────────────────────────────────────────────
// Main render function
// ─────────────────────────────────────────────

pub fn render(report: &MigrationReport, verbose: bool) {
    let separator = "─".repeat(60);

    println!("\n{}", separator.dimmed());
    println!("{}  {}", " SchemaRisk Analysis".bold(), report.file.cyan());
    println!("{}", separator.dimmed());

    // Overall risk badge
    println!(
        "\n  Migration Risk:  {}   (score: {})",
        risk_color(report.overall_risk),
        report.score.to_string().bold()
    );

    // Affected tables
    if !report.affected_tables.is_empty() {
        println!(
            "\n  {} {}",
            "Tables affected:".bold(),
            report.affected_tables.join(", ").cyan()
        );
    }

    // Lock estimate
    if let Some(secs) = report.estimated_lock_seconds {
        let lock_str = if secs >= 60 {
            format!("~{} min {} sec", secs / 60, secs % 60)
        } else {
            format!("~{} sec", secs)
        };
        let colored = if secs > 30 {
            lock_str.red()
        } else if secs > 5 {
            lock_str.yellow()
        } else {
            lock_str.green()
        };
        println!("  {} {}", "Estimated lock duration:".bold(), colored);
    }

    // Index rebuild
    if report.index_rebuild_required {
        println!(
            "  {} {}",
            "Index rebuild required:".bold(),
            "YES".red().bold()
        );
    }

    // Maintenance window
    if report.requires_maintenance_window {
        println!(
            "  {} {}",
            "Requires maintenance window:".bold(),
            "YES".red().bold()
        );
    }

    // Foreign key impacts
    if !report.fk_impacts.is_empty() {
        println!("\n  {}:", "Foreign Key Impact".bold().underline());
        for fk in &report.fk_impacts {
            let cascade_note = if fk.cascade {
                " (ON DELETE CASCADE!)".red().to_string()
            } else {
                String::new()
            };
            println!(
                "    {} {} → {}{}",
                "•".dimmed(),
                fk.constraint_name.yellow(),
                fk.to_table.cyan(),
                cascade_note
            );
        }
    }

    // Detected operations
    if verbose && !report.operations.is_empty() {
        println!("\n  {}:", "Detected Operations".bold().underline());
        for op in &report.operations {
            println!(
                "    {} [{}] {}",
                "•".dimmed(),
                risk_color(op.risk_level),
                op.description
            );
            if op.acquires_lock {
                println!("       {} acquires table lock", "⚠".yellow());
            }
            if op.index_rebuild {
                println!("       {} triggers index rebuild", "⟳".yellow());
            }
        }
    }

    // Warnings
    if !report.warnings.is_empty() {
        println!("\n  {}:", "Warnings".bold().underline());
        for w in &report.warnings {
            println!("    {} {}", "!".yellow().bold(), w);
        }
    }

    // Recommendations
    if !report.recommendations.is_empty() {
        println!("\n  {}:", "Recommendations".bold().underline());
        for r in &report.recommendations {
            println!("    {} {}", "→".green(), r);
        }
    }

    println!("\n{}", separator.dimmed());

    // Summary line for CI logs
    let stamp = if report.requires_maintenance_window {
        "  ⛔ This migration should NOT be deployed without review".red()
    } else if report.overall_risk >= RiskLevel::Medium {
        "  ⚠  Review recommended before deploying".yellow()
    } else {
        "  ✓  Migration looks safe".green()
    };
    println!("{}\n", stamp);
}

pub fn render_statement_breakdown(stmts: &[ParsedStatement], operations: &[DetectedOperation]) {
    let separator = "─".repeat(60);

    println!("\n{}", separator.dimmed());
    println!("{}", " Statement-by-Statement Breakdown".bold());
    println!("{}", separator.dimmed());

    for (index, stmt) in stmts.iter().enumerate() {
        let preview = statement_preview(stmt);
        println!("\n  [{:02}] {}", index + 1, preview);

        if let Some(op) = operations.get(index) {
            if !op.description.is_empty() {
                println!("       {} {}", "→".green(), op.description.cyan());
            }
            if let Some(warning) = &op.warning {
                println!("       {} {}", "⚠".yellow(), warning.yellow());
            }
        }
    }

    println!("\n{}", separator.dimmed());
}

pub fn render_graph_text(graph: &SchemaGraph) {
    let separator = "─".repeat(60);

    println!("\n{}", separator.dimmed());
    println!("{}", " Schema Dependency Graph".bold());
    println!("{}", separator.dimmed());

    let mut tables: Vec<String> = graph.table_index.keys().cloned().collect();
    tables.sort();

    if tables.is_empty() {
        println!("\n  {} No tables found in migration input.", "ℹ".cyan());
        println!("\n{}", separator.dimmed());
        return;
    }

    println!("\n  {}", "Tables".bold().underline());
    for table in &tables {
        println!("    {} {}", "•".dimmed(), table.cyan());
    }

    let mut fk_lines: Vec<String> = Vec::new();
    for edge in graph.graph.edge_references() {
        if let SchemaEdge::ForeignKey {
            constraint_name,
            from_columns,
            to_columns,
            cascade_delete,
            ..
        } = edge.weight()
        {
            let Some(SchemaNode::Table {
                name: from_table, ..
            }) = graph.graph.node_weight(edge.source())
            else {
                continue;
            };
            let Some(SchemaNode::Table { name: to_table, .. }) =
                graph.graph.node_weight(edge.target())
            else {
                continue;
            };

            let from_col = from_columns.first().map(String::as_str).unwrap_or("*");
            let to_col = to_columns.first().map(String::as_str).unwrap_or("*");
            let fk_name = constraint_name.as_deref().unwrap_or("unnamed_fk");
            let cascade_note = if *cascade_delete {
                " [ON DELETE CASCADE]"
            } else {
                ""
            };

            fk_lines.push(format!(
                "{}.{from_col} → {}.{to_col} ({fk_name}){cascade_note}",
                from_table, to_table
            ));
        }
    }
    fk_lines.sort();

    println!("\n  {}", "Foreign keys".bold().underline());
    if fk_lines.is_empty() {
        println!("    {} none", "•".dimmed());
    } else {
        for relation in fk_lines {
            println!("    {} {}", "•".dimmed(), relation);
        }
    }

    println!(
        "\n  {} {}",
        "Total tables:".bold(),
        tables.len().to_string().cyan()
    );
    println!("{}\n", separator.dimmed());
}

fn statement_preview(stmt: &ParsedStatement) -> String {
    match stmt {
        ParsedStatement::CreateTable { table, .. } => format!("CREATE TABLE {}", table),
        ParsedStatement::DropTable { tables, .. } => format!("DROP TABLE {}", tables.join(", ")),
        ParsedStatement::AlterTableAddColumn { table, column } => {
            format!(
                "ALTER TABLE {} ADD COLUMN {} {}",
                table, column.name, column.data_type
            )
        }
        ParsedStatement::AlterTableDropColumn { table, column, .. } => {
            format!("ALTER TABLE {} DROP COLUMN {}", table, column)
        }
        ParsedStatement::AlterTableAlterColumnType {
            table,
            column,
            new_type,
        } => format!(
            "ALTER TABLE {} ALTER COLUMN {} TYPE {}",
            table, column, new_type
        ),
        ParsedStatement::AlterTableSetNotNull { table, column } => {
            format!("ALTER TABLE {} ALTER COLUMN {} SET NOT NULL", table, column)
        }
        ParsedStatement::AlterTableAddForeignKey { table, fk } => {
            let from_cols = if fk.columns.is_empty() {
                "*".to_string()
            } else {
                fk.columns.join(", ")
            };
            let to_cols = if fk.ref_columns.is_empty() {
                "*".to_string()
            } else {
                fk.ref_columns.join(", ")
            };
            format!(
                "ALTER TABLE {} ADD FOREIGN KEY ({}) REFERENCES {} ({})",
                table, from_cols, fk.ref_table, to_cols
            )
        }
        ParsedStatement::AlterTableDropConstraint {
            table, constraint, ..
        } => format!("ALTER TABLE {} DROP CONSTRAINT {}", table, constraint),
        ParsedStatement::AlterTableRenameColumn { table, old, new } => {
            format!("ALTER TABLE {} RENAME COLUMN {} TO {}", table, old, new)
        }
        ParsedStatement::AlterTableRenameTable { old, new } => {
            format!("ALTER TABLE {} RENAME TO {}", old, new)
        }
        ParsedStatement::CreateIndex {
            index_name,
            table,
            columns,
            unique,
            concurrently,
        } => {
            let name = index_name.as_deref().unwrap_or("<unnamed>");
            let unique_str = if *unique { "UNIQUE " } else { "" };
            let concurrently_str = if *concurrently { " CONCURRENTLY" } else { "" };
            format!(
                "CREATE {}INDEX{} {} ON {} ({})",
                unique_str,
                concurrently_str,
                name,
                table,
                columns.join(", ")
            )
        }
        ParsedStatement::DropIndex { names, .. } => format!("DROP INDEX {}", names.join(", ")),
        ParsedStatement::AlterTableAddPrimaryKey { table, columns } => {
            format!(
                "ALTER TABLE {} ADD PRIMARY KEY ({})",
                table,
                columns.join(", ")
            )
        }
        ParsedStatement::AlterTableDropPrimaryKey { table } => {
            format!("ALTER TABLE {} DROP PRIMARY KEY", table)
        }
        ParsedStatement::AlterTableAlterColumnDefault {
            table,
            column,
            drop_default,
        } => {
            if *drop_default {
                format!("ALTER TABLE {} ALTER COLUMN {} DROP DEFAULT", table, column)
            } else {
                format!(
                    "ALTER TABLE {} ALTER COLUMN {} SET DEFAULT ...",
                    table, column
                )
            }
        }
        ParsedStatement::Reindex {
            target_type,
            target_name,
            concurrently,
        } => {
            let conc = if *concurrently { " CONCURRENTLY" } else { "" };
            format!("REINDEX{} {} {}", conc, target_type, target_name)
        }
        ParsedStatement::Cluster { table, index } => match (table, index) {
            (Some(t), Some(i)) => format!("CLUSTER {} USING {}", t, i),
            (Some(t), None) => format!("CLUSTER {}", t),
            _ => "CLUSTER".to_string(),
        },
        ParsedStatement::Truncate { tables, cascade } => {
            let cascade_str = if *cascade { " CASCADE" } else { "" };
            format!("TRUNCATE TABLE {}{}", tables.join(", "), cascade_str)
        }
        ParsedStatement::Other { raw } => {
            let trimmed = raw.trim();
            if trimmed.len() > 100 {
                format!("{}…", &trimmed[..99])
            } else {
                trimmed.to_string()
            }
        }
    }
}

// ─────────────────────────────────────────────
// Terminal capability detection (B-05 fix)
// ─────────────────────────────────────────────

/// Returns the appropriate `comfy-table` preset based on terminal Unicode support.
///
/// On xterm-compatible terminals and Unix systems, uses the richer UTF-8 preset.
/// On Windows terminals without full Unicode support, falls back to ASCII.
fn table_preset() -> &'static str {
    let unicode_ok = std::env::var("TERM")
        .map(|t| t.contains("xterm") || t.contains("rxvt") || t.contains("screen"))
        .unwrap_or(false)
        || cfg!(target_os = "linux")
        || cfg!(target_os = "macos");

    if unicode_ok {
        comfy_table::presets::UTF8_FULL_CONDENSED
    } else {
        comfy_table::presets::ASCII_FULL
    }
}

// ─────────────────────────────────────────────
// Multi-file summary table
// ─────────────────────────────────────────────

/// Render an aligned summary table using `comfy-table` for multi-file analysis.
pub fn render_summary_table(reports: &[MigrationReport]) {
    use comfy_table::{Attribute, Cell, CellAlignment, Color, ContentArrangement, Table};

    println!();
    let mut table = Table::new();
    table
        .load_preset(table_preset())
        .set_content_arrangement(ContentArrangement::Dynamic)
        .set_header(vec![
            Cell::new("File").add_attribute(Attribute::Bold),
            Cell::new("Risk").add_attribute(Attribute::Bold),
            Cell::new("Score")
                .add_attribute(Attribute::Bold)
                .set_alignment(CellAlignment::Right),
            Cell::new("Lock Duration")
                .add_attribute(Attribute::Bold)
                .set_alignment(CellAlignment::Right),
            Cell::new("Maint. Window").add_attribute(Attribute::Bold),
            Cell::new("Tables").add_attribute(Attribute::Bold),
        ]);

    for r in reports {
        let (risk_text, risk_color) = match r.overall_risk {
            RiskLevel::Critical => ("CRITICAL", Color::Red),
            RiskLevel::High => ("HIGH", Color::Yellow),
            RiskLevel::Medium => ("MEDIUM", Color::Cyan),
            RiskLevel::Low => ("LOW", Color::Green),
        };
        let duration = r
            .estimated_lock_seconds
            .map(|s| {
                if s >= 60 {
                    format!("~{}m {}s", s / 60, s % 60)
                } else {
                    format!("~{}s", s)
                }
            })
            .unwrap_or_else(|| "—".to_string());
        let window = if r.requires_maintenance_window {
            Cell::new("YES")
                .fg(Color::Red)
                .add_attribute(Attribute::Bold)
        } else {
            Cell::new("no").fg(Color::Green)
        };
        let tables_str = if r.affected_tables.is_empty() {
            "—".to_string()
        } else {
            r.affected_tables
                .iter()
                .take(3)
                .cloned()
                .collect::<Vec<_>>()
                .join(", ")
                + if r.affected_tables.len() > 3 {
                    " …"
                } else {
                    ""
                }
        };
        table.add_row(vec![
            Cell::new(shorten(&r.file, 40)),
            Cell::new(risk_text)
                .fg(risk_color)
                .add_attribute(Attribute::Bold),
            Cell::new(r.score.to_string()).set_alignment(CellAlignment::Right),
            Cell::new(duration).set_alignment(CellAlignment::Right),
            window,
            Cell::new(tables_str),
        ]);
    }

    println!("{table}");

    let max_risk = reports
        .iter()
        .map(|r| r.overall_risk)
        .max()
        .unwrap_or(RiskLevel::Low);
    println!(
        "\n  Highest risk across all files: {}\n",
        risk_color(max_risk)
    );
}

fn shorten(s: &str, max: usize) -> String {
    if s.len() <= max {
        s.to_string()
    } else {
        format!("…{}", &s[s.len().saturating_sub(max - 1)..])
    }
}

// ─────────────────────────────────────────────
// Lock table & timeline renderer
// ─────────────────────────────────────────────

pub fn render_timeline(timeline: &MigrationTimeline) {
    let sep = "─".repeat(70);
    println!("\n{}", sep.dimmed());
    println!("  {}", "Lock Simulation & Migration Timeline".bold());
    println!("{}", sep.dimmed());

    println!("\n  Lock Risk:         {}", risk_color(timeline.lock_risk));
    println!(
        "  Total duration:    ~{} sec",
        timeline.total_secs.to_string().cyan()
    );
    println!(
        "  Max lock hold:     {} sec",
        if timeline.max_lock_hold_secs > 30 {
            timeline.max_lock_hold_secs.to_string().red().bold()
        } else if timeline.max_lock_hold_secs > 5 {
            timeline.max_lock_hold_secs.to_string().yellow()
        } else {
            timeline.max_lock_hold_secs.to_string().green()
        }
    );

    // Per-operation lock table
    if !timeline.lock_events.is_empty() {
        println!("\n  {}:", "Operations and their locks".bold().underline());
        println!(
            "  {:<45} {:<26} {:<8} {}",
            "Statement".dimmed(),
            "Lock Mode".dimmed(),
            "Hold(s)".dimmed(),
            "Impact".dimmed()
        );
        println!("  {}", "·".repeat(110).dimmed());

        for ev in &timeline.lock_events {
            let stmt = shorten(&ev.statement, 44);
            let lock_str = lock_mode_color(ev.lock_mode);
            let hold_str = if ev.estimated_hold_secs > 30 {
                ev.estimated_hold_secs.to_string().red().bold()
            } else if ev.estimated_hold_secs > 5 {
                ev.estimated_hold_secs.to_string().yellow()
            } else {
                ev.estimated_hold_secs.to_string().green()
            };

            println!(
                "  {:<45} {:<35} {:<8} {}",
                stmt, lock_str, hold_str, ev.impact
            );

            if let Some(alt) = &ev.safe_alternative {
                println!(
                    "    {} {}",
                    "Safe alternative:".green().bold(),
                    alt.lines().next().unwrap_or(alt)
                );
                for extra_line in alt.lines().skip(1) {
                    println!("      {}", extra_line.dimmed());
                }
            }
        }
    }

    // Timeline steps
    println!("\n  {}:", "Execution timeline".bold().underline());
    for step in &timeline.steps {
        let lock_badge = match step.lock {
            Some(LockMode::AccessExclusive) => " [LOCKED: reads+writes]".red().to_string(),
            Some(LockMode::Share) => " [LOCKED: writes only]".yellow().to_string(),
            Some(LockMode::ShareUpdateExclusive) => {
                " [LOCK: allows reads+writes]".cyan().to_string()
            }
            Some(m) => format!(" [{}]", m.name()).dimmed().to_string(),
            None => String::new(),
        };
        println!(
            "  {:>6}s  {}{}",
            step.offset_secs,
            step.event.dimmed(),
            lock_badge
        );
    }

    println!("\n{}", sep.dimmed());
}

fn lock_mode_color(mode: LockMode) -> colored::ColoredString {
    match mode {
        LockMode::AccessExclusive => mode.name().red().bold(),
        LockMode::Exclusive => mode.name().red(),
        LockMode::ShareRowExclusive | LockMode::Share => mode.name().yellow(),
        LockMode::ShareUpdateExclusive => mode.name().cyan(),
        _ => mode.name().green(),
    }
}

// ─────────────────────────────────────────────
// Query impact renderer
// ─────────────────────────────────────────────

pub fn render_impact(report: &ImpactReport) {
    let sep = "─".repeat(60);
    println!("\n{}", sep.dimmed());
    println!("{}", " SchemaRisk Impact Report".bold());
    println!("{}", sep.dimmed());

    println!(
        "\n  Files scanned:      {}",
        report.files_scanned.to_string().cyan()
    );
    println!(
        "  Impacted files:     {}",
        if report.impacted_files.is_empty() {
            "0 (none found)".green().to_string()
        } else {
            report
                .impacted_files
                .len()
                .to_string()
                .yellow()
                .bold()
                .to_string()
        }
    );

    if report.impacted_files.is_empty() {
        println!(
            "\n  {} No source files reference the affected schema objects.",
            "✓".green()
        );
    } else {
        println!("\n  {}:", "Impacted files".bold().underline());
        for f in &report.impacted_files {
            println!("\n    {}", f.path.yellow().bold());
            if !f.tables_referenced.is_empty() {
                println!("      Tables:  {}", f.tables_referenced.join(", ").cyan());
            }
            if !f.columns_referenced.is_empty() {
                println!("      Columns: {}", f.columns_referenced.join(", ").cyan());
            }
            // Show up to 5 hits
            for hit in f.hits.iter().take(5) {
                println!(
                    "      {:>5}: {}",
                    format!("L{}", hit.line).dimmed(),
                    hit.snippet.dimmed()
                );
            }
            if f.hits.len() > 5 {
                println!(
                    "      {} more matches…",
                    (f.hits.len() - 5).to_string().dimmed()
                );
            }
        }
    }

    println!("{}", sep.dimmed());
}

// ─────────────────────────────────────────────
// Drift report renderer
// ─────────────────────────────────────────────

pub fn render_drift(report: &DriftReport) {
    let sep = "─".repeat(60);
    println!("\n{}", sep.dimmed());
    println!("{}", " SchemaRisk Drift Report".bold());
    println!("{}", sep.dimmed());

    if report.in_sync {
        println!(
            "\n  {} Schema is in sync — no drift detected.\n",
            "✓".green().bold()
        );
        println!("{}", sep.dimmed());
        return;
    }

    println!("\n  Overall drift:    {}", risk_color(report.overall_drift));
    println!(
        "  Total findings:   {}\n",
        report.total_findings.to_string().red().bold()
    );

    // Print findings grouped by severity
    for (label, severity, bullet_str) in [
        ("CRITICAL", RiskLevel::Critical, "✗"),
        ("HIGH", RiskLevel::High, "!"),
        ("MEDIUM", RiskLevel::Medium, "·"),
        ("LOW", RiskLevel::Low, "·"),
    ] {
        let items: Vec<_> = report
            .findings
            .iter()
            .filter(|f| f.severity() == severity)
            .collect();
        if items.is_empty() {
            continue;
        }
        let label_colored = match severity {
            RiskLevel::Critical => label.red().bold().to_string(),
            RiskLevel::High => label.truecolor(255, 140, 0).bold().to_string(),
            RiskLevel::Medium => label.yellow().to_string(),
            _ => label.dimmed().to_string(),
        };
        println!("  {}:", label_colored);
        for finding in items {
            let bullet = match severity {
                RiskLevel::Critical => bullet_str.red().to_string(),
                RiskLevel::High => bullet_str.yellow().to_string(),
                _ => bullet_str.dimmed().to_string(),
            };
            println!("    {} {}", bullet, finding.description());
        }
        println!();
    }

    println!("{}", sep.dimmed());
}

// ─────────────────────────────────────────────
// Fix suggestion renderer
// ─────────────────────────────────────────────

/// Pretty-print a list of `FixSuggestion`s from the recommendation engine.
pub fn render_fix_suggestions(fixes: &[FixSuggestion]) {
    use comfy_table::{Attribute, Cell, Color, ContentArrangement, Table};

    let sep = "─".repeat(60);
    println!("\n{}", sep.dimmed());
    println!("{}", " SchemaRisk Fix Suggestions".bold());
    println!("{}", sep.dimmed());

    // ── Compact summary table ─────────────────────────────────────────────
    let mut table = Table::new();
    table
        .load_preset(table_preset())
        .set_content_arrangement(ContentArrangement::Dynamic)
        .set_header(vec![
            Cell::new("ID").add_attribute(Attribute::Bold),
            Cell::new("Severity").add_attribute(Attribute::Bold),
            Cell::new("Title").add_attribute(Attribute::Bold),
            Cell::new("Auto-Fix").add_attribute(Attribute::Bold),
        ]);

    for fix in fixes {
        let (sev_text, sev_color) = match fix.severity {
            FixSeverity::Blocking => ("BLOCKING", Color::Red),
            FixSeverity::Warning => ("WARNING", Color::Yellow),
            FixSeverity::Info => ("INFO", Color::Cyan),
        };
        let auto_fix = if fix.auto_fixable {
            Cell::new("yes").fg(Color::Green)
        } else {
            Cell::new("manual").fg(Color::Yellow)
        };
        table.add_row(vec![
            Cell::new(&fix.rule_id),
            Cell::new(sev_text)
                .fg(sev_color)
                .add_attribute(Attribute::Bold),
            Cell::new(&fix.title),
            auto_fix,
        ]);
    }
    println!("{table}");

    // ── Full detail for each fix ──────────────────────────────────────────
    for fix in fixes {
        let severity_badge = match fix.severity {
            FixSeverity::Blocking => format!("[{}]", "BLOCKING".red().bold()),
            FixSeverity::Warning => format!("[{}]", "WARNING".yellow().bold()),
            FixSeverity::Info => format!("[{}]", "INFO".cyan()),
        };

        println!(
            "\n  {} {} {}",
            fix.rule_id.bold(),
            severity_badge,
            fix.title.bold()
        );
        println!();
        // Wrap long explanation at 72 chars
        for chunk in wrap_text(&fix.explanation, 72) {
            println!("    {chunk}");
        }
        println!();

        if let Some(sql) = &fix.fixed_sql {
            println!("  {}", "Fixed SQL:".green().bold());
            for line in sql.lines() {
                println!("    {}", line.green());
            }
            println!();
        }

        if let Some(steps) = &fix.migration_steps {
            println!("  {}", "Migration steps:".cyan().bold());
            for step in steps {
                if step.is_empty() {
                    println!();
                } else {
                    println!("    {}", step.dimmed());
                }
            }
            println!();
        }

        if let Some(url) = &fix.docs_url {
            println!("  {} {}", "Docs:".dimmed(), url.dimmed());
            println!();
        }

        println!("{}", sep.dimmed());
    }
}

/// Word-wrap a string at `width` columns, returning a vector of lines.
fn wrap_text(text: &str, width: usize) -> Vec<String> {
    let mut lines = Vec::new();
    for paragraph in text.split("\n") {
        let mut line = String::new();
        for word in paragraph.split_whitespace() {
            if line.is_empty() {
                line.push_str(word);
            } else if line.len() + 1 + word.len() <= width {
                line.push(' ');
                line.push_str(word);
            } else {
                lines.push(line.clone());
                line = word.to_string();
            }
        }
        if !line.is_empty() {
            lines.push(line);
        }
    }
    lines
}