aimx/

cell.rs

use std::{
    fmt,
    sync::Arc,
};

//use anyhow::Result;
use crate::{
    aim::{Row, Rule, Writer, WriterLike}, expressions::{Expression, ExpressionLike}, values::Value
};


#[derive(Debug, Clone, PartialEq)]
pub enum Cell {
    // Workflow rows
    Empty,
    Comment{comment: Arc<str>},
    Errata{identifier: Arc<str>, typedef: Arc<str>, reason: Arc<str>, formula: Arc<str>, location: Arc<str>},

    // Workflow source template
    Node{identifier: Arc<str>, value: Arc<str>},
    Format{identifier: Arc<str>, instruction: Arc<str>, template: Arc<str>, examples: Arc<Vec<Arc<str>>>},
    Branch{identifier: Arc<str>, condition: Arc<str>, target: Arc<str>},
    Retry{identifier: Arc<str>, count: u32, condition: Arc<str>, target: Arc<str>},
    Formula{identifier: Arc<str>, typedef: Arc<str>, formula: Arc<str>, value: Arc<str>},

    // Workflow target results
    Result{identifier: Arc<str>, typedef: Arc<str>, value: Arc<str>},

    // Workflow evaluation statistics
//  Eval{identifier: Arc<str>, /*TBD */},
}

impl Cell {

    /// Creates a new formula cell with predefined values for all fields.
    #[doc = include_str!("../docs/cell/new.md")]
    pub fn new(identifier: &str, typedef: &str, formula: &str, value: &str) -> Self {
        Cell::Formula { 
            identifier: Arc::from(identifier),
            typedef: Arc::from(typedef),
            formula: Arc::from(formula),
            value: Arc::from(value) 
        }
    }

    /// Converts a workflow row to a cell representation for API consumption.
    #[doc = include_str!("../docs/cell/convert_row.md")]
    pub fn convert_row(row: &Row) -> Self {
        match row {
            Row::Empty => Cell::Empty,
            Row::Comment(comment) => Cell::Comment { comment: comment.clone() },
            Row::Rule(rule) | Row::Touched(rule) => Self::convert_rule(rule),
        }
    }

    /// Converts a workflow row to a result cell representation for inference output.
    #[doc = include_str!("../docs/cell/convert_result.md")]
    pub fn convert_result(row: &Row) -> Self {
        match row {
            Row::Empty => Cell::Empty,
            Row::Comment(comment) => Cell::Comment { comment: comment.clone() },
            Row::Rule(rule) | Row::Touched(rule) => {
                // Compose error cell
                if rule.is_error() {
                    let value = rule.value();
                    if value.is_error() && let Value::Errata(errata) = &*value {
                        return Cell::Errata {
                            identifier: rule.identifier(),
                            typedef: Arc::from(rule.typedef().as_str()),
                            reason: errata.reason(),
                            formula: errata.formula(),
                            location: errata.location(),
                        };
                    } 
                }
                // Compose result cell
                Cell::Result { 
                    identifier: rule.identifier(),
                    typedef: Arc::from(rule.typedef().as_str()),
                    value: rule.value().to_arc_str(),
                }
            }
        }
    }

