dol/

eval.rs

//! Expression evaluation engine.
//!
//! Evaluates DOL [`Expression`] nodes against JSON-like field maps.
//! Supports arithmetic, comparison, boolean logic, function calls
//! (`upper`, `lower`, `date_format`, `coalesce`, etc.), and `CASE`/`IF`
//! expressions.
//!
//! # Example
//!
//! ```ignore
//! let fields = BTreeMap::from([("cpu", json!(87.5))]);
//! let expr = Expression::Comparison { left: ..., operator: Gt, right: ... };
//! assert!(eval::evaluate_expression(&fields, &expr)?);
//! ```

use std::borrow::Cow;
use std::cmp::Ordering;
use std::collections::BTreeMap;

use serde_json::{Number, Value as JsonValue};
use thiserror::Error;

use chrono::{Datelike, NaiveDateTime, Timelike};

use crate::ast::{BinOp, Expression, Operator, SetValue, Value};
use crate::{ANSI_BOLD, ANSI_FG_CYAN, ANSI_FG_RED, ANSI_FG_YELLOW, ANSI_RESET};

impl EvalError {
    /// Return a fully ANSI-coloured error string suitable for terminal display.
    #[must_use]
    pub fn format_color(&self) -> String {
        use std::fmt::Write;
        let mut out = String::new();

        write!(
            out,
            "{bold}{red}error{reset}: {msg}",
            bold = ANSI_BOLD,
            red = ANSI_FG_RED,
            reset = ANSI_RESET,
            msg = self,
        )
        .expect("write! to String is infallible");

        match self {
            EvalError::UnsupportedField { field } => {
                write!(
                    out,
                    "\n  {yellow}help{reset}: field `{field}` does not exist on this target",
                    yellow = ANSI_FG_YELLOW,
                    reset = ANSI_RESET,
                    field = field,
                )
                .expect("write! to String is infallible");
                write!(
                    out,
                    "\n  {cyan}note{reset}: use `fields <target>` to list available fields",
                    cyan = ANSI_FG_CYAN,
                    reset = ANSI_RESET,
                )
                .expect("write! to String is infallible");
            }
            EvalError::InvalidComparison { field, operator } => {
                write!(
                    out,
                    "\n  {yellow}help{reset}: field `{field}` cannot be used with operator `{operator}`",
                    yellow = ANSI_FG_YELLOW,
                    reset = ANSI_RESET,
                    field = field,
                    operator = operator,
                )
                .expect("write! to String is infallible");
            }
            EvalError::UnknownFunction { name } => {
                write!(
                    out,
                    "\n  {yellow}help{reset}: `{name}` is not a known function",
                    yellow = ANSI_FG_YELLOW,
                    reset = ANSI_RESET,
                    name = name,
                )
                .expect("write! to String is infallible");
            }
            EvalError::InvalidArguments { name } => {
                write!(
                    out,
                    "\n  {yellow}help{reset}: check the arguments for `{name}()`",
                    yellow = ANSI_FG_YELLOW,
                    reset = ANSI_RESET,
                    name = name,
                )
                .expect("write! to String is infallible");
            }
            _ => {}
        }

        out
    }
}

#[derive(Debug, Error)]
pub enum EvalError {
    #[error("unsupported field `{field}`")]
    UnsupportedField { field: String },
    #[error("field `{field}` cannot be compared with operator `{operator}`")]
    InvalidComparison { field: String, operator: String },
    #[error("arithmetic error: {0}")]
    Arithmetic(String),
    #[error("unknown function `{name}`")]
    UnknownFunction { name: String },
    #[error("invalid arguments for `{name}`")]
    InvalidArguments { name: String },
}

/// Evaluate any expression to a JSON value.
pub fn eval_expr(
    fields: &BTreeMap<String, JsonValue>,
    expression: &Expression,
) -> Result<JsonValue, EvalError> {
    match expression {
        Expression::Field(field) => resolve_field(fields, field).map(std::borrow::Cow::into_owned),

        Expression::Literal(value) => Ok(value_to_json(value)),

        Expression::Arithmetic { left, op, right } => {
            let l = eval_expr(fields, left)?;
            let r = eval_expr(fields, right)?;
            apply_arithmetic(&l, *op, &r)
        }

        Expression::Comparison {
            left,
            operator,
            right,
        } => {
            let result = eval_bool_expr(fields, left, *operator, right)?;
            Ok(JsonValue::Bool(result))
        }

        Expression::In { expr, values } => {
            let actual = eval_expr(fields, expr)?;
            for v in values {
                if json_value_eq(&actual, v) {
                    return Ok(JsonValue::Bool(true));
                }
            }
            Ok(JsonValue::Bool(false))
        }

        Expression::Between { expr, low, high } => {
            let val = eval_expr(fields, expr)?;
            let l = eval_expr(fields, low)?;
            let h = eval_expr(fields, high)?;
            let vf = json_as_f64(&val);
            let lf = json_as_f64(&l);
            let hf = json_as_f64(&h);
            match (vf, lf, hf) {
                (Some(v), Some(l), Some(h)) => Ok(JsonValue::Bool(v >= l && v <= h)),
                _ => Ok(JsonValue::Bool(false)),
            }
        }

        Expression::IsNull(expr) => {
            let val = eval_expr_opt(fields, expr);
            let is_null = match val {
                None | Some(JsonValue::Null) => true,
                Some(val) if val.is_string() && val.as_str().unwrap_or("").is_empty() => true,
                _ => false,
            };
            Ok(JsonValue::Bool(is_null))
        }

        Expression::IsNotNull(expr) => {
            let val = eval_expr_opt(fields, expr);
            let is_not_null = match val {
                None | Some(JsonValue::Null) => false,
                Some(val) if val.is_string() && val.as_str().unwrap_or("").is_empty() => false,
                _ => true,
            };
            Ok(JsonValue::Bool(is_not_null))
        }

        Expression::FnCall { name, args } => {
            let evaluated: Result<Vec<JsonValue>, _> =
                args.iter().map(|a| eval_expr(fields, a)).collect();
            apply_function(name, &evaluated?)
        }

        Expression::And(left, right) => {
            let l = eval_bool(fields, left)?;
            if !l {
                return Ok(JsonValue::Bool(false));
            }
            let r = eval_bool(fields, right)?;
            Ok(JsonValue::Bool(r))
        }

        Expression::Or(left, right) => {
            let l = eval_bool(fields, left)?;
            if l {
                return Ok(JsonValue::Bool(true));
            }
            let r = eval_bool(fields, right)?;
            Ok(JsonValue::Bool(r))
        }

        Expression::Not(expr) => {
            let val = eval_bool(fields, expr)?;
            Ok(JsonValue::Bool(!val))
        }
    }
}

