etdl_compiler/codegen/

rust.rs

use etdl_parser::ast::{BackoffStrategy, Condition, EtlDocument, EventTree, Node};
use etdl_parser::asyncapi::AsyncApiRegistry;
use etdl_parser::ecel;
use std::collections::BTreeMap;

use crate::validate::Diagnostic;

use super::{CodeGenerator, GeneratedFile};

pub struct RustCodeGenerator {
    pub version: String,
}

impl Default for RustCodeGenerator {
    fn default() -> Self {
        Self::new()
    }
}

impl RustCodeGenerator {
    pub fn new() -> Self {
        RustCodeGenerator {
            version: env!("CARGO_PKG_VERSION").to_string(),
        }
    }
}

impl CodeGenerator for RustCodeGenerator {
    fn target_name(&self) -> &'static str {
        "rust"
    }

    fn generate_all(
        &self,
        doc: &EtlDocument,
        fault_tree_probs: &BTreeMap<String, f64>,
        _registry: &AsyncApiRegistry,
        stem: &str,
        _diagnostics: &mut Vec<Diagnostic>,
    ) -> Result<Vec<GeneratedFile>, String> {
        let mut output = String::new();

        output.push_str(&format!(
            "// AUTOGENERATED BY ETDL COMPILER v{} - DO NOT EDIT DIRECTLY\n\n",
            self.version
        ));

        let imports = collect_imports(doc);
        output.push_str(&imports);
        output.push('\n');

        let inline_types = generate_inline_message_types(doc);
        if !inline_types.is_empty() {
            output.push_str(&inline_types);
        }

        let constants = generate_fault_tree_constants(doc, fault_tree_probs);
        output.push_str(&constants);

        for tree in doc.event_trees.values() {
            let handler_code = generate_event_tree_handler(doc, tree, fault_tree_probs)?;
            output.push_str(&handler_code);
            output.push('\n');
        }

        Ok(vec![GeneratedFile::new(format!("{stem}.rs"), output)])
    }
}

fn collect_imports(doc: &EtlDocument) -> String {
    let mut imports = String::from(
        "use std::time::Duration;\n\
         use etdl_core::BranchMonitor;\n\
         use etdl_core::condition::{contains, matches};\n\
         use etdl_core::publisher::Publisher;\n\
         use etdl_core::retry::{RetryPolicy, BackoffStrategy};\n\
         use etdl_core::WorkflowError;\n\
         use serde::Serialize;\n",
    );

    let mut alias_set: BTreeMap<String, bool> = BTreeMap::new();

    for tree in doc.event_trees.values() {
        if let etdl_parser::ast::MessageRef::External(ref ext_ref) = tree.initiating_event.message
        {
            alias_set.insert(ext_ref.alias.clone(), true);
        }

        for node in tree.nodes.values() {
            match node {
                Node::Operation(op) => {
                    if let Some(etdl_parser::ast::MessageRef::External(ref ext_ref)) = op.emits {
                        alias_set.insert(ext_ref.alias.clone(), true);
                    }
                }
                Node::Consequence(cons) => {
                    if let Some(etdl_parser::ast::ChannelRef::External(ref ext_ref)) =
                        cons.channel
                    {
                        alias_set.insert(ext_ref.alias.clone(), true);
                    }
                    if let Some(etdl_parser::ast::MessageRef::External(ref ext_ref)) =
                        cons.message
                    {
                        alias_set.insert(ext_ref.alias.clone(), true);
                    }
                }
                _ => {}
            }
        }
    }

    for alias in alias_set.keys() {
        let mod_name = alias.replace('-', "_");
        imports.push_str(&format!("use {}::messages::*;\n", mod_name));
    }

    imports
}

fn generate_fault_tree_constants(
    doc: &EtlDocument,
    fault_tree_probs: &BTreeMap<String, f64>,
) -> String {
    let mut output = String::new();

    for tree in doc.event_trees.values() {
        for (node_id, node) in &tree.nodes {
            if let Node::Operation(op) = node {
                if let Some(ref ps) = op.on_failure_probability_source {
                    if let Some((ft_id, prob)) = find_fault_tree_prob(ps, fault_tree_probs) {
                        output.push_str(&format!(
                            "// Computed from faultTrees.{}.topEvent at build time (Section 5.16)\n",
                            ft_id
                        ));
                        let const_name =
                            to_upper_snake(&format!("{}_failure_probability", node_id));
                        output.push_str(&format!("const {}: f64 = {:.6};\n\n", const_name, prob));
                    }
                }
            }
        }
    }

    output
}

