tellaro-query-language 3.0.1

//! List evaluation mutators for aggregate operations on arrays.
//!
//! Provides mutators that operate on array fields to compute aggregate values.

use super::{Mutator, MutatorParams};
use crate::error::Result;
use serde_json::{json, Value as JsonValue};

/// Mutator that evaluates if any element in a list is truthy
pub struct AnyMutator {
    _params: MutatorParams,
}

impl AnyMutator {
    pub fn new(params: MutatorParams) -> Self {
        Self { _params: params }
    }
}

impl Mutator for AnyMutator {
    fn apply(
        &self,
        _field_name: &str,
        _record: &JsonValue,
        value: &JsonValue,
    ) -> Result<JsonValue> {
        match value {
            JsonValue::Null => Ok(json!(false)),
            JsonValue::Array(arr) => {
                let result = arr.iter().any(is_truthy);
                Ok(json!(result))
            }
            _ => Ok(json!(is_truthy(value))),
        }
    }

    fn name(&self) -> &str {
        "any"
    }
}

/// Mutator that evaluates if all elements in a list are truthy
pub struct AllMutator {
    _params: MutatorParams,
}

impl AllMutator {
    pub fn new(params: MutatorParams) -> Self {
        Self { _params: params }
    }
}

impl Mutator for AllMutator {
    fn apply(
        &self,
        _field_name: &str,
        _record: &JsonValue,
        value: &JsonValue,
    ) -> Result<JsonValue> {
        match value {
            JsonValue::Null => Ok(json!(false)),
            JsonValue::Array(arr) => {
                let result = arr.iter().all(is_truthy);
                Ok(json!(result))
            }
            _ => Ok(json!(is_truthy(value))),
        }
    }

    fn name(&self) -> &str {
        "all"
    }
}

/// Mutator that calculates the average of numeric values
pub struct AvgMutator {
    _params: MutatorParams,
}

impl AvgMutator {
    pub fn new(params: MutatorParams) -> Self {
        Self { _params: params }
    }
}

impl Mutator for AvgMutator {
    fn apply(
        &self,
        _field_name: &str,
        _record: &JsonValue,
        value: &JsonValue,
    ) -> Result<JsonValue> {
        match value {
            JsonValue::Null => Ok(JsonValue::Null),
            JsonValue::Array(arr) => {
                let numeric_values: Vec<f64> = arr.iter().filter_map(to_numeric).collect();

                if numeric_values.is_empty() {
                    Ok(JsonValue::Null)
                } else {
                    let avg = numeric_values.iter().sum::<f64>() / numeric_values.len() as f64;
                    Ok(json!(avg))
                }
            }
            _ => {
                if let Some(num) = to_numeric(value) {
                    Ok(json!(num))
                } else {
                    Ok(JsonValue::Null)
                }
            }
        }
    }

    fn name(&self) -> &str {
        "avg"
    }
}

/// Alias for AvgMutator
pub struct AverageMutator {
    params: MutatorParams,
}

impl AverageMutator {
    pub fn new(params: MutatorParams) -> Self {
        Self { params }
    }
}

impl Mutator for AverageMutator {
    fn apply(&self, field_name: &str, record: &JsonValue, value: &JsonValue) -> Result<JsonValue> {
        let avg_mutator = AvgMutator::new(self.params.clone());
        avg_mutator.apply(field_name, record, value)
    }

    fn name(&self) -> &str {
        "average"
    }
}

/// Mutator that calculates the sum of numeric values
pub struct SumMutator {
    _params: MutatorParams,
}

impl SumMutator {
    pub fn new(params: MutatorParams) -> Self {
        Self { _params: params }
    }
}

impl Mutator for SumMutator {
    fn apply(
        &self,
        _field_name: &str,
        _record: &JsonValue,
        value: &JsonValue,
    ) -> Result<JsonValue> {
        match value {
            JsonValue::Null => Ok(json!(0.0)),
            JsonValue::Array(arr) => {
                let sum: f64 = arr.iter().filter_map(to_numeric).sum();
                Ok(json!(sum))
            }
            _ => {
                if let Some(num) = to_numeric(value) {
                    Ok(json!(num))
                } else {
                    Ok(json!(0.0))
                }
            }
        }
    }

    fn name(&self) -> &str {
        "sum"
    }
}

/// Mutator that finds the maximum numeric value
pub struct MaxMutator {
    _params: MutatorParams,
}

impl MaxMutator {
    pub fn new(params: MutatorParams) -> Self {
        Self { _params: params }
    }
}

