decy_debugger/

visualize_ast.rs

//! C AST visualization for debugging
//!
//! Provides formatted visualization of C ASTs parsed by clang-sys.
//! Inspired by spydecy's Python AST visualizer.

use anyhow::{Context, Result};
use colored::Colorize;
use decy_parser::{CParser, Expression, Function, Statement};
use std::fs;
use std::path::Path;

/// Visualize C source as AST
///
/// # Errors
///
/// Returns an error if the file cannot be read or parsed
pub fn visualize_c_ast(file_path: &Path, use_colors: bool) -> Result<String> {
    // Read the source file
    let source = fs::read_to_string(file_path)
        .with_context(|| format!("Failed to read file: {}", file_path.display()))?;

    // Parse to AST
    let parser = CParser::new()?;
    let ast = parser.parse(&source).context("Failed to parse C source")?;
    let functions = ast.functions();

    // Format the output
    let mut output = String::new();

    // Header
    if use_colors {
        output.push_str(&format!(
            "{}",
            "╔══════════════════════════════════════════════════════════╗\n".cyan()
        ));
        output.push_str(&format!(
            "{}",
            "║  Decy Debugger: C AST Visualization                     ║\n".cyan()
        ));
        output.push_str(&format!(
            "{}",
            "╚══════════════════════════════════════════════════════════╝\n".cyan()
        ));
    } else {
        output.push_str("╔══════════════════════════════════════════════════════════╗\n");
        output.push_str("║  Decy Debugger: C AST Visualization                     ║\n");
        output.push_str("╚══════════════════════════════════════════════════════════╝\n");
    }
    output.push('\n');

    // File info
    let file_label = if use_colors { "File:".bold().to_string() } else { "File:".to_string() };
    output.push_str(&format!("{} {}\n", file_label, file_path.display()));

    let size_label = if use_colors { "Size:".bold().to_string() } else { "Size:".to_string() };
    output.push_str(&format!("{} {} lines\n", size_label, source.lines().count()));
    output.push('\n');

    // Source code preview
    let source_header = if use_colors {
        "═══ Source Code ═══".yellow().bold().to_string()
    } else {
        "═══ Source Code ═══".to_string()
    };
    output.push_str(&format!("{source_header}\n"));

    for (i, line) in source.lines().enumerate() {
        if use_colors {
            output.push_str(&format!("{:3} │ {}\n", (i + 1).to_string().dimmed(), line));
        } else {
            output.push_str(&format!("{:3} │ {}\n", i + 1, line));
        }
    }
    output.push('\n');

    // AST tree
    let ast_header = if use_colors {
        "═══ Abstract Syntax Tree ═══".green().bold().to_string()
    } else {
        "═══ Abstract Syntax Tree ═══".to_string()
    };
    output.push_str(&format!("{}\n", ast_header));

    for function in functions {
        format_function(function, 0, &mut output, use_colors);
    }
    output.push('\n');

    // Statistics
    let stats_header = if use_colors {
        "═══ Statistics ═══".blue().bold().to_string()
    } else {
        "═══ Statistics ═══".to_string()
    };
    output.push_str(&format!("{}\n", stats_header));

    let func_count_label =
        if use_colors { "Functions:".bold().to_string() } else { "Functions:".to_string() };
    output.push_str(&format!("  {} {}\n", func_count_label, functions.len()));

    let total_statements: usize = functions.iter().map(|f| f.body.len()).sum();
    let stmt_count_label = if use_colors {
        "Total statements:".bold().to_string()
    } else {
        "Total statements:".to_string()
    };
    output.push_str(&format!("  {} {}\n", stmt_count_label, total_statements));

    Ok(output)
}

/// Format a function node with indentation
fn format_function(function: &Function, depth: usize, output: &mut String, use_colors: bool) {
    let indent = "  ".repeat(depth);

    let node_type = if use_colors {
        format!("Function: {}", function.name).green().bold().to_string()
    } else {
        format!("Function: {}", function.name)
    };

    output.push_str(&format!("{}├─ {}", indent, node_type));

    // Return type
    let return_type_str = format!("{:?}", function.return_type);
    if use_colors {
        output.push_str(&format!(" → {}", return_type_str.dimmed()));
    } else {
        output.push_str(&format!(" → {}", return_type_str));
    }
    output.push('\n');

    // Parameters
    if !function.parameters.is_empty() {
        let params_label =
            if use_colors { "Parameters:".blue().to_string() } else { "Parameters:".to_string() };
        output.push_str(&format!("{}  {} ", indent, params_label));

        for (i, param) in function.parameters.iter().enumerate() {
            if i > 0 {
                output.push_str(", ");
            }
            output.push_str(&format!("{}: {:?}", param.name, param.param_type));
        }
        output.push('\n');
    }

    // Body statements
    if !function.body.is_empty() {
        let body_label = if use_colors { "Body:".cyan().to_string() } else { "Body:".to_string() };
        output.push_str(&format!("{}  {}\n", indent, body_label));

        for stmt in &function.body {
            format_statement(stmt, depth + 2, output, use_colors);
        }
    }
}

