aimx/aim/

context.rs

//! Evaluation context for AIMX expression evaluation within workflows.
//!
//! Provides [`ContextLike`] and [`Context`] for resolving references, invoking
//! registered functions/methods, managing closure parameters, performing
//! inference, and running imperative workflow evaluation.
//! Context instances are not thread-safe and should be used per evaluation.
//!
use crate::{
    get_config,
    aim::{Row, Rule, Typedef, Workflow, WorkflowLike, WorkflowStatus, Workspace, Writer, LockManager},
    expressions::{Expression, ExpressionLike, Reference},
    functions::FunctionRegistry,
    inference::{Prompt, parse_response, send_request, validate_responses},
    values::{Errata, Value},
};
use anyhow::{Result, anyhow};
use std::{
    mem::replace,
    sync::Arc,
};

/// Evaluation context interface used by the AIMX engine.
///
/// Implementors provide:
/// - Reference lookup (`get_value` / `set_value`).
/// - Function and method dispatch via [`FunctionRegistry`].
/// - Closure parameter stack management.
/// - Inference calls into workflows or closures.
/// - Imperative workflow execution via [`ContextLike::run_evaluation`].
pub trait ContextLike {
    /// Start a new closure and save the current stack.
    fn start_closure(&mut self) -> [(Arc<str>, Arc<Value>); 2];

    /// Set the identifier of a closure parameter slot (0 or 1).
    fn set_key(&mut self, index: usize, identifier: Arc<str>);

    /// Set the value of the index mapped parameter used by element-wise functions like `map`.
    ///
    /// # Arguments
    ///
    /// * `index` - The index value to set (0 or 1)
    /// * `value` - The value to set
    fn set_parameter(&mut self, index: usize, value: Arc<Value>);

    /// End the closure and restore the previous stack.
    fn end_closure(&mut self, stack: [(Arc<str>, Arc<Value>); 2]);

    /// Get the value of a referenced rule or parameter variable.
    ///
    /// # Arguments
    ///
    /// * `reference` - The reference to resolve
    ///
    /// # Returns
    ///
    /// Returns the value of the referenced variable or an error if the reference
    /// cannot be resolved.
    fn get_value(&mut self, reference: &Reference) -> Result<Arc<Value>>;

    /// Set the value of a rule.
    ///
    /// # Arguments
    ///
    /// * `reference` - The reference to the rule to set
    /// * `value` - The value to assign
    ///
    /// # Returns
    ///
    /// Returns `Ok(())` on success or an error if the referenced rule cannot be set.
    fn set_value(&mut self, identifier: &str, value: Arc<Value>) -> Result<()>;

    /// Call a standalone function.
    ///
    /// # Arguments
    /// * `name` - The name of the function to call
    /// * `arg` - The argument(s) to pass to the function (Value can be Empty, Literal, or Array)
    ///
    /// # Returns
    ///
    /// Returns the result of the function call or an error if the function is not found
    /// or if there's an error during execution.
    fn function_call(&mut self, name: Arc<str>, arg: Arc<Value>) -> Result<Arc<Value>>;

    /// Call a method on a value.
    ///
    /// # Arguments
    /// * `name` - The name of the method to call
    /// * `value` - The value on which to call the method
    /// * `arg` - The argument(s) to pass to the method (Value can be Empty, Literal, or Array)
    ///
    /// # Returns
    ///
    /// Returns the result of the method call or an error if the method is not found
    /// or if there's an error during execution.
    fn method_call(&mut self, name: Arc<str>, value: Arc<Value>, arg: Arc<Value>) -> Result<Arc<Value>>;

    /// Run inference on a referenced workflow.
    ///
    /// # Arguments
    /// * `reference` - The workflow reference
    /// * `arg` - The argument(s) to pass to the inference call (Value can be Empty, Literal, or Array)
    ///
    /// # Returns
    ///
    /// Returns the result of the inference call or an error if the workflow is not found
    /// or if there's an error during execution.
    fn inference_call(&mut self, reference: Arc<Reference>, arg: Arc<Value>) -> Result<Arc<Value>>;

    fn run_evaluation(&mut self, start_state: Option<Arc<str>>) -> WorkflowStatus;
}

pub struct StackFrame {
    prev_source: Arc<Workflow>,
    prev_target: Workflow,
}