    /// Converts a workflow rule to a cell representation for API consumption.
    #[doc = include_str!("../docs/cell/convert_rule.md")]
    pub fn convert_rule(rule: &Rule) -> Self {
        // Compose error cell
        if rule.is_error() {
            let value = rule.value();
            if value.is_error() && let Value::Errata(errata) = &*value {
                return Cell::Errata {
                    identifier: rule.identifier(),
                    typedef: Arc::from(rule.typedef().as_str()),
                    reason: errata.reason(),
                    formula: errata.formula(),
                    location: errata.location(),
                };
            } 
            let expression = rule.expression();
            if expression.is_error() && let Expression::Errata(errata) = expression {
                return Cell::Errata {
                    identifier: rule.identifier(),
                    typedef: Arc::from(rule.typedef().as_str()),
                    reason: errata.reason(),
                    formula: errata.formula(),
                    location: errata.location(),
                };
            }
        }
        // Compose node cell
        if rule.is_node() {
            return Cell::Node {
                identifier: rule.identifier(),
                value: rule.value().to_arc_str(),
            };
        }

        let typedef = rule.typedef();

        // Compose format cell
        if typedef.is_format() {
            let value = rule.value();
            if let Value::Format(format) = &*value {
                return Cell::Format {
                    identifier: rule.identifier(),
                    instruction: format.instruction(),
                    template: format.template(),
                    examples: format.examples(),
                };
            }
        }

        // Compose eval cell
/*
        TODO we probably want to load the most recent eval record here
        if typedef.is_eval() {
            let value = rule.value();
            if let Value::Eval(eval) = &*value {
                return Cell::Eval {
                    // TBD
                };
            }
        }
*/
        // Compose branch cell
        if typedef.is_branch() {
            let expression = rule.expression();
            if let Expression::Branch(branch) = expression {
                return Cell::Branch { 
                    identifier: rule.identifier(),
                    condition: Arc::from(branch.condition().to_formula()),
                    target: branch.target(),
                };
            }
        }
        // Compose retry cell
        if typedef.is_retry() {
            let expression = rule.expression();
            if let Expression::Retry(retry) = expression {
                return Cell::Retry { 
                    identifier: rule.identifier(),
                    count: retry.count(),
                    condition: Arc::from(retry.condition().to_formula()),
                    target: retry.target(),
                };
            }
        }

        Cell::Formula {
            identifier: rule.identifier(),
            typedef: Arc::from(typedef.as_str()),
            formula: Arc::from(rule.expression().to_formula()),
            value: rule.value().to_arc_str(),
        } 
    }

    /// Checks whether a cell represents an empty workflow row.
    #[doc = include_str!("../docs/cell/is_empty.md")]
    pub fn is_empty(&self) -> bool {
        matches!(self, Cell::Empty)
    }
    
    /// Checks whether a cell represents a comment in the workflow.
    #[doc = include_str!("../docs/cell/is_comment.md")]
    pub fn is_comment(&self) -> bool {
        matches!(self, Cell::Comment{..})
    }

    /// Checks whether a cell represents an error state containing error information.
    #[doc = include_str!("../docs/cell/is_error.md")]
    pub fn is_error(&self) -> bool {
        matches!(self, Cell::Errata{..})
    }

    /// Checks whether a cell represents a node in the workflow.
    #[doc = include_str!("../docs/cell/is_node.md")]
    pub fn is_node(&self) -> bool {
        matches!(self, Cell::Node{..})
    }

    /// Checks whether a cell represents a format instruction in the workflow.
    #[doc = include_str!("../docs/cell/is_format.md")]
    pub fn is_format(&self) -> bool {
        matches!(self, Cell::Format{..})
    }

    /// Checks whether a cell represents a branch instruction in the workflow.
    #[doc = include_str!("../docs/cell/is_branch.md")]
    pub fn is_branch(&self) -> bool {
        matches!(self, Cell::Branch{..})
    }

    /// Checks whether a cell represents a retry instruction in the workflow.
    #[doc = include_str!("../docs/cell/is_retry.md")]
    pub fn is_retry(&self) -> bool {
        matches!(self, Cell::Retry{..})
    }

    /// Checks whether a cell represents a formula in the workflow.
    #[doc = include_str!("../docs/cell/is_formula.md")]
    pub fn is_formula(&self) -> bool {
        matches!(self, Cell::Formula{..})
    }

    /// Checks whether a cell represents a result in the workflow.
    #[doc = include_str!("../docs/cell/is_result.md")]
    pub fn is_result(&self) -> bool {
        matches!(self, Cell::Result{..})
    }

    /// Retrieves the comment text from a comment cell, or an empty string for other cell types.
    #[doc = include_str!("../docs/cell/comment.md")]
    pub fn comment(&self) -> Option<Arc<str>> {
        match self {
            Cell::Comment { comment } => Some(comment.clone()),
            _ => None,
        }
    }