/// Format a statement node
fn format_statement(stmt: &Statement, depth: usize, output: &mut String, use_colors: bool) {
    let indent = "  ".repeat(depth);

    let stmt_str = match stmt {
        Statement::Return(Some(expr)) => {
            let label = if use_colors { "Return".red().to_string() } else { "Return".to_string() };
            format!("{}: {}", label, format_expression(expr, use_colors))
        }
        Statement::Return(None) => {
            if use_colors {
                "Return (void)".red().to_string()
            } else {
                "Return (void)".to_string()
            }
        }
        Statement::Assignment { target, value } => {
            let label = if use_colors {
                "Assignment".yellow().to_string()
            } else {
                "Assignment".to_string()
            };
            format!("{}: {} = {}", label, target, format_expression(value, use_colors))
        }
        Statement::If { condition, then_block, else_block } => {
            let mut s = if use_colors {
                format!("{}: {}", "If".magenta(), format_expression(condition, use_colors))
            } else {
                format!("If: {}", format_expression(condition, use_colors))
            };

            s.push_str(&format!(" (then: {} stmts", then_block.len()));
            if let Some(else_b) = else_block {
                s.push_str(&format!(", else: {} stmts)", else_b.len()));
            } else {
                s.push(')');
            }
            s
        }
        Statement::While { condition, body } => {
            let label =
                if use_colors { "While".magenta().to_string() } else { "While".to_string() };
            format!(
                "{}: {} ({} stmts)",
                label,
                format_expression(condition, use_colors),
                body.len()
            )
        }
        Statement::For { init, condition, increment, body } => {
            let label = if use_colors { "For".magenta().to_string() } else { "For".to_string() };
            format!(
                "{}: init={:?}, cond={:?}, inc={:?} ({} stmts)",
                label,
                init,
                condition,
                increment,
                body.len()
            )
        }
        Statement::VariableDeclaration { name, var_type, initializer } => {
            let label =
                if use_colors { "VarDecl".cyan().to_string() } else { "VarDecl".to_string() };
            let mut s = format!("{}: {:?} {}", label, var_type, name);
            if let Some(init) = initializer {
                s.push_str(&format!(" = {}", format_expression(init, use_colors)));
            }
            s
        }
        _ => format!("{:?}", stmt),
    };

    output.push_str(&format!("{}├─ {}\n", indent, stmt_str));
}