/// Resolve an `onFailureProbabilitySource` internal reference to its fault-tree
/// top-event probability. The pointer is `#/faultTrees/<id>/topEvent`; the
/// referenced fault-tree id selects the probability from the resolver output.
fn find_fault_tree_prob(
    ps: &etdl_parser::ast::InternalRef,
    fault_tree_probs: &BTreeMap<String, f64>,
) -> Option<(String, f64)> {
    let ft_id = extract_ft_id(&ps.pointer);
    fault_tree_probs.get(&ft_id).map(|&v| (ft_id.clone(), v))
}

fn generate_event_tree_handler(
    doc: &EtlDocument,
    tree: &EventTree,
    fault_tree_probs: &BTreeMap<String, f64>,
) -> Result<String, String> {
    let mut output = String::new();

    let fn_name = format!("handle_{}", to_snake_case(&tree.initiating_event.id));
    let message_type = ref_to_rust_type(&tree.initiating_event.message);

    output.push_str(&format!(
        "pub async fn {}(message: {}, publisher: &dyn Publisher) -> Result<(), WorkflowError> {{\n",
        fn_name, message_type
    ));

    let first_barrier = find_first_barrier(tree);
    let monitor_name = first_barrier
        .map(to_snake_case)
        .unwrap_or_else(|| "monitor".to_string());

    output.push_str(&format!(
        "    let mut {} = BranchMonitor::new(\"{}\");\n\n",
        monitor_name,
        first_barrier.unwrap_or("root")
    ));

    let start_node_id = &tree.initiating_event.next;
    let body = generate_node_code(doc, tree, start_node_id, 1, fault_tree_probs, &monitor_name)?;
    output.push_str(&body);

    output.push_str("    Ok(())\n");
    output.push_str("}\n");

    Ok(output)
}

fn find_first_barrier(tree: &EventTree) -> Option<&str> {
    let mut current = &tree.initiating_event.next;
    loop {
        match tree.nodes.get(current.as_str()) {
            Some(Node::Barrier(_)) => return Some(current.as_str()),
            Some(Node::Operation(op)) => {
                current = &op.next;
            }
            Some(Node::Consequence(_)) => return None,
            None => return None,
        }
    }
}

fn generate_node_code(
    doc: &EtlDocument,
    tree: &EventTree,
    node_id: &str,
    depth: usize,
    fault_tree_probs: &BTreeMap<String, f64>,
    monitor_name: &str,
) -> Result<String, String> {
    let node = tree
        .nodes
        .get(node_id)
        .ok_or_else(|| format!("node '{}' not found", node_id))?;

    match node {
        Node::Barrier(barrier) => generate_barrier_code(
            tree,
            node_id,
            barrier,
            depth,
            doc,
            fault_tree_probs,
            monitor_name,
        ),
        Node::Operation(op) => generate_operation_code(
            tree,
            node_id,
            op,
            depth,
            doc,
            fault_tree_probs,
            monitor_name,
        ),
        Node::Consequence(cons) => generate_consequence_code(cons, depth),
    }
}

fn generate_barrier_code(
    tree: &EventTree,
    node_id: &str,
    barrier: &etdl_parser::ast::Barrier,
    depth: usize,
    doc: &EtlDocument,
    fault_tree_probs: &BTreeMap<String, f64>,
    monitor_name: &str,
) -> Result<String, String> {
    let indent = "    ".repeat(depth);
    let mut output = String::new();

    for (i, branch) in barrier.branches.iter().enumerate() {
        if i == 0 {
            if branch.condition == Condition::Default {
                let prob = get_branch_prob(branch, node_id, fault_tree_probs);
                if let Some(p) = prob {
                    output.push_str(&format!(
                        "{}    {}.record_branch(\"{}\", {:.6});\n",
                        indent, monitor_name, branch.outcome, p
                    ));
                }
                let body = generate_node_code(
                    doc,
                    tree,
                    &branch.next,
                    depth + 1,
                    fault_tree_probs,
                    monitor_name,
                )?;
                output.push_str(&body);
            } else {
                let cond = condition_to_rust_code(&branch.condition);
                output.push_str(&format!("{}if {} {{\n", indent, cond));

                let prob = get_branch_prob(branch, node_id, fault_tree_probs);
                if let Some(p) = prob {
                    output.push_str(&format!(
                        "{}    {}.record_branch(\"{}\", {:.6});\n",
                        indent, monitor_name, branch.outcome, p
                    ));
                }

                let body = generate_node_code(
                    doc,
                    tree,
                    &branch.next,
                    depth + 1,
                    fault_tree_probs,
                    monitor_name,
                )?;
                output.push_str(&body);
                output.push_str(&format!("{}}}", indent));
            }
        } else if branch.condition == Condition::Default {
            output.push_str(" else {\n");

            let prob = get_branch_prob(branch, node_id, fault_tree_probs);
            if let Some(p) = prob {
                output.push_str(&format!(
                    "{}    {}.record_branch(\"{}\", {:.6});\n",
                    indent, monitor_name, branch.outcome, p
                ));
            }

            let body = generate_node_code(
                doc,
                tree,
                &branch.next,
                depth + 1,
                fault_tree_probs,
                monitor_name,
            )?;
            output.push_str(&body);
            output.push_str(&format!("{}}}\n", indent));
        } else {
            let cond = condition_to_rust_code(&branch.condition);
            output.push_str(&format!(" else if {} {{\n", cond));

            let prob = get_branch_prob(branch, node_id, fault_tree_probs);
            if let Some(p) = prob {
                output.push_str(&format!(
                    "{}    {}.record_branch(\"{}\", {:.6});\n",
                    indent, monitor_name, branch.outcome, p
                ));
            }

            let body = generate_node_code(
                doc,
                tree,
                &branch.next,
                depth + 1,
                fault_tree_probs,
                monitor_name,
            )?;
            output.push_str(&body);
            output.push_str(&format!("{}}}", indent));
        }
    }

    Ok(output)
}

