sage_codegen/

generator.rs

//! Main code generator.

use crate::emit::Emitter;
use sage_loader::ModuleTree;
use sage_parser::{
    AgentDecl, BinOp, Block, ConstDecl, EnumDecl, EventKind, Expr, FnDecl, Literal, Program,
    RecordDecl, Stmt, StringPart, UnaryOp,
};
use sage_types::TypeExpr;

/// Generated Rust project files.
pub struct GeneratedProject {
    /// The main.rs content.
    pub main_rs: String,
    /// The Cargo.toml content.
    pub cargo_toml: String,
}

/// Generate Rust code from a Sage program (single file).
pub fn generate(program: &Program, project_name: &str) -> GeneratedProject {
    let mut gen = Generator::new();
    let main_rs = gen.generate_program(program);
    let cargo_toml = gen.generate_cargo_toml(project_name);
    GeneratedProject {
        main_rs,
        cargo_toml,
    }
}

/// Generate Rust code from a module tree (multi-file project).
///
/// This flattens all modules into a single Rust file, generating all agents
/// and functions with appropriate visibility modifiers.
pub fn generate_module_tree(tree: &ModuleTree, project_name: &str) -> GeneratedProject {
    let mut gen = Generator::new();
    let main_rs = gen.generate_module_tree(tree);
    let cargo_toml = gen.generate_cargo_toml(project_name);
    GeneratedProject {
        main_rs,
        cargo_toml,
    }
}

struct Generator {
    emit: Emitter,
}

impl Generator {
    fn new() -> Self {
        Self {
            emit: Emitter::new(),
        }
    }

    fn generate_program(&mut self, program: &Program) -> String {
        // Prelude
        self.emit
            .writeln("//! Generated by Sage compiler. Do not edit.");
        self.emit.blank_line();
        self.emit.writeln("use sage_runtime::prelude::*;");
        self.emit.blank_line();

        // Constants
        for const_decl in &program.consts {
            self.generate_const(const_decl);
            self.emit.blank_line();
        }

        // Enums
        for enum_decl in &program.enums {
            self.generate_enum(enum_decl);
            self.emit.blank_line();
        }

        // Records
        for record in &program.records {
            self.generate_record(record);
            self.emit.blank_line();
        }

        // Functions
        for func in &program.functions {
            self.generate_function(func);
            self.emit.blank_line();
        }

        // Agents
        for agent in &program.agents {
            self.generate_agent(agent);
            self.emit.blank_line();
        }

        // Entry point (required for executables)
        if let Some(run_agent) = &program.run_agent {
            // Find the entry agent
            if let Some(agent) = program.agents.iter().find(|a| a.name.name == run_agent.name) {
                self.generate_main(agent);
            }
        }

        std::mem::take(&mut self.emit).finish()
    }

    fn generate_module_tree(&mut self, tree: &ModuleTree) -> String {
        // Prelude
        self.emit
            .writeln("//! Generated by Sage compiler. Do not edit.");
        self.emit.blank_line();
        self.emit.writeln("use sage_runtime::prelude::*;");
        self.emit.blank_line();

        // Generate all modules, starting with the root
        // We flatten everything into one file for simplicity
        // (A more advanced implementation would generate mod.rs files)

        // First, generate non-root modules
        for (path, module) in &tree.modules {
            if path != &tree.root {
                self.emit.write("// Module: ");
                if path.is_empty() {
                    self.emit.writeln("(root)");
                } else {
                    self.emit.writeln(&path.join("::"));
                }

                for const_decl in &module.program.consts {
                    self.generate_const(const_decl);
                    self.emit.blank_line();
                }

                for enum_decl in &module.program.enums {
                    self.generate_enum(enum_decl);
                    self.emit.blank_line();
                }

                for record in &module.program.records {
                    self.generate_record(record);
                    self.emit.blank_line();
                }

                for func in &module.program.functions {
                    self.generate_function(func);
                    self.emit.blank_line();
                }

                for agent in &module.program.agents {
                    self.generate_agent(agent);
                    self.emit.blank_line();
                }
            }
        }

        // Then, generate the root module
        if let Some(root_module) = tree.modules.get(&tree.root) {
            self.emit.writeln("// Root module");

            for const_decl in &root_module.program.consts {
                self.generate_const(const_decl);
                self.emit.blank_line();
            }

            for enum_decl in &root_module.program.enums {
                self.generate_enum(enum_decl);
                self.emit.blank_line();
            }

            for record in &root_module.program.records {
                self.generate_record(record);
                self.emit.blank_line();
            }

            for func in &root_module.program.functions {
                self.generate_function(func);
                self.emit.blank_line();
            }

            for agent in &root_module.program.agents {
                self.generate_agent(agent);
                self.emit.blank_line();
            }

            // Entry point (only in root module)
            if let Some(run_agent) = &root_module.program.run_agent {
                // Find the entry agent
                if let Some(agent) = root_module
                    .program
                    .agents
                    .iter()
                    .find(|a| a.name.name == run_agent.name)
                {
                    self.generate_main(agent);
                }
            }
        }

        std::mem::take(&mut self.emit).finish()
    }

