jsonfilter 0.2.1

mod test;
use std::cmp::Ordering;

use serde_json::json;

/// Compares two JSON values `a` and `b` based on their ordering.
///
/// This function evaluates the relationship between the JSON values `a` and `b` using the following criteria:
/// - If `a` is greater than `b`, returns `std::cmp::Ordering::Greater`.
/// - If `a` is less than `b`, returns `std::cmp::Ordering::Less`.
/// - If `a` is equal to `b`, returns `std::cmp::Ordering::Equal`.
///
/// # Arguments
///
/// * `a` - A reference to a `serde_json::Value` representing the first JSON value.
/// * `b` - A reference to a `serde_json::Value` representing the second JSON value.
///
/// # Returns
///
/// Returns `std::cmp::Ordering` indicating the relationship between `a` and `b`.
///
/// # Panics
///
/// This function panics if the values cant be compared.
///
/// # Examples
///
/// ```
/// use serde_json::json;
/// use std::cmp::Ordering;
/// use jsonfilter::order;
///
/// let a = json!(10);
/// let b = json!(5);
/// assert_eq!(order(&a, &b), Ordering::Greater);
/// ```
#[must_use]
pub fn order(a: &serde_json::Value, b: &serde_json::Value) -> std::cmp::Ordering {
    if matches(
        &serde_json::json!({
            "a": { "$gt": b}
        }),
        &serde_json::json!({
            "a": a
        }),
    ) {
        Ordering::Greater
    } else if matches(
        &serde_json::json!({
            "a": { "$lt": b}
        }),
        &serde_json::json!({
            "a": a
        }),
    ) {
        Ordering::Less
    } else if matches(
        &serde_json::json!({
            "a": b
        }),
        &serde_json::json!({
            "a": a
        }),
    ) {
        Ordering::Equal
    } else {
        unreachable!()
    }
}

/// Compares two `serde_json::Value` objects and determines if the first value is less than the second value.
///
/// # Arguments
///
/// * `a` - A reference to the first `serde_json::Value` to be compared. This can be a floating-point number, integer, unsigned integer, or a string.
/// * `b` - A reference to the second `serde_json::Value` to be compared. This should be of the same type as `a`.
///
/// # Returns
///
/// * `true` if `a` is less than `b`.
/// * `false` otherwise.
///
/// # Panics
///
/// This function will panic if `a` and `b` are not of the same type or if they are of an unsupported type.
fn less_than_json(a: &serde_json::Value, b: &serde_json::Value) -> bool {
    if a.is_f64() {
        let a = a.as_f64().unwrap();
        let b = b.as_f64().unwrap();
        a < b
    } else if a.is_i64() {
        let a = a.as_i64().unwrap();
        let b = b.as_i64().unwrap();
        a < b
    } else if a.is_u64() {
        let a = a.as_u64().unwrap();
        let b = b.as_u64().unwrap();
        a < b
    } else if a.is_string() {
        let a = a.as_str().unwrap();
        let b = b.as_str().unwrap();
        a < b
    } else {
        unreachable!()
    }
}

/// Compares two `serde_json::Value` objects and determines if the first value is greater than the second value.
///
/// # Arguments
///
/// * `a` - A reference to the first `serde_json::Value` to be compared. This can be a floating-point number, integer, unsigned integer, or a string.
/// * `b` - A reference to the second `serde_json::Value` to be compared. This should be of the same type as `a`.
///
/// # Returns
///
/// * `true` if `a` is greater than `b`.
/// * `false` otherwise.
///
/// # Panics
///
/// This function will panic if `a` and `b` are not of the same type or if they are of an unsupported type.
fn greater_than_json(a: &serde_json::Value, b: &serde_json::Value) -> bool {
    if a.is_f64() {
        let a = a.as_f64().unwrap();
        let b = b.as_f64().unwrap();
        a > b
    } else if a.is_i64() {
        let a = a.as_i64().unwrap();
        let b = b.as_i64().unwrap();
        a > b
    } else if a.is_u64() {
        let a = a.as_u64().unwrap();
        let b = b.as_u64().unwrap();
        a > b
    } else if a.is_string() {
        let a = a.as_str().unwrap();
        let b = b.as_str().unwrap();
        a > b
    } else {
        unreachable!()
    }
}