fn generate_operation_code(
    tree: &EventTree,
    node_id: &str,
    op: &etdl_parser::ast::Operation,
    depth: usize,
    doc: &EtlDocument,
    fault_tree_probs: &BTreeMap<String, f64>,
    monitor_name: &str,
) -> Result<String, String> {
    let indent = "    ".repeat(depth);
    let mut output = String::new();

    let handler_name = to_snake_case(&op.handler);
    let timeout = op.timeout_ms.unwrap_or(5000);

    if let Some(ref retry) = op.retry_policy {
        let strategy = match retry
            .backoff_strategy
            .as_ref()
            .unwrap_or(&BackoffStrategy::Fixed)
        {
            BackoffStrategy::Exponential => "BackoffStrategy::Exponential",
            BackoffStrategy::Fixed => "BackoffStrategy::Fixed",
        };
        output.push_str(&format!(
            "{}let retry = RetryPolicy {{\n\
             {}    max_attempts: {},\n\
             {}    backoff_ms: {},\n\
             {}    strategy: {},\n\
             {}}};\n",
            indent, indent, retry.max_attempts, indent, retry.backoff_ms, indent, strategy, indent
        ));
        output.push_str(&format!(
            "{}match retry.execute(|| {}(&message), Duration::from_millis({})).await {{\n",
            indent, handler_name, timeout
        ));
    } else {
        output.push_str(&format!(
            "{}match {}(&message).await {{\n",
            indent, handler_name
        ));
    }

    output.push_str(&format!("{}    Ok(_result) => {{\n", indent));

    // Record a success on the SAME SLA key `record_failure` (in the `Err`
    // arm below) uses, so that key's rolling window sees both outcomes
    // instead of only ever seeing failures — an operation that failed
    // `sla::MIN_OBSERVATIONS` times over its lifetime otherwise triggered
    // an unconditional false SLA anomaly regardless of its actual overall
    // failure rate (observed frequency was permanently 1.0). See
    // `BranchMonitor::record_success`'s doc comment.
    if op.on_failure.is_some() {
        if let Some(ref ps) = op.on_failure_probability_source {
            let const_name = to_upper_snake(&format!("{}_failure_probability", node_id));
            let prob_exists = find_fault_tree_prob(ps, fault_tree_probs).is_some();
            if prob_exists {
                output.push_str(&format!(
                    "{}        {}.record_success(\"{}\", Some({}));\n",
                    indent, monitor_name, node_id, const_name
                ));
            } else {
                output.push_str(&format!(
                    "{}        {}.record_success(\"{}\", None);\n",
                    indent, monitor_name, node_id
                ));
            }
        }
    }

    let next_node = tree.nodes.get(&op.next);
    match next_node {
        Some(Node::Consequence(cons)) => {
            emit_send(cons, "_result", &indent, &mut output);
        }
        Some(_) => {
            generate_node_code(
                doc,
                tree,
                &op.next,
                depth + 2,
                fault_tree_probs,
                monitor_name,
            )
            .map(|body| output.push_str(&body))?;
        }
        None => {}
    }

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

    if let Some(ref _on_failure_id) = op.on_failure {
        output.push_str(&format!("{}    Err(err) => {{\n", indent));

        if let Some(ref ps) = op.on_failure_probability_source {
            let const_name = to_upper_snake(&format!("{}_failure_probability", node_id));
            let prob_exists = find_fault_tree_prob(ps, fault_tree_probs).is_some();
            if prob_exists {
                output.push_str(&format!(
                    "{}        {}.record_failure(\"{}\", &err, Some({}));\n",
                    indent, monitor_name, node_id, const_name
                ));
            } else {
                output.push_str(&format!(
                    "{}        {}.record_failure(\"{}\", &err, None);\n",
                    indent, monitor_name, node_id
                ));
            }
        } else {
            output.push_str(&format!(
                "{}        {}.record_failure(\"{}\", &err, None);\n",
                indent, monitor_name, node_id
            ));
        }

        let on_failure_id = op.on_failure.as_ref().unwrap();
        match tree.nodes.get(on_failure_id) {
            Some(Node::Consequence(cons)) => {
                emit_send(cons, "message", &indent, &mut output);
            }
            _ => {
                generate_node_code(
                    doc,
                    tree,
                    on_failure_id,
                    depth + 2,
                    fault_tree_probs,
                    monitor_name,
                )
                .map(|body| output.push_str(&body))?;
            }
        }

        output.push_str(&format!("{}    }}\n", indent));
    } else {
        output.push_str(&format!(
            "{}    Err(err) => return Err(WorkflowError::new(format!(\"{{}}\", err))),\n",
            indent
        ));
    }

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

    Ok(output)
}