    fn generate_cargo_toml(&self, name: &str) -> String {
        // Use a relative path that works from target/sage/<project>/
        // This assumes the standard project layout
        format!(
            r#"[package]
name = "{name}"
version = "0.1.0"
edition = "2021"

[dependencies]
sage-runtime = {{ path = "../../../crates/sage-runtime" }}
tokio = {{ version = "1", features = ["full"] }}
serde = {{ version = "1", features = ["derive"] }}
serde_json = "1"

# Standalone project, not part of parent workspace
[workspace]
"#
        )
    }

    fn generate_const(&mut self, const_decl: &ConstDecl) {
        if const_decl.is_pub {
            self.emit.write("pub ");
        }
        self.emit.write("const ");
        self.emit.write(&const_decl.name.name);
        self.emit.write(": ");
        self.emit_type(&const_decl.ty);
        self.emit.write(" = ");
        self.generate_expr(&const_decl.value);
        self.emit.writeln(";");
    }

    fn generate_enum(&mut self, enum_decl: &EnumDecl) {
        if enum_decl.is_pub {
            self.emit.write("pub ");
        }
        self.emit
            .writeln("#[derive(Debug, Clone, Copy, PartialEq, Eq)]");
        self.emit.write("enum ");
        self.emit.write(&enum_decl.name.name);
        self.emit.writeln(" {");
        self.emit.indent();
        for variant in &enum_decl.variants {
            self.emit.write(&variant.name.name);
            if let Some(payload_ty) = &variant.payload {
                self.emit.write("(");
                self.emit_type(payload_ty);
                self.emit.write(")");
            }
            self.emit.writeln(",");
        }
        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_record(&mut self, record: &RecordDecl) {
        if record.is_pub {
            self.emit.write("pub ");
        }
        self.emit.writeln("#[derive(Debug, Clone)]");
        self.emit.write("struct ");
        self.emit.write(&record.name.name);
        self.emit.writeln(" {");
        self.emit.indent();
        for field in &record.fields {
            self.emit.write(&field.name.name);
            self.emit.write(": ");
            self.emit_type(&field.ty);
            self.emit.writeln(",");
        }
        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_function(&mut self, func: &FnDecl) {
        // Function signature with visibility
        if func.is_pub {
            self.emit.write("pub ");
        }
        self.emit.write("fn ");
        self.emit.write(&func.name.name);
        self.emit.write("(");

        for (i, param) in func.params.iter().enumerate() {
            if i > 0 {
                self.emit.write(", ");
            }
            self.emit.write(&param.name.name);
            self.emit.write(": ");
            self.emit_type(&param.ty);
        }

        self.emit.write(") -> ");

        // RFC-0007: Wrap return type in SageResult if fallible
        if func.is_fallible {
            self.emit.write("SageResult<");
            self.emit_type(&func.return_ty);
            self.emit.write(">");
        } else {
            self.emit_type(&func.return_ty);
        }

        self.emit.write(" ");
        self.generate_block(&func.body);
    }

    fn generate_agent(&mut self, agent: &AgentDecl) {
        let name = &agent.name.name;

        // RFC-0011: Check for tool usage
        let has_tools = !agent.tool_uses.is_empty();
        let needs_struct_body = !agent.beliefs.is_empty() || has_tools;

        // Struct definition with visibility
        if agent.is_pub {
            self.emit.write("pub ");
        }
        self.emit.write("struct ");
        self.emit.write(name);
        if !needs_struct_body {
            self.emit.writeln(";");
        } else {
            self.emit.writeln(" {");
            self.emit.indent();

            // RFC-0011: Generate tool fields
            for tool_use in &agent.tool_uses {
                // Generate field like: http: HttpClient
                self.emit.write(&tool_use.name.to_lowercase());
                self.emit.write(": ");
                self.emit.write(&tool_use.name);
                self.emit.writeln("Client,");
            }

            // Regular belief fields
            for belief in &agent.beliefs {
                self.emit.write(&belief.name.name);
                self.emit.write(": ");
                self.emit_type(&belief.ty);
                self.emit.writeln(",");
            }
            self.emit.dedent();
            self.emit.writeln("}");
        }
        self.emit.blank_line();

        // Find the output type from the start handler
        let output_type = self.infer_agent_output_type(agent);

        // Impl block
        self.emit.write("impl ");
        self.emit.write(name);
        self.emit.writeln(" {");
        self.emit.indent();

        // Generate handlers
        for handler in &agent.handlers {
            match &handler.event {
                EventKind::Start => {
                    self.emit
                        .write("async fn on_start(self, ctx: &mut AgentContext<");
                    self.emit.write(&output_type);
                    self.emit.write(">) -> SageResult<");
                    self.emit.write(&output_type);
                    self.emit.writeln("> {");
                    self.emit.indent();
                    self.generate_block_contents(&handler.body);
                    self.emit.dedent();
                    self.emit.writeln("}");
                }

                // RFC-0007: Generate on_error handler
                EventKind::Error { param_name } => {
                    self.emit.write("async fn on_error(self, ");
                    self.emit.write(&param_name.name);
                    self.emit.write(": SageError, ctx: &mut AgentContext<");
                    self.emit.write(&output_type);
                    self.emit.write(">) -> SageResult<");
                    self.emit.write(&output_type);
                    self.emit.writeln("> {");
                    self.emit.indent();
                    self.generate_block_contents(&handler.body);
                    self.emit.dedent();
                    self.emit.writeln("}");
                }

                // Other handlers (message, stop) - future work
                _ => {}
            }
        }

        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_main(&mut self, agent: &AgentDecl) {
        let entry_agent = &agent.name.name;
        let has_error_handler = agent
            .handlers
            .iter()
            .any(|h| matches!(h.event, EventKind::Error { .. }));

        // RFC-0011: Check if agent uses tools
        let has_tools = !agent.tool_uses.is_empty();

        self.emit.writeln("#[tokio::main]");
        self.emit
            .writeln("async fn main() -> Result<(), Box<dyn std::error::Error>> {");
        self.emit.indent();

        // Helper to generate agent construction (with or without tool fields)
        let agent_construct = if has_tools {
            let mut s = format!("{entry_agent} {{ ");
            for (i, tool_use) in agent.tool_uses.iter().enumerate() {
                if i > 0 {
                    s.push_str(", ");
                }
                // Generate: http: HttpClient::from_env()
                s.push_str(&tool_use.name.to_lowercase());
                s.push_str(": ");
                s.push_str(&tool_use.name);
                s.push_str("Client::from_env()");
            }
            s.push_str(" }");
            s
        } else {
            entry_agent.to_string()
        };

        if has_error_handler {
            // RFC-0007: Generate error dispatch code
            // Handlers take &mut ctx, so no cloning needed
            self.emit
                .writeln("let handle = sage_runtime::spawn(|mut ctx| async move {");
            self.emit.indent();
            self.emit.write("let agent = ");
            self.emit.write(&agent_construct);
            self.emit.writeln(";");
            self.emit.writeln("match agent.on_start(&mut ctx).await {");
            self.emit.indent();
            self.emit.writeln("Ok(result) => Ok(result),");
            self.emit.write("Err(e) => ");
            self.emit.write(&agent_construct);
            self.emit.writeln(".on_error(e, &mut ctx).await,");
            self.emit.dedent();
            self.emit.writeln("}");
            self.emit.dedent();
            self.emit.writeln("});");
        } else {
            // Simple case: no error handler
            self.emit.write("let handle = sage_runtime::spawn(|mut ctx| ");
            self.emit.write(&agent_construct);
            self.emit.writeln(".on_start(&mut ctx));");
        }

        self.emit.writeln("let result = handle.result().await?;");
        self.emit.writeln("println!(\"{:?}\", result);");
        self.emit.writeln("Ok(())");

        self.emit.dedent();
        self.emit.writeln("}");
    }

    fn generate_block(&mut self, block: &Block) {
        self.emit.open_brace();
        self.generate_block_contents(block);
        self.emit.close_brace();
    }

    fn generate_block_inline(&mut self, block: &Block) {
        self.emit.open_brace();
        self.generate_block_contents(block);
        self.emit.close_brace_inline();
    }

    fn generate_block_contents(&mut self, block: &Block) {
        for stmt in &block.stmts {
            self.generate_stmt(stmt);
        }
    }

    fn generate_stmt(&mut self, stmt: &Stmt) {
        match stmt {
            Stmt::Let {
                name, ty, value, ..
            } => {
                self.emit.write("let ");
                if ty.is_some() {
                    self.emit.write(&name.name);
                    self.emit.write(": ");
                    self.emit_type(ty.as_ref().unwrap());
                } else {
                    self.emit.write(&name.name);
                }
                self.emit.write(" = ");
                self.generate_expr(value);
                self.emit.writeln(";");
            }

            Stmt::Assign { name, value, .. } => {
                self.emit.write(&name.name);
                self.emit.write(" = ");
                self.generate_expr(value);
                self.emit.writeln(";");
            }

            Stmt::Return { value, .. } => {
                self.emit.write("return ");
                if let Some(expr) = value {
                    self.generate_expr(expr);
                }
                self.emit.writeln(";");
            }

            Stmt::If {
                condition,
                then_block,
                else_block,
                ..
            } => {
                self.emit.write("if ");
                self.generate_expr(condition);
                self.emit.write(" ");
                if else_block.is_some() {
                    self.generate_block_inline(then_block);
                    self.emit.write(" else ");
                    match else_block.as_ref().unwrap() {
                        sage_parser::ElseBranch::Block(block) => {
                            self.generate_block(block);
                        }
                        sage_parser::ElseBranch::ElseIf(stmt) => {
                            self.generate_stmt(stmt);
                        }
                    }
                } else {
                    self.generate_block(then_block);
                }
            }

            Stmt::For {
                pattern,
                iter,
                body,
                ..
            } => {
                self.emit.write("for ");
                self.emit_pattern(pattern);
                self.emit.write(" in ");
                self.generate_expr(iter);
                self.emit.write(" ");
                self.generate_block(body);
            }

            Stmt::While {
                condition, body, ..
            } => {
                self.emit.write("while ");
                self.generate_expr(condition);
                self.emit.write(" ");
                self.generate_block(body);
            }

            Stmt::Loop { body, .. } => {
                self.emit.write("loop ");
                self.generate_block(body);
            }

            Stmt::Break { .. } => {
                self.emit.writeln("break;");
            }

            Stmt::Expr { expr, .. } => {
                // Handle emit specially
                if let Expr::Emit { value, .. } = expr {
                    self.emit.write("return ctx.emit(");
                    self.generate_expr(value);
                    self.emit.writeln(");");
                } else {
                    self.generate_expr(expr);
                    self.emit.writeln(";");
                }
            }

            Stmt::LetTuple { names, value, .. } => {
                self.emit.write("let (");
                for (i, name) in names.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit.write(&name.name);
                }
                self.emit.write(") = ");
                self.generate_expr(value);
                self.emit.writeln(";");
            }
        }
    }

    fn generate_expr(&mut self, expr: &Expr) {
        match expr {
            Expr::Literal { value, .. } => {
                self.emit_literal(value);
            }

            Expr::Var { name, .. } => {
                self.emit.write(&name.name);
            }

            Expr::Binary {
                op, left, right, ..
            } => {
                // Handle string concatenation specially
                if matches!(op, BinOp::Concat) {
                    self.emit.write("format!(\"{}{}\", ");
                    self.generate_expr(left);
                    self.emit.write(", ");
                    self.generate_expr(right);
                    self.emit.write(")");
                } else {
                    self.emit.write("(");
                    self.generate_expr(left);
                    self.emit.write(" ");
                    self.emit_binop(op);
                    self.emit.write(" ");
                    self.generate_expr(right);
                    self.emit.write(")");
                }
            }

            Expr::Unary { op, operand, .. } => {
                self.emit_unaryop(op);
                self.generate_expr(operand);
            }

            Expr::Call { name, args, .. } => {
                let fn_name = &name.name;

                // Handle builtins
                match fn_name.as_str() {
                    "print" => {
                        self.emit.write("println!(\"{}\", ");
                        self.generate_expr(&args[0]);
                        self.emit.write(")");
                    }
                    "str" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".to_string()");
                    }
                    "len" => {
                        self.generate_expr(&args[0]);
                        self.emit.write(".len() as i64");
                    }
                    _ => {
                        self.emit.write(fn_name);
                        self.emit.write("(");
                        for (i, arg) in args.iter().enumerate() {
                            if i > 0 {
                                self.emit.write(", ");
                            }
                            self.generate_expr(arg);
                        }
                        self.emit.write(")");
                    }
                }
            }

            Expr::SelfField { field, .. } => {
                self.emit.write("self.");
                self.emit.write(&field.name);
            }

            Expr::SelfMethodCall { method, args, .. } => {
                self.emit.write("self.");
                self.emit.write(&method.name);
                self.emit.write("(");
                for (i, arg) in args.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(arg);
                }
                self.emit.write(")");
            }

            Expr::List { elements, .. } => {
                self.emit.write("vec![");
                for (i, elem) in elements.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(elem);
                }
                self.emit.write("]");
            }

