# Step 1: Generate coverage (recommended)
cargo llvm-cov --lcov --output-path lcov.info

# Step 2: Run debtmap with full context
debtmap analyze . --lcov lcov.info --context --format markdown --top 5

debtmap analyze . --format markdown --top 5

Is it a visitor/matcher pattern (large match/switch)?
├─ YES → Accept complexity, add tests if needed
└─ NO → Continue

Is it orchestrating I/O operations?
├─ YES → Extract pure business logic, keep thin I/O shell
└─ NO → Continue

Does it classify/categorize inputs?
├─ YES → Extract as pure static function
└─ NO → Continue

Does it have repeated conditional patterns?
├─ YES → Consolidate with pattern matching
└─ NO → Continue

Does it have nested loops?
├─ YES → Convert to iterator chains
└─ NO → Evaluate if refactoring is truly needed

// Before: Mixed concerns, complexity 15
fn process_data(input: &str, db: &Database) -> Result<Report> {
    let data = db.fetch(input)?;  // I/O
    let mut total = 0.0;
    for item in &data.items {
        if item.active && item.value > 0.0 {
            total += item.value * get_multiplier(&item.category);
        }
    }
    if total > 1000.0 { total *= 0.9; }  // Discount
    db.save_report(Report { total })?;  // I/O
    Ok(Report { total })
}

// After: Pure core, imperative shell
fn calculate_item_value(item: &Item) -> f64 {
    if item.active && item.value > 0.0 {
        item.value * get_multiplier(&item.category)
    } else {
        0.0
    }
}

fn calculate_total(items: &[Item]) -> f64 {
    items.iter().map(calculate_item_value).sum()
}

fn apply_bulk_discount(total: f64) -> f64 {
    if total > 1000.0 { total * 0.9 } else { total }
}

fn compute_report_total(items: &[Item]) -> f64 {
    apply_bulk_discount(calculate_total(items))
}

// Thin I/O wrapper
fn process_data(input: &str, db: &Database) -> Result<Report> {
    let data = db.fetch(input)?;
    let total = compute_report_total(&data.items);
    let report = Report { total };
    db.save_report(&report)?;
    Ok(report)
}

// Before: If-else chain
fn classify_call(name: &str) -> CallType {
    if name.contains("async") || name.contains("await") {
        CallType::Async
    } else if name.starts_with("handle_") {
        CallType::Delegate
    } else if name.starts_with("map") {
        CallType::Pipeline
    } else {
        CallType::Direct
    }
}

// After: Match with guards (cleaner, same complexity)
fn classify_call(name: &str) -> CallType {
    match () {
        _ if name.contains("async") || name.contains("await") => CallType::Async,
        _ if name.starts_with("handle_") => CallType::Delegate,
        _ if name.starts_with("map") => CallType::Pipeline,
        _ => CallType::Direct,
    }
}

// Before: Imperative loop
let mut result = Vec::new();
for item in items {
    if item.active {
        if let Some(value) = process(&item) {
            result.push(value);
        }
    }
}

// After: Iterator chain
let result: Vec<_> = items
    .iter()
    .filter(|item| item.active)
    .filter_map(|item| process(item))
    .collect();

// Before: god_object.rs with 50+ functions

// After: Split into focused modules
mod parser;      // Parsing logic
mod validator;   // Validation rules
mod calculator;  // Calculations
mod formatter;   // Output formatting

// BAD: Too many tiny helpers for simple logic
fn is_positive(x: f64) -> bool { x > 0.0 }
fn is_active(item: &Item) -> bool { item.active }
fn combine_checks(item: &Item) -> bool { is_active(item) && is_positive(item.value) }

// GOOD: Keep simple conditions inline
items.iter().filter(|i| i.active && i.value > 0.0)

// BAD: Helper only exists for tests
fn process_item_for_testing(item: &Item) -> f64 { ... }

// GOOD: Make production code testable
fn calculate_item_value(item: &Item) -> f64 { ... }  // Used in production AND tests

// DON'T refactor legitimate match statements
// Visitor patterns naturally have high cyclomatic complexity
// That's OK - the pattern is correct
impl Visitor for MyVisitor {
    fn visit_expr(&mut self, expr: &Expr) {
        match expr {
            Expr::Binary { .. } => { ... }
            Expr::Unary { .. } => { ... }
            Expr::Call { .. } => { ... }
            // 20 more variants - this is FINE
        }
    }
}

// BAD: Added traits and generics to "simplify"
trait Processable { fn process(&self) -> f64; }
impl Processable for Item { ... }
fn process_all<T: Processable>(items: &[T]) -> f64 { ... }

// GOOD: Keep it simple
fn process_items(items: &[Item]) -> f64 {
    items.iter().map(|i| i.value * i.multiplier).sum()
}

// Pure: Testable without any setup
fn calculate_discount(is_premium: bool, total: f64) -> f64 {
    let rate = if is_premium { 0.15 } else { 0.05 };
    total * (1.0 - rate)
}

// Prefer: Struct update syntax
fn with_discount(order: Order, discount: f64) -> Order {
    Order { discount, ..order }
}

// Prefer: Builder-style methods
impl User {
    fn with_name(self, name: String) -> Self {
        Self { name, ..self }
    }
}

// Sequential operations
fn process(path: &Path) -> Result<Report> {
    let content = fs::read_to_string(path)
        .context("Failed to read file")?;
    let data = parse(&content)
        .context("Failed to parse content")?;
    let validated = validate(data)
        .context("Validation failed")?;
    Ok(generate_report(validated))
}

use anyhow::Context;

// Always add context to errors
fn load_config(path: &Path) -> Result<Config> {
    let content = fs::read_to_string(path)
        .with_context(|| format!("Failed to read config from {:?}", path))?;
    toml::from_str(&content)
        .context("Invalid TOML in config file")
}

# 1. Run tests
cargo test

# 2. Check for warnings
cargo clippy -- -D warnings

# 3. Format code
cargo fmt

# 4. Regenerate coverage (if tests added)
cargo llvm-cov --lcov --output-path lcov.info

# 5. Verify improvement
debtmap analyze . --lcov lcov.info --format markdown --top 1