codegen_elixir.rs

// SPDX-License-Identifier: MPL-2.0
// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
//
// 007 Agent Meta-Language — Elixir/OTP Code Generator
//
// Compiles the 007 AST into a runnable Elixir/OTP project:
//   - Agents become GenServer modules
//   - Supervisors become Supervisor modules
//   - Functions, DataBindings, TypeDecls become library modules
//   - Protocols become Behaviour modules
//   - An Application module boots the OTP tree
//   - A mix.exs and config/config.exs are generated
//
// The Harvard Architecture invariant (Data vs Control) is preserved
// in the generated code: DataExpr maps to pure Elixir expressions,
// ControlExpr maps to effectful GenServer interactions.

use serde::{Deserialize, Serialize};

use crate::ast::*;

// ============================================================
// Output types
// ============================================================

/// A complete generated Elixir project.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ElixirProject {
    /// All generated .ex source files.
    pub files: Vec<ElixirFile>,
    /// The contents of mix.exs.
    pub mix_exs: String,
    /// The contents of config/config.exs.
    pub config: String,
}

/// A single generated Elixir source file.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ElixirFile {
    /// Relative path from project root (e.g. "lib/my_app/agents/reviewer.{}", "ex").
    pub path: String,
    /// The full Elixir source text.
    pub content: String,
}

/// Errors that can occur during code generation.
#[derive(Debug)]
pub enum CodegenError {
    /// A 007 construct that has no direct Elixir representation.
    UnsupportedConstruct(String),
}

impl std::fmt::Display for CodegenError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CodegenError::UnsupportedConstruct(s) => write!(f, "Unsupported: {}", s),
        }
    }
}

impl std::error::Error for CodegenError {}

// ============================================================
// Generation context
// ============================================================

/// Internal context threaded through code generation.
pub struct GenContext {
    /// Snake-case project name (e.g. "my_app").
    project_name: String,
    /// PascalCase project module prefix (e.g. "MyApp").
    project_module: String,
    /// Fully-qualified Functions module (e.g. "MyApp.Functions").
    functions_module: String,
    /// Fully-qualified Data module (e.g. "MyApp.Data").
    #[allow(dead_code)]
    data_module: String,
}

impl GenContext {
    fn new(project_name: &str) -> Self {
        let snake = to_snake_case(project_name);
        let pascal = to_pascal_case(project_name);
        Self {
            project_name: snake.clone(),
            project_module: pascal.clone(),
            functions_module: format!("{}.Functions", pascal),
            data_module: format!("{}.Data", pascal),
        }
    }
}

// ============================================================
// Main entry point
// ============================================================

/// Generate a complete Elixir/OTP project from a 007 AST.
///
/// Walks every `TopLevelDecl` in `program` and produces:
/// - One GenServer file per Agent
/// - One Supervisor file per Supervisor
/// - Collected Functions, DataBindings, TypeDecls modules
/// - Protocol/Behaviour modules
/// - Application module
/// - mix.exs and config/config.exs
pub fn generate_elixir(
    program: &Program,
    project_name: &str,
) -> Result<ElixirProject, CodegenError> {
    let ctx = GenContext::new(project_name);

    let mut files: Vec<ElixirFile> = Vec::new();
    let mut functions: Vec<&FunctionDecl> = Vec::new();
    let mut data_bindings: Vec<&DataBinding> = Vec::new();
    let mut type_decls: Vec<&TypeDeclNode> = Vec::new();
    let mut supervisors: Vec<&SupervisorDecl> = Vec::new();
    let mut supervisor_names: Vec<String> = Vec::new();
    let mut locales: Vec<&LocaleDecl> = Vec::new();

    for decl in &program.declarations {
        match decl {
            TopLevelDecl::Agent(agent) => {
                files.push(gen_agent(agent, &ctx));
            }
            TopLevelDecl::Supervisor(sup) => {
                supervisors.push(sup);
                supervisor_names.push(sup.name.clone());
                files.push(gen_supervisor(sup, &ctx));
            }
            TopLevelDecl::Function(func) => {
                functions.push(func);
            }
            TopLevelDecl::DataBinding(db) => {
                data_bindings.push(db);
            }
            TopLevelDecl::Sentinel(_) => {
                // Sentinels are compile-time only; no Elixir output
            }
            TopLevelDecl::TypeDecl(td) => {
                type_decls.push(td);
            }
            TopLevelDecl::Protocol(proto) => {
                files.push(gen_protocol(proto, &ctx));
            }
            TopLevelDecl::Behaviour(beh) => {
                files.push(gen_behaviour(beh, &ctx));
            }
            TopLevelDecl::Choreography(choreo) => {
                // Choreographies are global coordination protocols.
                // They don't have a direct Elixir equivalent; emit a
                // documentation module describing the protocol.
                files.push(gen_choreography_doc(choreo, &ctx));
            }
            TopLevelDecl::Locale(locale) => {
                locales.push(locale);
            }
            TopLevelDecl::Import(_) => {
                // Imports are resolved at 007 compile time.
                // No Elixir artifact needed.
            }
            TopLevelDecl::Discourse(_) => {
                // Discourse blocks are type-checker directives; no Elixir output.
            }
            TopLevelDecl::Macro(_) => {
                // Macros are expanded at compile time.
            }
            TopLevelDecl::DslBlock(_) => {
                // DSL blocks are handled by external toolchains.
            }
        }
    }

    // Collected modules
    if !functions.is_empty() {
        files.push(gen_functions_module(&functions, &ctx));
    }
    if !data_bindings.is_empty() {
        files.push(gen_data_module(&data_bindings, &ctx));
    }
    if !type_decls.is_empty() {
        files.push(gen_types_module(&type_decls, &ctx));
    }

    // Locale routing module (BEAM distribution)
    if !locales.is_empty() {
        files.push(gen_locale_module(&locales, &ctx));
    }

    // Application module
    files.push(gen_application_module(&supervisor_names, &ctx));

    // Standard library modules
    files.extend(gen_stdlib_modules(&ctx));

    let mix_exs = gen_mix_exs(&ctx);
    let config = gen_config_exs();

    // Validate all generated files before handing the project off.
    if let Err(e) = validate_generated_files(&ctx, &files) {
        log::error!("Generated Elixir project failed validation: {}", e);
    }

    Ok(ElixirProject {
        files,
        mix_exs,
        config,
    })
}

/// Validate the generated Elixir files before returning the project.
///
/// Checks that every file has a non-empty path and non-empty content. This
/// catches codegen bugs (empty module bodies, missing stdlib files) before
/// the project is handed to `mix compile`. The real compilation step belongs
/// to the BEAM toolchain — see `beam_roundtrip.rs` for that.
fn validate_generated_files(
    _ctx: &GenContext,
    files: &[ElixirFile],
) -> Result<(), Box<dyn std::error::Error>> {
    for file in files {
        if file.path.is_empty() {
            return Err("Generated file has empty path".into());
        }
        if file.content.is_empty() {
            return Err(format!("Generated file '{}' has empty content", file.path).into());
        }
        // Sanity-check that every file carries the SPDX header injected by the
        // individual generators. If it's missing, something went wrong upstream.
        if !file.content.contains("SPDX-License-Identifier") {
            log::warn!(
                "Generated file '{}' is missing SPDX header — codegen bug?",
                file.path
            );
        }
    }
    log::debug!("validate_generated_files: {} files OK", files.len());
    Ok(())
}

// ============================================================
// Locale Routing — BEAM Distribution
// ============================================================

/// Generate Elixir code for a LocaleExpr reference.
fn gen_locale_expr(expr: &LocaleExpr) -> String {
    match expr {
        LocaleExpr::Named(name) => format!(":{}", to_snake_case(name)),
        LocaleExpr::Constructor(ctor) => gen_locale_constructor(ctor),
    }
}

/// Generate Elixir code for a LocaleConstructor.
fn gen_locale_constructor(ctor: &LocaleConstructor) -> String {
    match ctor {
        LocaleConstructor::Local => ":local".to_string(),
        LocaleConstructor::Gpu { device } => format!("{{:gpu, {}}}", device),
        LocaleConstructor::Remote { url, model } => {
            let url_str = url.as_deref().unwrap_or("localhost");
            let model_str = model.as_deref().unwrap_or("default");
            format!("{{:remote, \"{}\", \"{}\"}}", url_str, model_str)
        }
        LocaleConstructor::Edge { region, model } => {
            let region_str = region.as_deref().unwrap_or("default");
            let model_str = model.as_deref().unwrap_or("default");
            format!("{{:edge, \"{}\", \"{}\"}}", region_str, model_str)
        }
        LocaleConstructor::Cluster { nodes, models: _ } => {
            let node_list: Vec<String> = nodes.iter().map(|n| format!("\"{}\"", n)).collect();
            format!("{{:cluster, [{}]}}", node_list.join(", "))
        }
    }
}