#[derive(Debug, Clone, Copy)]
/// Represents errors that can occur while processing filters.
pub enum FilterError {
    /// Indicates that the schema of the filter is invalid.
    InvalidFilter,
    /// Indicates that an unknown operator was encountered in the filter.
    UnknownOperator,
    /// Indicates that a key was not found in the object being filtered.
    KeyNotFound,
}

/// Matches a filter against a raw object and returns a boolean indicating if the filter matches the object.
///
/// # Arguments
///
/// * `filter` - A reference to a `serde_json::Value` representing the filter to apply. Must be an object.
/// * `obj` - A reference to a `serde_json::Value` representing the object to match against. Must be an object.
///
/// # Returns
///
/// Returns `true` if the filter matches the object, otherwise `false`.
///
/// # Examples
///
/// ```
/// use serde_json::json;
/// use jsonfilter::matches;
///
/// let filter = json!({"name": "John", "age": 30});
/// let obj = json!({"name": "John", "age": 30, "city": "New York"});
///
/// assert!(matches(&filter, &obj));
/// ```
#[must_use]
pub fn matches(filter: &serde_json::Value, obj: &serde_json::Value) -> bool {
    try_matches(filter, obj).unwrap()
}

/// Matches a filter against a raw object and returns a boolean indicating if the filter matches the object.
///
/// # Arguments
///
/// * `filter` - A reference to a `serde_json::Value` representing the filter to apply. Must be an object.
/// * `obj` - A reference to a `serde_json::Value` representing the object to match against. Must be an object.
///
/// # Returns
///
/// * `Ok(true)` if the object matches the filter criteria.
/// * `Ok(false)` if the object does not match the filter criteria.
/// * `Err(FilterError)` if there is an error in the filtering process.
pub fn try_matches(
    filter: &serde_json::Value,
    obj: &serde_json::Value,
) -> Result<bool, FilterError> {
    let filter = filter.as_object().unwrap();
    let obj_map = obj.as_object().unwrap();

    // Handle the case where the filter has a single key, such as top level $and, $or, $not
    if filter.len() == 1 {
        let filter_keys: Vec<_> = filter.keys().collect();
        let op = filter_keys.first().unwrap();
        let op_arg = filter.get(op.as_str()).unwrap();
        match op.as_str() {
            "$and" => {
                if let serde_json::Value::Array(and_list) = op_arg {
                    let and_list_bool: Vec<Result<bool, FilterError>> = and_list
                        .iter()
                        .map(|sub_filter| try_matches(sub_filter, obj))
                        .collect();
                    if let Some(err) = and_list_bool.iter().find(|x| x.is_err()) {
                        return *err;
                    }
                    return Ok(!and_list_bool.iter().map(|x| x.unwrap()).any(|x| !x));
                }
                return Err(FilterError::InvalidFilter);
            }
            "$or" => {
                if let serde_json::Value::Array(or_list) = op_arg {
                    let or_list_bool: Vec<Result<bool, FilterError>> = or_list
                        .iter()
                        .map(|sub_filter| try_matches(sub_filter, obj))
                        .collect();
                    if let Some(err) = or_list_bool.iter().find(|x| x.is_err()) {
                        return *err;
                    }
                    return Ok(or_list_bool.iter().map(|x| x.unwrap()).any(|x| x));
                }
                return Err(FilterError::InvalidFilter);
            }
            "$not" => {
                if let Some(inner) = filter.get("$not") {
                    let new_filter = inner;
                    return Ok(!try_matches(new_filter, obj)?);
                }
                return Err(FilterError::InvalidFilter);
            }
            _ => {
                if op.starts_with('$') {
                    return Err(FilterError::UnknownOperator);
                }
            }
        }
    }

    let mut conditions = vec![];

    for (key, val) in filter {
        if val.is_object() {
            let val_keys: Vec<_> = val.as_object().unwrap().keys().collect();
            if val_keys.first().unwrap().starts_with('$') {
                // handle operators
                conditions.push(match_operator(val, obj, key.as_str()));
            } else {
                // nested
                for (_, _) in val.as_object().unwrap() {
                    let new_filter = filter.get(key).unwrap();
                    if let Some(val) = obj_map.get(key) {
                        conditions.push(try_matches(new_filter, val));
                    } else {
                        return Err(FilterError::KeyNotFound);
                    }
                }
            }
            continue;
        }

        // Compare simple key-value pairs
        if let Some(valb) = obj_map.get(key) {
            if val != valb {
                conditions.push(Ok(false));
            }
        } else {
            return Err(FilterError::KeyNotFound);
        }
    }

    check(&conditions)
}

