sz_configtool_lib/calls/

expression.rs

//! Expression call management operations
//!
//! Functions for managing CFG_EFCALL (expression calls) and CFG_EFBOM
//! (expression bill of materials) configuration sections.

use crate::error::{Result, SzConfigError};
use crate::helpers::{
    find_in_config_array, get_next_id, lookup_efunc_id, lookup_element_id, lookup_feature_id,
};
use serde_json::{Value, json};

// ============================================================================
// Parameter Structs
// ============================================================================

/// Parameters for adding an expression call
#[derive(Debug, Clone)]
pub struct AddExpressionCallParams<'a> {
    pub efunc_code: &'a str,
    pub element_list: Vec<(String, String, Option<String>)>, // (element, required, feature)
    pub ftype_code: Option<&'a str>,
    pub felem_code: Option<&'a str>,
    pub exec_order: Option<i64>,
    pub expression_feature: Option<&'a str>,
    pub is_virtual: &'a str,
}

impl<'a> AddExpressionCallParams<'a> {
    pub fn new(efunc_code: &'a str, element_list: Vec<(String, String, Option<String>)>) -> Self {
        Self {
            efunc_code,
            element_list,
            ftype_code: None,
            felem_code: None,
            exec_order: None,
            expression_feature: None,
            is_virtual: "No",
        }
    }
}

/// Parameters for expression call element operations
#[derive(Debug, Clone)]
pub struct ExpressionCallElementParams {
    pub ftype_id: i64,
    pub felem_id: i64,
    pub exec_order: i64,
    pub felem_req: String,
}

impl ExpressionCallElementParams {
    pub fn new(ftype_id: i64, felem_id: i64, exec_order: i64, felem_req: String) -> Self {
        Self {
            ftype_id,
            felem_id,
            exec_order,
            felem_req,
        }
    }
}

/// Parameters for identifying expression call element (for delete operations)
#[derive(Debug, Clone)]
pub struct ExpressionCallElementKey {
    pub ftype_id: i64,
    pub felem_id: i64,
    pub exec_order: i64,
}

impl ExpressionCallElementKey {
    pub fn new(ftype_id: i64, felem_id: i64, exec_order: i64) -> Self {
        Self {
            ftype_id,
            felem_id,
            exec_order,
        }
    }
}

/// Parameters for setting (updating) an expression call
#[derive(Debug, Clone, Default)]
pub struct SetExpressionCallParams {
    pub efcall_id: i64,
    pub exec_order: Option<i64>,
}

impl TryFrom<&Value> for SetExpressionCallParams {
    type Error = SzConfigError;

    fn try_from(json: &Value) -> Result<Self> {
        let efcall_id = json
            .get("efcallId")
            .and_then(|v| v.as_i64())
            .ok_or_else(|| SzConfigError::MissingField("efcallId".to_string()))?;

        Ok(Self {
            efcall_id,
            exec_order: json.get("execOrder").and_then(|v| v.as_i64()),
        })
    }
}