            Expr::Paren { inner, .. } => {
                self.emit.write("(");
                self.generate_expr(inner);
                self.emit.write(")");
            }

            Expr::Infer { template, .. } => {
                self.emit.write("ctx.infer_string(&");
                self.emit_string_template(template);
                self.emit.write(").await?");
            }

            Expr::Spawn { agent, fields, .. } => {
                self.emit.write("sage_runtime::spawn(|ctx| ");
                self.emit.write(&agent.name);
                if fields.is_empty() {
                    self.emit.write(".on_start(ctx))");
                } else {
                    self.emit.write(" { ");
                    for (i, field) in fields.iter().enumerate() {
                        if i > 0 {
                            self.emit.write(", ");
                        }
                        self.emit.write(&field.name.name);
                        self.emit.write(": ");
                        self.generate_expr(&field.value);
                    }
                    self.emit.write(" }.on_start(ctx))");
                }
            }

            Expr::Await { handle, .. } => {
                self.generate_expr(handle);
                self.emit.write(".result().await?");
            }

            Expr::Send {
                handle, message, ..
            } => {
                self.generate_expr(handle);
                self.emit.write(".send(sage_runtime::Message::new(");
                self.generate_expr(message);
                self.emit.write(")?).await?");
            }

            Expr::Emit { value, .. } => {
                self.emit.write("ctx.emit(");
                self.generate_expr(value);
                self.emit.write(")");
            }