    /// Retrieves the identifier associated with a cell in the workflow.
    #[doc = include_str!("../docs/cell/identifier.md")]
    pub fn identifier(&self) -> Option<Arc<str>> {
        match self {
            Cell::Errata { identifier, typedef: _, reason: _, formula: _, location: _ }
            | Cell::Node { identifier, value: _ }
            | Cell::Format { identifier, instruction: _, template: _, examples: _ }
            | Cell::Branch { identifier, condition: _, target: _ }
            | Cell::Retry { identifier, count: _, condition: _, target: _ }
            | Cell::Formula { identifier, typedef: _, formula: _, value: _ }
            | Cell::Result { identifier, typedef: _, value: _ } => Some(identifier.clone()),
            _ => None,
        }
    }

    /// Retrieves the type definition string associated with a cell in the workflow.
    #[doc = include_str!("../docs/cell/typedef.md")]
    pub fn typedef(&self) -> Option<Arc<str>> {
        match self {
            Cell::Errata { identifier: _, typedef, reason: _, formula: _, location: _ }
            | Cell::Formula { identifier: _, typedef, formula: _, value: _ }
            | Cell::Result { identifier: _, typedef, value: _ } => Some(typedef.clone()),
            Cell::Node { .. } => Some(Arc::from("Node")),
            Cell::Format { .. } => Some(Arc::from("Format")),
            Cell::Branch { .. } => Some(Arc::from("Branch")),
            Cell::Retry { .. } => Some(Arc::from("Retry")),
            _ => None,
        }

    }

    /// Retrieves the error reason string from a cell that represents an error state.
    #[doc = include_str!("../docs/cell/reason.md")]
    pub fn reason(&self) -> Option<Arc<str>> {
        match self {
            Cell::Errata { identifier: _, typedef: _, reason, formula: _, location: _ } => Some(reason.clone()),
            _ => None,
        }
    }

    /// Retrieves the formula string from a cell that contains a formula or error information.
    #[doc = include_str!("../docs/cell/formula.md")]
    pub fn formula(&self) -> Option<Arc<str>> {
        match self {
            Cell::Errata { identifier: _, typedef: _, reason: _, formula, location: _ }
            | Cell::Formula { identifier: _, typedef: _, formula, value: _ } => Some(formula.clone()),
            _ => None,
        }
    }

    /// Retrieves the error location string from a cell that represents an error state, or an empty string for other cell types.
    #[doc = include_str!("../docs/cell/location.md")]
    pub fn location(&self) -> Option<Arc<str>> {
        match self {
            Cell::Errata { identifier: _, typedef: _, reason: _, formula: _, location } => {
                if location.is_empty() {
                    None
                } else {
                    Some(location.clone())
                }
            }
            _ => None,
        }
    }

    /// Retrieves the computed value string from a cell that contains a value or an empty string for other cell types.
    #[doc = include_str!("../docs/cell/value.md")]
    pub fn value(&self) -> Option<Arc<str>> {
        match self {
            Cell::Node { identifier: _, value }
            | Cell::Formula { identifier: _, typedef: _, formula: _, value }
            | Cell::Result { identifier: _, typedef: _, value } => Some(value.clone()),
            _ => None,
        }
    }

    /// Retrieves the instruction string from a cell that contains a format instruction.
    #[doc = include_str!("../docs/cell/instruction.md")]
    pub fn instruction(&self) -> Option<Arc<str>> {
        match self {
            Cell::Format { identifier: _, instruction, template: _, examples: _ } => Some(instruction.clone()),
            _ => None,
        }
    }

    /// Retrieves the template string from a cell that contains a format instruction.
    #[doc = include_str!("../docs/cell/template.md")]
    pub fn template(&self) -> Option<Arc<str>> {
        match self {
            Cell::Format { identifier: _, instruction: _, template, examples: _ } => Some(template.clone()),
            _ => None,
        }
    }

    /// Retrieves the example strings from a cell that contains a format instruction.
    #[doc = include_str!("../docs/cell/examples.md")]
    pub fn examples(&self) -> Option<Arc<Vec<Arc<str>>>> {
        match self {
            Cell::Format { identifier: _, instruction: _, template: _, examples } => Some(examples.clone()),
            _ => None,
        }
    }