/// Emit a `publisher.publish(...)` call for a `send` consequence.
fn emit_send(
    cons: &etdl_parser::ast::Consequence,
    payload_expr: &str,
    indent: &str,
    output: &mut String,
) {
    match cons.consequence_operation {
        etdl_parser::ast::ConsequenceOperation::Send => {
            if let Some(ref channel_ref) = cons.channel {
                let channel_name = channel_ref_name(channel_ref);
                output.push_str(&format!(
                    "{}        publisher.publish(\"{}\", &etdl_core::serde_json::to_value({}).map_err(|e| WorkflowError::new(format!(\"{{}}\", e)))?)?;\n",
                    indent, channel_name, payload_expr
                ));
            }
        }
        etdl_parser::ast::ConsequenceOperation::Terminate => {}
    }
}

fn generate_consequence_code(
    cons: &etdl_parser::ast::Consequence,
    depth: usize,
) -> Result<String, String> {
    let indent = "    ".repeat(depth);
    let mut output = String::new();

    match cons.consequence_operation {
        etdl_parser::ast::ConsequenceOperation::Send => {
            if let Some(ref channel_ref) = cons.channel {
                let channel_name = channel_ref_name(channel_ref);
                output.push_str(&format!(
                    "{}publisher.publish(\"{}\", &etdl_core::serde_json::to_value(message).map_err(|e| WorkflowError::new(format!(\"{{}}\", e)))?)?;\n",
                    indent, channel_name
                ));
            }
        }
        etdl_parser::ast::ConsequenceOperation::Terminate => {}
    }

    if depth == 1 {
        output.push_str(&format!("{}Ok(())\n", indent));
    }

    Ok(output)
}

fn condition_to_rust_code(condition: &Condition) -> String {
    match condition {
        Condition::Default => "true".to_string(),
        Condition::Comparison(cmp) => {
            use ecel::Comparator as C;
            match cmp.op {
                // `in` and `matches` lower to etdl_core::condition helpers.
                C::In => {
                    let left = path_or_literal(&cmp.left);
                    let right = array_or_literal(&cmp.right);
                    format!("etdl_core::condition::contains(&{}, &{})", right, left)
                }
                C::Matches => {
                    // `etdl_core::condition::matches` takes `value: &str`.
                    // A path operand renders as a bare owned-field
                    // expression (e.g. `message.payload.status`, typically
                    // `String`); it must be borrowed (`&message.payload.
                    // status`) so `&String -> &str` deref coercion applies
                    // at the call site — passing it unborrowed was a type
                    // error (`expected &str, found String`). A literal
                    // operand (`ECEL §6.5` says the left side of `matches`
                    // should be a path, but codegen stays defensive here)
                    // already renders as a `&'static str` literal and must
                    // NOT be re-borrowed.
                    let left = match &cmp.left {
                        ecel::Operand::Path(_) => format!("&{}", operand_to_path_expr(&cmp.left)),
                        ecel::Operand::Literal(lit) => literal_to_val_str(lit),
                    };
                    let right = literal_to_val_str(&literal_of(&cmp.right));
                    format!("etdl_core::condition::matches({}, {})", left, right)
                }
                _ => {
                    let (left_path, has_wildcard) = build_path_expression(&cmp.left);
                    let right = operand_to_val_str(&cmp.right);
                    let op = comparator_str(&cmp.op);

                    if has_wildcard {
                        // Wildcard path on the left: quantify over the array.
                        format!(
                            "{}.iter().all(|item| item{} {} {})",
                            left_path.path_prefix, left_path.remaining_path, op, right
                        )
                    } else {
                        let l = if left_path.path_prefix.is_empty()
                            && left_path.remaining_path.is_empty()
                        {
                            operand_to_val_str(&cmp.left)
                        } else {
                            left_path.path_prefix + &left_path.remaining_path
                        };
                        let r = if right.is_empty() {
                            operand_to_path_expr(&cmp.right)
                        } else {
                            right
                        };
                        format!("{} {} {}", l, op, r)
                    }
                }
            }
        }
    }
}