/// Generate the Oo7.Locale module — locale registry and migration dispatch.
///
/// This module maps locale names to BEAM distribution targets and provides
/// the `migrate/3` function that routes computation to the correct node.
fn gen_locale_module(locales: &[&LocaleDecl], ctx: &GenContext) -> ElixirFile {
    let mut locale_entries = String::new();
    for locale in locales {
        let ctor = gen_locale_constructor(&locale.constructor);
        locale_entries.push_str(&format!(
            "  def resolve(:{}), do: {}\n",
            to_snake_case(&locale.name),
            ctor
        ));
    }

    let content = format!(
        r#"defmodule {prefix}.Locale do
  @moduledoc """
  Locale registry and migration dispatch for 007 agents.
  Maps locale names to BEAM distribution targets (nodes, GPU devices,
  remote endpoints) and provides migrate/3 for transparent locale routing.

  Generated by the 007 MK2 compiler.
  """

  # ---- Locale Registry ----
  # Each locale declaration maps to a resolve/1 clause.

{entries}  def resolve(locale), do: {{:error, :unknown_locale, locale}}

  # ---- Migration Dispatch ----

  @doc """
  Migrate a computation to a target locale.

  `expr_fn` is a zero-arity function capturing the expression to evaluate.
  `from` and `to` are locale atoms or tuples resolved by resolve/1.

  Returns the result of evaluating `expr_fn` at the target locale.
  """
  def migrate(expr_fn, from, to) when is_function(expr_fn, 0) do
    from_locale = resolve_locale(from)
    to_locale = resolve_locale(to)
    do_migrate(expr_fn, from_locale, to_locale)
  end

  defp resolve_locale(locale) when is_atom(locale), do: resolve(locale)
  defp resolve_locale(locale) when is_tuple(locale), do: locale

  # Local → Local: just execute in place.
  defp do_migrate(expr_fn, _from, :local), do: expr_fn.()

  # Any → GPU: execute locally with GPU device hint.
  # In production, this would dispatch to Nx/EXLA with device placement.
  defp do_migrate(expr_fn, _from, {{:gpu, device}}) do
    # GPU dispatch — placeholder for Nx device placement.
    # In production: Nx.default_backend({{EXLA.Backend, device_id: device}})
    _device = device
    expr_fn.()
  end

  # Any → Remote: dispatch via :rpc.call to the remote node.
  defp do_migrate(expr_fn, _from, {{:remote, url, _model}}) do
    node = url_to_node(url)
    case Node.connect(node) do
      true ->
        :rpc.call(node, Kernel, :apply, [expr_fn, []])
      false ->
        {{:error, :node_unreachable, node}}
    end
  end

  # Any → Edge: same as Remote but with region-based node selection.
  defp do_migrate(expr_fn, _from, {{:edge, region, _model}}) do
    node = region_to_node(region)
    case Node.connect(node) do
      true ->
        :rpc.call(node, Kernel, :apply, [expr_fn, []])
      false ->
        {{:error, :node_unreachable, node}}
    end
  end

  # Any → Cluster: load-balanced dispatch across cluster nodes.
  defp do_migrate(expr_fn, _from, {{:cluster, nodes}}) do
    # Round-robin node selection via :erlang.phash2.
    index = :erlang.phash2(make_ref(), length(nodes))
    node_url = Enum.at(nodes, index)
    node = url_to_node(node_url)
    case Node.connect(node) do
      true ->
        :rpc.call(node, Kernel, :apply, [expr_fn, []])
      false ->
        # Fallback: try next node.
        fallback_node = url_to_node(Enum.at(nodes, rem(index + 1, length(nodes))))
        case Node.connect(fallback_node) do
          true -> :rpc.call(fallback_node, Kernel, :apply, [expr_fn, []])
          false -> {{:error, :cluster_unreachable, nodes}}
        end
    end
  end

  # Unknown locale type — execute locally with warning.
  defp do_migrate(expr_fn, _from, _to) do
    IO.warn("Unknown locale type — executing locally")
    expr_fn.()
  end

  # ---- Helpers ----

  defp url_to_node(url) when is_binary(url) do
    # Convert URL to Erlang node name.
    # "https://host.example.com" → :"oo7@host.example.com"
    # "host.local" → :"oo7@host.local"
    host = url
      |> String.replace(~r/^https?:\/\//, "")
      |> String.split("/")
      |> List.first()
      |> String.split(":")
      |> List.first()
    :"oo7@#{{host}}"
  end

  defp region_to_node(region) when is_binary(region) do
    # Map region to a well-known edge node name.
    :"oo7_edge@#{{region}}.edge.local"
  end
end
"#,
        prefix = ctx.project_module,
        entries = locale_entries
    );

    ElixirFile {
        path: format!("lib/{}/locale.ex", to_snake_case(&ctx.project_name)),
        content,
    }
}

/// Generate standard library modules.
fn gen_stdlib_modules(ctx: &GenContext) -> Vec<ElixirFile> {
    vec![
        gen_result_module(ctx),
        gen_collections_module(ctx),
        gen_stream_module(ctx),
        gen_time_module(ctx),
    ]
}

// ============================================================
// Data expression codegen (Harvard: pure, total)
// ============================================================

/// Generate an Elixir expression from a 007 DataExpr.
///
/// DataExprs are total and pure — they map to simple Elixir literals
/// and pure function calls.
fn gen_data_expr(expr: &DataExpr) -> String {
    match expr {
        DataExpr::Int(n) => format!("{}", n),
        DataExpr::Float(f) => {
            if f.is_nan() {
                ":nan".to_string()
            } else if f.is_infinite() {
                if *f > 0.0 {
                    ":infinity".to_string()
                } else {
                    ":neg_infinity".to_string()
                }
            } else {
                // Ensure there's always a decimal point for Elixir
                let s = format!("{}", f);
                if s.contains('.') {
                    s
                } else {
                    format!("{}.0", s)
                }
            }
        }
        DataExpr::String(s) => format!("\"{}\"", escape_elixir_string(s)),
        DataExpr::Bool(b) => {
            if *b {
                "true".to_string()
            } else {
                "false".to_string()
            }
        }
        DataExpr::Add(l, r) => {
            format!("({} + {})", gen_data_expr(l), gen_data_expr(r))
        }
        DataExpr::Sub(l, r) => {
            format!("({} - {})", gen_data_expr(l), gen_data_expr(r))
        }
        DataExpr::Mul(l, r) => {
            format!("({} * {})", gen_data_expr(l), gen_data_expr(r))
        }
        DataExpr::Div(l, r) => {
            // Elixir: use safe_div helper for totality (div by zero → nil)
            format!("safe_div({}, {})", gen_data_expr(l), gen_data_expr(r))
        }
        DataExpr::Mod(l, r) => {
            format!("safe_rem({}, {})", gen_data_expr(l), gen_data_expr(r))
        }
        DataExpr::Record(fields) => {
            let inner: Vec<String> = fields
                .iter()
                .map(|(k, v)| format!("{}: {}", to_snake_case(k), gen_data_expr(v)))
                .collect();
            format!("%{{{}}}", inner.join(", "))
        }
        DataExpr::List(items) => {
            let inner: Vec<String> = items.iter().map(gen_data_expr).collect();
            format!("[{}]", inner.join(", "))
        }
        DataExpr::Rational(n, d) => format!("{{:rational, {}, {}}}", n, d),
        DataExpr::Complex(r, i) => format!("{{:complex, {}, {}}}", r, i),
        DataExpr::Symbolic(s) => format!("\"{}\"", escape_elixir_string(s)),
        DataExpr::Min(l, r) => format!("min({}, {})", gen_data_expr(l), gen_data_expr(r)),
        DataExpr::Max(l, r) => format!("max({}, {})", gen_data_expr(l), gen_data_expr(r)),
        DataExpr::Or(l, r) => format!("({} or {})", gen_data_expr(l), gen_data_expr(r)),
        DataExpr::Xor(l, r) => {
            // Elixir XOR via Bitwise.bxor or boolean negation
            format!("bxor({}, {})", gen_data_expr(l), gen_data_expr(r))
        }
        DataExpr::Var(name) => to_snake_case(name),
        DataExpr::FieldAccess(expr, field) => {
            format!(
                "Map.get({}, :{})",
                gen_data_expr(expr),
                to_snake_case(field)
            )
        }
        DataExpr::PureCall(name, args) => {
            let arg_strs: Vec<String> = args.iter().map(gen_data_expr).collect();
            format!(
                "{}.{}({})",
                "Functions",
                to_snake_case(name),
                arg_strs.join(", ")
            )
        }
    }
}

// ============================================================
// Control expression codegen (Harvard: effectful)
// ============================================================

/// Generate an Elixir expression from a 007 ControlExpr.
///
/// ControlExprs may invoke side effects — sends, spawns, exchanges.
/// They map to GenServer calls and Elixir control flow.
pub fn gen_control_expr(expr: &ControlExpr, ctx: &GenContext) -> String {
    match expr {
        ControlExpr::DataLit(d) => gen_data_expr(d),
        ControlExpr::Var(x) => to_snake_case(x),
        ControlExpr::BinOp(l, op, r) => {
            let left = gen_control_expr(l, ctx);
            let right = gen_control_expr(r, ctx);
            match op {
                BinOp::Div => format!("div({}, {})", left, right),
                BinOp::Mod => format!("rem({}, {})", left, right),
                _ => format!("({} {} {})", left, elixir_binop(op), right),
            }
        }
        ControlExpr::Call(name, args) => {
            let arg_strs: Vec<String> = args.iter().map(|a| gen_control_expr(a, ctx)).collect();
            format!(
                "{}.{}({})",
                ctx.functions_module,
                to_snake_case(name),
                arg_strs.join(", ")
            )
        }
        ControlExpr::Constructor(name, args) => {
            if args.is_empty() {
                format!("{{:{}}}", to_snake_case(name))
            } else {
                let arg_strs: Vec<String> = args.iter().map(|a| gen_control_expr(a, ctx)).collect();
                format!("{{:{}, {}}}", to_snake_case(name), arg_strs.join(", "))
            }
        }
        ControlExpr::MethodCall(recv, method, args) => gen_method_call(recv, method, args, ctx),
        ControlExpr::FieldAccess(expr, field) => {
            format!(
                "Map.get({}, :{})",
                gen_control_expr(expr, ctx),
                to_snake_case(field)
            )
        }
        ControlExpr::Exchange(handle, message) => {
            format!(
                "GenServer.call({}, {{:exchange, {}}})",
                gen_control_expr(handle, ctx),
                gen_control_expr(message, ctx)
            )
        }
        ControlExpr::Receive => {
            "receive do\n      msg -> msg\n    after\n      0 -> nil\n    end".to_string()
        }
        ControlExpr::Migrate { expr, from, to } => {
            // Locale routing via BEAM distribution.
            // Dispatches to Oo7.Locale.migrate/3 which uses :rpc.call
            // for Remote/Edge/Cluster locales, local eval for Local/GPU.
            let inner = gen_control_expr(expr, ctx);
            let from_str = gen_locale_expr(from);
            let to_str = gen_locale_expr(to);
            format!(
                "{}.Locale.migrate(fn -> {} end, {}, {})",
                ctx.project_module, inner, from_str, to_str
            )
        }
        ControlExpr::VerifyIntegrity(name) => {
            format!("Oo7.Sentinel.verify({})", to_snake_case(name))
        }
        ControlExpr::QueryTrace { label, .. } => {
            format!(
                ":ets.lookup(:oo7_traces, \"{}\") |> List.first()",
                escape_elixir_string(label)
            )
        }
        // Agent self-introspection — Harvard-safe (Control → Data)
        ControlExpr::QueryCapabilities => "Process.get(:oo7_capabilities) || []".to_string(),
        ControlExpr::QueryDiscourse => "Process.get(:oo7_discourse) || nil".to_string(),
        ControlExpr::QueryBudget => "Process.get(:oo7_budget) || nil".to_string(),
        ControlExpr::QueryStrategy => {
            "Process.get(:oo7_strategy) || \"predicate_first\"".to_string()
        }
        ControlExpr::Record(fields) => {
            let inner: Vec<String> = fields
                .iter()
                .map(|(k, v)| format!("{}: {}", to_snake_case(k), gen_control_expr(v, ctx)))
                .collect();
            format!("%{{{}}}", inner.join(", "))
        }
        ControlExpr::List(items) => {
            let inner: Vec<String> = items.iter().map(|i| gen_control_expr(i, ctx)).collect();
            format!("[{}]", inner.join(", "))
        }
        ControlExpr::Bridge { expr, from, to } => {
            // Bridge passes a value across discourse boundaries.
            // In Elixir, this is a no-op on the value — discourse semantics
            // are handled at the type level. Emit a tagged tuple for tracing.
            format!(
                "{{:bridge, {}, :{}, :{}}}",
                gen_control_expr(expr, ctx),
                to_snake_case(from),
                to_snake_case(to)
            )
        }
    }
}

/// Map a 007 BinOp to its Elixir infix operator string.
///
/// Div and Mod are handled specially (function call form) in the caller.
fn elixir_binop(op: &BinOp) -> &'static str {
    match op {
        BinOp::Add => "+",
        BinOp::Sub => "-",
        BinOp::Mul => "*",
        BinOp::Div => "div", // caller uses function form
        BinOp::Mod => "rem", // caller uses function form
        BinOp::Eq => "==",
        BinOp::Neq => "!=",
        BinOp::Lt => "<",
        BinOp::Gt => ">",
        BinOp::Lte => "<=",
        BinOp::Gte => ">=",
        BinOp::And => "and",
        BinOp::Or => "or",
        BinOp::Concat => "<>",
    }
}