impl StackFrame {
    fn new(prev_source: Arc<Workflow>, prev_target: Workflow,) -> Self {
        Self {
            prev_source,
            prev_target,
        }
    }
}

/// Default AIMX evaluation context implementing [`ContextLike`].
///
/// Holds the current locator, active workflow (read-only and optional mutable clone),
/// closure parameters, and an optional workflow lock. Supports reference resolution,
/// rule updates, inference into nested workflows, and imperative workflow execution.
/// Not thread-safe; use per evaluation.
#[derive(Debug)]
pub struct Context {
    source: Arc<Workflow>,
    target: Workflow,
    parameters: [(Arc<str>, Arc<Value>); 2],
}

impl Context {
    /// Acquire context with enhanced error handling
    pub fn open_with_error_handling(source_locator: Arc<Reference>, target_locator: Arc<Reference>) -> Result<Self> {
        let source_node = Workspace::locate_node(&source_locator)?;
        let source = source_node.get_workflow()?;
        let target_node = Workspace::locate_node(&target_locator)?;
        let target = target_node.get_workflow_mut()?;
        Ok(Self {
            source,
            target,
            parameters: [(Value::empty_str(), Value::empty()), (Value::empty_str(), Value::empty())],
        })
    }
}

impl Context {
    // -----------------------------------------------------------------------------
    // Test Methods
    // -----------------------------------------------------------------------------

    // A helper function to create a context for integration tests
    pub fn for_testing() -> Result<Self> {
        let locator = Reference::workspace();
        let source = Arc::new(Workflow::for_testing(locator.clone())?);
        let target = Workflow::for_testing(locator)?;
        Ok(Self {
            source,
            target,
            parameters: [(Value::empty_str(), Value::empty()), (Value::empty_str(), Value::empty())],
        })
    }

    /// Test Helper function to add a predefined value to the context for testing purposes.
    ///
    /// This method creates a rule with the given identifier and value and adds it
    /// to the workspace. This is primarily used for testing expressions that reference
    /// predefined variables.
    ///
    /// # Arguments
    ///
    /// * `identifier` - The identifier name for the value
    /// * `value` - The value to associate with the identifier
    ///
    /// # Returns
    ///
    /// Returns the modified context for method chaining.
    pub fn with_value(mut self, identifier: &str, value: Value) -> Self {
        let typedef = value.get_type().unwrap_or(Typedef::Any);
        let rule = Rule::new(
            Arc::from(identifier),
            typedef,
            Expression::Empty,
            Arc::new(value)
        );
        self.target.append_or_update(Row::Rule(Arc::new(rule)));
        self
    }

    /// Test Helper function to add a predefined rule to the context for testing purposes.
    pub fn with_rule(
        mut self,
        identifier: &str,
        typedef: Typedef,
        expression: Expression,
        value: Value,
    ) -> Self {
        let rule = Rule::new(
            Arc::from(identifier),
            typedef,
            expression,
            Arc::new(value)
        );
        self.target.append_or_update(Row::Rule(Arc::new(rule)));
        self
    }

    /// Test Helper function to commit the predefined rules to the source workflow for testing.
    pub fn with_commit(mut self) -> Self {
        self.source = Arc::new(self.target.clone());
        self
    }

    /// Test Helper function to lookup the predefined rule values in the workflow for testing.
    pub fn get_local(&mut self, identifier: &str) -> Result<Arc<Value>> {
        let local_reference = Reference::new(Arc::from(identifier));
        self.get_value(&local_reference)
    }

    // -----------------------------------------------------------------------------
    // Api Methods
    // -----------------------------------------------------------------------------

    // Exclusively called by Instance::locate() via Instance::get_context_lock()
    pub fn open(source_locator: Arc<Reference>, target_locator: Arc<Reference>) -> Result<Self> {
        Self::open_with_error_handling(source_locator, target_locator)
    }

    pub fn save(&mut self) -> Result<()> {
        let locator = self.source.locator();
        // Save the target workflow
        self.target.save()?;
        // If the source and target are the same
        if self.target.locator()  == locator {
            let node = Workspace::locate_node(&locator)?;
            // Atomically copy the target to update the source
            node.set_workflow(self.target.clone());
        }
        Ok(())
    }