/// Like `eval_expr` but returns None instead of erroring on missing fields.
fn eval_expr_opt(
    fields: &BTreeMap<String, JsonValue>,
    expression: &Expression,
) -> Option<JsonValue> {
    match expression {
        Expression::Field(field) => fields.get(field).cloned().or_else(|| {
            // Also try label.xxx access
            if let Some(label_key) = field.strip_prefix("label.")
                && let Some(JsonValue::Array(items)) = fields.get("labels")
            {
                for item in items {
                    if let JsonValue::String(entry) = item
                        && let Some(eq_pos) = entry.find('=')
                    {
                        let key = &entry[..eq_pos];
                        let val = &entry[eq_pos + 1..];
                        if key == label_key {
                            return Some(JsonValue::String(val.to_owned()));
                        }
                    }
                }
            }
            None
        }),
        Expression::Literal(value) => Some(value_to_json(value)),
        _ => eval_expr(fields, expression).ok(),
    }
}

/// Evaluate an expression as a boolean (for `where`, `if` contexts).
pub fn eval_bool(
    fields: &BTreeMap<String, JsonValue>,
    expression: &Expression,
) -> Result<bool, EvalError> {
    let val = eval_expr(fields, expression)?;
    Ok(json_is_truthy(&val))
}

/// Legacy wrapper — kept for backward compatibility.
pub fn evaluate_expression(
    fields: &BTreeMap<String, JsonValue>,
    expression: &Expression,
) -> Result<bool, EvalError> {
    eval_bool(fields, expression)
}

fn json_is_truthy(val: &JsonValue) -> bool {
    match val {
        JsonValue::Null => false,
        JsonValue::Bool(b) => *b,
        JsonValue::Number(n) => n.as_f64().is_some_and(|f| f != 0.0),
        JsonValue::String(s) => !s.is_empty() && s != "0" && s.to_lowercase() != "false",
        JsonValue::Array(a) => !a.is_empty(),
        JsonValue::Object(_) => true,
    }
}

fn eval_bool_expr(
    fields: &BTreeMap<String, JsonValue>,
    left: &Expression,
    operator: Operator,
    right: &Expression,
) -> Result<bool, EvalError> {
    let l = eval_expr(fields, left)?;
    let r = eval_expr(fields, right)?;

    match operator {
        Operator::Eq => Ok(json_eq(&l, &r)),
        Operator::NotEq => Ok(!json_eq(&l, &r)),
        Operator::Contains => {
            json_contains_val(&l, &r).ok_or_else(|| EvalError::InvalidComparison {
                field: format!("{l:?}"),
                operator: "Contains".to_owned(),
            })
        }
        Operator::Matches => {
            let pattern = match &r {
                JsonValue::String(s) => s.clone(),
                _ => {
                    return Err(EvalError::InvalidComparison {
                        field: format!("{l:?}"),
                        operator: "Matches".to_owned(),
                    });
                }
            };
            let re = regex::Regex::new(&pattern).map_err(|_| EvalError::InvalidComparison {
                field: format!("{l:?}"),
                operator: "Matches (invalid regex)".to_owned(),
            })?;
            match &l {
                JsonValue::String(s) => Ok(re.is_match(s)),
                JsonValue::Array(values) => Ok(values.iter().any(|v| {
                    let s = render_json_cell(v);
                    re.is_match(&s)
                })),
                _ => Err(EvalError::InvalidComparison {
                    field: format!("{l:?}"),
                    operator: "Matches".to_owned(),
                }),
            }
        }
        Operator::StartsWith => {
            let l_str = match &l {
                JsonValue::String(s) => s.clone(),
                _ => {
                    return Err(EvalError::InvalidComparison {
                        field: format!("{l:?}"),
                        operator: "StartsWith".to_owned(),
                    });
                }
            };
            let r_str = match &r {
                JsonValue::String(s) => s.clone(),
                _ => {
                    return Err(EvalError::InvalidComparison {
                        field: format!("{r:?}"),
                        operator: "StartsWith".to_owned(),
                    });
                }
            };
            Ok(l_str.starts_with(&r_str))
        }
        Operator::EndsWith => {
            let l_str = match &l {
                JsonValue::String(s) => s.clone(),
                _ => {
                    return Err(EvalError::InvalidComparison {
                        field: format!("{l:?}"),
                        operator: "EndsWith".to_owned(),
                    });
                }
            };
            let r_str = match &r {
                JsonValue::String(s) => s.clone(),
                _ => {
                    return Err(EvalError::InvalidComparison {
                        field: format!("{r:?}"),
                        operator: "EndsWith".to_owned(),
                    });
                }
            };
            Ok(l_str.ends_with(&r_str))
        }
        Operator::Gt | Operator::Lt | Operator::Gte | Operator::Lte => {
            let ln = json_as_f64(&l).ok_or_else(|| EvalError::InvalidComparison {
                field: format!("{l:?}"),
                operator: format!("{operator:?}"),
            })?;
            let rn = json_as_f64(&r).ok_or_else(|| EvalError::InvalidComparison {
                field: format!("{r:?}"),
                operator: format!("{operator:?}"),
            })?;
            Ok(match operator {
                Operator::Gt => ln > rn,
                Operator::Lt => ln < rn,
                Operator::Gte => ln >= rn,
                Operator::Lte => ln <= rn,
                _ => unreachable!(),
            })
        }
    }
}