impl Mutator for MaxMutator {
    fn apply(
        &self,
        _field_name: &str,
        _record: &JsonValue,
        value: &JsonValue,
    ) -> Result<JsonValue> {
        match value {
            JsonValue::Null => Ok(JsonValue::Null),
            JsonValue::Array(arr) => {
                let max = arr
                    .iter()
                    .filter_map(to_numeric)
                    .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));

                if let Some(max_val) = max {
                    Ok(json!(max_val))
                } else {
                    Ok(JsonValue::Null)
                }
            }
            _ => {
                if let Some(num) = to_numeric(value) {
                    Ok(json!(num))
                } else {
                    Ok(JsonValue::Null)
                }
            }
        }
    }

    fn name(&self) -> &str {
        "max"
    }
}

/// Mutator that finds the minimum numeric value
pub struct MinMutator {
    _params: MutatorParams,
}

impl MinMutator {
    pub fn new(params: MutatorParams) -> Self {
        Self { _params: params }
    }
}

impl Mutator for MinMutator {
    fn apply(
        &self,
        _field_name: &str,
        _record: &JsonValue,
        value: &JsonValue,
    ) -> Result<JsonValue> {
        match value {
            JsonValue::Null => Ok(JsonValue::Null),
            JsonValue::Array(arr) => {
                let min = arr
                    .iter()
                    .filter_map(to_numeric)
                    .min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));

                if let Some(min_val) = min {
                    Ok(json!(min_val))
                } else {
                    Ok(JsonValue::Null)
                }
            }
            _ => {
                if let Some(num) = to_numeric(value) {
                    Ok(json!(num))
                } else {
                    Ok(JsonValue::Null)
                }
            }
        }
    }

    fn name(&self) -> &str {
        "min"
    }
}

/// Helper function to determine if a value is truthy
fn is_truthy(value: &JsonValue) -> bool {
    match value {
        JsonValue::Null => false,
        JsonValue::Bool(b) => *b,
        JsonValue::Number(n) => n.as_f64().unwrap_or(0.0) != 0.0,
        JsonValue::String(s) => !s.is_empty(),
        JsonValue::Array(arr) => !arr.is_empty(),
        JsonValue::Object(obj) => !obj.is_empty(),
    }
}

/// Helper function to convert value to numeric
fn to_numeric(value: &JsonValue) -> Option<f64> {
    match value {
        JsonValue::Number(n) => n.as_f64(),
        JsonValue::String(s) => s.parse::<f64>().ok(),
        JsonValue::Bool(b) => Some(if *b { 1.0 } else { 0.0 }),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;
    use std::collections::HashMap;

    #[test]
    fn test_any_mutator() {
        let mutator = AnyMutator::new(HashMap::new());
        let record = json!({});

        // Test array with truthy values
        let value = json!([true, false, true]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(true));

        // Test array with all falsy values
        let value = json!([false, 0, ""]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(false));

        // Test single value
        let value = json!(42);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(true));

        // Test null
        let value = JsonValue::Null;
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(false));
    }

    #[test]
    fn test_all_mutator() {
        let mutator = AllMutator::new(HashMap::new());
        let record = json!({});

        // Test array with all truthy values
        let value = json!([true, 1, "hello"]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(true));

        // Test array with some falsy values
        let value = json!([true, false, true]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(false));

        // Test empty array (should be true, following Python's all() behavior)
        let value = json!([]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(true));
    }

    #[test]
    fn test_avg_mutator() {
        let mutator = AvgMutator::new(HashMap::new());
        let record = json!({});

        // Test numeric array
        let value = json!([10, 20, 30]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(20.0));

        // Test mixed array (strings that can be parsed)
        let value = json!([10, "20", 30]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(20.0));

        // Test single value
        let value = json!(42);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(42.0));

        // Test empty array
        let value = json!([]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, JsonValue::Null);
    }

    #[test]
    fn test_sum_mutator() {
        let mutator = SumMutator::new(HashMap::new());
        let record = json!({});

        // Test numeric array
        let value = json!([10, 20, 30]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(60.0));

        // Test single value
        let value = json!(42);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(42.0));

        // Test null
        let value = JsonValue::Null;
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(0.0));
    }

    #[test]
    fn test_max_mutator() {
        let mutator = MaxMutator::new(HashMap::new());
        let record = json!({});

        // Test numeric array
        let value = json!([10, 50, 30]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(50.0));

        // Test single value
        let value = json!(42);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(42.0));
    }

    #[test]
    fn test_min_mutator() {
        let mutator = MinMutator::new(HashMap::new());
        let record = json!({});

        // Test numeric array
        let value = json!([10, 50, 30]);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(10.0));

        // Test single value
        let value = json!(42);
        let result = mutator.apply("field", &record, &value).unwrap();
        assert_eq!(result, json!(42.0));
    }
}