/// Add a new expression call with element list
///
/// Creates a new expression call linking a function to a feature or element
/// with an execution order and associated elements (EBOM records).
///
/// # Arguments
/// * `config` - Configuration JSON string
/// * `params` - Expression call parameters
///
/// # Returns
/// Tuple of (modified_config, new_efcall_record)
///
/// # Errors
/// - `InvalidParameter` if both ftype_code and felem_code are specified or both missing
/// - `Duplicate` if exec_order is already taken for the feature/element
/// - `NotFound` if function/feature/element codes don't exist
pub fn add_expression_call(
    config: &str,
    params: AddExpressionCallParams,
) -> Result<(String, Value)> {
    let mut config_data: Value =
        serde_json::from_str(config).map_err(|e| SzConfigError::JsonParse(e.to_string()))?;

    // Get next EFCALL_ID (seed at 1000 for user-created calls)
    let efcall_id = get_next_id(&config_data, "G2_CONFIG.CFG_EFCALL", "EFCALL_ID", 1000)?;

    // Lookup function ID
    let efunc_id = lookup_efunc_id(config, params.efunc_code)?;

    // Determine FTYPE_ID and FELEM_ID (-1 means not specified)
    let mut ftype_id: i64 = -1;
    let mut felem_id: i64 = -1;

    if let Some(feature) = params.ftype_code.filter(|f| !f.eq_ignore_ascii_case("ALL")) {
        ftype_id = lookup_feature_id(config, feature)?;
    }

    if let Some(element) = params.felem_code.filter(|e| !e.eq_ignore_ascii_case("N/A")) {
        felem_id = lookup_element_id(config, element)?;
    }

    // Validate: exactly one of (feature, element) must be specified
    if (ftype_id > 0 && felem_id > 0) || (ftype_id < 0 && felem_id < 0) {
        return Err(SzConfigError::InvalidInput(
            "Either a feature or an element must be specified, but not both".to_string(),
        ));
    }

    // Determine exec_order
    let final_exec_order = if let Some(order) = params.exec_order {
        // Check if this exec_order is already taken for this feature/element
        let order_taken = config_data["G2_CONFIG"]["CFG_EFCALL"]
            .as_array()
            .map(|arr| {
                arr.iter().any(|call| {
                    call["FTYPE_ID"].as_i64() == Some(ftype_id)
                        && call["FELEM_ID"].as_i64() == Some(felem_id)
                        && call["EXEC_ORDER"].as_i64() == Some(order)
                })
            })
            .unwrap_or(false);

        if order_taken {
            return Err(SzConfigError::AlreadyExists(format!(
                "Execution order {order} already taken for this feature/element"
            )));
        }
        order
    } else {
        // Get next available exec_order for this feature/element combination
        config_data["G2_CONFIG"]["CFG_EFCALL"]
            .as_array()
            .map(|arr| {
                arr.iter()
                    .filter(|call| {
                        call["FTYPE_ID"].as_i64() == Some(ftype_id)
                            && call["FELEM_ID"].as_i64() == Some(felem_id)
                    })
                    .filter_map(|call| call["EXEC_ORDER"].as_i64())
                    .max()
                    .map(|max| max + 1)
                    .unwrap_or(1)
            })
            .unwrap_or(1)
    };

    // Lookup expression feature ID if specified
    let efeat_ftype_id = if let Some(expr_feat) = params
        .expression_feature
        .filter(|f| !f.eq_ignore_ascii_case("N/A"))
    {
        lookup_feature_id(config, expr_feat)?
    } else {
        -1
    };

    // Process element list and create EFBOM records
    let mut efbom_records = Vec::new();
    let mut bom_exec_order = 0;

    for (element_code, required, feature_opt) in params.element_list {
        bom_exec_order += 1;

        // Keep feature name for error messages (clone before consuming)
        let _bom_feature_name_for_errors = feature_opt.clone();

        // Determine BOM FTYPE_ID
        let bom_ftype_id =
            if let Some(bom_feature) = feature_opt.filter(|f| !f.eq_ignore_ascii_case("PARENT")) {
                if bom_feature.eq_ignore_ascii_case("parent") {
                    0 // Special value for parent feature link
                } else {
                    lookup_feature_id(config, &bom_feature)?
                }
            } else {
                -1
            };

        // Lookup element ID (always global lookup - feature field is just metadata for EFBOM)
        let bom_felem_id = lookup_element_id(config, &element_code)?;

        // Create EFBOM record
        efbom_records.push(json!({
            "EFCALL_ID": efcall_id,
            "FTYPE_ID": bom_ftype_id,
            "FELEM_ID": bom_felem_id,
            "EXEC_ORDER": bom_exec_order,
            "FELEM_REQ": required
        }));
    }

    // Create new CFG_EFCALL record
    let new_record = json!({
        "EFCALL_ID": efcall_id,
        "FTYPE_ID": ftype_id,
        "FELEM_ID": felem_id,
        "EFUNC_ID": efunc_id,
        "EXEC_ORDER": final_exec_order,
        "EFEAT_FTYPE_ID": efeat_ftype_id,
        "IS_VIRTUAL": params.is_virtual
    });

    // Add to config
    if let Some(efcall_array) = config_data["G2_CONFIG"]["CFG_EFCALL"].as_array_mut() {
        efcall_array.push(new_record.clone());
    } else {
        return Err(SzConfigError::MissingSection("CFG_EFCALL".to_string()));
    }

    if let Some(efbom_array) = config_data["G2_CONFIG"]["CFG_EFBOM"].as_array_mut() {
        efbom_array.extend(efbom_records);
    } else {
        return Err(SzConfigError::MissingSection("CFG_EFBOM".to_string()));
    }

    let modified_config =
        serde_json::to_string(&config_data).map_err(|e| SzConfigError::JsonParse(e.to_string()))?;

    Ok((modified_config, new_record))
}