/// Checks if all conditions in the given list are met.
///
/// This function iterates through a list of `Result<bool, FilterError>` conditions, checking for errors first.
/// If any condition is an error, it returns that error. Otherwise, it returns `Ok(true)` if all conditions are `true`
/// and `Ok(false)` if any condition is `false`.
///
/// # Arguments
///
/// * `conditions` - A slice of `Result<bool, FilterError>` representing the conditions to be checked.
///
/// # Returns
///
/// * `Ok(true)` if all conditions are true.
/// * `Ok(false)` if any condition is false.
/// * `Err(FilterError)` if any condition is an error.
fn check(conditions: &[Result<bool, FilterError>]) -> Result<bool, FilterError> {
    conditions.iter().find(|x| x.is_err()).map_or_else(
        || Ok(!conditions.iter().map(|x| x.unwrap()).any(|x| !x)),
        |possible_error| *possible_error,
    )
}

/// Matches a filter operator against a key-value pair in the object and determines if the condition is met.
///
/// # Arguments
///
/// * `val` - The value associated with the operator in the filter. This should be a JSON object.
/// * `raw_obj` - The object to be filtered. This should be a JSON object.
/// * `key` - The key in the object that the filter operator applies to.
///
/// # Returns
///
/// * `Ok(true)` if the condition specified by the filter operator is met.
/// * `Ok(false)` if the condition specified by the filter operator is not met.
/// * `Err(FilterError)` if there is an error in the filtering process.
///
/// # Errors
///
/// This function will return an error if:
/// * The filter or object is not a valid JSON object.
/// * An unknown operator is used in the filter.
/// * A required key is not found in the object.
/// * The filter format is invalid.
fn match_operator(
    val: &serde_json::Value,
    raw_obj: &serde_json::Value,
    key: &str,
) -> Result<bool, FilterError> {
    let obj = raw_obj.as_object().unwrap();
    let val = val.as_object().unwrap();

    if val.keys().len() == 1 {
        let keys: Vec<_> = val.keys().collect();
        let op = keys.first().unwrap().as_str();
        let op_arg = val.get(op).unwrap();
        match op {
            "$and" => {
                if let serde_json::Value::Array(and_list) = op_arg {
                    let and_list_bool: Vec<Result<bool, FilterError>> = and_list
                        .iter()
                        .map(|sub_filter| try_matches(sub_filter, raw_obj))
                        .collect();
                    if let Some(err) = and_list_bool.iter().find(|x| x.is_err()) {
                        return *err;
                    }
                    return Ok(!and_list_bool.iter().map(|x| x.unwrap()).any(|x| !x));
                }
                return Err(FilterError::InvalidFilter);
            }
            "$or" => {
                if let serde_json::Value::Array(or_list) = op_arg {
                    let or_list_bool: Vec<Result<bool, FilterError>> = or_list
                        .iter()
                        .map(|sub_filter| try_matches(sub_filter, raw_obj))
                        .collect();
                    if let Some(err) = or_list_bool.iter().find(|x| x.is_err()) {
                        return *err;
                    }
                    return Ok(or_list_bool.iter().map(|x| x.unwrap()).any(|x| x));
                }
                return Err(FilterError::InvalidFilter);
            }
            "$lt" => {
                if let Some(a) = obj.get(key) {
                    return Ok(less_than_json(a, op_arg));
                }
                return Err(FilterError::KeyNotFound);
            }
            "$lte" => {
                if let Some(a) = obj.get(key) {
                    return Ok(less_than_json(a, op_arg) || a == op_arg);
                }
                return Err(FilterError::KeyNotFound);
            }
            "$gt" => {
                if let Some(valb) = obj.get(key) {
                    return Ok(greater_than_json(valb, op_arg));
                }
                return Err(FilterError::KeyNotFound);
            }
            "$gte" => {
                if let Some(a) = obj.get(key) {
                    return Ok(greater_than_json(a, op_arg) || a == op_arg);
                }
                return Err(FilterError::KeyNotFound);
            }
            "$not" => {
                if let Some(serde_json::Value::Object(inner)) = val.get("$not") {
                    let new_filter = json!({
                        key: inner
                    });
                    return Ok(!try_matches(&new_filter, raw_obj)?);
                }
                return Err(FilterError::InvalidFilter);
            }
            "$ne" => {
                if let Some(valb) = obj.get(key) {
                    return Ok(valb != op_arg);
                }
                return Err(FilterError::KeyNotFound);
            }
            "$in" => {
                if let Some(valb) = obj.get(key) {
                    if let serde_json::Value::Array(list) = valb {
                        return Ok(list.iter().any(|x| x == op_arg));
                    }
                    return Err(FilterError::InvalidFilter);
                }
                return Err(FilterError::KeyNotFound);
            }
            "$nin" => {
                if let Some(valb) = obj.get(key) {
                    if let serde_json::Value::Array(list) = valb {
                        return Ok(!list.iter().any(|x| x == op_arg));
                    }
                    return Err(FilterError::InvalidFilter);
                }
                return Err(FilterError::KeyNotFound);
            }
            "$exists" => {
                if let serde_json::Value::Bool(exists) = op_arg {
                    let valb = obj.get(key).is_some();
                    return Ok(*exists == valb);
                }
                return Err(FilterError::InvalidFilter);
            }
            "$size" => {
                if let Some(serde_json::Value::Array(list)) = obj.get(key) {
                    let val_size = list.len() as u64;
                    if let serde_json::Value::Number(pref_size) = op_arg {
                        let pref_size = pref_size.as_u64().unwrap();
                        return Ok(pref_size == val_size);
                    }
                    if let serde_json::Value::Object(s_op_obj) = op_arg {
                        if s_op_obj.len() == 1 {
                            let keys: Vec<_> = s_op_obj.keys().collect();
                            let key = keys.first().unwrap();
                            let val = s_op_obj.get(*key).unwrap().as_u64().unwrap();
                            match key.as_str() {
                                "$gt" => {
                                    return Ok(val_size > val);
                                }
                                "$gte" => {
                                    return Ok(val_size >= val);
                                }
                                "$lt" => {
                                    return Ok(val_size < val);
                                }
                                "$lte" => {
                                    return Ok(val_size <= val);
                                }
                                _ => {}
                            }
                        }
                    }
                    return Err(FilterError::InvalidFilter);
                }
                return Err(FilterError::KeyNotFound);
            }
            "$regex" => {
                if let serde_json::Value::String(regex_pattern) = op_arg {
                    if let Some(serde_json::Value::String(valb)) = obj.get(key) {
                        let pattern = regex::Regex::new(regex_pattern).unwrap();
                        return Ok(pattern.is_match(valb));
                    }
                    return Err(FilterError::KeyNotFound);
                }
                return Err(FilterError::InvalidFilter);
            }
            "$type" => {
                if let Some(valb) = obj.get(key) {
                    if let serde_json::Value::String(type_str) = op_arg {
                        return Ok(match type_str.to_lowercase().as_str() {
                            "null" => valb.is_null(),
                            "string" => valb.is_string(),
                            "number" => valb.is_number(),
                            "object" => valb.is_object(),
                            "array" => valb.is_array(),
                            "boolean" => valb.is_boolean(),
                            _ => false,
                        });
                    }
                    return Err(FilterError::InvalidFilter);
                }
                return Err(FilterError::KeyNotFound);
            }
            _ => {
                if op.starts_with('$') {
                    return Err(FilterError::UnknownOperator);
                }
            }
        }
    }

    Err(FilterError::InvalidFilter)
}