    pub fn save_all(&mut self) -> Result<()> {
        let locator = self.source.locator();
        // Save the target workflow
        self.target.save_all()?;
        // If the source and target are the same
        if self.target.locator()  == locator {
            let node = Workspace::locate_node(&locator)?;
            // Atomically copy the target to update the source
            node.set_workflow(self.target.clone());
        }
        Ok(())
    }

    /// Gets read-only access to the current workflow.
    ///
    /// Returns a clone of the Arc reference to the current workflow, allowing
    /// read-only access to workflow data without affecting the context's ownership.
    pub fn source(&self) -> Arc<Workflow> {
        self.source.clone()
    }

    /// Gets mutable access to the workflow if available.
    ///
    /// Returns a mutable reference to the workflow if one is currently being
    /// modified, or None if only read-only access is available.
    pub fn target(&mut self) -> &mut Workflow {
        &mut self.target
    }

    fn enter_scope(&mut self, source: Arc<Workflow>, target_locator: Arc<Reference>) -> Result<StackFrame> {
        let target = Workflow::for_testing(target_locator)?;
        let prev_source = replace(&mut self.source, source);
        let prev_target = replace(&mut self.target, target);
        Ok(StackFrame::new(prev_source, prev_target))
    }

    fn exit_scope(&mut self, stack: StackFrame) -> Workflow {
        self.source = stack.prev_source;
        replace(&mut self.target, stack.prev_target)
    }

    fn locate_value(&self, reference: &Reference) -> Result<Arc<Value>> {
        match reference {
            Reference::One(one) => {
                // Try target workflow
                if let Some(rule) = self.target.get_rule(one) {
                    return Ok(rule.value().clone());
                }
                // Try source workflow
                if let Some(rule) = self.source.get_rule(one) {
                    return Ok(rule.value().clone());
                }
            }
            Reference::Two(one, two) => {
                // Try target workflow
                if let Some(rule) = self.target.get_rule(one) {
                    if let Some(node) = rule.get_node() {
                        if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                            return Ok(rule.value().clone());
                        }
                    }
                }
                // Try source workflow
                if let Some(rule) = self.source.get_rule(one) {
                    if let Some(node) = rule.get_node() {
                        if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                            return Ok(rule.value().clone());
                        }
                    }
                }
            }
            Reference::Three(one, two, three) => {
                // Try target workflow
                if let Some(rule) = self.target.get_rule(one) {
                    if let Some(node) = rule.get_node() {
                        if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                            if let Some(node) = rule.get_node() {
                                if let Some(rule) = &node.get_workflow()?.get_rule(three) {
                                    return Ok(rule.value().clone());
                                }
                            }
                        }
                    }
                }
                // Try source workflow
                if let Some(rule) = self.source.get_rule(one) {
                    if let Some(node) = rule.get_node() {
                        if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                            if let Some(node) = rule.get_node() {
                                if let Some(rule) = &node.get_workflow()?.get_rule(three) {
                                    return Ok(rule.value().clone());
                                }
                            }
                        }
                    }
                }
            }
            _ => {}
        }
        if let Some(rule) = Workspace::locate_rule(reference)? {
            return Ok(rule.value().clone());
        }
        Err(anyhow!("Undefined locator ~{}", reference))
    }

    fn locate_typedef(&mut self, identifier: &str) -> Result<Typedef> {
        // Try target workflow
        if let Some(rule) = self.target.get_rule(identifier) {
            return Ok(rule.typedef().clone());
        }
        // Try source workflow
        if let Some(rule) = self.source.get_rule(identifier) {
            return Ok(rule.typedef().clone());
        }
        Err(anyhow!("Undefined locator ~{}", identifier))
    }

    // Dereference the Value and return a normalized reference to it.
    fn locate_inference(&self, reference: &Reference) -> Result<(Reference, Arc<str>, Arc<Value>)> {
        match reference {
            Reference::One(one) => {
                // Try writable workflow
                if let Some(rule) = self.target.get_rule(one) {
                    let normalized = self.target.locator().combine_and_normalize(reference)?;
                    return Ok((normalized, one.clone(), rule.value().clone()));
                }
                // Try read-only workflow
                if let Some(rule) = self.source.get_rule(one) {
                    let normalized = self.source.locator().combine_and_normalize(reference)?;
                    return Ok((normalized, one.clone(), rule.value().clone()));
                }
            }
            Reference::Two(one, two) => {
                // Try writable workflow
                if let Some(rule) = self.target.get_rule(one) {
                    if let Some(node) = rule.get_node() {
                        if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                            let normalized = self.target.locator().combine_and_normalize(reference)?;
                            return Ok((normalized, two.clone(), rule.value().clone()));
                        }
                    }
                }
                // Try read-only workflow
                if let Some(rule) = self.source.get_rule(one) {
                    if let Some(node) = rule.get_node() {
                        if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                            let normalized = self.source.locator().combine_and_normalize(reference)?;
                            return Ok((normalized, two.clone(), rule.value().clone()));
                        }
                    }
                }
                // Try workspace
                if let Ok(node) = Workspace::get_node(one) {
                    if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                        return Ok((reference.clone(), two.clone(), rule.value().clone()));
                    }
                }
            }
            Reference::Three(one, two, three) => {
                // Try workspace
                if let Ok(node) = Workspace::get_node(one) {
                    if let Some(rule) = &node.get_workflow()?.get_rule(two) {
                        if let Some(node) = rule.get_node() {
                            if let Some(rule) = &node.get_workflow()?.get_rule(three) {
                                return Ok((reference.clone(), three.clone(), rule.value().clone()));
                            }
                        }
                    }
                }
            }
            _ => {}
        }
        Err(anyhow!(
            "Undefined locator {} within {} scope~{}",
            reference,
            &self.source.locator(),
            reference
        ))
    }

    pub fn print(&self, writer: &mut Writer) {
        self.source.locator().print(writer);
        writer.write_str(", ");
        self.target.locator().print(writer);
    }
}