/// Render a path operand (or literal) as an expression usable as the left side
/// of a helper call.
fn path_or_literal(operand: &ecel::Operand) -> String {
    match operand {
        ecel::Operand::Path(_) => operand_to_path_expr(operand),
        ecel::Operand::Literal(lit) => literal_to_val_str(lit),
    }
}

/// Render an array path or array literal for the right side of `in`.
fn array_or_literal(operand: &ecel::Operand) -> String {
    match operand {
        ecel::Operand::Path(_) => operand_to_path_expr(operand),
        ecel::Operand::Literal(lit) => literal_to_val_str(lit),
    }
}

fn literal_of(operand: &ecel::Operand) -> ecel::Literal {
    match operand {
        ecel::Operand::Literal(lit) => lit.clone(),
        ecel::Operand::Path(_) => ecel::Literal::String(String::new()),
    }
}

struct PathParts {
    path_prefix: String,
    remaining_path: String,
}

fn build_path_expression(operand: &ecel::Operand) -> (PathParts, bool) {
    match operand {
        ecel::Operand::Path(path_expr) => {
            let segments = &path_expr.segments;
            let mut pre_wildcard = Vec::new();
            let mut post_wildcard = Vec::new();
            let mut has_wildcard = false;

            for (i, seg) in segments.iter().enumerate() {
                if i == 0 {
                    continue;
                }
                if has_wildcard {
                    post_wildcard.push(seg.clone());
                } else if matches!(seg, ecel::PathSegment::Wildcard) {
                    has_wildcard = true;
                } else {
                    pre_wildcard.push(seg.clone());
                }
            }

            let mut prefix = String::from("message");
            for seg in &pre_wildcard {
                match seg {
                    ecel::PathSegment::Field(name) => {
                        prefix.push('.');
                        prefix.push_str(&to_snake_case(name));
                    }
                    ecel::PathSegment::Index(idx) => {
                        prefix.push_str(&format!("[{}]", idx));
                    }
                    ecel::PathSegment::QuotedKey(name) => {
                        prefix.push_str(&format!("[\"{}\"]", name));
                    }
                    _ => {}
                }
            }

            let mut suffix = String::new();
            for seg in &post_wildcard {
                match seg {
                    ecel::PathSegment::Field(name) => {
                        suffix.push('.');
                        suffix.push_str(&to_snake_case(name));
                    }
                    ecel::PathSegment::Index(idx) => {
                        suffix.push_str(&format!("[{}]", idx));
                    }
                    ecel::PathSegment::QuotedKey(name) => {
                        suffix.push_str(&format!("[\"{}\"]", name));
                    }
                    _ => {}
                }
            }

            (
                PathParts {
                    path_prefix: prefix,
                    remaining_path: suffix,
                },
                has_wildcard,
            )
        }
        ecel::Operand::Literal(_) => (
            PathParts {
                path_prefix: String::new(),
                remaining_path: String::new(),
            },
            false,
        ),
    }
}

fn operand_to_path_expr(operand: &ecel::Operand) -> String {
    match operand {
        ecel::Operand::Path(path) => {
            let segments = &path.segments;
            let mut out = String::from("message");
            for seg in segments.iter().skip(1) {
                match seg {
                    ecel::PathSegment::Field(name) => {
                        out.push('.');
                        out.push_str(&to_snake_case(name));
                    }
                    ecel::PathSegment::Wildcard => {}
                    ecel::PathSegment::Index(idx) => {
                        out.push_str(&format!("[{}]", idx));
                    }
                    ecel::PathSegment::QuotedKey(name) => {
                        out.push_str(&format!("[\"{}\"]", name));
                    }
                }
            }
            out
        }
        ecel::Operand::Literal(_) => String::new(),
    }
}

fn operand_to_val_str(operand: &ecel::Operand) -> String {
    match operand {
        ecel::Operand::Path(_) => "".to_string(),
        ecel::Operand::Literal(lit) => literal_to_val_str(lit),
    }
}

fn literal_to_val_str(lit: &ecel::Literal) -> String {
    match lit {
        ecel::Literal::Number(n) => n.to_string(),
        ecel::Literal::String(s) => format!("\"{}\"", s),
        ecel::Literal::Bool(b) => b.to_string(),
        ecel::Literal::Null => "None".to_string(),
        ecel::Literal::Array(items) => {
            let inner: Vec<String> = items.iter().map(literal_to_val_str).collect();
            format!("vec![{}]", inner.join(", "))
        }
    }
}