/// Generate Elixir for a method call, dispatching common methods
/// to appropriate Elixir standard library functions.
fn gen_method_call(
    recv: &ControlExpr,
    method: &str,
    args: &[ControlExpr],
    ctx: &GenContext,
) -> String {
    let recv_str = gen_control_expr(recv, ctx);
    match method {
        "length" => format!(
            "(if is_binary({}), do: String.length({}), else: length({}))",
            recv_str, recv_str, recv_str
        ),
        "to_upper" => format!("String.upcase({})", recv_str),
        "to_lower" => format!("String.downcase({})", recv_str),
        "get" => {
            let idx = if args.is_empty() {
                "0".to_string()
            } else {
                gen_control_expr(&args[0], ctx)
            };
            format!("Enum.at({}, {})", recv_str, idx)
        }
        "push" => {
            let val = if args.is_empty() {
                "nil".to_string()
            } else {
                gen_control_expr(&args[0], ctx)
            };
            format!("{} ++ [{}]", recv_str, val)
        }
        "keys" => format!("Map.keys({})", recv_str),
        "id" => format!("inspect({})", recv_str),
        _ => {
            let arg_strs: Vec<String> = args.iter().map(|a| gen_control_expr(a, ctx)).collect();
            format!("{}.{}({})", recv_str, method, arg_strs.join(", "))
        }
    }
}

// ============================================================
// Control statement codegen
// ============================================================

/// Generate Elixir source for a single ControlStmt.
///
/// Returns one or more lines of Elixir code at the given indentation level.
pub fn gen_control_stmt(stmt: &ControlStmt, ctx: &GenContext, indent: usize) -> String {
    let ind = make_indent(indent);
    match stmt {
        ControlStmt::Let { pattern, value, .. } => {
            format!(
                "{}{} = {}",
                ind,
                gen_pattern(pattern),
                gen_control_expr(value, ctx)
            )
        }
        ControlStmt::Send { target, message } => {
            format!(
                "{}GenServer.cast({}, {{:receive, {}}})",
                ind,
                gen_control_expr(target, ctx),
                gen_control_expr(message, ctx)
            )
        }
        ControlStmt::SendFinal { target, message } => {
            let target_str = gen_control_expr(target, ctx);
            let msg_str = gen_control_expr(message, ctx);
            format!(
                "{}GenServer.cast({}, {{:receive, {}}})\n{}GenServer.stop({})",
                ind, target_str, msg_str, ind, target_str
            )
        }
        ControlStmt::Spawn {
            binding,
            agent_name,
            ..
        } => {
            format!(
                "{}{{:ok, {}}} = {}.Agents.{}.start_link([])",
                ind,
                to_snake_case(binding),
                ctx.project_module,
                agent_name
            )
        }
        ControlStmt::If {
            condition,
            then_body,
            else_body,
        } => {
            let mut out = format!("{}if {} do\n", ind, gen_control_expr(condition, ctx));
            out.push_str(&gen_stmts(then_body, ctx, indent + 1));
            if !else_body.is_empty() {
                out.push_str(&format!("\n{}else\n", ind));
                out.push_str(&gen_stmts(else_body, ctx, indent + 1));
            }
            out.push_str(&format!("\n{}end", ind));
            out
        }
        ControlStmt::Match { scrutinee, arms } => {
            let mut out = format!("{}case {} do\n", ind, gen_control_expr(scrutinee, ctx));
            for (pattern, body) in arms {
                let pat_str = match pattern {
                    Pattern::Var(name) => to_snake_case(name),
                    _ => gen_pattern(pattern),
                };
                out.push_str(&format!("{}  {} ->\n", ind, pat_str));
                match body {
                    ControlExprOrBlock::Expr(e) => {
                        out.push_str(&format!("{}    {}\n", ind, gen_control_expr(e, ctx)));
                    }
                    ControlExprOrBlock::Block(stmts, _trace) => {
                        out.push_str(&gen_stmts(stmts, ctx, indent + 2));
                        out.push('\n');
                    }
                }
            }
            out.push_str(&format!("{}end", ind));
            out
        }
        ControlStmt::Branch {
            modifier,
            traced,
            arms,
        } => gen_branch(modifier, traced, arms, ctx, indent),
        ControlStmt::Loop { body, .. } => {
            let mut out = format!(
                "{}Stream.iterate(0, &(&1 + 1))\n\
                 {}|> Enum.reduce_while(nil, fn _, _acc ->\n\
                 {}  try do\n",
                ind, ind, ind
            );
            out.push_str(&gen_stmts(body, ctx, indent + 2));
            out.push_str(&format!(
                "\n{}    {{:cont, nil}}\n\
                 {}  catch\n\
                 {}    {{:break, val}} -> {{:halt, val}}\n\
                 {}    :continue -> {{:cont, nil}}\n\
                 {}  end\n\
                 {}end)",
                ind, ind, ind, ind, ind, ind
            ));
            out
        }
        ControlStmt::Return(Some(expr)) => format!("{}{}", ind, gen_control_expr(expr, ctx)),
        ControlStmt::Return(None) => format!("{}nil", ind),
        ControlStmt::Break(Some(expr)) => {
            format!("{}throw({{:break, {}}})", ind, gen_control_expr(expr, ctx))
        }
        ControlStmt::Break(None) => format!("{}throw({{:break, nil}})", ind),
        ControlStmt::Continue => format!("{}throw(:continue)", ind),
        ControlStmt::Reversible(body) => {
            let mut out = format!("{}try do\n", ind);
            out.push_str(&gen_stmts(body, ctx, indent + 1));
            out.push_str(&format!(
                "\n{}rescue\n{}  e -> {{:error, e}}\n{}end",
                ind, ind, ind
            ));
            out
        }
        ControlStmt::Irreversible(body) => {
            let mut out = format!("{}# irreversible block\n", ind);
            out.push_str(&gen_stmts(body, ctx, indent));
            out
        }
        ControlStmt::Reverse(body) => {
            let mut out = format!("{}# reverse block\n", ind);
            out.push_str(&gen_stmts(body, ctx, indent));
            out
        }
        ControlStmt::ReversibleAs { binding, body } => {
            let mut out = format!("{}# reversible as {}\n{}try do\n", ind, binding, ind);
            out.push_str(&gen_stmts(body, ctx, indent + 1));
            out.push_str(&format!(
                "\n{}rescue\n{}  e -> {{:error, e}}\n{}end",
                ind, ind, ind
            ));
            out
        }
        ControlStmt::ReverseNamed { target } => {
            format!("{}# reverse {}", ind, target)
        }
        ControlStmt::EnterDiscourse { discourse, body } => {
            // Discourse context — emit a comment and execute the body.
            // Runtime discourse semantics are a future extension.
            let mut out = format!("{}# enter discourse: {}\n", ind, discourse);
            out.push_str(&gen_stmts(body, ctx, indent));
            out
        }
        ControlStmt::Expr(e) => {
            format!("{}{}", ind, gen_control_expr(e, ctx))
        }
    }
}