impl ContextLike for Context {
    /// Start a new closure and save the current parameter stack.
    fn start_closure(&mut self) -> [(Arc<str>, Arc<Value>); 2] {
        replace(
            &mut self.parameters,
            [(Value::empty_str(), Value::empty()), (Value::empty_str(), Value::empty())],
        )
    }

    /// Set the key of the indexed mapped parameter used by element-wise functions like `map`.
    ///
    /// # Arguments
    ///
    /// * `index` - The index key to set (0 or 1)
    /// * `identifier` - The key to set
    fn set_key(&mut self, index: usize, identifier: Arc<str>) {
        if self.parameters[index].0 != identifier {
            self.parameters[index].0 = identifier.clone();
        }
    }

    /// Set the value of the index mapped parameter used by element-wise functions like `map`.
    ///
    /// # Arguments
    ///
    /// * `index` - The index value to set (0 or 1)
    /// * `value` - The value to set
    fn set_parameter(&mut self, index: usize, value: Arc<Value>) {
        self.parameters[index].1 = value.clone();
    }

    /// End the closure and restore the previous parameter stack.
    fn end_closure(&mut self, stack: [(Arc<str>, Arc<Value>); 2]) {
        self.parameters = stack;
    }
    /// Get the value of a referenced rule or parameter variable.
    ///
    /// This implementation only supports single-part references (default identifiers).
    /// Multi-part references (e.g., `object.property`) are not supported in this
    /// simplified context.
    ///
    /// # Arguments
    ///
    /// * `reference` - The reference to resolve
    ///
    /// # Returns
    ///
    /// Returns a `Result<Value>` containing the referenced value or an error
    /// if the reference cannot be resolved.
    fn get_value(&mut self, reference: &Reference) -> Result<Arc<Value>> {
        // Check closure parameters first
        if *reference == *self.parameters[0].0 {
            Ok(self.parameters[0].1.clone())
        } else if *reference == *self.parameters[1].0 {
            Ok(self.parameters[1].1.clone())
        } else {
            self.locate_value(reference)
        }
    }