/// Emit the comparison operator. `in` and `matches` are not Rust syntax, so they
/// are emitted as calls to `etdl_core` helper functions. The helpers take the
/// operands on the right (path value and literal) so the generated expression is
/// `etdl_core::condition::contains(<path>, <literal>)` for `in` and
/// `etdl_core::condition::matches(<path>, "<re2>")` for `matches`.
fn comparator_str(op: &ecel::Comparator) -> &str {
    match op {
        ecel::Comparator::Eq => "==",
        ecel::Comparator::Neq => "!=",
        ecel::Comparator::Gte => ">=",
        ecel::Comparator::Lte => "<=",
        ecel::Comparator::Gt => ">",
        ecel::Comparator::Lt => "<",
        ecel::Comparator::In => "in",
        ecel::Comparator::Matches => "matches",
    }
}

fn ref_to_rust_type(msg_ref: &etdl_parser::ast::MessageRef) -> String {
    let pointer = match msg_ref {
        etdl_parser::ast::MessageRef::External(r) => &r.pointer,
        etdl_parser::ast::MessageRef::Internal(r) => &r.pointer,
    };
    extract_last_segment_str(pointer)
}

/// The channel-name string a `publisher.publish(...)` call uses: for an
/// External Reference, the last JSON Pointer segment (matching the
/// pre-existing convention for message types); for a bare channel-name
/// string (Section 5.3.5, only valid when the document has no
/// `asyncapi_imports`), the literal name itself, unmodified — it is a
/// runtime channel address, not a Rust identifier.
fn channel_ref_name(channel_ref: &etdl_parser::ast::ChannelRef) -> String {
    match channel_ref {
        etdl_parser::ast::ChannelRef::External(ext_ref) => {
            extract_last_segment_str(&ext_ref.pointer)
        }
        etdl_parser::ast::ChannelRef::Bare(name) => name.clone(),
    }
}

fn extract_last_segment_str(pointer: &str) -> String {
    let parts: Vec<&str> = pointer.split('/').collect();
    let last = parts.last().unwrap_or(&"Unknown");
    to_pascal_case(last)
}

/// Collects the `<id>`s of every Internal Message Reference
/// (`#/components/messages/<id>`) used anywhere in `doc`, so their inline
/// Message Schema Objects can have matching Rust types generated (there is
/// no external, AsyncAPI-toolchain-generated module to import them from,
/// unlike an External Reference's `{alias}::messages::*`).
fn collect_internal_message_ids(doc: &EtlDocument) -> std::collections::BTreeSet<String> {
    use etdl_parser::ast::MessageRef;

    fn note(msg_ref: &MessageRef, ids: &mut std::collections::BTreeSet<String>) {
        if let MessageRef::Internal(int_ref) = msg_ref {
            if let Some(id) = int_ref.pointer.strip_prefix("#/components/messages/") {
                ids.insert(id.to_string());
            }
        }
    }

    let mut ids = std::collections::BTreeSet::new();

    for tree in doc.event_trees.values() {
        note(&tree.initiating_event.message, &mut ids);

        for node in tree.nodes.values() {
            match node {
                Node::Operation(op) => {
                    if let Some(ref m) = op.emits {
                        note(m, &mut ids);
                    }
                }
                Node::Consequence(cons) => {
                    if let Some(ref m) = cons.message {
                        note(m, &mut ids);
                    }
                }
                _ => {}
            }
        }
    }

    if let Some(ref fault_trees) = doc.fault_trees {
        for ft in fault_trees.values() {
            if let Some(ref m) = ft.top_event.message {
                note(m, &mut ids);
            }
            for be in ft.basic_events.values() {
                if let Some(ref m) = be.message {
                    note(m, &mut ids);
                }
            }
        }
    }

    ids
}

/// Generates a Rust struct (and any nested structs its object-typed
/// properties need) for every inline `components.messages.<id>` entry
/// actually referenced via an Internal Message Reference somewhere in
/// `doc`. The top-level struct for `<id>` is named `to_pascal_case(<id>)`,
/// matching `ref_to_rust_type`'s naming for the same reference.
fn generate_inline_message_types(doc: &EtlDocument) -> String {
    let ids = collect_internal_message_ids(doc);
    if ids.is_empty() {
        return String::new();
    }

    let messages = doc.components.as_ref().and_then(|c| c.messages.as_ref());

    let mut output = String::new();
    for id in &ids {
        let Some(message) = messages.and_then(|m| m.get(id)) else {
            continue;
        };
        generate_message_envelope(id, message, &mut output);
    }
    output
}