/// Generate a `branch` construct — the hermeneutic moment.
///
/// Maps to a cond block in Elixir. If `traced`, records the decision
/// in the ETS trace table. If `cached`, wraps with an ETS lookup.
/// If `speculative`, wraps arms in Task.async for parallel eval.
fn gen_branch(
    modifier: &Option<BranchModifier>,
    traced: &Option<String>,
    arms: &[BranchArm],
    ctx: &GenContext,
    indent: usize,
) -> String {
    let ind = make_indent(indent);
    let mut out = String::new();

    // For cached branches, check ETS first
    if *modifier == Some(BranchModifier::Cached)
        && let Some(label) = traced
    {
        out.push_str(&format!(
            "{}case :ets.lookup(:oo7_traces, \"{}\") do\n\
             {}  [{{_, cached_result}} | _] -> cached_result\n\
             {}  [] ->\n",
            ind,
            escape_elixir_string(label),
            ind,
            ind
        ));
    }

    let branch_indent = if *modifier == Some(BranchModifier::Cached) && traced.is_some() {
        indent + 2
    } else {
        indent
    };
    let bi = make_indent(branch_indent);

    if *modifier == Some(BranchModifier::Speculative) {
        // Speculative: spawn Task.async for each arm, await first success
        out.push_str(&format!("{}tasks = [\n", bi));
        for arm in arms {
            out.push_str(&format!(
                "{}  Task.async(fn ->\n\
                 {}    # arm: {}\n",
                bi, bi, arm.label
            ));
            out.push_str(&gen_stmts(&arm.body, ctx, branch_indent + 2));
            out.push_str(&format!("\n{}  end),\n", bi));
        }
        out.push_str(&format!(
            "{}]\n{}Task.await_many(tasks) |> List.first()",
            bi, bi
        ));
    } else {
        // Standard or cached: cond block
        out.push_str(&format!("{}cond do\n", bi));
        for arm in arms {
            let guard = gen_given_guard(&arm.given);
            out.push_str(&format!("{}  {} ->\n", bi, guard));
            if let Some(label) = traced {
                // Record trace
                out.push_str(&format!(
                    "{}    :ets.insert(:oo7_traces, {{\"{}\", \"{}\"}})\n",
                    bi,
                    escape_elixir_string(label),
                    escape_elixir_string(&arm.label)
                ));
            }
            out.push_str(&gen_stmts(&arm.body, ctx, branch_indent + 2));
            out.push('\n');
        }
        out.push_str(&format!("{}end", bi));
    }

    // Close cached wrapper
    if *modifier == Some(BranchModifier::Cached) && traced.is_some() {
        out.push_str(&format!("\n{}end", ind));
    }

    out
}

/// Generate a guard expression from a GivenClause for use in cond arms.
///
/// If there is no given clause, returns "true" (unconditional arm).
fn gen_given_guard(given: &Option<GivenClause>) -> String {
    match given {
        None => "true".to_string(),
        Some(clause) => {
            let predicates: Vec<String> = clause
                .items
                .iter()
                .filter_map(|item| match item {
                    GivenItem::Predicate { left, op, right } => {
                        let op_str = match op {
                            PredOp::Gt => ">",
                            PredOp::Lt => "<",
                            PredOp::Gte => ">=",
                            PredOp::Lte => "<=",
                            PredOp::Eq => "==",
                            PredOp::Neq => "!=",
                        };
                        Some(format!(
                            "{} {} {}",
                            gen_data_expr(left),
                            op_str,
                            gen_data_expr(right)
                        ))
                    }
                    _ => None, // Named/Bare items are evidence, not guards
                })
                .collect();
            if predicates.is_empty() {
                "true".to_string()
            } else {
                predicates.join(" and ")
            }
        }
    }
}

// ============================================================
// Pattern codegen
// ============================================================

/// Generate an Elixir pattern from a 007 Pattern.
fn gen_pattern(pattern: &Pattern) -> String {
    match pattern {
        Pattern::Var(name) => to_snake_case(name),
        Pattern::Wildcard => "_".to_string(),
        Pattern::Constructor(name, pats) => {
            if pats.is_empty() {
                format!("{{:{}}}", to_snake_case(name))
            } else {
                let inner: Vec<String> = pats.iter().map(gen_pattern).collect();
                format!("{{:{}, {}}}", to_snake_case(name), inner.join(", "))
            }
        }
        Pattern::Tuple(pats) => {
            let inner: Vec<String> = pats.iter().map(gen_pattern).collect();
            format!("{{{}}}", inner.join(", "))
        }
        Pattern::Literal(DataExpr::Int(n)) => format!("{}", n),
        Pattern::Literal(DataExpr::String(s)) => {
            format!("\"{}\"", escape_elixir_string(s))
        }
        Pattern::Literal(DataExpr::Bool(b)) => {
            if *b {
                "true".to_string()
            } else {
                "false".to_string()
            }
        }
        Pattern::Literal(DataExpr::Float(f)) => format!("{}", f),
        Pattern::Literal(_) => "_".to_string(),
    }
}

// ============================================================
// Agent codegen — GenServer module
// ============================================================

