reasoninglayer 0.2.1

//! LIFE-style user-defined function DTOs.

use serde::{Deserialize, Serialize};

/// Binary operator for expressions within function bodies.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum BinaryOperatorDto {
    Add,
    Subtract,
    Multiply,
    Divide,
}

/// Value type for function literals (tagged).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", content = "value")]
pub enum FunctionValueDto {
    Integer(i64),
    Real(f64),
    String(String),
    Boolean(bool),
    Uninstantiated,
}

/// Recursive expression. Values use `tag = "type"` discrimination.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ExpressionDto {
    Variable {
        name: String,
    },
    Literal {
        value: FunctionValueDto,
    },
    BinaryOp {
        op: BinaryOperatorDto,
        left: Box<ExpressionDto>,
        right: Box<ExpressionDto>,
    },
    FunctionCall {
        function_name: String,
        arguments: Vec<ExpressionDto>,
    },
}

/// Function body — what a clause computes.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum FunctionBodyDto {
    Value {
        value: FunctionValueDto,
    },
    Expression {
        expr: ExpressionDto,
    },
    FunctionCall {
        function_name: String,
        arguments: Vec<ExpressionDto>,
    },
}

/// Guard condition on a function clause.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum FunctionGuardDto {
    GreaterThan {
        var: String,
        value: FunctionValueDto,
    },
    LessThan {
        var: String,
        value: FunctionValueDto,
    },
    Equal {
        var: String,
        value: FunctionValueDto,
    },
    And {
        guards: Vec<FunctionGuardDto>,
    },
    Or {
        guards: Vec<FunctionGuardDto>,
    },
}

/// Pattern for function clause parameter matching.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum PatternDto {
    Variable { name: String },
    Integer { value: i64 },
    Real { value: f64 },
    String { value: String },
    Boolean { value: bool },
    Wildcard,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionClauseDto {
    pub body: FunctionBodyDto,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guard: Option<FunctionGuardDto>,
    pub parameters: Vec<PatternDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegisterFunctionRequest {
    pub arity: u32,
    pub clauses: Vec<FunctionClauseDto>,
    pub name: String,
    pub tenant_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegisterFunctionResponse {
    pub arity: u32,
    pub clauses_count: u64,
    pub function_id: String,
    pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EvaluateFunctionRequest {
    pub arguments: Vec<FunctionValueDto>,
    pub function_name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_depth: Option<u32>,
    pub tenant_id: String,
}

/// Response from evaluation — either a value or a suspension.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "result_type")]
pub enum EvaluateFunctionResponse {
    Value { value: FunctionValueDto },
    Suspend { reason: String },
}