/// Emits the message envelope type for one inline `components.messages.<id>`
/// entry: a `pub struct <Name> { payload: <Name>Payload, headers: Option<...> }`,
/// matching the `{payload, headers}` shape an External Reference's
/// AsyncAPI-toolchain-generated type already has (see
/// `etdl-compiler/tests/gencheck/src/messages.rs`'s stubs) — this is what
/// makes `message.payload.<field>` path codegen (`build_path_expression`)
/// work identically regardless of which kind of Message Reference produced
/// `message`.
fn generate_message_envelope(id: &str, message: &etdl_parser::ast::Message, output: &mut String) {
    let type_name = to_pascal_case(id);
    let payload_type_name = format!("{}Payload", type_name);
    let payload: serde_json::Value =
        serde_json::to_value(&message.payload).unwrap_or(serde_json::Value::Null);

    let mut nested = String::new();
    let payload_rust_type = schema_to_rust_type(&payload_type_name, &payload, &mut nested);
    output.push_str(&nested);

    output.push_str("#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\n");
    output.push_str(&format!("pub struct {} {{\n", type_name));
    output.push_str(&format!("    pub payload: {},\n", payload_rust_type));
    output.push_str("    #[serde(default)]\n");
    output.push_str("    pub headers: Option<serde_json::Value>,\n");
    output.push_str("}\n\n");
}

/// Emits a `pub struct <name> { ... }` for an object-typed JSON Schema
/// (`schema.properties`), deriving `Serialize`/`Deserialize`. A property
/// listed in `schema.required` becomes a non-optional field; any other
/// property becomes `Option<T>` with `#[serde(default)]`. A schema with no
/// `properties` (or a non-object schema) falls back to a
/// `serde_json::Value`-wrapping newtype, so the type always exists even
/// when the schema is too loose to model precisely.
fn generate_struct_from_schema(name: &str, schema: &serde_json::Value, output: &mut String) {
    let Some(properties) = schema.get("properties").and_then(|p| p.as_object()) else {
        output.push_str(&format!(
            "#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\npub struct {}(pub serde_json::Value);\n\n",
            name
        ));
        return;
    };

    let required: std::collections::BTreeSet<&str> = schema
        .get("required")
        .and_then(|r| r.as_array())
        .map(|arr| arr.iter().filter_map(|v| v.as_str()).collect())
        .unwrap_or_default();

    let mut nested = String::new();
    let mut fields = String::new();

    for (field_name, field_schema) in properties {
        let snake = to_snake_case(field_name);
        let nested_type_name = format!("{}{}", name, to_pascal_case(field_name));
        let rust_type = schema_to_rust_type(&nested_type_name, field_schema, &mut nested);
        let is_required = required.contains(field_name.as_str());

        if snake != *field_name {
            fields.push_str(&format!("    #[serde(rename = \"{}\")]\n", field_name));
        }

        if is_required {
            fields.push_str(&format!("    pub {}: {},\n", snake, rust_type));
        } else {
            fields.push_str("    #[serde(default)]\n");
            fields.push_str(&format!("    pub {}: Option<{}>,\n", snake, rust_type));
        }
    }

    output.push_str(&nested);
    output.push_str("#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\n");
    output.push_str(&format!("pub struct {} {{\n", name));
    output.push_str(&fields);
    output.push_str("}\n\n");
}

/// Maps a JSON Schema fragment to a Rust type, generating a nested struct
/// (appended to `nested`) for an object-typed property under
/// `candidate_name`. Anything not representable as a concrete Rust type
/// (missing/unrecognized `type`) falls back to `serde_json::Value`.
fn schema_to_rust_type(candidate_name: &str, schema: &serde_json::Value, nested: &mut String) -> String {
    match schema.get("type").and_then(|t| t.as_str()) {
        Some("string") => "String".to_string(),
        Some("integer") => "i64".to_string(),
        Some("number") => "f64".to_string(),
        Some("boolean") => "bool".to_string(),
        Some("array") => {
            let item_type = match schema.get("items") {
                Some(items_schema) => {
                    schema_to_rust_type(&format!("{}Item", candidate_name), items_schema, nested)
                }
                None => "serde_json::Value".to_string(),
            };
            format!("Vec<{}>", item_type)
        }
        Some("object") => {
            if schema.get("properties").is_some() {
                generate_struct_from_schema(candidate_name, schema, nested);
                candidate_name.to_string()
            } else {
                "serde_json::Value".to_string()
            }
        }
        _ => "serde_json::Value".to_string(),
    }
}