    /// Get the value of a rule or parameter.
    ///
    /// # Arguments
    ///
    /// * `reference` - The reference to set
    /// * `literal` - The value to assign
    ///
    /// # Returns
    ///
    /// Returns `Ok(())` if the referenced value was set or an error if the
    /// reference cannot be resolved.
    fn set_value(&mut self, identifier: &str, value: Arc<Value>) -> Result<()> {
        // Check closure parameters first
        if *identifier == *self.parameters[0].0 {
            self.parameters[0].1 = value;
            Ok(())
        } else if *identifier == *self.parameters[1].0 {
            self.parameters[1].1 = value;
            Ok(())
        } else {
            // Find the referenced rule's typedef
            match self.locate_typedef(identifier) {
                Ok(typedef) => {
                    // Promote type
                    let value = match value.to_type(&typedef) {
                        Ok(v) => v,
                        Err(e) => return Err(anyhow!("{}~{}", e, identifier)),
                    };
                    // Try mutable workflow first
                    if let Some(rule) = self.target.get_rule(identifier) {
                        let mut new_rule = (*rule).clone();
                        new_rule.set_value(value)?;
                        let _ = self.target.update_rule(Arc::new(new_rule));
                        Ok(())
                    } else {
                        Err(anyhow!("Undefined locator ~{}", identifier))
                    }
                }
                Err(e) => Err(e),
            }
        }
    }

    /// Call a standalone function.
    ///
    /// Delegates function calls to the singleton function registry.
    ///
    /// # Arguments
    ///
    /// * `name` - The name of the function to call
    /// * `arg` - The argument(s) to pass to the function
    ///
    /// # Returns
    ///
    /// Returns a `Result<Value>` containing the function result or an error
    /// if the function is not found or execution fails.
    fn function_call(&mut self, name: Arc<str>, arg: Arc<Value>) -> Result<Arc<Value>> {
        let registry = FunctionRegistry::read_lock()?;
        registry.function_call(self, name, arg)
    }

    /// Call a method on a value.
    ///
    /// Delegates method calls to the singleton function registry.
    ///
    /// # Arguments
    ///
    /// * `name` - The name of the method to call
    /// * `value` - The value on which to call the method
    /// * `arg` - The argument(s) to pass to the method
    ///
    /// # Returns
    ///
    /// Returns a `Result<Value>` containing the method result or an error
    /// if the method is not found or execution fails.
    fn method_call(&mut self, name: Arc<str>, value: Arc<Value>, arg: Arc<Value>) -> Result<Arc<Value>> {
        let registry = FunctionRegistry::read_lock()?;
        registry.method_call(self, name, value, arg)
    }

    /// Run inference on a workflow node or call a closure.
    ///
    /// * `Node` - Delegates inference to a workflow node
    /// * `Closure` - Delegates closure calls to a first class function
    ///
    /// # Arguments
    ///
    /// * `reference` - A reference to the rule containing the node or closure
    /// * `arg` - The argument(s) to pass to the inference/call
    ///
    /// # Returns
    ///
    /// Returns a `Result<Value>` containing the inference/call result or an error
    /// if the rule is not found or the inference/call fails.
    fn inference_call(&mut self, reference: Arc<Reference>, arg: Arc<Value>) -> Result<Arc<Value>> {

        let (source_locator, identifier, value) = self.locate_inference(&reference)?;

        if *self.source.locator() == source_locator {
            return Err(anyhow!("Circular inference detected ~{}", source_locator));
        }

        let node = match &*value {
            Value::Node(node) => node,
            // Call the first class function
            Value::Closure(closure) => {
                return closure.call(self, arg);
            }
            _ => {
                return Err(anyhow!(
                    "Expected Node or Closure found {}~{}",
                    value.type_as_string(),
                    source_locator
                ));
            }
        };

        let target_locator = Arc::new(self.target.locator().add_child(identifier)?);

        // 1️⃣ Acquire file-specific write lock ONLY when this is a descendant workflow
        let mutex = LockManager::get_mutex(target_locator.clone());
        let _lock_guard = mutex.lock()
            .expect("Lock poisoned in context inference.");

        // 2️⃣ Push current state onto stack and switch to the new node workflow
        let source = node.get_workflow()?.clone();
        let stack = self.enter_scope(source, target_locator)?;

        let inference = node.inference().clone();
        let model = inference.model();
        //let pattern = self.source.pattern();
        // Get the inference provider
        let provider = get_config().unwrap().get_provider(model).clone();

        // 3️⃣ Assign arguments
        // TODO add argument list to node?

        // 4️⃣ Generate a prompt for the workflow pattern
        let prompt = Prompt::generate(self.source.clone(), self, &provider.capability);

        // 5️⃣  Send provider inference prompt
        match send_request(&provider, &prompt) {
            Ok(response) => {
                // 6️⃣ Parse inference response
                if let Some(responses) = parse_response(&response.text()) {
                    // 7️⃣ Validate and assign responses
                    validate_responses(self, responses);
                }
                //let input = inference.finish();
            }
            _ => {}
        }

        // 8️⃣ Evaluate workflow expressions
        let status = self.run_evaluation(None);
        let _ = status;

        // 9️⃣ Pop previous state from stack
        let mut target = self.exit_scope(stack);

        // 🔟 Save changes and update node state
        target.save()?;
        // Atomically replace the old node workflow with the new workflow.
        node.set_workflow(target);

        // Return results
        Ok(Value::empty())
        // _lock_guard is dropped here, releasing the lock if it was acquired.

    }