fn apply_arithmetic(
    left: &JsonValue,
    op: BinOp,
    right: &JsonValue,
) -> Result<JsonValue, EvalError> {
    let l = json_as_f64(left)
        .ok_or_else(|| EvalError::Arithmetic(format!("left operand is not numeric: {left:?}")))?;
    let r = json_as_f64(right)
        .ok_or_else(|| EvalError::Arithmetic(format!("right operand is not numeric: {right:?}")))?;
    let result = match op {
        BinOp::Add => l + r,
        BinOp::Sub => l - r,
        BinOp::Mul => l * r,
        BinOp::Div => {
            if r == 0.0 {
                return Err(EvalError::Arithmetic("division by zero".to_owned()));
            }
            l / r
        }
        BinOp::Mod => {
            if r == 0.0 {
                return Err(EvalError::Arithmetic("modulo by zero".to_owned()));
            }
            l % r
        }
    };
    Number::from_f64(result)
        .map(JsonValue::Number)
        .ok_or_else(|| EvalError::Arithmetic("result is NaN or infinity".to_owned()))
}

fn apply_function(name: &str, args: &[JsonValue]) -> Result<JsonValue, EvalError> {
    match name {
        "upper" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::String(s.to_uppercase()))
        }
        "lower" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::String(s.to_lowercase()))
        }
        "length" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::Number(Number::from(s.len() as u64)))
        }
        "trim" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::String(s.trim().to_owned()))
        }
        "concat" => {
            let result: String = args.iter().map(render_json_cell).collect();
            Ok(JsonValue::String(result))
        }
        "substring" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let start = args.get(1).and_then(json_as_f64).map_or(0, |f| f as usize);
            let len = args
                .get(2)
                .and_then(json_as_f64)
                .map_or(s.len(), |f| f as usize);
            let end = (start + len).min(s.len());
            let sub = if start < s.len() { &s[start..end] } else { "" };
            Ok(JsonValue::String(sub.to_owned()))
        }
        "coalesce" => {
            for arg in args {
                if !(matches!(arg, JsonValue::Null)
                    || arg.is_string() && arg.as_str().unwrap_or("").is_empty())
                {
                    return Ok(arg.clone());
                }
            }
            Ok(JsonValue::Null)
        }
        "starts_with" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let prefix = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::Bool(s.starts_with(prefix)))
        }
        "ends_with" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let suffix = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::Bool(s.ends_with(suffix)))
        }
        "replace" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let from = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let to = args.get(2).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::String(s.replace(from, to)))
        }
        "reverse" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            Ok(JsonValue::String(s.chars().rev().collect()))
        }
        "repeat" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let n = args.get(1).and_then(json_as_f64).map_or(0, |f| f as usize);
            Ok(JsonValue::String(s.repeat(n)))
        }
        "position" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let substr = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let pos = s.find(substr).map_or(0, |i| i as u64);
            Ok(JsonValue::Number(Number::from(pos)))
        }
        "now" => Ok(JsonValue::String(chrono::Utc::now().to_rfc3339())),
        "date_format" => {
            let ts = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let fmt = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let dt = parse_timestamp(ts)?;
            let result = dt.format(fmt).to_string();
            Ok(JsonValue::String(result))
        }
        "date_diff" => {
            let a = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let b = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let unit = args.get(2).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let dt_a = parse_timestamp(a)?;
            let dt_b = parse_timestamp(b)?;
            let diff = dt_b.signed_duration_since(dt_a);
            let result = match unit {
                "seconds" | "s" => diff.num_seconds(),
                "minutes" | "m" => diff.num_minutes(),
                "hours" | "h" => diff.num_hours(),
                "days" | "d" => diff.num_days(),
                _ => {
                    return Err(EvalError::InvalidArguments {
                        name: name.to_owned(),
                    });
                }
            };
            Ok(JsonValue::Number(Number::from(result)))
        }
        "extract" => {
            let ts = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let part = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let dt = parse_timestamp(ts)?;
            let result = match part {
                "year" => i64::from(dt.year()),
                "month" => i64::from(dt.month()),
                "day" => i64::from(dt.day()),
                "hour" => i64::from(dt.hour()),
                "minute" => i64::from(dt.minute()),
                "second" => i64::from(dt.second()),
                _ => {
                    return Err(EvalError::InvalidArguments {
                        name: name.to_owned(),
                    });
                }
            };
            Ok(JsonValue::Number(Number::from(result)))
        }
        "split_part" => {
            let s = args.first().and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let delim = args.get(1).and_then(|v| v.as_str()).ok_or_else(|| {
                EvalError::InvalidArguments {
                    name: name.to_owned(),
                }
            })?;
            let n = args.get(2).and_then(json_as_f64).map_or(1, |f| f as usize);
            let part = s
                .split(delim)
                .nth(n.saturating_sub(1))
                .unwrap_or("")
                .to_owned();
            Ok(JsonValue::String(part))
        }
        "to_int" => {
            let val = args.first().ok_or_else(|| EvalError::InvalidArguments {
                name: name.to_owned(),
            })?;
            let result = match val {
                JsonValue::Number(n) => n.as_f64().map(|f| f as i64).unwrap_or(0),
                JsonValue::String(s) => {
                    if let Ok(n) = s.parse::<i64>() {
                        n
                    } else if let Ok(f) = s.parse::<f64>() {
                        f as i64
                    } else {
                        0
                    }
                }
                JsonValue::Bool(b) => i64::from(*b),
                _ => 0,
            };
            Ok(JsonValue::Number(Number::from(result)))
        }
        "to_float" => {
            let val = args.first().ok_or_else(|| EvalError::InvalidArguments {
                name: name.to_owned(),
            })?;
            let result = json_as_f64(val).unwrap_or(0.0);
            Number::from_f64(result)
                .map(JsonValue::Number)
                .ok_or_else(|| EvalError::InvalidArguments {
                    name: name.to_owned(),
                })
        }
        "to_string" => {
            let val = args.first().ok_or_else(|| EvalError::InvalidArguments {
                name: name.to_owned(),
            })?;
            Ok(JsonValue::String(render_json_cell(val)))
        }
        _ => Err(EvalError::UnknownFunction {
            name: name.to_owned(),
        }),
    }
}