fn get_branch_prob(
    branch: &etdl_parser::ast::Branch,
    _node_id: &str,
    fault_tree_probs: &BTreeMap<String, f64>,
) -> Option<f64> {
    if let Some(ref ps) = branch.probability_source {
        let ft_id = extract_ft_id(&ps.pointer);
        return fault_tree_probs.get(&ft_id).copied();
    }
    branch.effective_probability()
}

fn extract_ft_id(pointer: &str) -> String {
    pointer
        .trim_start_matches("#/faultTrees/")
        .trim_end_matches("/topEvent")
        .to_string()
}

fn to_snake_case(s: &str) -> String {
    let mut result = String::new();
    for (i, c) in s.chars().enumerate() {
        if c.is_uppercase() {
            if i > 0 {
                result.push('_');
            }
            result.push(c.to_lowercase().next().unwrap());
        } else {
            result.push(c);
        }
    }
    result
}

fn to_upper_snake(s: &str) -> String {
    let snake = to_snake_case(s);
    snake.to_uppercase()
}

fn to_pascal_case(s: &str) -> String {
    let mut result = String::new();
    let mut capitalize = true;
    for c in s.chars() {
        if c == '_' || c == '-' || c == ' ' {
            capitalize = true;
        } else if capitalize {
            result.extend(c.to_uppercase());
            capitalize = false;
        } else {
            result.push(c);
        }
    }
    result
}

#[cfg(test)]
mod tests {
    use super::*;
    use etdl_parser::ast::{EtlDocument, InternalRef};

    fn parse(yaml: &str) -> EtlDocument {
        serde_yaml::from_str(yaml).expect("valid yaml")
    }

    fn multi_ft_doc() -> EtlDocument {
        parse(
            r##"
etdl: "1.0.0"
info:
  title: "MultiFT"
  version: "1.0.0"
  domain: "D"
asyncapi_imports: {}
eventTrees:
  T:
    initiatingEvent:
      id: I
      message: "a#/m"
      next: O
    nodes:
      O:
        type: operation
        action: execute
        handler: "h"
        next: C
        onFailure: FC
        onFailureProbabilitySource: "#/faultTrees/B/topEvent"
      C:
        type: consequence
        operation: terminate
      FC:
        type: consequence
        operation: terminate
faultTrees:
  A:
    topEvent:
      id: A1
      description: "a"
      rootCause: AE
    basicEvents:
      AE:
        description: "ae"
        probability: 0.9
  B:
    topEvent:
      id: B1
      description: "b"
      rootCause: BE
    basicEvents:
      BE:
        description: "be"
        probability: 0.01
"##,
        )
    }

    #[test]
    fn find_fault_tree_prob_selects_by_pointer() {
        let doc = multi_ft_doc();
        let probs = crate::fault_tree::resolve_fault_trees(&doc, &mut Vec::new());
        assert_eq!(probs["A"], 0.9);
        assert_eq!(probs["B"], 0.01);

        // The pointer selects tree B, not the first map entry (A).
        let ps = InternalRef {
            pointer: "#/faultTrees/B/topEvent".to_string(),
        };
        let (id, prob) = find_fault_tree_prob(&ps, &probs).expect("resolves");
        assert_eq!(id, "B");
        assert!((prob - 0.01).abs() < 1e-9);
    }

    #[test]
    fn generated_constants_use_correct_tree() {
        let doc = multi_ft_doc();
        let probs = crate::fault_tree::resolve_fault_trees(&doc, &mut Vec::new());
        let constants = generate_fault_tree_constants(&doc, &probs);
        assert!(constants.contains("faultTrees.B.topEvent"));
        assert!(constants.contains("= 0.010000"));
        assert!(!constants.contains("faultTrees.A.topEvent"));
    }

    #[test]
    fn in_operator_lowers_to_contains() {
        let cond = etdl_parser::ecel::parse_condition(
            "message.payload.status in [\"PAID\", \"AUTHORIZED\"]",
        )
        .unwrap();
        let code = condition_to_rust_code(&cond);
        assert!(
            code.contains("etdl_core::condition::contains"),
            "got: {}",
            code
        );
        assert!(code.contains("\"PAID\""));
    }

    #[test]
    fn matches_operator_lowers_to_regex() {
        let cond = etdl_parser::ecel::parse_condition(
            "message.payload.reference matches \"^ORD-[0-9]{8}$\"",
        )
        .unwrap();
        let code = condition_to_rust_code(&cond);
        assert!(
            code.contains("etdl_core::condition::matches"),
            "got: {}",
            code
        );
    }

    #[test]
    fn comparison_emits_valid_rust() {
        let cond = etdl_parser::ecel::parse_condition("message.payload.amount >= 10000").unwrap();
        let code = condition_to_rust_code(&cond);
        assert_eq!(code, "message.payload.amount >= 10000");
    }
}