reasoninglayer 0.2.1

//! Utilities DTOs (relational arithmetic, math functions, bitwise/modular ops, string ops, copy).

use serde::{Deserialize, Serialize};

// ─── Arithmetic ─────────────────────────────────────────────────────────────

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ArithValueDto {
    Integer { value: i64 },
    Real { value: f64 },
    TermRef { term_id: String },
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RelationalArithRequest {
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arg1: Option<ArithValueDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arg2: Option<ArithValueDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arg3: Option<ArithValueDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status", rename_all = "snake_case")]
pub enum RelationalArithResponse {
    Success {
        result: ArithValueDto,
        computed_arg: u64,
    },
    Residuate1 {
        term_id: String,
    },
    Residuate2 {
        term1_id: String,
        term2_id: String,
    },
    Residuate3 {
        term1_id: String,
        term2_id: String,
        term3_id: String,
    },
    Curry {
        missing_count: u64,
    },
    Fail {
        reason: String,
    },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MathFunctionType {
    Sqrt,
    Pow,
    Sin,
    Cos,
    Tan,
    Asin,
    Acos,
    Atan,
    Atan2,
    Sinh,
    Cosh,
    Tanh,
    Asinh,
    Acosh,
    Atanh,
    Exp,
    Log,
    Log10,
    Floor,
    Ceiling,
    Round,
    Truncate,
    Abs,
    Sign,
    Pi,
    E,
    DegToRad,
    RadToDeg,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MathFunctionRequest {
    pub session_id: String,
    pub function: MathFunctionType,
    pub args: Vec<Option<f64>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum MathResultDto {
    Integer { value: i64 },
    Real { value: f64 },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status", rename_all = "snake_case")]
pub enum MathFunctionResponse {
    Success { result: MathResultDto },
    Residuate { term_ids: Vec<String> },
    DomainError { message: String },
    Fail,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BitwiseOperationType {
    And,
    Or,
    Xor,
    Not,
    LeftShift,
    RightShift,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BitwiseRequest {
    pub session_id: String,
    pub operation: BitwiseOperationType,
    pub args: Vec<Option<i64>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status", rename_all = "snake_case")]
pub enum BitwiseResponse {
    Success { result: i64 },
    Residuate { term_ids: Vec<String> },
    Fail { reason: String },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ModularOperationType {
    Mod,
    Gcd,
    Lcm,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModularArithRequest {
    pub operation: ModularOperationType,
    pub arg1: i64,
    pub arg2: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ModularArithResponse {
    pub result: i64,
}

// ─── String operations ──────────────────────────────────────────────────────

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StringConcatRequest {
    pub string1: String,
    pub string2: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StringConcatResponse {
    pub result: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StringLengthRequest {
    pub string_value: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StringLengthResponse {
    pub length: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubstringRequest {
    pub string_value: String,
    pub start: u64,
    pub length: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SubstringResponse {
    pub result: String,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StringOperationType {
    ToUpper,
    ToLower,
    Trim,
    TrimStart,
    TrimEnd,
    Reverse,
    CharAt,
    IndexOf,
    Replace,
    Split,
    Contains,
    StartsWith,
    EndsWith,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StringOpParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub index: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub search: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub replacement: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delimiter: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StringOpRequest {
    pub operation: StringOperationType,
    pub string_value: String,
    #[serde(default)]
    pub params: StringOpParams,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum StringOpResponse {
    String { result: String },
    Char { result: char },
    Integer { result: i64 },
    Boolean { result: bool },
    Strings { result: Vec<String> },
    NotFound,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StringCompareRequest {
    pub string1: String,
    pub string2: String,
    #[serde(default)]
    pub ignore_case: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StringCompareResponse {
    pub ordering: i32,
    pub are_equal: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum NumberValueDto {
    Integer { value: i64 },
    Real { value: f64 },
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct NumberFormatDto {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub precision: Option<u64>,
    #[serde(default)]
    pub scientific: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NumberToStringRequest {
    pub value: NumberValueDto,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub format: Option<NumberFormatDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct NumberToStringResponse {
    pub result: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AscRequest {
    pub character: char,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AscResponse {
    pub code: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChrRequest {
    pub code: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status", rename_all = "snake_case")]
pub enum ChrResponse {
    Success { character: char },
    InvalidCode { code: i64 },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StringCompareOperator {
    Lt,
    Gt,
    Le,
    Ge,
    Eq,
    Ne,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StringComparePredicateRequest {
    pub string1: String,
    pub string2: String,
    pub operator: StringCompareOperator,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StringComparePredicateResponse {
    pub success: bool,
    pub operator: Option<StringCompareOperator>,
    pub explanation: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchStringCompareRequest {
    pub comparisons: Vec<StringComparePredicateRequest>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BatchStringCompareResponse {
    #[serde(default)]
    pub results: Vec<StringComparePredicateResponse>,
    pub all_succeeded: bool,
}

// ─── Copy operations ────────────────────────────────────────────────────────

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CopyModeDto {
    Exact,
    Quote,
    Eval,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CopyTermRequest {
    pub session_id: String,
    pub term_id: String,
    pub copy_mode: CopyModeDto,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CopyTermResponse {
    pub original_term_id: String,
    pub copied_term_id: String,
    pub copy_mode: Option<CopyModeDto>,
    #[serde(default)]
    pub copied_features: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SingleCopyRequest {
    pub term_id: String,
    pub copy_mode: CopyModeDto,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchCopyRequest {
    pub session_id: String,
    pub copies: Vec<SingleCopyRequest>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CopyResultDto {
    pub original_term_id: String,
    pub copied_term_id: String,
    pub success: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BatchCopyResponse {
    #[serde(default)]
    pub copies: Vec<CopyResultDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeepCopyRequest {
    pub session_id: String,
    pub term_id: String,
    pub copy_mode: CopyModeDto,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_depth: Option<u64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TermTranslationDto {
    pub original_id: String,
    pub copied_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeepCopyResponse {
    pub original_term_id: String,
    pub copied_term_id: String,
    pub copy_mode: Option<CopyModeDto>,
    pub terms_copied: u64,
    pub cycles_detected: bool,
    #[serde(default)]
    pub translation_table: Vec<TermTranslationDto>,
}