/// Delete an expression call by ID
///
/// Also deletes associated EFBOM records.
///
/// # Arguments
/// * `config` - Configuration JSON string
/// * `efcall_id` - Expression call ID to delete
///
/// # Returns
/// Modified configuration JSON string
///
/// # Errors
/// - `NotFound` if call ID doesn't exist
pub fn delete_expression_call(config: &str, efcall_id: i64) -> Result<String> {
    let mut config_data: Value =
        serde_json::from_str(config).map_err(|e| SzConfigError::JsonParse(e.to_string()))?;

    // Validate that the call exists
    let call_exists = config_data["G2_CONFIG"]["CFG_EFCALL"]
        .as_array()
        .map(|arr| {
            arr.iter()
                .any(|call| call["EFCALL_ID"].as_i64() == Some(efcall_id))
        })
        .unwrap_or(false);

    if !call_exists {
        return Err(SzConfigError::NotFound(format!(
            "Expression call ID {efcall_id} does not exist"
        )));
    }

    // Delete the expression call
    if let Some(efcall_array) = config_data["G2_CONFIG"]["CFG_EFCALL"].as_array_mut() {
        efcall_array.retain(|record| record["EFCALL_ID"].as_i64() != Some(efcall_id));
    }

    // Delete associated EFBOM records
    if let Some(efbom_array) = config_data["G2_CONFIG"]["CFG_EFBOM"].as_array_mut() {
        efbom_array.retain(|record| record["EFCALL_ID"].as_i64() != Some(efcall_id));
    }

    serde_json::to_string(&config_data).map_err(|e| SzConfigError::JsonParse(e.to_string()))
}

/// Get a single expression call by ID
///
/// # Arguments
/// * `config` - Configuration JSON string
/// * `efcall_id` - Expression call ID
///
/// # Returns
/// JSON Value representing the expression call record
///
/// # Errors
/// - `NotFound` if call ID doesn't exist
pub fn get_expression_call(config: &str, efcall_id: i64) -> Result<Value> {
    find_in_config_array(config, "CFG_EFCALL", "EFCALL_ID", &efcall_id.to_string())?.ok_or_else(
        || SzConfigError::NotFound(format!("Expression call ID {efcall_id} does not exist")),
    )
}