fn parse_timestamp(s: &str) -> Result<NaiveDateTime, EvalError> {
    // Try ISO 8601 format first, then common formats
    if let Ok(dt) = chrono::DateTime::parse_from_rfc3339(s) {
        return Ok(dt.naive_utc());
    }
    if let Ok(dt) = chrono::DateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S") {
        return Ok(dt.naive_utc());
    }
    if let Ok(dt) = NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S") {
        return Ok(dt);
    }
    if let Ok(dt) = NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f") {
        return Ok(dt);
    }
    if let Ok(dt) = NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S%.fZ") {
        return Ok(dt);
    }
    Err(EvalError::InvalidArguments {
        name: "timestamp".to_owned(),
    })
}

fn resolve_field<'a>(
    fields: &'a BTreeMap<String, JsonValue>,
    field: &str,
) -> Result<Cow<'a, JsonValue>, EvalError> {
    if let Some(value) = fields.get(field) {
        return Ok(Cow::Borrowed(value));
    }

    if let Some(label_key) = field.strip_prefix("label.") {
        let labels = fields
            .get("labels")
            .ok_or_else(|| EvalError::UnsupportedField {
                field: field.to_owned(),
            })?;

        match labels {
            JsonValue::Array(items) => {
                for item in items {
                    if let JsonValue::String(entry) = item
                        && let Some(eq_pos) = entry.find('=')
                    {
                        let key = &entry[..eq_pos];
                        let val = &entry[eq_pos + 1..];
                        if key == label_key {
                            return Ok(Cow::Owned(JsonValue::String(val.to_owned())));
                        }
                    }
                }
            }
            JsonValue::String(s) => {
                for entry in s.split(',') {
                    let entry = entry.trim();
                    if let Some(eq_pos) = entry.find('=') {
                        let key = &entry[..eq_pos];
                        let val = &entry[eq_pos + 1..];
                        if key == label_key {
                            return Ok(Cow::Owned(JsonValue::String(val.to_owned())));
                        }
                    }
                }
            }
            _ => {}
        }

        return Err(EvalError::UnsupportedField {
            field: field.to_owned(),
        });
    }

    fields
        .get(field)
        .ok_or_else(|| EvalError::UnsupportedField {
            field: field.to_owned(),
        })
        .map(Cow::Borrowed)
}

pub fn evaluate_set_value(
    fields: &BTreeMap<String, JsonValue>,
    set_value: &SetValue,
) -> Result<JsonValue, EvalError> {
    match set_value {
        SetValue::Literal(value) => Ok(value_to_json(value)),
        SetValue::Expr(expr) => eval_expr(fields, expr),
        SetValue::Case {
            when_clauses,
            else_value,
        } => {
            for (condition, result) in when_clauses {
                if eval_bool(fields, condition)? {
                    return eval_expr(fields, result);
                }
            }
            Ok(else_value
                .as_ref()
                .map_or(Ok(JsonValue::Null), |expr| eval_expr(fields, expr))?)
        }
        SetValue::IfElse {
            condition,
            then_value,
            else_value,
        } => {
            if eval_bool(fields, condition)? {
                eval_expr(fields, then_value)
            } else {
                Ok(else_value
                    .as_ref()
                    .map_or(Ok(JsonValue::Null), |expr| eval_expr(fields, expr))?)
            }
        }
    }
}

pub fn value_to_json(value: &Value) -> JsonValue {
    match value {
        Value::String(s) | Value::Identifier(s) => JsonValue::String(s.clone()),
        Value::Integer(n) => JsonValue::Number(Number::from(*n)),
        Value::Float(f) | Value::Percentage(f) => {
            Number::from_f64(*f).map_or(JsonValue::Null, JsonValue::Number)
        }
        Value::Boolean(b) => JsonValue::Bool(*b),
    }
}