/// Format an expression for display
fn format_expression(expr: &Expression, use_colors: bool) -> String {
    match expr {
        Expression::IntLiteral(n) => {
            if use_colors {
                n.to_string().bright_yellow().to_string()
            } else {
                n.to_string()
            }
        }
        Expression::Variable(name) => {
            if use_colors {
                name.blue().to_string()
            } else {
                name.clone()
            }
        }
        Expression::BinaryOp { left, op, right } => {
            format!(
                "({} {:?} {})",
                format_expression(left, use_colors),
                op,
                format_expression(right, use_colors)
            )
        }
        Expression::FunctionCall { function, arguments } => {
            let args_str = arguments
                .iter()
                .map(|arg| format_expression(arg, use_colors))
                .collect::<Vec<_>>()
                .join(", ");

            if use_colors {
                format!("{}({})", function.magenta(), args_str)
            } else {
                format!("{}({})", function, args_str)
            }
        }
        _ => format!("{:?}", expr),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Write;
    use tempfile::NamedTempFile;

    #[test]
    fn test_visualize_simple_function() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "int add(int a, int b) {{ return a + b; }}").unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());

        let output = result.unwrap();
        assert!(output.contains("Function: add"));
        assert!(output.contains("Return"));
    }

    #[test]
    fn test_visualize_with_colors() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "int main() {{ return 0; }}").unwrap();

        let result = visualize_c_ast(temp_file.path(), true);
        assert!(result.is_ok());

        // Just verify it produces output (color codes make exact matching hard)
        let output = result.unwrap();
        assert!(!output.is_empty());
        assert!(output.contains("main"));
    }

    // ============================================================================
    // Coverage: for loop, while loop, if/else, variable decl, assignment
    // ============================================================================

    #[test]
    fn test_visualize_for_loop() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(
            temp_file,
            "int main() {{ int i; for (i = 0; i < 10; i = i + 1) {{ }} return 0; }}"
        )
        .unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Function: main"));
    }

    #[test]
    fn test_visualize_while_loop() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "int main() {{ int x = 10; while (x) {{ x = x - 1; }} return 0; }}")
            .unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Function: main"));
    }

    #[test]
    fn test_visualize_if_else() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(
            temp_file,
            "int main() {{ int x = 5; if (x) {{ return 1; }} else {{ return 0; }} }}"
        )
        .unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Function: main"));
    }

    #[test]
    fn test_visualize_variable_declaration() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "int main() {{ int x = 42; int y = x + 1; return y; }}").unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Function: main"));
    }

    #[test]
    fn test_visualize_assignment() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "int main() {{ int x = 0; x = 42; return x; }}").unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
    }

    #[test]
    fn test_visualize_function_call() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(
            temp_file,
            "int add(int a, int b) {{ return a + b; }}\nint main() {{ return add(2, 3); }}"
        )
        .unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
        let output = result.unwrap();
        // Should show both functions
        assert!(output.contains("Function: add") || output.contains("Function: main"));
    }

    #[test]
    fn test_visualize_multiple_parameters() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "int add3(int a, int b, int c) {{ return a + b + c; }}").unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Parameters:"));
    }

    #[test]
    fn test_visualize_void_return() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "void noop() {{ return; }}").unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
    }

    #[test]
    fn test_visualize_statistics() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "int f1() {{ return 1; }}\nint f2() {{ return 2; }}").unwrap();

        let result = visualize_c_ast(temp_file.path(), false);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Statistics"));
        assert!(output.contains("Functions:"));
        assert!(output.contains("Total statements:"));
    }

    #[test]
    fn test_visualize_colors_for_loop() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(
            temp_file,
            "int main() {{ int i; for (i = 0; i < 5; i = i + 1) {{ }} return 0; }}"
        )
        .unwrap();

        let result = visualize_c_ast(temp_file.path(), true);
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(!output.is_empty());
    }

    #[test]
    fn test_visualize_colors_if_else() {
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(
            temp_file,
            "int main() {{ int x = 1; if (x) {{ return 1; }} else {{ return 0; }} }}"
        )
        .unwrap();

        let result = visualize_c_ast(temp_file.path(), true);
        assert!(result.is_ok());
    }

    // ============================================================================
    // Coverage: error paths
    // ============================================================================

    #[test]
    fn test_visualize_nonexistent_file() {
        let result = visualize_c_ast(Path::new("/nonexistent/file.c"), false);
        assert!(result.is_err());
    }

    // ============================================================================
    // Coverage: format_expression and format_statement direct tests
    // ============================================================================

    #[test]
    fn test_format_expression_int_literal_no_colors() {
        let expr = Expression::IntLiteral(42);
        let result = format_expression(&expr, false);
        assert_eq!(result, "42");
    }

    #[test]
    fn test_format_expression_int_literal_with_colors() {
        let expr = Expression::IntLiteral(42);
        let result = format_expression(&expr, true);
        // Color codes wrap the number
        assert!(result.contains("42"));
    }

    #[test]
    fn test_format_expression_variable_no_colors() {
        let expr = Expression::Variable("x".to_string());
        let result = format_expression(&expr, false);
        assert_eq!(result, "x");
    }

    #[test]
    fn test_format_expression_variable_with_colors() {
        let expr = Expression::Variable("x".to_string());
        let result = format_expression(&expr, true);
        assert!(result.contains("x"));
    }

    #[test]
    fn test_format_expression_binary_op() {
        let expr = Expression::BinaryOp {
            left: Box::new(Expression::IntLiteral(1)),
            op: decy_parser::parser::BinaryOperator::Add,
            right: Box::new(Expression::IntLiteral(2)),
        };
        let result = format_expression(&expr, false);
        assert!(result.contains("1"));
        assert!(result.contains("2"));
        assert!(result.contains("Add"));
    }

    #[test]
    fn test_format_expression_function_call_no_colors() {
        let expr = Expression::FunctionCall {
            function: "printf".to_string(),
            arguments: vec![Expression::Variable("msg".to_string())],
        };
        let result = format_expression(&expr, false);
        assert!(result.contains("printf"));
        assert!(result.contains("msg"));
    }

    #[test]
    fn test_format_expression_function_call_with_colors() {
        let expr = Expression::FunctionCall {
            function: "printf".to_string(),
            arguments: vec![Expression::IntLiteral(0)],
        };
        let result = format_expression(&expr, true);
        assert!(result.contains("printf"));
    }

    #[test]
    fn test_format_expression_catchall() {
        let expr = Expression::StringLiteral("hello".to_string());
        let result = format_expression(&expr, false);
        // Falls through to Debug format
        assert!(!result.is_empty());
    }

    #[test]
    fn test_format_statement_return_some_no_colors() {
        let stmt = Statement::Return(Some(Expression::IntLiteral(0)));
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("Return"));
        assert!(output.contains("0"));
    }

    #[test]
    fn test_format_statement_return_none_no_colors() {
        let stmt = Statement::Return(None);
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("Return (void)"));
    }

    #[test]
    fn test_format_statement_return_none_with_colors() {
        let stmt = Statement::Return(None);
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, true);
        assert!(output.contains("Return"));
    }

    #[test]
    fn test_format_statement_assignment_no_colors() {
        let stmt =
            Statement::Assignment { target: "x".to_string(), value: Expression::IntLiteral(42) };
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("Assignment"));
        assert!(output.contains("x"));
    }

    #[test]
    fn test_format_statement_if_with_else_no_colors() {
        let stmt = Statement::If {
            condition: Expression::Variable("x".to_string()),
            then_block: vec![Statement::Return(Some(Expression::IntLiteral(1)))],
            else_block: Some(vec![Statement::Return(Some(Expression::IntLiteral(0)))]),
        };
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("If"));
        assert!(output.contains("then: 1 stmts"));
        assert!(output.contains("else: 1 stmts"));
    }

    #[test]
    fn test_format_statement_if_with_else_with_colors() {
        let stmt = Statement::If {
            condition: Expression::Variable("x".to_string()),
            then_block: vec![Statement::Return(Some(Expression::IntLiteral(1)))],
            else_block: Some(vec![Statement::Return(Some(Expression::IntLiteral(0)))]),
        };
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, true);
        assert!(output.contains("else: 1 stmts"));
    }

    #[test]
    fn test_format_statement_while_no_colors() {
        let stmt = Statement::While {
            condition: Expression::Variable("running".to_string()),
            body: vec![Statement::Return(Some(Expression::IntLiteral(0)))],
        };
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("While"));
        assert!(output.contains("1 stmts"));
    }

    #[test]
    fn test_format_statement_for_no_colors() {
        let stmt = Statement::For {
            init: vec![Statement::VariableDeclaration {
                name: "i".to_string(),
                var_type: decy_parser::Type::Int,
                initializer: Some(Expression::IntLiteral(0)),
            }],
            condition: Some(Expression::Variable("i".to_string())),
            increment: vec![],
            body: vec![],
        };
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("For"));
    }

    #[test]
    fn test_format_statement_var_decl_no_colors() {
        let stmt = Statement::VariableDeclaration {
            name: "x".to_string(),
            var_type: decy_parser::Type::Int,
            initializer: Some(Expression::IntLiteral(42)),
        };
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("VarDecl"));
        assert!(output.contains("x"));
    }

    #[test]
    fn test_format_statement_var_decl_no_init() {
        let stmt = Statement::VariableDeclaration {
            name: "y".to_string(),
            var_type: decy_parser::Type::Int,
            initializer: None,
        };
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(output.contains("VarDecl"));
        assert!(output.contains("y"));
    }

    #[test]
    fn test_format_statement_catchall() {
        let stmt = Statement::Break;
        let mut output = String::new();
        format_statement(&stmt, 0, &mut output, false);
        assert!(!output.is_empty());
    }

    #[test]
    fn test_format_function_no_body() {
        let function = Function {
            name: "empty".to_string(),
            return_type: decy_parser::Type::Void,
            parameters: vec![],
            body: vec![],
            cuda_qualifier: None,
        };
        let mut output = String::new();
        format_function(&function, 0, &mut output, false);
        assert!(output.contains("Function: empty"));
    }

    #[test]
    fn test_format_function_with_colors() {
        let function = Function {
            name: "test_fn".to_string(),
            return_type: decy_parser::Type::Int,
            parameters: vec![decy_parser::Parameter::new("x".to_string(), decy_parser::Type::Int)],
            body: vec![Statement::Return(Some(Expression::Variable("x".to_string())))],
            cuda_qualifier: None,
        };
        let mut output = String::new();
        format_function(&function, 0, &mut output, true);
        assert!(output.contains("test_fn"));
    }
}