            Expr::StringInterp { template, .. } => {
                self.emit_string_template(template);
            }

            Expr::Match {
                scrutinee, arms, ..
            } => {
                self.emit.write("match ");
                self.generate_expr(scrutinee);
                self.emit.writeln(" {");
                self.emit.indent();
                for arm in arms {
                    self.emit_pattern(&arm.pattern);
                    self.emit.write(" => ");
                    self.generate_expr(&arm.body);
                    self.emit.writeln(",");
                }
                self.emit.dedent();
                self.emit.write("}");
            }

            Expr::RecordConstruct { name, fields, .. } => {
                self.emit.write(&name.name);
                self.emit.write(" { ");
                for (i, field) in fields.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit.write(&field.name.name);
                    self.emit.write(": ");
                    self.generate_expr(&field.value);
                }
                self.emit.write(" }");
            }

            Expr::FieldAccess { object, field, .. } => {
                self.generate_expr(object);
                self.emit.write(".");
                self.emit.write(&field.name);
            }

            Expr::Receive { .. } => {
                self.emit.write("ctx.receive().await?");
            }

            // RFC-0007: Error handling
            Expr::Try { expr, .. } => {
                // Generate the inner expression with ? for error propagation
                self.generate_expr(expr);
                self.emit.write("?");
            }

            Expr::Catch {
                expr,
                error_bind,
                recovery,
                ..
            } => {
                // Generate a match expression to handle the Result
                self.emit.write("match ");
                self.generate_expr(expr);
                self.emit.writeln(" {");
                self.emit.indent();

                // Ok arm - unwrap the value
                self.emit.writeln("Ok(__val) => __val,");

                // Err arm - run recovery
                if let Some(err_name) = error_bind {
                    self.emit.write("Err(");
                    self.emit.write(&err_name.name);
                    self.emit.write(") => ");
                } else {
                    self.emit.write("Err(_) => ");
                }
                self.generate_expr(recovery);
                self.emit.writeln(",");

                self.emit.dedent();
                self.emit.write("}");
            }

            // RFC-0009: Closures
            Expr::Closure { params, body, .. } => {
                // Generate: Box::new(move |param1: Type1, param2: Type2| { body })
                self.emit.write("Box::new(move |");
                for (i, param) in params.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit.write(&param.name.name);
                    if let Some(ty) = &param.ty {
                        self.emit.write(": ");
                        self.emit_type(ty);
                    }
                }
                self.emit.write("| ");
                self.generate_expr(body);
                self.emit.write(")");
            }

            // RFC-0010: Tuples and Maps
            Expr::Tuple { elements, .. } => {
                self.emit.write("(");
                for (i, elem) in elements.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(elem);
                }
                self.emit.write(")");
            }

            Expr::TupleIndex { tuple, index, .. } => {
                self.generate_expr(tuple);
                self.emit.write(&format!(".{index}"));
            }

            Expr::Map { entries, .. } => {
                if entries.is_empty() {
                    self.emit.write("std::collections::HashMap::new()");
                } else {
                    self.emit.write("std::collections::HashMap::from([");
                    for (i, entry) in entries.iter().enumerate() {
                        if i > 0 {
                            self.emit.write(", ");
                        }
                        self.emit.write("(");
                        self.generate_expr(&entry.key);
                        self.emit.write(", ");
                        self.generate_expr(&entry.value);
                        self.emit.write(")");
                    }
                    self.emit.write("])");
                }
            }

            Expr::VariantConstruct {
                enum_name,
                variant,
                payload,
                ..
            } => {
                self.emit.write(&enum_name.name);
                self.emit.write("::");
                self.emit.write(&variant.name);
                if let Some(payload_expr) = payload {
                    self.emit.write("(");
                    self.generate_expr(payload_expr);
                    self.emit.write(")");
                }
            }

            // RFC-0011: Tool calls
            Expr::ToolCall {
                tool,
                function,
                args,
                ..
            } => {
                // Generate: self.tool_name.function(args).await
                // Returns SageResult<T> - must be handled with try/catch
                self.emit.write("self.");
                self.emit.write(&tool.name.to_lowercase());
                self.emit.write(".");
                self.emit.write(&function.name);
                self.emit.write("(");
                for (i, arg) in args.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.generate_expr(arg);
                }
                self.emit.write(").await");
            }
        }
    }

    fn emit_pattern(&mut self, pattern: &sage_parser::Pattern) {
        use sage_parser::Pattern;
        match pattern {
            Pattern::Wildcard { .. } => {
                self.emit.write("_");
            }
            Pattern::Variant {
                enum_name,
                variant,
                payload,
                ..
            } => {
                if let Some(enum_name) = enum_name {
                    self.emit.write(&enum_name.name);
                    self.emit.write("::");
                }
                self.emit.write(&variant.name);
                if let Some(inner_pattern) = payload {
                    self.emit.write("(");
                    self.emit_pattern(inner_pattern);
                    self.emit.write(")");
                }
            }
            Pattern::Literal { value, .. } => {
                self.emit_literal(value);
            }
            Pattern::Binding { name, .. } => {
                self.emit.write(&name.name);
            }
            Pattern::Tuple { elements, .. } => {
                self.emit.write("(");
                for (i, elem) in elements.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit_pattern(elem);
                }
                self.emit.write(")");
            }
        }
    }

    fn emit_literal(&mut self, lit: &Literal) {
        match lit {
            Literal::Int(n) => {
                self.emit.write(&format!("{n}_i64"));
            }
            Literal::Float(f) => {
                self.emit.write(&format!("{f}_f64"));
            }
            Literal::Bool(b) => {
                self.emit.write(if *b { "true" } else { "false" });
            }
            Literal::String(s) => {
                // Escape the string for Rust
                self.emit.write("\"");
                for c in s.chars() {
                    match c {
                        '"' => self.emit.write_raw("\\\""),
                        '\\' => self.emit.write_raw("\\\\"),
                        '\n' => self.emit.write_raw("\\n"),
                        '\r' => self.emit.write_raw("\\r"),
                        '\t' => self.emit.write_raw("\\t"),
                        _ => self.emit.write_raw(&c.to_string()),
                    }
                }
                self.emit.write("\".to_string()");
            }
        }
    }

    fn emit_string_template(&mut self, template: &sage_parser::StringTemplate) {
        if !template.has_interpolations() {
            // Simple string literal
            if let Some(StringPart::Literal(s)) = template.parts.first() {
                self.emit.write("\"");
                self.emit.write_raw(s);
                self.emit.write("\".to_string()");
            }
            return;
        }

        // Build format string and args
        self.emit.write("format!(\"");
        for part in &template.parts {
            match part {
                StringPart::Literal(s) => {
                    // Escape braces for format string
                    let escaped = s.replace('{', "{{").replace('}', "}}");
                    self.emit.write_raw(&escaped);
                }
                StringPart::Interpolation(_) => {
                    self.emit.write_raw("{}");
                }
            }
        }
        self.emit.write("\"");

        // Add the interpolation args
        for part in &template.parts {
            if let StringPart::Interpolation(ident) = part {
                self.emit.write(", ");
                self.emit.write(&ident.name);
            }
        }
        self.emit.write(")");
    }

    fn emit_type(&mut self, ty: &TypeExpr) {
        match ty {
            TypeExpr::Int => self.emit.write("i64"),
            TypeExpr::Float => self.emit.write("f64"),
            TypeExpr::Bool => self.emit.write("bool"),
            TypeExpr::String => self.emit.write("String"),
            TypeExpr::Unit => self.emit.write("()"),
            TypeExpr::List(inner) => {
                self.emit.write("Vec<");
                self.emit_type(inner);
                self.emit.write(">");
            }
            TypeExpr::Option(inner) => {
                self.emit.write("Option<");
                self.emit_type(inner);
                self.emit.write(">");
            }
            TypeExpr::Inferred(inner) => {
                // Inferred<T> just becomes T at runtime
                self.emit_type(inner);
            }
            TypeExpr::Agent(agent_name) => {
                // Agent handles use the agent's output type, but we don't know it here
                // For now, just use a generic output type
                self.emit.write("AgentHandle<");
                self.emit.write(&agent_name.name);
                self.emit.write("Output>");
            }
            TypeExpr::Named(name) => {
                self.emit.write(&name.name);
            }

            // RFC-0007: Error handling
            TypeExpr::Error => {
                self.emit.write("sage_runtime::SageError");
            }

            // RFC-0009: Function types
            TypeExpr::Fn(params, ret) => {
                self.emit.write("Box<dyn Fn(");
                for (i, param) in params.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit_type(param);
                }
                self.emit.write(") -> ");
                self.emit_type(ret);
                self.emit.write(" + Send + 'static>");
            }

            // RFC-0010: Maps, tuples, Result
            TypeExpr::Map(key, value) => {
                self.emit.write("std::collections::HashMap<");
                self.emit_type(key);
                self.emit.write(", ");
                self.emit_type(value);
                self.emit.write(">");
            }
            TypeExpr::Tuple(elems) => {
                self.emit.write("(");
                for (i, elem) in elems.iter().enumerate() {
                    if i > 0 {
                        self.emit.write(", ");
                    }
                    self.emit_type(elem);
                }
                self.emit.write(")");
            }
            TypeExpr::Result(ok, err) => {
                self.emit.write("Result<");
                self.emit_type(ok);
                self.emit.write(", ");
                self.emit_type(err);
                self.emit.write(">");
            }
        }
    }

    fn emit_binop(&mut self, op: &BinOp) {
        let s = match op {
            BinOp::Add => "+",
            BinOp::Sub => "-",
            BinOp::Mul => "*",
            BinOp::Div => "/",
            BinOp::Eq => "==",
            BinOp::Ne => "!=",
            BinOp::Lt => "<",
            BinOp::Gt => ">",
            BinOp::Le => "<=",
            BinOp::Ge => ">=",
            BinOp::And => "&&",
            BinOp::Or => "||",
            BinOp::Concat => "++", // Handled specially above
        };
        self.emit.write(s);
    }

    fn emit_unaryop(&mut self, op: &UnaryOp) {
        let s = match op {
            UnaryOp::Neg => "-",
            UnaryOp::Not => "!",
        };
        self.emit.write(s);
    }

    fn infer_agent_output_type(&self, agent: &AgentDecl) -> String {
        // Look for emit expression in start handler to infer return type
        // For now, default to i64
        for handler in &agent.handlers {
            if let EventKind::Start = &handler.event {
                if let Some(ty) = self.find_emit_type(&handler.body) {
                    return ty;
                }
            }
        }
        "i64".to_string()
    }

    fn find_emit_type(&self, block: &Block) -> Option<String> {
        for stmt in &block.stmts {
            if let Stmt::Expr { expr, .. } = stmt {
                if let Expr::Emit { value, .. } = expr {
                    return Some(self.infer_expr_type(value));
                }
            }
            // Check nested blocks
            if let Stmt::If {
                then_block,
                else_block,
                ..
            } = stmt
            {
                if let Some(ty) = self.find_emit_type(then_block) {
                    return Some(ty);
                }
                if let Some(else_branch) = else_block {
                    if let sage_parser::ElseBranch::Block(block) = else_branch {
                        if let Some(ty) = self.find_emit_type(block) {
                            return Some(ty);
                        }
                    }
                }
            }
        }
        None
    }

    fn infer_expr_type(&self, expr: &Expr) -> String {
        match expr {
            Expr::Literal { value, .. } => match value {
                Literal::Int(_) => "i64".to_string(),
                Literal::Float(_) => "f64".to_string(),
                Literal::Bool(_) => "bool".to_string(),
                Literal::String(_) => "String".to_string(),
            },
            Expr::Var { .. } => "i64".to_string(), // Conservative default
            Expr::Binary { op, .. } => {
                if matches!(
                    op,
                    BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Gt | BinOp::Le | BinOp::Ge
                ) {
                    "bool".to_string()
                } else if matches!(op, BinOp::Concat) {
                    "String".to_string()
                } else {
                    "i64".to_string()
                }
            }
            Expr::Infer { .. } | Expr::StringInterp { .. } => "String".to_string(),
            Expr::Call { name, .. } if name.name == "str" => "String".to_string(),
            Expr::Call { name, .. } if name.name == "len" => "i64".to_string(),
            _ => "i64".to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use sage_lexer::lex;
    use sage_parser::parse;
    use std::sync::Arc;

    fn generate_source(source: &str) -> String {
        let lex_result = lex(source).expect("lexing failed");
        let source_arc: Arc<str> = Arc::from(source);
        let (program, errors) = parse(lex_result.tokens(), source_arc);
        assert!(errors.is_empty(), "parse errors: {errors:?}");
        let program = program.expect("should parse");
        generate(&program, "test").main_rs
    }

    #[test]
    fn generate_minimal_program() {
        let source = r#"
            agent Main {
                on start {
                    emit(42);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("struct Main;"));
        assert!(output.contains("async fn on_start"));
        assert!(output.contains("ctx.emit(42_i64)"));
        assert!(output.contains("#[tokio::main]"));
    }

    #[test]
    fn generate_function() {
        let source = r#"
            fn add(a: Int, b: Int) -> Int {
                return a + b;
            }
            agent Main {
                on start {
                    emit(add(1, 2));
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("fn add(a: i64, b: i64) -> i64"));
        assert!(output.contains("return (a + b);"));
    }

    #[test]
    fn generate_agent_with_beliefs() {
        let source = r#"
            agent Worker {
                value: Int

                on start {
                    emit(self.value * 2);
                }
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("struct Worker {"));
        assert!(output.contains("value: i64,"));
        assert!(output.contains("self.value"));
    }

    #[test]
    fn generate_string_interpolation() {
        let source = r#"
            agent Main {
                on start {
                    let name = "World";
                    let msg = "Hello, {name}!";
                    print(msg);
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("format!(\"Hello, {}!\", name)"));
    }

    #[test]
    fn generate_control_flow() {
        let source = r#"
            agent Main {
                on start {
                    let x = 10;
                    if x > 5 {
                        emit(1);
                    } else {
                        emit(0);
                    }
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("if (x > 5_i64)"), "output:\n{output}");
        // else is on the same line after close brace
        assert!(output.contains("else"), "output:\n{output}");
    }

    #[test]
    fn generate_loops() {
        let source = r#"
            agent Main {
                on start {
                    for x in [1, 2, 3] {
                        print(str(x));
                    }
                    let n = 0;
                    while n < 5 {
                        n = n + 1;
                    }
                    emit(n);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("for x in vec![1_i64, 2_i64, 3_i64]"));
        assert!(output.contains("while (n < 5_i64)"));
    }

    #[test]
    fn generate_pub_function() {
        let source = r#"
            pub fn helper(x: Int) -> Int {
                return x * 2;
            }
            agent Main {
                on start {
                    emit(helper(21));
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("pub fn helper(x: i64) -> i64"));
    }

    #[test]
    fn generate_pub_agent() {
        let source = r#"
            pub agent Worker {
                on start {
                    emit(42);
                }
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("pub struct Worker;"));
    }

    #[test]
    fn generate_module_tree_simple() {
        use sage_loader::load_single_file;
        use std::fs;
        use tempfile::TempDir;

        let dir = TempDir::new().unwrap();
        let file = dir.path().join("test.sg");
        fs::write(
            &file,
            r#"
agent Main {
    on start {
        emit(42);
    }
}
run Main;
"#,
        )
        .unwrap();

        let tree = load_single_file(&file).unwrap();
        let project = generate_module_tree(&tree, "test");

        assert!(project.main_rs.contains("struct Main;"));
        assert!(project.main_rs.contains("async fn on_start"));
        assert!(project.main_rs.contains("#[tokio::main]"));
    }

    #[test]
    fn generate_record_declaration() {
        let source = r#"
            record Point {
                x: Int,
                y: Int,
            }
            agent Main {
                on start {
                    let p = Point { x: 10, y: 20 };
                    emit(p.x);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("#[derive(Debug, Clone)]"));
        assert!(output.contains("struct Point {"));
        assert!(output.contains("x: i64,"));
        assert!(output.contains("y: i64,"));
        assert!(output.contains("Point { x: 10_i64, y: 20_i64 }"));
        assert!(output.contains("p.x"));
    }

    #[test]
    fn generate_enum_declaration() {
        let source = r#"
            enum Status {
                Active,
                Inactive,
                Pending,
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("#[derive(Debug, Clone, Copy, PartialEq, Eq)]"));
        assert!(output.contains("enum Status {"));
        assert!(output.contains("Active,"));
        assert!(output.contains("Inactive,"));
        assert!(output.contains("Pending,"));
    }

    #[test]
    fn generate_const_declaration() {
        let source = r#"
            const MAX_SIZE: Int = 100;
            const GREETING: String = "Hello";
            agent Main {
                on start {
                    emit(MAX_SIZE);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("const MAX_SIZE: i64 = 100_i64;"));
        assert!(output.contains("const GREETING: String = \"Hello\".to_string();"));
    }

    #[test]
    fn generate_match_expression() {
        let source = r#"
            enum Status {
                Active,
                Inactive,
            }
            fn check_status(s: Status) -> Int {
                return match s {
                    Active => 1,
                    Inactive => 0,
                };
            }
            agent Main {
                on start {
                    emit(0);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        assert!(output.contains("match s {"));
        assert!(output.contains("Active => 1_i64,"));
        assert!(output.contains("Inactive => 0_i64,"));
    }

    // =========================================================================
    // RFC-0007: Error handling codegen tests
    // =========================================================================

    #[test]
    fn generate_fallible_function() {
        let source = r#"
            fn get_data(url: String) -> String fails {
                return url;
            }
            agent Main {
                on start { emit(0); }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // Fallible function should return SageResult<T>
        assert!(output.contains("fn get_data(url: String) -> SageResult<String>"));
    }

    #[test]
    fn generate_try_expression() {
        let source = r#"
            fn fallible() -> Int fails { return 42; }
            fn caller() -> Int fails {
                let x = try fallible();
                return x;
            }
            agent Main {
                on start { emit(0); }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // try should generate ? operator
        assert!(output.contains("fallible()?"));
    }

    #[test]
    fn generate_catch_expression() {
        let source = r#"
            fn fallible() -> Int fails { return 42; }
            agent Main {
                on start {
                    let x = fallible() catch { 0 };
                    emit(x);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // catch should generate match expression
        assert!(output.contains("match fallible()"));
        assert!(output.contains("Ok(__val) => __val"));
        assert!(output.contains("Err(_) => 0_i64"));
    }

    #[test]
    fn generate_catch_with_binding() {
        let source = r#"
            fn fallible() -> Int fails { return 42; }
            agent Main {
                on start {
                    let x = fallible() catch(e) { 0 };
                    emit(x);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // catch with binding should capture the error
        assert!(output.contains("Err(e) => 0_i64"));
    }

    #[test]
    fn generate_on_error_handler() {
        let source = r#"
            agent Main {
                on start {
                    emit(0);
                }
                on error(e) {
                    emit(1);
                }
            }
            run Main;
        "#;

        let output = generate_source(source);
        // Should generate on_error method with &mut ctx
        assert!(output.contains("async fn on_error(self, e: SageError, ctx: &mut AgentContext"));
        // Main should dispatch to on_error on failure with &mut ctx
        assert!(output.contains(".on_error(e, &mut ctx)"));
    }

    // =========================================================================
    // RFC-0011: Tool support codegen tests
    // =========================================================================

    #[test]
    fn generate_agent_with_tool_use() {
        let source = r#"
            agent Fetcher {
                use Http

                on start {
                    let r = Http.get("https://example.com");
                    emit(0);
                }
            }
            run Fetcher;
        "#;

        let output = generate_source(source);
        // Should generate struct with http field
        assert!(output.contains("struct Fetcher {"));
        assert!(output.contains("http: HttpClient,"));
        // Should initialize HttpClient in main
        assert!(output.contains("http: HttpClient::from_env()"));
        // Should generate tool call
        assert!(output.contains("self.http.get("));
    }

    #[test]
    fn generate_tool_call_expression() {
        let source = r#"
            agent Fetcher {
                use Http

                on start {
                    let response = Http.get("https://httpbin.org/get");
                    emit(0);
                }
            }
            run Fetcher;
        "#;

        let output = generate_source(source);
        // Tool call should generate self.http.get(...).await (no ?, handled by try/catch)
        assert!(output.contains("self.http.get(\"https://httpbin.org/get\".to_string()).await"));
    }
}