/// Generate a complete GenServer module for a 007 Agent.
fn gen_agent(agent: &AgentDecl, ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Agents.{}", ctx.project_module, agent.name);
    let path = format!(
        "lib/{}/agents/{}.{}",
        ctx.project_name,
        to_snake_case(&agent.name),
        "ex"
    );

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str(&format!("  @moduledoc \"007 Agent: {}\"\n", agent.name));
    code.push_str("  use GenServer\n\n");

    // Struct from state declarations
    let state_fields: Vec<String> = agent
        .states
        .iter()
        .map(|(name, _)| to_snake_case(name))
        .collect();
    let data_fields: Vec<String> = agent
        .data_blocks
        .iter()
        .map(|db| to_snake_case(&db.name))
        .collect();
    let all_fields: Vec<String> = state_fields
        .iter()
        .chain(data_fields.iter())
        .cloned()
        .collect();

    if !all_fields.is_empty() {
        let field_atoms: Vec<String> = all_fields.iter().map(|f| format!(":{}", f)).collect();
        code.push_str(&format!("  defstruct [{}]\n\n", field_atoms.join(", ")));
    }

    // start_link
    code.push_str("  def start_link(opts \\\\ []) do\n");
    code.push_str("    GenServer.start_link(__MODULE__, opts)\n");
    code.push_str("  end\n\n");

    // init
    code.push_str("  @impl true\n");
    code.push_str("  def init(_opts) do\n");
    if all_fields.is_empty() {
        code.push_str("    {:ok, %{}}\n");
    } else {
        code.push_str("    state = %__MODULE__{\n");
        for (name, expr) in &agent.states {
            code.push_str(&format!(
                "      {}: {},\n",
                to_snake_case(name),
                gen_data_expr(expr)
            ));
        }
        for db in &agent.data_blocks {
            code.push_str(&format!(
                "      {}: {},\n",
                to_snake_case(&db.name),
                gen_data_expr(&db.expr)
            ));
        }
        code.push_str("    }\n");
        code.push_str("    {:ok, state}\n");
    }
    code.push_str("  end\n");

    // Handlers
    for handler in &agent.handlers {
        code.push('\n');
        match handler.event.as_str() {
            "receive" => {
                code.push_str("  @impl true\n");
                let param_pattern = gen_handler_params(&handler.params);
                code.push_str(&format!(
                    "  def handle_cast({{:receive, {}}}, state) do\n",
                    param_pattern
                ));
                code.push_str(&gen_stmts(&handler.body, ctx, 2));
                code.push_str("\n    {:noreply, state}\n");
                code.push_str("  end\n");
            }
            "error" | "timeout" => {
                code.push_str("  @impl true\n");
                let param_pattern = gen_handler_params(&handler.params);
                code.push_str(&format!(
                    "  def handle_info({{:{}, {}}}, state) do\n",
                    handler.event, param_pattern
                ));
                code.push_str(&gen_stmts(&handler.body, ctx, 2));
                code.push_str("\n    {:noreply, state}\n");
                code.push_str("  end\n");
            }
            _ => {
                // Custom event — handle_info with atom tag
                code.push_str("  @impl true\n");
                let param_pattern = gen_handler_params(&handler.params);
                code.push_str(&format!(
                    "  def handle_info({{:{}, {}}}, state) do\n",
                    to_snake_case(&handler.event),
                    param_pattern
                ));
                code.push_str(&gen_stmts(&handler.body, ctx, 2));
                code.push_str("\n    {:noreply, state}\n");
                code.push_str("  end\n");
            }
        }
    }

    // Exchange support — generic handle_call
    code.push('\n');
    code.push_str("  @impl true\n");
    code.push_str("  def handle_call({:exchange, msg}, _from, state) do\n");
    code.push_str("    {:reply, msg, state}\n");
    code.push_str("  end\n");

    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

/// Generate the Elixir pattern for handler parameters.
///
/// Produces a map pattern like `%{name: name, score: score}` from
/// the handler's parameter list.
fn gen_handler_params(params: &[(String, String)]) -> String {
    if params.is_empty() {
        "_msg".to_string()
    } else if params.len() == 1 {
        let (name, _) = &params[0];
        to_snake_case(name)
    } else {
        let fields: Vec<String> = params
            .iter()
            .map(|(name, _)| {
                let sn = to_snake_case(name);
                format!("{}: {}", sn, sn)
            })
            .collect();
        format!("%{{{}}}", fields.join(", "))
    }
}

// ============================================================
// Supervisor codegen
// ============================================================

/// Generate a Supervisor module for a 007 Supervisor.
fn gen_supervisor(sup: &SupervisorDecl, ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Supervisors.{}", ctx.project_module, sup.name);
    let path = format!(
        "lib/{}/supervisors/{}.{}",
        ctx.project_name,
        to_snake_case(&sup.name),
        "ex"
    );

    let strategy_atom = match sup.strategy.as_str() {
        "one_for_one" => ":one_for_one",
        "one_for_all" => ":one_for_all",
        "rest_for_one" => ":rest_for_one",
        other => {
            // Best effort: use the strategy as-is with colon prefix
            // (this is a fallback — the user wrote something non-standard)
            return ElixirFile {
                path,
                content: format!(
                    "# SPDX-License-Identifier: MPL-2.0\n\
                     # Generated by 007 compiler\n\
                     # WARNING: unknown strategy '{}'\n",
                    other
                ),
            };
        }
    };

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str(&format!("  @moduledoc \"007 Supervisor: {}\"\n", sup.name));
    code.push_str("  use Supervisor\n\n");

    code.push_str("  def start_link(opts \\\\ []) do\n");
    code.push_str("    Supervisor.start_link(__MODULE__, opts, name: __MODULE__)\n");
    code.push_str("  end\n\n");

    code.push_str("  @impl true\n");
    code.push_str("  def init(_opts) do\n");
    code.push_str("    children = [\n");
    for child in &sup.children {
        code.push_str(&format!(
            "      {{{}.Agents.{}, []}},\n",
            ctx.project_module, child.agent_name
        ));
    }
    code.push_str("    ]\n\n");

    let mut init_opts = format!("strategy: {}", strategy_atom);
    if let Some((max, period, _unit)) = &sup.max_restarts {
        init_opts.push_str(&format!(", max_restarts: {}, max_seconds: {}", max, period));
    }

    code.push_str(&format!("    Supervisor.init(children, {})\n", init_opts));
    code.push_str("  end\n");
    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

// ============================================================
// Protocol / Behaviour codegen
// ============================================================

/// Generate a Behaviour module from a 007 Protocol.
///
/// Session protocols map to Elixir behaviours with callback specs
/// derived from the protocol steps.
fn gen_protocol(proto: &ProtocolDecl, ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Protocols.{}", ctx.project_module, proto.name);
    let path = format!(
        "lib/{}/protocols/{}.{}",
        ctx.project_name,
        to_snake_case(&proto.name),
        "ex"
    );

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str(&format!(
        "  @moduledoc \"007 Session Protocol: {}\"\n\n",
        proto.name
    ));

    // Extract message types as callbacks
    let mut seen_callbacks: Vec<String> = Vec::new();
    collect_protocol_callbacks(&proto.steps, &mut seen_callbacks);

    for cb in &seen_callbacks {
        code.push_str(&format!("  @callback {}(term()) :: term()\n", cb));
    }

    if seen_callbacks.is_empty() {
        code.push_str("  # No message callbacks extracted from protocol steps.\n");
    }

    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

/// Recursively collect callback names from protocol steps.
fn collect_protocol_callbacks(steps: &[ProtocolStep], callbacks: &mut Vec<String>) {
    for step in steps {
        match step {
            ProtocolStep::Message { msg_type, .. } => {
                let cb = to_snake_case(msg_type);
                if !callbacks.contains(&cb) {
                    callbacks.push(cb);
                }
            }
            ProtocolStep::Branch { arms, .. } => {
                for arm in arms {
                    collect_protocol_callbacks(&arm.steps, callbacks);
                }
            }
            ProtocolStep::Loop { steps, .. } => {
                collect_protocol_callbacks(steps, callbacks);
            }
            ProtocolStep::Rec(_) => {}
        }
    }
}

/// Generate a Behaviour module from a 007 BehaviourDecl.
fn gen_behaviour(beh: &BehaviourDecl, ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Behaviours.{}", ctx.project_module, beh.name);
    let path = format!(
        "lib/{}/behaviours/{}.{}",
        ctx.project_name,
        to_snake_case(&beh.name),
        "ex"
    );

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str(&format!("  @moduledoc \"007 Behaviour: {}\"\n\n", beh.name));

    for handler in &beh.handlers {
        let params_arity = handler.params.len();
        code.push_str(&format!(
            "  @callback handle_{}({}) :: term()\n",
            to_snake_case(&handler.event),
            (0..params_arity)
                .map(|_| "term()".to_string())
                .collect::<Vec<_>>()
                .join(", ")
        ));
    }

    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

// ============================================================
// Choreography documentation module
// ============================================================

/// Generate a documentation module for a 007 Choreography.
///
/// Choreographies are global multi-party protocols that don't have
/// a direct Elixir equivalent. We emit a documentation module so the
/// developer can implement the coordination manually.
fn gen_choreography_doc(choreo: &ChoreographyDecl, ctx: &GenContext) -> ElixirFile {
    let module_name = format!(
        "{}.Choreographies.{}",
        ctx.project_module,
        to_pascal_case(&choreo.name)
    );
    let path = format!(
        "lib/{}/choreographies/{}.{}",
        ctx.project_name,
        to_snake_case(&choreo.name),
        "ex"
    );

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str(&format!(
        "  @moduledoc \"\"\"\n  007 Choreography: {}\n\n\
         Choreographies describe multi-party coordination from a global\n  \
         perspective. This module documents the protocol for manual implementation.\n\n  \
         Parameters: {}\n  \
         Steps: {}\n  \"\"\"\n",
        choreo.name,
        choreo
            .params
            .iter()
            .map(|(n, t)| format!("{}: {}", n, t))
            .collect::<Vec<_>>()
            .join(", "),
        choreo.steps.len()
    ));
    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

// ============================================================
// Collected module codegen
// ============================================================

/// Generate the Functions module containing all 007 function declarations.
fn gen_functions_module(functions: &[&FunctionDecl], ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Functions", ctx.project_module);
    let path = format!("lib/{}/functions.{}", ctx.project_name, "ex");

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str("  @moduledoc \"007 Functions\"\n\n");

    for func in functions {
        let purity_comment = match func.purity {
            Purity::Total => "# @total",
            Purity::Pure => "# @pure",
            Purity::Impure => "# @impure",
            Purity::Neural => "# @neural",
        };
        code.push_str(&format!("  {}\n", purity_comment));

        let param_names: Vec<String> = func
            .params
            .iter()
            .map(|(name, _)| to_snake_case(name))
            .collect();
        code.push_str(&format!(
            "  def {}({}) do\n",
            to_snake_case(&func.name),
            param_names.join(", ")
        ));

        if func.body.is_empty() {
            code.push_str("    nil\n");
        } else {
            code.push_str(&gen_stmts(&func.body, ctx, 2));
            code.push('\n');
        }

        code.push_str("  end\n\n");
    }

    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

/// Generate the Data module containing all 007 data bindings.
fn gen_data_module(bindings: &[&DataBinding], ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Data", ctx.project_module);
    let path = format!("lib/{}/data.{}", ctx.project_name, "ex");

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str("  @moduledoc \"007 Data Bindings (total, pure)\"\n\n");

    for db in bindings {
        code.push_str(&format!(
            "  def {} do\n    {}\n  end\n\n",
            to_snake_case(&db.name),
            gen_data_expr(&db.expr)
        ));
    }

    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

/// Generate the Types module containing all 007 type declarations.
fn gen_types_module(types: &[&TypeDeclNode], ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Types", ctx.project_module);
    let path = format!("lib/{}/types.{}", ctx.project_name, "ex");

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str("  @moduledoc \"007 Type Declarations\"\n\n");

    for td in types {
        match &td.body {
            TypeBody::Alias(target) => {
                code.push_str(&format!(
                    "  # type {} = {}\n  @type {} :: {}\n\n",
                    td.name,
                    target,
                    to_snake_case(&td.name),
                    elixir_type_ref(target)
                ));
            }
            TypeBody::Record(fields) => {
                code.push_str(&format!("  # type {} = record\n", td.name));
                code.push_str(&format!("  @type {} :: %{{\n", to_snake_case(&td.name)));
                for (name, typ) in fields {
                    code.push_str(&format!(
                        "    {}: {},\n",
                        to_snake_case(name),
                        elixir_type_ref(typ)
                    ));
                }
                code.push_str("  }\n\n");
            }
            TypeBody::Enum(variants) => {
                code.push_str(&format!("  # type {} = enum\n", td.name));
                let variant_types: Vec<String> = variants
                    .iter()
                    .map(|v| {
                        if v.fields.is_empty() {
                            format!(":{}", to_snake_case(&v.name))
                        } else {
                            let field_types: Vec<String> =
                                v.fields.iter().map(|(_, t)| elixir_type_ref(t)).collect();
                            format!(
                                "{{:{}, {}}}",
                                to_snake_case(&v.name),
                                field_types.join(", ")
                            )
                        }
                    })
                    .collect();
                code.push_str(&format!(
                    "  @type {} :: {}\n\n",
                    to_snake_case(&td.name),
                    variant_types.join(" | ")
                ));
            }
        }
    }

    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

/// Map a 007 type name to an Elixir typespec reference.
fn elixir_type_ref(type_name: &str) -> String {
    match type_name {
        "Int" => "integer()".to_string(),
        "Float" => "float()".to_string(),
        "String" => "String.t()".to_string(),
        "Bool" => "boolean()".to_string(),
        "Unit" => "nil".to_string(),
        _ => "term()".to_string(),
    }
}

// ============================================================
// Application module
// ============================================================

/// Generate the Application module that boots the OTP tree.
fn gen_application_module(supervisor_names: &[String], ctx: &GenContext) -> ElixirFile {
    let module_name = format!("{}.Application", ctx.project_module);
    let path = format!("lib/{}/application.{}", ctx.project_name, "ex");

    let mut code = String::new();
    code.push_str("# SPDX-License-Identifier: MPL-2.0\n");
    code.push_str("# Generated by 007 compiler\n\n");
    code.push_str(&format!("defmodule {} do\n", module_name));
    code.push_str("  @moduledoc \"007 Application entry point\"\n");
    code.push_str("  use Application\n\n");
    code.push_str("  @impl true\n");
    code.push_str("  def start(_type, _args) do\n");
    code.push_str("    :ets.new(:oo7_traces, [:named_table, :public, :bag])\n\n");
    code.push_str("    children = [\n");
    for name in supervisor_names {
        code.push_str(&format!(
            "      {}.Supervisors.{},\n",
            ctx.project_module, name
        ));
    }
    code.push_str("    ]\n\n");
    code.push_str(&format!(
        "    Supervisor.start_link(children, strategy: :one_for_one, name: {}.Supervisor)\n",
        ctx.project_module
    ));
    code.push_str("  end\n");
    code.push_str("end\n");

    ElixirFile {
        path,
        content: code,
    }
}

// ============================================================
// mix.exs and config
// ============================================================

/// Generate the mix.exs project file.
fn gen_mix_exs(ctx: &GenContext) -> String {
    format!(
        "# SPDX-License-Identifier: MPL-2.0\n\
         # Generated by 007 compiler\n\n\
         defmodule {project_module}.MixProject do\n\
         \x20 use Mix.Project\n\n\
         \x20 def project do\n\
         \x20   [\n\
         \x20     app: :{project_name},\n\
         \x20     version: \"0.1.0\",\n\
         \x20     elixir: \"~> 1.15\",\n\
         \x20     start_permanent: Mix.env() == :prod,\n\
         \x20     deps: deps()\n\
         \x20   ]\n\
         \x20 end\n\n\
         \x20 def application do\n\
         \x20   [\n\
         \x20     extra_applications: [:logger],\n\
         \x20     mod: {{{project_module}.Application, []}}\n\
         \x20   ]\n\
         \x20 end\n\n\
         \x20 defp deps, do: []\n\
         end\n",
        project_module = ctx.project_module,
        project_name = ctx.project_name,
    )
}

/// Generate config/config.exs.
fn gen_config_exs() -> String {
    "# SPDX-License-Identifier: MPL-2.0\n\
     # Generated by 007 compiler\n\n\
     import Config\n\n\
     config :logger, level: :info\n"
        .to_string()
}

// ============================================================
// Helpers
// ============================================================

/// Generate a block of statements, each on its own line.
fn gen_stmts(stmts: &[ControlStmt], ctx: &GenContext, indent: usize) -> String {
    stmts
        .iter()
        .map(|s| gen_control_stmt(s, ctx, indent))
        .collect::<Vec<_>>()
        .join("\n")
}

/// Create an indentation string of `level * 2` spaces.
fn make_indent(level: usize) -> String {
    "  ".repeat(level)
}

/// Convert a PascalCase or camelCase identifier to snake_case.
///
/// Inserts an underscore before each uppercase letter that follows
/// a lowercase letter or digit, then lowercases everything.
///
/// Examples:
///   "TeamSupervisor" -> "team_supervisor"
///   "myAgent" -> "my_agent"
///   "HTTPClient" -> "http_client"
///   "already_snake" -> "already_snake"
fn to_snake_case(s: &str) -> String {
    let mut result = String::with_capacity(s.len() + 4);
    let chars: Vec<char> = s.chars().collect();
    for (i, &ch) in chars.iter().enumerate() {
        if ch.is_ascii_uppercase() {
            if i > 0 {
                let prev = chars[i - 1];
                // Insert underscore before uppercase if:
                // - Previous char is lowercase or digit, OR
                // - Previous char is uppercase AND next char is lowercase
                //   (handles "HTTPClient" -> "http_client")
                if prev.is_ascii_lowercase() || prev.is_ascii_digit() {
                    result.push('_');
                } else if prev.is_ascii_uppercase()
                    && let Some(&next) = chars.get(i + 1)
                    && next.is_ascii_lowercase()
                {
                    result.push('_');
                }
            }
            result.push(ch.to_ascii_lowercase());
        } else {
            result.push(ch);
        }
    }
    result
}

/// Convert a snake_case or lowercase identifier to PascalCase.
///
/// Capitalizes the first letter and each letter after an underscore,
/// removing underscores.
///
/// Examples:
///   "my_app" -> "MyApp"
///   "team_supervisor" -> "TeamSupervisor"
///   "Already" -> "Already"
fn to_pascal_case(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut capitalize_next = true;
    for ch in s.chars() {
        if ch == '_' || ch == '-' {
            capitalize_next = true;
        } else if capitalize_next {
            result.push(ch.to_ascii_uppercase());
            capitalize_next = false;
        } else {
            result.push(ch);
        }
    }
    result
}

/// Escape special characters in a string for Elixir string literals.
///
/// Handles: backslash, double-quote, newline, carriage return, tab,
/// and null byte.
fn escape_elixir_string(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    for ch in s.chars() {
        match ch {
            '\\' => result.push_str("\\\\"),
            '"' => result.push_str("\\\""),
            '\n' => result.push_str("\\n"),
            '\r' => result.push_str("\\r"),
            '\t' => result.push_str("\\t"),
            '\0' => result.push_str("\\0"),
            c => result.push(c),
        }
    }
    result
}

// ============================================================
// Tests for helper functions (unit-level, not integration)
// ============================================================

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

    #[test]
    fn test_to_snake_case() {
        assert_eq!(to_snake_case("TeamSupervisor"), "team_supervisor");
        assert_eq!(to_snake_case("myAgent"), "my_agent");
        assert_eq!(to_snake_case("HTTPClient"), "http_client");
        assert_eq!(to_snake_case("already_snake"), "already_snake");
        assert_eq!(to_snake_case("A"), "a");
        assert_eq!(to_snake_case("ABC"), "abc");
    }

    #[test]
    fn test_to_pascal_case() {
        assert_eq!(to_pascal_case("my_app"), "MyApp");
        assert_eq!(to_pascal_case("team_supervisor"), "TeamSupervisor");
        assert_eq!(to_pascal_case("Already"), "Already");
    }

    #[test]
    fn test_escape_elixir_string() {
        assert_eq!(escape_elixir_string("hello"), "hello");
        assert_eq!(escape_elixir_string("say \"hi\""), "say \\\"hi\\\"");
        assert_eq!(escape_elixir_string("line1\nline2"), "line1\\nline2");
        assert_eq!(escape_elixir_string("a\\b"), "a\\\\b");
    }
}

// ============================================================
// Standard Library Module Generation
// ============================================================

/// Generate the Result module.
fn gen_result_module(ctx: &GenContext) -> ElixirFile {
    let path = format!("lib/{}/stdlib/result.ex", ctx.project_name);
    let module_prefix = format!("{}Stdlib.Result", ctx.project_module);
    let mut content = gen_spdx_header();
    content.push_str(&format!(
        r#"
defmodule {} do
  @moduledoc """
  Result type for representing success or failure.
  """

  @type t(a, b) :: {{:ok, a}} | {{:error, b}}.

  @doc """
  Create a successful Result.
  """
  @spec ok(a) :: t(a, b)
  def ok(value), do: {{:ok, value}}

  @doc """
  Create a failed Result.
  """
  @spec err(b) :: t(a, b)
  def err(error), do: {{:error, error}}

  @doc """
  Check if a Result is ok.
  """
  @spec is_ok(t(a, b)) :: boolean()
  def is_ok({{:ok, _}}), do: true
  def is_ok({{:error, _}}), do: false

  @doc """
  Check if a Result is error.
  """
  @spec is_err(t(a, b)) :: boolean()
  def is_err({{:error, _}}), do: true
  def is_err({{:ok, _}}), do: false

  @doc """
  Extract the value from a Result or return a default.
  """
  @spec unwrap_or(t(a, b), a) :: a
  def unwrap_or({{:ok, value}}, _default), do: value
  def unwrap_or({{:error, _}}, default), do: default

  @doc """
  Map a function over the ok value.
  """
  @spec map(t(a, b), (a -> c)) :: t(c, b)
  def map({{:ok, value}}, fun), do: {{:ok, fun.(value)}}
  def map({{:error, error}}, _fun), do: {{:error, error}}

  @doc """
  Chain operations on Result.
  """
  @spec and_then(t(a, b), (a -> t(c, b))) :: t(c, b)
  def and_then({{:ok, value}}, fun), do: fun.(value)
  def and_then({{:error, error}}, _fun), do: {{:error, error}}
end
"#,
        module_prefix
    ));
    ElixirFile { path, content }
}

/// Generate the Collections module.
fn gen_collections_module(ctx: &GenContext) -> ElixirFile {
    let path = format!("lib/{}/stdlib/collections.ex", ctx.project_name);
    let module_prefix = format!("{}Stdlib.Collections", ctx.project_module);
    let mut content = gen_spdx_header();
    content.push_str(&format!(
        r#"
defmodule {} do
  @moduledoc """
  Collection operations for lists.
  """

  @doc """
  Map a function over a list.
  """
  @spec map(list(a), (a -> b)) :: list(b)
  def map([], _fun), do: []
  def map([head | tail], fun), do: [fun.(head) | map(tail, fun)]

  @doc """
  Filter a list based on a predicate.
  """
  @spec filter(list(a), (a -> boolean())) :: list(a)
  def filter([], _pred), do: []
  def filter([head | tail], pred) do
    if pred.(head) do
      [head | filter(tail, pred)]
    else
      filter(tail, pred)
    end
  end

  @doc """
  Reduce a list to a single value.
  """
  @spec reduce(list(a), b, (b, a -> b)) :: b
  def reduce([], acc, _fun), do: acc
  def reduce([head | tail], acc, fun), do: reduce(tail, fun.(acc, head), fun)

  @doc """
  Fold a list from the left.
  """
  @spec foldl(list(a), b, (b, a -> b)) :: b
  def foldl(list, acc, fun), do: reduce(list, acc, fun)

  @doc """
  Fold a list from the right.
  """
  @spec foldr(list(a), b, (a, b -> b)) :: b
  def foldr([], acc, _fun), do: acc
  def foldr([head | tail], acc, fun), do: fun.(head, foldr(tail, acc, fun))

  @doc """
  Check if all elements satisfy a predicate.
  """
  @spec all(list(a), (a -> boolean())) :: boolean()
  def all([], _pred), do: true
  def all([head | tail], pred), do: pred.(head) && all(tail, pred)

  @doc """
  Check if any element satisfies a predicate.
  """
  @spec any(list(a), (a -> boolean())) :: boolean()
  def any([], _pred), do: false
  def any([head | tail], pred), do: pred.(head) || any(tail, pred)

  @doc """
  Get the length of a list.
  """
  @spec length(list(a)) :: non_neg_integer()
  def length([]), do: 0
  def length([_ | tail]), do: 1 + length(tail)

  @doc """
  Reverse a list.
  """
  @spec reverse(list(a)) :: list(a)
  def reverse(list), do: reverse_acc([], list)

  defp reverse_acc(acc, []), do: acc
  defp reverse_acc(acc, [head | tail]), do: reverse_acc([head | acc], tail)

  @doc """
  Concatenate two lists.
  """
  @spec concat(list(a), list(a)) :: list(a)
  def concat([], list), do: list
  def concat([head | tail], list), do: [head | concat(tail, list)]

  @doc """
  Take the first n elements of a list.
  """
  @spec take(list(a), non_neg_integer()) :: list(a)
  def take(_, 0), do: []
  def take([], _), do: []
  def take([head | tail], n) when n > 0, do: [head | take(tail, n - 1)]

  @doc """
  Drop the first n elements of a list.
  """
  @spec drop(list(a), non_neg_integer()) :: list(a)
  def drop(list, 0), do: list
  def drop([], _), do: []
  def drop([_ | tail], n) when n > 0, do: drop(tail, n - 1)

  @doc """
  Zip two lists together.
  """
  @spec zip(list(a), list(b)) :: list({{a, b}})
  def zip([], _), do: []
  def zip(_, []), do: []
  def zip([head1 | tail1], [head2 | tail2]), do: [{{head1, head2}} | zip(tail1, tail2)]

  @doc """
  Unzip a list of pairs into two lists.
  """
  @spec unzip(list({{a, b}})) :: {{list(a), list(b)}}
  def unzip([]), do: {{[], []}}
  def unzip([{{head1, head2}} | tail]) do
    {{tail1, tail2}} = unzip(tail)
    {{[head1 | tail1], [head2 | tail2]}}
  end
end
"#,
        module_prefix
    ));
    ElixirFile { path, content }
}

/// Generate the Stream module.
fn gen_stream_module(ctx: &GenContext) -> ElixirFile {
    let path = format!("lib/{}/stdlib/stream.ex", ctx.project_name);
    let module_prefix = format!("{}Stdlib.Stream", ctx.project_module);
    let mut content = gen_spdx_header();
    content.push_str(&format!(
        r#"
defmodule {} do
  @moduledoc """
  Lazy sequences for efficient processing.
  """

  @type t(a) :: %__struct__{{head: a, tail: (() -> t(a))}} | :nil.

  @doc """
  Create a stream from a list.
  """
  @spec from_list(list(a)) :: t(a)
  def from_list([]), do: :nil
  def from_list([head | tail]), do: %__struct__{{head: head, tail: fn -> from_list(tail) end}}

  @doc """
  Convert a stream to a list.
  """
  @spec to_list(t(a)) :: list(a)
  def to_list(:nil), do: []
  def to_list(%__struct__{{head: head, tail: tail}}), do: [head | to_list.(tail.())]

  @doc """
  Map a function over a stream.
  """
  @spec map(t(a), (a -> b)) :: t(b)
  def map(:nil, _fun), do: :nil
  def map(%__struct__{{head: head, tail: tail}}, fun), do:
    %__struct__{{head: fun.(head), tail: fn -> map(tail.(), fun) end}}

  @doc """
  Filter a stream based on a predicate.
  """
  @spec filter(t(a), (a -> boolean())) :: t(a)
  def filter(:nil, _pred), do: :nil
  def filter(%__struct__{{head: head, tail: tail}}, pred) do
    if pred.(head) do
      %__struct__{{head: head, tail: fn -> filter(tail.(), pred) end}}
    else
      filter(tail.(), pred)
    end
  end

  @doc """
  Take the first n elements of a stream.
  """
  @spec take(t(a), non_neg_integer()) :: t(a)
  def take(_, 0), do: :nil
  def take(:nil, _), do: :nil
  def take(%__struct__{{head: head, tail: tail}}, n) when n > 0, do:
    %__struct__{{head: head, tail: fn -> take(tail.(), n - 1) end}}

  @doc """
  Drop the first n elements of a stream.
  """
  @spec drop(t(a), non_neg_integer()) :: t(a)
  def drop(stream, 0), do: stream
  def drop(:nil, _), do: :nil
  def drop(%__struct__{{tail: tail}}, n) when n > 0, do: drop(tail.(), n - 1)

  @doc """
  Create an infinite stream of natural numbers.
  """
  @spec naturals() :: t(integer())
  def naturals(), do: naturals_from(0)

  defp naturals_from(n), do:
    %__struct__{{head: n, tail: fn -> naturals_from(n + 1) end}}

  @doc """
  Create an infinite stream of a repeated value.
  """
  @spec repeat(a) :: t(a)
  def repeat(value), do:
    %__struct__{{head: value, tail: fn -> repeat(value) end}}

  @doc """
  Create a stream by iterating a function.
  """
  @spec iterate((a -> a), a) :: t(a)
  def iterate(fun, initial), do:
    %__struct__{{head: initial, tail: fn -> iterate(fun, fun.(initial)) end}}

  @doc """
  Zip two streams together.
  """
  @spec zip(t(a), t(b)) :: t({{a, b}})
  def zip(:nil, _), do: :nil
  def zip(_, :nil), do: :nil
  def zip(%__struct__{{head: head1, tail: tail1}}, %__struct__{{head: head2, tail: tail2}}), do:
    %__struct__{{head: {{head1, head2}}, tail: fn -> zip(tail1.(), tail2.()) end}}

  @doc """
  Take elements from a stream while a predicate holds.
  """
  @spec take_while(t(a), (a -> boolean())) :: t(a)
  def take_while(:nil, _pred), do: :nil
  def take_while(%__struct__{{head: head, tail: tail}}, pred) do
    if pred.(head) do
      %__struct__{{head: head, tail: fn -> take_while(tail.(), pred) end}}
    else
      :nil
    end
  end

  @doc """
  Drop elements from a stream while a predicate holds.
  """
  @spec drop_while(t(a), (a -> boolean())) :: t(a)
  def drop_while(:nil, _pred), do: :nil
  def drop_while(%__struct__{{head: head, tail: tail}}, pred) do
    if pred.(head) do
      drop_while(tail.(), pred)
    else
      %__struct__{{head: head, tail: tail}}
    end
  end
end
"#,
        module_prefix
    ));
    ElixirFile { path, content }
}

/// Generate the Time module.
fn gen_time_module(ctx: &GenContext) -> ElixirFile {
    let path = format!("lib/{}/stdlib/time.ex", ctx.project_name);
    let module_prefix = format!("{}Stdlib.Time", ctx.project_module);
    let mut content = gen_spdx_header();
    content.push_str(&format!(
        r#"
defmodule {} do
  @moduledoc """
  Time and date handling.
  """

  @type t() :: %__struct__{{seconds: integer()}}.

  @doc """
  Create a Time from seconds since the Unix epoch.
  """
  @spec from_unix(integer()) :: t()
  def from_unix(seconds), do: %__struct__{{seconds: seconds}}

  @doc """
  Get the current time.
  """
  @spec now() :: t()
  def now(), do: from_unix(System.system_time(:second))

  @doc """
  Get the seconds since the Unix epoch.
  """
  @spec to_unix(t()) :: integer()
  def to_unix(%__struct__{{seconds: seconds}}), do: seconds

  @doc """
  Add seconds to a Time.
  """
  @spec add_seconds(t(), integer()) :: t()
  def add_seconds(%__struct__{{seconds: s}}, seconds), do: from_unix(s + seconds)

  @doc """
  Subtract seconds from a Time.
  """
  @spec subtract_seconds(t(), integer()) :: t()
  def subtract_seconds(%__struct__{{seconds: s}}, seconds), do: from_unix(s - seconds)

  @doc """
  Calculate the difference between two Times in seconds.
  """
  @spec diff_seconds(t(), t()) :: integer()
  def diff_seconds(time1, time2), do: to_unix(time1) - to_unix(time2)

  @doc """
  Check if one Time is before another.
  """
  @spec is_before(t(), t()) :: boolean()
  def is_before(time1, time2), do: to_unix(time1) < to_unix(time2)

  @doc """
  Check if one Time is after another.
  """
  @spec is_after(t(), t()) :: boolean()
  def is_after(time1, time2), do: to_unix(time1) > to_unix(time2)

  @doc """
  Check if two Times are equal.
  """
  @spec is_equal(t(), t()) :: boolean()
  def is_equal(time1, time2), do: to_unix(time1) == to_unix(time2)

  @doc """
  Convert a Time to a string.
  """
  @spec to_string(t()) :: String.t()
  def to_string(%__struct__{{seconds: seconds}}), do: "Time(" <> to_string(seconds) <> "s)"
end
"#,
        module_prefix
    ));
    ElixirFile { path, content }
}

/// Generate SPDX license header.
fn gen_spdx_header() -> String {
    "// SPDX-License-Identifier: MPL-2.0\n".to_string()
}

// ============================================================
// Integration tests — codegen structure
// ============================================================

#[cfg(test)]
mod codegen_tests {
    use super::*;
    use crate::ast::*;

    // ── helpers ──────────────────────────���───────────────────

    fn minimal_agent(name: &str) -> AgentDecl {
        AgentDecl {
            name: name.to_string(),
            capabilities: vec![],
            budget: None,
            implements: vec![],
            locale: None,
            data_blocks: vec![],
            handlers: vec![],
            states: vec![],
        }
    }

    fn agent_with_state(name: &str, field: &str, val: i64) -> AgentDecl {
        let mut a = minimal_agent(name);
        a.states.push((field.to_string(), DataExpr::Int(val)));
        a
    }

    fn agent_with_handler(name: &str, event: &str, body: Vec<ControlStmt>) -> AgentDecl {
        let mut a = minimal_agent(name);
        a.handlers.push(Handler {
            event: event.to_string(),
            params: vec![("msg".to_string(), "String".to_string())],
            body,
        });
        a
    }

    fn ctx() -> GenContext {
        GenContext::new("my_app")
    }

    // ── gen_agent ─────────────────────────────────────────────

    #[test]
    fn gen_agent_minimal_genserver_skeleton() {
        let agent = minimal_agent("Reviewer");
        let file = gen_agent(&agent, &ctx());

        assert!(file.path.ends_with("reviewer.ex"), "path={}", file.path);
        assert!(file.content.contains("defmodule MyApp.Agents.Reviewer do"));
        assert!(file.content.contains("use GenServer"));
        assert!(file.content.contains("def start_link(opts \\\\ []) do"));
        assert!(file.content.contains("@impl true"));
        assert!(file.content.contains("def init(_opts) do"));
        // Exchange support — every agent must have this
        assert!(file.content.contains("def handle_call({:exchange, msg}"));
        assert!(file.content.contains("SPDX-License-Identifier"));
    }

    #[test]
    fn gen_agent_struct_from_state() {
        let agent = agent_with_state("Worker", "score", 0);
        let file = gen_agent(&agent, &ctx());

        assert!(file.content.contains("defstruct [:score]"));
        assert!(file.content.contains("score: 0"));
    }

    #[test]
    fn gen_agent_receive_handler_maps_to_handle_cast() {
        let agent = agent_with_handler(
            "Worker",
            "receive",
            vec![ControlStmt::Expr(ControlExpr::Var("msg".to_string()))],
        );
        let file = gen_agent(&agent, &ctx());

        assert!(file.content.contains("def handle_cast({:receive,"));
        assert!(file.content.contains("{:noreply, state}"));
    }

    #[test]
    fn gen_agent_custom_event_maps_to_handle_info() {
        let agent = agent_with_handler(
            "Worker",
            "tick",
            vec![ControlStmt::Expr(ControlExpr::DataLit(DataExpr::Int(1)))],
        );
        let file = gen_agent(&agent, &ctx());

        assert!(file.content.contains("def handle_info({:tick,"));
    }

    // ── gen_supervisor ────────────────────────────────────────

    #[test]
    fn gen_supervisor_one_for_one() {
        let sup = SupervisorDecl {
            name: "Main".to_string(),
            strategy: "one_for_one".to_string(),
            max_restarts: None,
            children: vec![ChildSpec {
                agent_name: "Worker".to_string(),
                caps: vec![],
            }],
            handlers: vec![],
        };
        let file = gen_supervisor(&sup, &ctx());

        assert!(file.path.ends_with("main.ex"), "path={}", file.path);
        assert!(file.content.contains("defmodule MyApp.Supervisors.Main do"));
        assert!(file.content.contains("use Supervisor"));
        assert!(file.content.contains("one_for_one"));
        assert!(file.content.contains("MyApp.Agents.Worker"));
    }

    // ── gen_control_stmt — branch / loop / return ─────────────

    #[test]
    fn gen_control_stmt_return_with_value_is_indented() {
        let stmt = ControlStmt::Return(Some(ControlExpr::DataLit(DataExpr::Int(42))));
        let out = gen_control_stmt(&stmt, &ctx(), 2);
        // Must carry leading indent (4 spaces at level 2)
        assert!(out.starts_with("    "), "missing indent: {:?}", out);
        assert!(out.contains("42"));
    }

    #[test]
    fn gen_control_stmt_return_none_is_nil() {
        let stmt = ControlStmt::Return(None);
        let out = gen_control_stmt(&stmt, &ctx(), 1);
        assert!(out.contains("nil"));
    }

    #[test]
    fn gen_control_stmt_break_emits_throw() {
        let stmt = ControlStmt::Break(Some(ControlExpr::DataLit(DataExpr::Int(0))));
        let out = gen_control_stmt(&stmt, &ctx(), 1);
        assert!(out.contains("throw({:break,"));
    }

    #[test]
    fn gen_control_stmt_continue_emits_throw() {
        let stmt = ControlStmt::Continue;
        let out = gen_control_stmt(&stmt, &ctx(), 1);
        assert!(out.contains("throw(:continue)"));
    }

    #[test]
    fn gen_control_stmt_loop_wraps_in_stream_reduce() {
        let stmt = ControlStmt::Loop {
            label: None,
            body: vec![ControlStmt::Return(None)],
        };
        let out = gen_control_stmt(&stmt, &ctx(), 1);
        assert!(out.contains("Stream.iterate"), "missing stream: {}", out);
        assert!(out.contains("Enum.reduce_while"), "missing reduce: {}", out);
        assert!(
            out.contains("{:break, val}"),
            "missing break handler: {}",
            out
        );
    }

    #[test]
    fn gen_branch_cond_do_structure() {
        let arms = vec![
            BranchArm {
                label: "high".to_string(),
                given: None,
                body: vec![ControlStmt::Expr(ControlExpr::DataLit(DataExpr::Bool(
                    true,
                )))],
                trace: None,
            },
            BranchArm {
                label: "low".to_string(),
                given: None,
                body: vec![ControlStmt::Expr(ControlExpr::DataLit(DataExpr::Bool(
                    false,
                )))],
                trace: None,
            },
        ];
        let out = gen_branch(&None, &None, &arms, &ctx(), 1);
        assert!(out.contains("cond do"), "no cond: {}", out);
        assert!(out.contains("true ->"), "no fallthrough arm: {}", out);
        assert!(out.contains("end"), "no end: {}", out);
    }

    #[test]
    fn gen_branch_cached_wraps_ets_lookup() {
        let arms = vec![BranchArm {
            label: "ok".to_string(),
            given: None,
            body: vec![],
            trace: None,
        }];
        let label = Some("triage".to_string());
        let out = gen_branch(&Some(BranchModifier::Cached), &label, &arms, &ctx(), 1);
        assert!(
            out.contains(":ets.lookup(:oo7_traces"),
            "missing ETS lookup: {}",
            out
        );
        assert!(
            out.contains("cached_result"),
            "missing cached_result arm: {}",
            out
        );
    }

    #[test]
    fn gen_branch_speculative_spawns_tasks() {
        let arms = vec![
            BranchArm {
                label: "a".to_string(),
                given: None,
                body: vec![],
                trace: None,
            },
            BranchArm {
                label: "b".to_string(),
                given: None,
                body: vec![],
                trace: None,
            },
        ];
        let out = gen_branch(&Some(BranchModifier::Speculative), &None, &arms, &ctx(), 1);
        assert!(out.contains("Task.async"), "missing Task.async: {}", out);
        assert!(
            out.contains("Task.await_many"),
            "missing await_many: {}",
            out
        );
    }

    // ── gen_control_stmt — send / spawn ───────────────────────

    #[test]
    fn gen_control_stmt_send_emits_genserver_cast() {
        let stmt = ControlStmt::Send {
            target: ControlExpr::Var("pid".to_string()),
            message: ControlExpr::DataLit(DataExpr::String("hello".to_string())),
        };
        let out = gen_control_stmt(&stmt, &ctx(), 1);
        assert!(out.contains("GenServer.cast(pid,"));
        assert!(out.contains(":receive"));
    }

    #[test]
    fn gen_control_stmt_spawn_emits_start_link() {
        let stmt = ControlStmt::Spawn {
            linear: false,
            attested: false,
            binding: "w".to_string(),
            agent_name: "Worker".to_string(),
            caps: vec![],
            args: vec![],
        };
        let out = gen_control_stmt(&stmt, &ctx(), 1);
        assert!(out.contains("MyApp.Agents.Worker.start_link"));
        assert!(out.contains("{:ok, w}"));
    }

    // ── generate_elixir — full pipeline ───────────────────────

    #[test]
    fn generate_elixir_empty_program_produces_application_and_mix() {
        let program = Program {
            declarations: vec![],
            annotations: vec![],
        };
        let result = generate_elixir(&program, "empty_app").expect("codegen should succeed");

        assert!(!result.mix_exs.is_empty(), "mix.exs empty");
        assert!(!result.config.is_empty(), "config empty");
        // Even an empty program produces the application module + stdlib modules
        assert!(!result.files.is_empty(), "no files generated");

        let has_app = result
            .files
            .iter()
            .any(|f| f.content.contains("use Application"));
        assert!(has_app, "Application module not found");
    }

    #[test]
    fn generate_elixir_agent_produces_genserver_file() {
        let program = Program {
            declarations: vec![TopLevelDecl::Agent(agent_with_state("Scorer", "score", 0))],
            annotations: vec![],
        };
        let result = generate_elixir(&program, "scorer_app").expect("codegen should succeed");

        let agent_file = result
            .files
            .iter()
            .find(|f| f.path.contains("agents/scorer"))
            .expect("agent file not found");

        assert!(agent_file.content.contains("use GenServer"));
        assert!(agent_file.content.contains("defstruct [:score]"));
    }

    #[test]
    fn generate_elixir_ets_table_initialized_in_application() {
        let program = Program {
            declarations: vec![],
            annotations: vec![],
        };
        let result = generate_elixir(&program, "ets_app").expect("codegen should succeed");

        let app = result
            .files
            .iter()
            .find(|f| f.content.contains("use Application"))
            .expect("Application module not found");

        // :oo7_traces ETS table must be created in start/2 for cached branches to work
        assert!(
            app.content.contains(":ets.new(:oo7_traces,"),
            "ETS table init missing from Application.start/2"
        );
    }

    #[test]
    fn generate_elixir_validate_all_files_have_spdx() {
        let program = Program {
            declarations: vec![TopLevelDecl::Agent(minimal_agent("A"))],
            annotations: vec![],
        };
        let result = generate_elixir(&program, "spdx_app").expect("codegen should succeed");

        for file in &result.files {
            assert!(
                file.content.contains("SPDX-License-Identifier"),
                "File '{}' missing SPDX header",
                file.path
            );
        }
    }
}