#[must_use]
pub fn json_eq(left: &JsonValue, right: &JsonValue) -> bool {
    match (left, right) {
        (JsonValue::String(a), JsonValue::String(b)) => a == b,
        (JsonValue::Bool(a), JsonValue::Bool(b)) => a == b,
        (JsonValue::Number(a), _) => a.as_f64() == json_as_f64(right),
        (_, JsonValue::Number(b)) => json_as_f64(left) == b.as_f64(),
        _ => left == right,
    }
}

// Kept for backward compat with the few external callers
#[must_use]
pub fn json_value_eq(actual: &JsonValue, expected: &Value) -> bool {
    match (actual, expected) {
        (JsonValue::String(actual), Value::String(expected) | Value::Identifier(expected)) => {
            actual == expected
        }
        (JsonValue::Bool(actual), Value::Boolean(expected)) => actual == expected,
        (JsonValue::Number(actual), expected) => actual.as_f64() == value_as_f64(expected),
        _ => false,
    }
}

#[must_use]
pub fn json_contains_val(actual: &JsonValue, expected: &JsonValue) -> Option<bool> {
    let expected_str = match expected {
        JsonValue::String(s) => s.clone(),
        other => other.to_string(),
    };

    match actual {
        JsonValue::String(actual) => Some(actual.contains(&expected_str)),
        JsonValue::Array(values) => Some(values.iter().any(|value| match value {
            JsonValue::String(actual) => actual.contains(&expected_str),
            other => other.to_string().contains(&expected_str),
        })),
        _ => None,
    }
}

// Keep old signature for backward compat
#[must_use]
pub fn json_contains(actual: &JsonValue, expected: &Value) -> Option<bool> {
    json_contains_val(actual, &value_to_json(expected))
}

#[must_use]
pub fn compare_json_values(left: &JsonValue, right: &JsonValue) -> Ordering {
    match (json_as_f64(left), json_as_f64(right)) {
        (Some(left), Some(right)) => left.partial_cmp(&right).unwrap_or(Ordering::Equal),
        _ => render_json_cell(left).cmp(&render_json_cell(right)),
    }
}

/// Parse a human-readable byte size string (e.g. "93.6MB", "28.7GB", "155MB",
/// "13.1MB", "1024", "1.5KiB") into bytes as f64.
fn parse_byte_size(s: &str) -> Option<f64> {
    let s = s.trim();
    if s.is_empty() {
        return None;
    }

    // Split number from unit suffix.
    // The number can be an integer or decimal.
    let (num_str, unit) = {
        let trimmed = s.trim_end();
        // Find where the numeric part ends
        let num_end = trimmed
            .char_indices()
            .take_while(|(_, c)| c.is_ascii_digit() || *c == '.')
            .last()
            .map_or(0, |(i, _)| i + 1);
        if num_end == 0 {
            // No leading digits — try direct parse
            return s.parse::<f64>().ok();
        }
        let num_part = &trimmed[..num_end];
        let unit_part = trimmed[num_end..].trim();
        (num_part, unit_part)
    };

    let number: f64 = num_str.parse().ok()?;

    if unit.is_empty() {
        return Some(number);
    }

    let multiplier = match unit.to_lowercase().as_str() {
        "b" => 1.0,
        "kb" | "k" => 1_000.0,
        "mb" | "m" => 1_000_000.0,
        "gb" | "g" => 1_000_000_000.0,
        "tb" | "t" => 1_000_000_000_000.0,
        "kib" | "ki" => 1024.0,
        "mib" | "mi" => 1024.0 * 1024.0,
        "gib" | "gi" => 1024.0 * 1024.0 * 1024.0,
        "tib" | "ti" => 1024.0 * 1024.0 * 1024.0 * 1024.0,
        _ => return None,
    };

    Some(number * multiplier)
}

#[must_use]
pub fn json_as_f64(value: &JsonValue) -> Option<f64> {
    match value {
        JsonValue::Number(value) => value.as_f64(),
        JsonValue::String(value) => {
            // Try direct parse first (fast path for plain numbers)
            if let Ok(n) = value.parse::<f64>() {
                return Some(n);
            }
            // Fall back to byte-size parsing for human-readable sizes
            parse_byte_size(value)
        }
        _ => None,
    }
}

#[must_use]
pub fn value_as_f64(value: &Value) -> Option<f64> {
    match value {
        Value::Integer(value) => Some(*value as f64),
        Value::Float(value) | Value::Percentage(value) => Some(*value),
        Value::String(value) | Value::Identifier(value) => value.parse().ok(),
        Value::Boolean(_) => None,
    }
}

#[must_use]
pub fn value_as_text(value: &Value) -> Option<String> {
    match value {
        Value::String(value) | Value::Identifier(value) => Some(value.clone()),
        Value::Integer(value) => Some(value.to_string()),
        Value::Float(value) | Value::Percentage(value) => Some(value.to_string()),
        Value::Boolean(value) => Some(value.to_string()),
    }
}

pub fn render_json_cell(value: &JsonValue) -> String {
    match value {
        JsonValue::Null => String::new(),
        JsonValue::String(value) => value.clone(),
        JsonValue::Array(values) => values
            .iter()
            .map(render_json_cell)
            .collect::<Vec<_>>()
            .join(","),
        other => other.to_string(),
    }
}

#[cfg(test)]
mod tests {
    fn cmp_expr(field: &str, op: Operator, val: Value) -> Expression {
        Expression::Comparison {
            left: Box::new(Expression::Field(field.to_owned())),
            operator: op,
            right: Box::new(Expression::Literal(val)),
        }
    }

    fn in_expr(field: &str, values: Vec<Value>) -> Expression {
        Expression::In {
            expr: Box::new(Expression::Field(field.to_owned())),
            values,
        }
    }
    use super::*;