    /// Evaluate this workflow as an imperative rule program.
    ///
    /// This interpreter walks rules by row index and respects control-flow
    /// values produced by rule evaluation.
    ///
    /// Branch and Retry rules are treated as workflow-level control
    /// constructs; their `Value::Branch` results are not written back
    /// via `set_value`.
    ///
    /// To guard against accidental cycles (e.g. infinite branch loops),
    /// a fixed maximum step count is enforced. Exceeding this limit
    /// terminates evaluation with a `WorkflowStatus::Failed` result.
    ///
    /// # Parameters
    ///
    /// * `context` - The evaluation context providing variable access
    /// * `start_state` - Optional rule identifier to start from when
    ///                   resuming a suspended workflow.
    fn run_evaluation(&mut self, start_state: Option<Arc<str>>) -> WorkflowStatus {
        const MAX_STEPS: usize = 10_000;

        let mut steps: usize = 0;
        let mut index: usize = match start_state {
            Some(ref identifier) => self.source.get_index(identifier).unwrap_or(0),
            None => 0,
        };
        let row_len = self.source.row_count();

        // Index-based interpreter loop
        while index < row_len {
            if steps >= MAX_STEPS {
                // Protect against cycles; caller can inspect Errata if emitted
                let state_id = match self.source.get_row(index).rule() {
                    Some(rule) => Some(rule.identifier()),
                    None => None,
                };

                let errata = Some(Arc::new(Errata::Two {
                    reason: Arc::from("MAX_STEPS exceeded in workflow evaluation"),
                    formula: Arc::from(format!("Workflow: {}", self.source.locator())),
                }));
                return WorkflowStatus::Failed { state_id, errata };
            }
            steps += 1;

            let rule = match self.source.get_row(index).rule() {
                Some(rule) => rule,
                None => {
                    index += 1;
                    continue;
                }
            };

            let current_id = rule.identifier();

            // Evaluate the rule; Rule::evaluate already maps non-critical
            // errors into Value::Errata.
            match rule.evaluate(self) {
                Ok(value) => {
                    match &*value {
                        Value::Branch(target) => {
                            // Control-flow branch: jump to target rule if it exists.
                            if let Some(next_index) = self.source.get_index(target) {
                                index = next_index;
                                continue;
                            } else {
                                // Unknown branch target: signal failure at this rule.
                                let errata = Some(Arc::new(Errata::Three {
                                    reason: Arc::from(format!("Unknown branch target '{}'", target)),
                                    formula: current_id.clone(),
                                    location: target.clone(),
                                }));
                                return WorkflowStatus::Failed {
                                    state_id: Some(current_id),
                                    errata,
                                };
                            }
                        }
                        // Normal values (including Errata) are left for
                        // Rule::evaluate / Context to handle; proceed.
                        _ => {
                            index += 1;
                        }
                    }
                }
                Err(err) => {
                    // Critical errors: capture details into Errata and surface
                    // them via the workflow status so callers can propagate.
                    let errata = Some(Arc::new(Errata::Two {
                        reason: Arc::from(format!("Workflow evaluation error at '{}': {}", current_id, err)),
                        formula: current_id.clone(),
                    }));
                    return WorkflowStatus::Failed {
                        state_id: Some(current_id),
                        errata,
                    };
                }
            }
        }

        WorkflowStatus::Completed
    }
}