/// List all expression calls with resolved names
///
/// Returns all expression calls with feature, element, and function codes resolved.
///
/// # Arguments
/// * `config` - Configuration JSON string
///
/// # Returns
/// Vector of JSON Values with resolved names
pub fn list_expression_calls(config: &str) -> Result<Vec<Value>> {
    let config_data: Value =
        serde_json::from_str(config).map_err(|e| SzConfigError::JsonParse(e.to_string()))?;

    let empty_array = vec![];
    let efcall_array = config_data
        .get("G2_CONFIG")
        .and_then(|g| g.get("CFG_EFCALL"))
        .and_then(|v| v.as_array())
        .unwrap_or(&empty_array);

    let ftype_array = config_data
        .get("G2_CONFIG")
        .and_then(|g| g.get("CFG_FTYPE"))
        .and_then(|v| v.as_array())
        .unwrap_or(&empty_array);

    let felem_array = config_data
        .get("G2_CONFIG")
        .and_then(|g| g.get("CFG_FELEM"))
        .and_then(|v| v.as_array())
        .unwrap_or(&empty_array);

    let efunc_array = config_data
        .get("G2_CONFIG")
        .and_then(|g| g.get("CFG_EFUNC"))
        .and_then(|v| v.as_array())
        .unwrap_or(&empty_array);

    // Helper functions for ID resolution
    let resolve_ftype = |ftype_id: i64| -> String {
        if ftype_id <= 0 {
            "all".to_string()
        } else {
            ftype_array
                .iter()
                .find(|ft| ft.get("FTYPE_ID").and_then(|v| v.as_i64()) == Some(ftype_id))
                .and_then(|ft| ft.get("FTYPE_CODE"))
                .and_then(|v| v.as_str())
                .unwrap_or("all")
                .to_string()
        }
    };

    let resolve_felem = |felem_id: i64| -> String {
        if felem_id <= 0 {
            "n/a".to_string()
        } else {
            felem_array
                .iter()
                .find(|fe| fe.get("FELEM_ID").and_then(|v| v.as_i64()) == Some(felem_id))
                .and_then(|fe| fe.get("FELEM_CODE"))
                .and_then(|v| v.as_str())
                .unwrap_or("n/a")
                .to_string()
        }
    };

    let resolve_efunc = |efunc_id: i64| -> String {
        efunc_array
            .iter()
            .find(|ef| ef.get("EFUNC_ID").and_then(|v| v.as_i64()) == Some(efunc_id))
            .and_then(|ef| ef.get("EFUNC_CODE"))
            .and_then(|v| v.as_str())
            .unwrap_or("unknown")
            .to_string()
    };

    // Transform expression calls
    let items: Vec<Value> = efcall_array
        .iter()
        .map(|item| {
            let ftype_id = item.get("FTYPE_ID").and_then(|v| v.as_i64()).unwrap_or(0);
            let felem_id = item.get("FELEM_ID").and_then(|v| v.as_i64()).unwrap_or(0);
            let efunc_id = item.get("EFUNC_ID").and_then(|v| v.as_i64()).unwrap_or(0);

            let efeat_ftype_id = item.get("EFEAT_FTYPE_ID").and_then(|v| v.as_i64()).unwrap_or(-1);

            json!({
                "id": item.get("EFCALL_ID").and_then(|v| v.as_i64()).unwrap_or(0),
                "feature": resolve_ftype(ftype_id),
                "element": resolve_felem(felem_id),
                "execOrder": item.get("EXEC_ORDER").and_then(|v| v.as_i64()).unwrap_or(0),
                "function": resolve_efunc(efunc_id),
                "isVirtual": item.get("IS_VIRTUAL").and_then(|v| v.as_str()).unwrap_or("No"),
                "expressionFeature": if efeat_ftype_id <= 0 { "n/a".to_string() } else { resolve_ftype(efeat_ftype_id) }
            })
        })
        .collect();

    Ok(items)
}

/// Update an expression call (stub - not implemented in Python)
///
/// # Arguments
/// * `config` - Configuration JSON string
/// * `params` - Expression call parameters (efcall_id required, others optional to update)
///
/// # Returns
/// Modified configuration JSON string
pub fn set_expression_call(config: &str, _params: SetExpressionCallParams) -> Result<String> {
    // This is a stub - the Python version doesn't implement this
    Ok(config.to_string())
}