    fn fields(pairs: &[(&str, &str)]) -> BTreeMap<String, JsonValue> {
        pairs
            .iter()
            .map(|(k, v)| (k.to_string(), JsonValue::String(v.to_string())))
            .collect()
    }

    #[test]
    fn evaluates_string_equality() {
        let f = fields(&[("status", "running")]);
        let expr = cmp_expr("status", Operator::Eq, Value::String("running".into()));
        assert!(evaluate_expression(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_numeric_comparison() {
        let mut f = BTreeMap::new();
        f.insert("cpu".into(), serde_json::json!(87.5));
        let expr = cmp_expr("cpu", Operator::Gt, Value::Percentage(80.0));
        assert!(evaluate_expression(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_and_or_not() {
        let f = fields(&[("a", "1"), ("b", "2")]);
        let left = cmp_expr("a", Operator::Eq, Value::String("1".into()));
        let right = cmp_expr("b", Operator::Eq, Value::String("9".into()));
        assert!(
            evaluate_expression(
                &f,
                &Expression::Or(Box::new(left.clone()), Box::new(right.clone()))
            )
            .unwrap()
        );
        assert!(
            !evaluate_expression(&f, &Expression::And(Box::new(left), Box::new(right))).unwrap()
        );
    }

    #[test]
    fn evaluates_set_case() {
        let mut f = BTreeMap::new();
        f.insert("cpu".into(), serde_json::json!(87.5));
        let sv = SetValue::Case {
            when_clauses: vec![
                (
                    cmp_expr("cpu", Operator::Gt, Value::Percentage(80.0)),
                    Expression::Literal(Value::String("critical".into())),
                ),
                (
                    cmp_expr("cpu", Operator::Gt, Value::Percentage(50.0)),
                    Expression::Literal(Value::String("warning".into())),
                ),
            ],
            else_value: Some(Expression::Literal(Value::String("ok".into()))),
        };
        let result = evaluate_set_value(&f, &sv).unwrap();
        assert_eq!(result, JsonValue::String("critical".to_string()));
    }

    #[test]
    fn evaluates_set_case_else() {
        let mut f = BTreeMap::new();
        f.insert("cpu".into(), serde_json::json!(30.0));
        let sv = SetValue::Case {
            when_clauses: vec![(
                cmp_expr("cpu", Operator::Gt, Value::Percentage(80.0)),
                Expression::Literal(Value::String("critical".into())),
            )],
            else_value: Some(Expression::Literal(Value::String("ok".into()))),
        };
        let result = evaluate_set_value(&f, &sv).unwrap();
        assert_eq!(result, JsonValue::String("ok".to_string()));
    }

    #[test]
    fn evaluates_set_if_else() {
        let f = fields(&[("state", "running")]);
        let sv = SetValue::IfElse {
            condition: cmp_expr("state", Operator::Eq, Value::Identifier("running".into())),
            then_value: Expression::Literal(Value::String("up".into())),
            else_value: Some(Expression::Literal(Value::String("down".into()))),
        };
        let result = evaluate_set_value(&f, &sv).unwrap();
        assert_eq!(result, JsonValue::String("up".to_string()));
    }

    #[test]
    fn evaluates_matches_regex() {
        let f = fields(&[("name", "api-service-v2")]);
        let expr = cmp_expr(
            "name",
            Operator::Matches,
            Value::String("^api-.*\\d+$".into()),
        );
        assert!(evaluate_expression(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_matches_regex_no_match() {
        let f = fields(&[("name", "api-service")]);
        let expr = cmp_expr(
            "name",
            Operator::Matches,
            Value::String("^api-.*\\d+$".into()),
        );
        assert!(!evaluate_expression(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_in_operator() {
        let f = fields(&[("state", "running")]);
        let expr = in_expr(
            "state",
            vec![
                Value::String("running".into()),
                Value::String("restarting".into()),
            ],
        );
        assert!(evaluate_expression(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_in_operator_no_match() {
        let f = fields(&[("state", "exited")]);
        let expr = in_expr(
            "state",
            vec![
                Value::String("running".into()),
                Value::String("restarting".into()),
            ],
        );
        assert!(!evaluate_expression(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_label_field_access() {
        let mut f = BTreeMap::new();
        f.insert("labels".into(), serde_json::json!(["env=prod", "tier=api"]));
        let expr = cmp_expr("label.env", Operator::Eq, Value::String("prod".into()));
        assert!(evaluate_expression(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_label_field_no_match() {
        let mut f = BTreeMap::new();
        f.insert("labels".into(), serde_json::json!(["env=staging"]));
        let expr = cmp_expr("label.env", Operator::Eq, Value::String("prod".into()));
        assert!(!evaluate_expression(&f, &expr).unwrap());
    }

    // ── New Tier 1 tests ──

    #[test]
    fn evaluates_arithmetic() {
        let mut f = BTreeMap::new();
        f.insert("cpu".into(), serde_json::json!(80.0));
        f.insert("mem".into(), serde_json::json!(200.0));

        // cpu + mem > 250
        let sum = Expression::Arithmetic {
            left: Box::new(Expression::Field("cpu".to_owned())),
            op: BinOp::Add,
            right: Box::new(Expression::Field("mem".to_owned())),
        };
        let cmp = Expression::Comparison {
            left: Box::new(sum),
            operator: Operator::Gt,
            right: Box::new(Expression::Literal(Value::Float(250.0))),
        };
        assert!(eval_bool(&f, &cmp).unwrap());

        // cpu * 2 = 160
        let mul = Expression::Arithmetic {
            left: Box::new(Expression::Field("cpu".to_owned())),
            op: BinOp::Mul,
            right: Box::new(Expression::Literal(Value::Float(2.0))),
        };
        let eq = Expression::Comparison {
            left: Box::new(mul),
            operator: Operator::Eq,
            right: Box::new(Expression::Literal(Value::Float(160.0))),
        };
        assert!(eval_bool(&f, &eq).unwrap());
    }

    #[test]
    fn evaluates_between() {
        let mut f = BTreeMap::new();
        f.insert("cpu".into(), serde_json::json!(65.0));
        let expr = Expression::Between {
            expr: Box::new(Expression::Field("cpu".to_owned())),
            low: Box::new(Expression::Literal(Value::Float(50.0))),
            high: Box::new(Expression::Literal(Value::Float(80.0))),
        };
        assert!(eval_bool(&f, &expr).unwrap());

        f.insert("cpu".into(), serde_json::json!(95.0));
        assert!(!eval_bool(&f, &expr).unwrap());
    }

    #[test]
    fn evaluates_is_null() {
        let mut f = BTreeMap::new();
        f.insert("name".into(), JsonValue::String("web".into()));
        let expr = Expression::IsNull(Box::new(Expression::Field("name".to_owned())));
        assert!(!eval_bool(&f, &expr).unwrap());
        assert!(eval_bool(&BTreeMap::new(), &expr).unwrap());
    }

    #[test]
    fn evaluates_is_not_null() {
        let mut f = BTreeMap::new();
        f.insert("name".into(), JsonValue::String("web".into()));
        let expr = Expression::IsNotNull(Box::new(Expression::Field("name".to_owned())));
        assert!(eval_bool(&f, &expr).unwrap());
        assert!(!eval_bool(&BTreeMap::new(), &expr).unwrap());
    }

    #[test]
    fn evaluates_function_calls() {
        let f = fields(&[("name", "Api-Service")]);
        let upper = Expression::FnCall {
            name: "upper".to_owned(),
            args: vec![Expression::Field("name".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &upper).unwrap(),
            JsonValue::String("API-SERVICE".to_owned())
        );

        let lower = Expression::FnCall {
            name: "lower".to_owned(),
            args: vec![Expression::Field("name".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &lower).unwrap(),
            JsonValue::String("api-service".to_owned())
        );

        let len = Expression::FnCall {
            name: "length".to_owned(),
            args: vec![Expression::Field("name".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &len).unwrap(),
            JsonValue::Number(Number::from(11))
        );

        let concat = Expression::FnCall {
            name: "concat".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String(":v1".to_owned())),
            ],
        };
        assert_eq!(
            eval_expr(&f, &concat).unwrap(),
            JsonValue::String("Api-Service:v1".to_owned())
        );
    }

    #[test]
    fn evaluates_set_expr() {
        let mut f = BTreeMap::new();
        f.insert("memory".into(), serde_json::json!(1073741824u64));
        let sv = SetValue::Expr(Expression::Arithmetic {
            left: Box::new(Expression::Field("memory".to_owned())),
            op: BinOp::Div,
            right: Box::new(Expression::Literal(Value::Float(1073741824.0))),
        });
        let result = evaluate_set_value(&f, &sv).unwrap();
        assert_eq!(result, JsonValue::Number(Number::from_f64(1.0).unwrap()));
    }

    #[test]
    fn multiplies_arithmetic() {
        let mut f = BTreeMap::new();
        f.insert("cpu".into(), serde_json::json!(50.0));
        // (cpu + 10) * 2
        let add = Expression::Arithmetic {
            left: Box::new(Expression::Field("cpu".to_owned())),
            op: BinOp::Add,
            right: Box::new(Expression::Literal(Value::Float(10.0))),
        };
        let mul = Expression::Arithmetic {
            left: Box::new(add),
            op: BinOp::Mul,
            right: Box::new(Expression::Literal(Value::Float(2.0))),
        };
        let result = eval_expr(&f, &mul).unwrap();
        assert_eq!(result.as_f64(), Some(120.0));
    }

    #[test]
    fn evaluates_starts_with() {
        let f = fields(&[("name", "api-service")]);
        let expr = Expression::FnCall {
            name: "starts_with".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String("api".to_owned())),
            ],
        };
        assert_eq!(eval_expr(&f, &expr).unwrap(), JsonValue::Bool(true));

        let expr_no = Expression::FnCall {
            name: "starts_with".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String("web".to_owned())),
            ],
        };
        assert_eq!(eval_expr(&f, &expr_no).unwrap(), JsonValue::Bool(false));
    }

    #[test]
    fn evaluates_ends_with() {
        let f = fields(&[("name", "api-service")]);
        let expr = Expression::FnCall {
            name: "ends_with".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String("service".to_owned())),
            ],
        };
        assert_eq!(eval_expr(&f, &expr).unwrap(), JsonValue::Bool(true));
    }

    #[test]
    fn evaluates_replace() {
        let f = fields(&[("name", "api-service-v2")]);
        let expr = Expression::FnCall {
            name: "replace".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String("service".to_owned())),
                Expression::Literal(Value::String("app".to_owned())),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::String("api-app-v2".to_owned())
        );
    }

    #[test]
    fn evaluates_reverse() {
        let f = fields(&[("name", "abc")]);
        let expr = Expression::FnCall {
            name: "reverse".to_owned(),
            args: vec![Expression::Field("name".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::String("cba".to_owned())
        );
    }

    #[test]
    fn evaluates_repeat() {
        let f = fields(&[("name", "ab")]);
        let expr = Expression::FnCall {
            name: "repeat".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::Integer(3)),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::String("ababab".to_owned())
        );
    }

    #[test]
    fn evaluates_position() {
        let f = fields(&[("name", "hello world")]);
        let expr = Expression::FnCall {
            name: "position".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String("world".to_owned())),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::Number(Number::from(6))
        );
    }

    #[test]
    fn evaluates_position_not_found() {
        let f = fields(&[("name", "hello")]);
        let expr = Expression::FnCall {
            name: "position".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String("xyz".to_owned())),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::Number(Number::from(0))
        );
    }

    #[test]
    fn evaluates_split_part() {
        let f = fields(&[("name", "a,b,c,d")]);
        let expr = Expression::FnCall {
            name: "split_part".to_owned(),
            args: vec![
                Expression::Field("name".to_owned()),
                Expression::Literal(Value::String(",".to_owned())),
                Expression::Literal(Value::Integer(2)),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::String("b".to_owned())
        );
    }

    #[test]
    fn evaluates_now() {
        let expr = Expression::FnCall {
            name: "now".to_owned(),
            args: vec![],
        };
        let result = eval_expr(&BTreeMap::new(), &expr).unwrap();
        assert!(result.is_string());
        let s = result.as_str().unwrap();
        assert!(s.len() > 10, "now() should return an ISO timestamp");
    }

    #[test]
    fn evaluates_date_format() {
        let f = fields(&[("ts", "2026-06-01T12:30:00Z")]);
        let expr = Expression::FnCall {
            name: "date_format".to_owned(),
            args: vec![
                Expression::Field("ts".to_owned()),
                Expression::Literal(Value::String("%Y-%m-%d".to_owned())),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::String("2026-06-01".to_owned())
        );
    }

    #[test]
    fn evaluates_date_diff_days() {
        let f = fields(&[
            ("start", "2026-01-01T00:00:00Z"),
            ("end", "2026-01-11T00:00:00Z"),
        ]);
        let expr = Expression::FnCall {
            name: "date_diff".to_owned(),
            args: vec![
                Expression::Field("start".to_owned()),
                Expression::Field("end".to_owned()),
                Expression::Literal(Value::String("days".to_owned())),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::Number(Number::from(10))
        );
    }

    #[test]
    fn evaluates_extract_year() {
        let f = fields(&[("ts", "2026-06-15T08:30:00Z")]);
        let expr = Expression::FnCall {
            name: "extract".to_owned(),
            args: vec![
                Expression::Field("ts".to_owned()),
                Expression::Literal(Value::String("year".to_owned())),
            ],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::Number(Number::from(2026))
        );
    }

    #[test]
    fn handles_division_by_zero() {
        let mut f = BTreeMap::new();
        f.insert("x".into(), serde_json::json!(10.0));
        let div = Expression::Arithmetic {
            left: Box::new(Expression::Field("x".to_owned())),
            op: BinOp::Div,
            right: Box::new(Expression::Literal(Value::Float(0.0))),
        };
        assert!(eval_expr(&f, &div).is_err());
    }
    #[test]
    fn evaluates_to_int_from_string() {
        let f = fields(&[("val", "42")]);
        let expr = Expression::FnCall {
            name: "to_int".to_owned(),
            args: vec![Expression::Field("val".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::Number(Number::from(42))
        );
    }

    #[test]
    fn evaluates_to_int_from_float_string() {
        let f = fields(&[("val", "42.7")]);
        let expr = Expression::FnCall {
            name: "to_int".to_owned(),
            args: vec![Expression::Field("val".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::Number(Number::from(42))
        );
    }

    #[test]
    fn evaluates_to_int_from_bool_true() {
        let mut f = std::collections::BTreeMap::new();
        f.insert("val".into(), JsonValue::Bool(true));
        let expr = Expression::FnCall {
            name: "to_int".to_owned(),
            args: vec![Expression::Field("val".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::Number(Number::from(1))
        );
    }

    #[test]
    fn evaluates_to_float_from_integer() {
        let mut f = std::collections::BTreeMap::new();
        f.insert("val".into(), JsonValue::Number(Number::from(42)));
        let expr = Expression::FnCall {
            name: "to_float".to_owned(),
            args: vec![Expression::Field("val".to_owned())],
        };
        let result = eval_expr(&f, &expr).unwrap();
        assert_eq!(result.as_f64(), Some(42.0));
    }

    #[test]
    #[allow(clippy::approx_constant)]
    fn evaluates_to_float_from_string() {
        let f = fields(&[("val", "3.14")]);
        let expr = Expression::FnCall {
            name: "to_float".to_owned(),
            args: vec![Expression::Field("val".to_owned())],
        };
        let result = eval_expr(&f, &expr).unwrap();
        assert_eq!(result.as_f64(), Some(3.14));
    }

    #[test]
    fn evaluates_to_string_from_number() {
        let mut f = std::collections::BTreeMap::new();
        f.insert("val".into(), JsonValue::Number(Number::from(42)));
        let expr = Expression::FnCall {
            name: "to_string".to_owned(),
            args: vec![Expression::Field("val".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::String("42".to_owned())
        );
    }

    #[test]
    fn evaluates_to_string_from_bool() {
        let mut f = std::collections::BTreeMap::new();
        f.insert("val".into(), JsonValue::Bool(true));
        let expr = Expression::FnCall {
            name: "to_string".to_owned(),
            args: vec![Expression::Field("val".to_owned())],
        };
        assert_eq!(
            eval_expr(&f, &expr).unwrap(),
            JsonValue::String("true".to_owned())
        );
    }
}