    /// Retrieves the condition string from a cell that contains a condition or an empty string for other cell types.
    #[doc = include_str!("../docs/cell/condition.md")]
    pub fn condition(&self) -> Option<Arc<str>> {
        match self {
            Cell::Branch { identifier: _, condition, target: _ }
            | Cell::Retry { identifier: _, count: _, condition, target: _ } => Some(condition.clone()),
            _ => None,
        }
    }

    /// Retrieves the target identifier string from cells that contain target information.
    #[doc = include_str!("../docs/cell/target.md")]
    pub fn target(&self) -> Option<Arc<str>> {
        match self {
            Cell::Branch { identifier: _, condition: _, target }
            | Cell::Retry { identifier: _, count: _, condition: _, target } => Some(target.clone()),
            _ => None,
        }
    }

    /// Retrieves the retry count from a cell that represents a retry instruction in the workflow.
    #[doc = include_str!("../docs/cell/count.md")]
    pub fn count(&self) -> Option<u32> {
        match self {
            Cell::Retry { identifier: _, count, condition: _, target: _ } => Some(*count),
            _ => None,
        }
    }


    /// Serializes a cell's content to a writer in a human-readable format.
    #[doc = include_str!("../docs/cell/print.md")]
    pub fn print(&self, writer: &mut Writer) {
        match self {
            Cell::Empty => {}
            Cell::Comment{comment} => {
                if writer.is_formulizer() {
                    writer.write_str(comment);
                }
            }
            Cell::Errata { identifier, typedef, reason, formula, location } => {
               writer.write_str(identifier);
                writer.write_str(": ");
                writer.write_str(typedef);
                writer.write_str(" =");
                if !formula.is_empty() {
                    writer.write_char(' ');
                    writer.write_str(formula);
                }
                writer.write_str(" # ");
                writer.write_str(reason);
                let _ = location;
            }
            Cell::Result { identifier, typedef, value } => {
                writer.write_str(identifier);
                writer.write_str(": ");
                writer.write_str(typedef);
                writer.write_str(" =");
                if !value.is_empty() {
                    writer.write_str(" $");
                    writer.print(value);
                }
            }
            Cell::Node { identifier, value} => {
                writer.write_str(identifier);
                writer.write_str(": Node =");
                if !value.is_empty() {
                    writer.write_str(" $");
                    writer.print(value);
                }
            }
            Cell::Format { identifier, instruction, template, examples } => {
                writer.write_str(identifier);
                writer.write_str(": Format = ");
                writer.print(instruction);
                writer.write_str(" <");
                writer.print(template);
                writer.write_str("> ");
                for (index, example) in examples.iter().enumerate() {
                    if index > 0 {
                        writer.write_str(", ");
                    }
                    writer.print(example);
                }
            }
            Cell::Branch { identifier, condition, target } => {
                writer.write_str(identifier);
                writer.write_str(": Branch = ");
                writer.print(condition);
                writer.write_str(" -> ");
                writer.print(target);
            }
            Cell::Retry { identifier, count, condition, target } => {
                writer.write_str(identifier);
                writer.write_str(": Retry = ");
                writer.write_unsigned(*count);
                writer.write_str(", ");
                writer.print(condition);
                writer.write_str(" -> ");
                writer.print(target);

            }
            Cell::Formula { identifier, typedef, formula, value} => {
                writer.write_str(identifier);
                writer.write_str(": ");
                writer.write_str(typedef);
                writer.write_str(" =");
                if !formula.is_empty() {
                    writer.write_char(' ');
                    writer.write_str(formula);
                }
                if !value.is_empty() {
                    writer.write_str(" $");
                    writer.print(value);
                }
            }
        }
        if writer.is_formulizer() {
            writer.write_eol();
        }
    }

    /// Return the formula-string representation (round-trippable by the parser).
    #[doc = include_str!("../docs/cell/to_formula.md")]
    pub fn to_formula(&self) -> String {
        let mut writer = Writer::formulizer();
        self.print(&mut writer);
        writer.finish()
    }
}

impl WriterLike for Cell {
    fn write(&self, writer: &mut Writer) {
        self.print(writer);
    }
}

impl fmt::Display for Cell {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_stringized())
    }
}