/// Add an expression call element (EBOM record)
///
/// Creates a new expression bill of materials entry.
///
/// # Arguments
/// * `config` - Configuration JSON string
/// * `efcall_id` - Expression call ID
/// * `params` - Expression call element parameters
///
/// # Returns
/// Tuple of (modified_config, new_ebom_record)
pub fn add_expression_call_element(
    config: &str,
    efcall_id: i64,
    params: ExpressionCallElementParams,
) -> Result<(String, Value)> {
    let mut config_data: Value =
        serde_json::from_str(config).map_err(|e| SzConfigError::JsonParse(e.to_string()))?;

    // Validate ftype_id is a valid feature ID (not -1 sentinel value)
    if params.ftype_id < 0 {
        return Err(SzConfigError::InvalidInput(format!(
            "{} is not a valid feature ID",
            params.ftype_id
        )));
    }

    // Check if element already exists
    // Python duplicate check (line 2941): checks [call_id_field, "FTYPE_ID", "FELEM_ID"] - 3 fields only
    // EXEC_ORDER excluded from check because same element at different positions is still a duplicate
    if let Some(ebom_array) = config_data
        .get("G2_CONFIG")
        .and_then(|g| g.get("CFG_EFBOM"))
        .and_then(|v| v.as_array())
    {
        for item in ebom_array {
            if item.get("EFCALL_ID").and_then(|v| v.as_i64()) == Some(efcall_id)
                && item.get("FTYPE_ID").and_then(|v| v.as_i64()) == Some(params.ftype_id)
                && item.get("FELEM_ID").and_then(|v| v.as_i64()) == Some(params.felem_id)
            // && item.get("EXEC_ORDER").and_then(|v| v.as_i64()) == Some(params.exec_order)
            // ↑ Commented out: Python excludes EXEC_ORDER from duplicate check (sz_configtool line 2941)
            // Reason: Same element in same call is duplicate regardless of position/order
            {
                return Err(SzConfigError::AlreadyExists(
                    "Feature/element already exists for call".to_string(),
                ));
            }
        }
    }

    // Create new EBOM record (use params.exec_order directly - no auto-assignment)
    let new_record = json!({
        "EFCALL_ID": efcall_id,
        "FTYPE_ID": params.ftype_id,
        "FELEM_ID": params.felem_id,
        "EXEC_ORDER": params.exec_order,
        "FELEM_REQ": params.felem_req
    });

    // Add to CFG_EFBOM
    if let Some(ebom_array) = config_data["G2_CONFIG"]["CFG_EFBOM"].as_array_mut() {
        ebom_array.push(new_record.clone());
    } else {
        return Err(SzConfigError::MissingSection("CFG_EFBOM".to_string()));
    }

    let modified_config =
        serde_json::to_string(&config_data).map_err(|e| SzConfigError::JsonParse(e.to_string()))?;

    Ok((modified_config, new_record))
}

/// Delete an expression call element
///
/// # Arguments
/// * `config` - Configuration JSON string
/// * `efcall_id` - Expression call ID
/// * `key` - Expression call element key (identifying the element to delete)
///
/// # Returns
/// Modified configuration JSON string
pub fn delete_expression_call_element(
    config: &str,
    efcall_id: i64,
    key: ExpressionCallElementKey,
) -> Result<String> {
    let mut config_data: Value =
        serde_json::from_str(config).map_err(|e| SzConfigError::JsonParse(e.to_string()))?;

    // Validate that the element exists
    let element_exists = config_data["G2_CONFIG"]["CFG_EFBOM"]
        .as_array()
        .map(|arr| {
            arr.iter().any(|item| {
                item.get("EFCALL_ID").and_then(|v| v.as_i64()) == Some(efcall_id)
                    && item.get("FTYPE_ID").and_then(|v| v.as_i64()) == Some(key.ftype_id)
                    && item.get("FELEM_ID").and_then(|v| v.as_i64()) == Some(key.felem_id)
                    && item.get("EXEC_ORDER").and_then(|v| v.as_i64()) == Some(key.exec_order)
            })
        })
        .unwrap_or(false);

    if !element_exists {
        return Err(SzConfigError::NotFound(
            "Expression call element not found".to_string(),
        ));
    }

    // Delete the element
    if let Some(ebom_array) = config_data["G2_CONFIG"]["CFG_EFBOM"].as_array_mut() {
        ebom_array.retain(|item| {
            !(item.get("EFCALL_ID").and_then(|v| v.as_i64()) == Some(efcall_id)
                && item.get("FTYPE_ID").and_then(|v| v.as_i64()) == Some(key.ftype_id)
                && item.get("FELEM_ID").and_then(|v| v.as_i64()) == Some(key.felem_id)
                && item.get("EXEC_ORDER").and_then(|v| v.as_i64()) == Some(key.exec_order))
        });
    }

    serde_json::to_string(&config_data).map_err(|e| SzConfigError::JsonParse(e.to_string()))
}

/// Update an expression call element (stub - not typically used)
///
/// # Arguments
/// * `config` - Configuration JSON string
/// * `params` - Expression call element parameters (efcall_id, ftype_id, felem_id, exec_order, updates)
///
/// # Returns
/// Modified configuration JSON string
pub fn set_expression_call_element(
    config: &str,
    _params: ExpressionCallElementParams,
) -> Result<String> {
    // This is a stub - not commonly used
    Ok(config.to_string())
}