haste_fhirpath/

lib.rs

mod error;
mod parser;
use crate::{
    error::{FunctionError, OperationError},
    parser::{
        Expression, FunctionInvocation, Identifier, Invocation, Literal, Operation,
        QualifiedIdentifier, Term,
    },
};
use dashmap::DashMap;
pub use error::FHIRPathError;
use haste_fhir_model::r4::{
    conversion::{
        BOOLEAN_TYPES, NUMBER_TYPES, STRING_TYPES, downcast_bool, downcast_number, downcast_string,
    },
    generated::{
        resources::ResourceType,
        types::{FHIRBoolean, FHIRDecimal, FHIRId, FHIRInteger, FHIRString, Reference},
    },
};
use haste_reflect::MetaValue;
use haste_reflect_derive::Reflect;
use std::pin::Pin;
use std::{
    collections::HashMap,
    sync::{Arc, LazyLock, Mutex},
};

mod allocators;
use allocators::AllocatorTrait;

fn evaluate_literal<'b>(
    literal: &Literal,
    context: &Context<'b>,
) -> Result<Context<'b>, FHIRPathError> {
    match literal {
        Literal::String(string) => Ok(context.new_context_from(vec![context.allocate_literal(
            FHIRString {
                value: Some(string.clone()),
                ..Default::default()
            },
        )])),
        Literal::Integer(int) => Ok(context.new_context_from(vec![context.allocate_literal(
            FHIRInteger {
                value: Some(*int),
                ..Default::default()
            },
        )])),
        Literal::Float(decimal) => Ok(context.new_context_from(vec![context.allocate_literal(
            FHIRDecimal {
                value: Some(*decimal),
                ..Default::default()
            },
        )])),
        Literal::Boolean(bool) => Ok(context.new_context_from(vec![context.allocate_literal(
            FHIRBoolean {
                value: Some(*bool),
                ..Default::default()
            },
        )])),
        Literal::Null => Ok(context.new_context_from(vec![])),
        _ => Err(FHIRPathError::InvalidLiteral(literal.to_owned())),
    }
}

async fn evaluate_invocation<'a>(
    invocation: &Invocation,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    match invocation {
        Invocation::This => Ok(context),
        Invocation::Index(index_expression) => {
            let index = evaluate_expression(index_expression, context.clone(), config).await?;
            if index.values.len() != 1 {
                return Err(FHIRPathError::OperationError(
                    OperationError::InvalidCardinality,
                ));
            }

            let float_index = downcast_number(index.values[0])?;

            // Ensure the index is non-negative and has no fractional part
            if float_index < 0.0 || float_index.fract() != 0.0 {
                return Err(FHIRPathError::OperationError(OperationError::InvalidIndex));
            }

            // Suppress clippy warnings because the float is guaranteed to be a valid,
            // non-negative integer index by the safety checks immediately above.
            #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
            let index: usize = (float_index as u64)
                .try_into()
                .map_err(|_| FHIRPathError::OperationError(OperationError::IndexOutOfBounds))?;

            if let Some(value) = context.values.get(index) {
                Ok(context.new_context_from(vec![*value]))
            } else {
                Ok(context.new_context_from(vec![]))
            }
        }
        Invocation::IndexAccessor => Err(FHIRPathError::NotImplemented("index access".to_string())),
        Invocation::Total => Err(FHIRPathError::NotImplemented("total".to_string())),
        Invocation::Identifier(Identifier(id)) => Ok(context.new_context_from(
            context
                .values
                .iter()
                .flat_map(|v| v.get_field(id).map_or_else(Vec::new, |v| v.flatten()))
                .collect(),
        )),
        Invocation::Function(function) => evaluate_function(function, context, config).await,
    }
}

async fn evaluate_term<'a>(
    term: &Term,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    match term {
        Term::Literal(literal) => evaluate_literal(literal, &context),
        Term::ExternalConstant(constant) => {
            resolve_external_constant(
                constant,
                config.as_ref().and_then(|c| c.variable_resolver.as_ref()),
                context,
            )
            .await
        }
        Term::Parenthesized(expression) => evaluate_expression(expression, context, config).await,
        Term::Invocation(invocation) => evaluate_invocation(invocation, context, config).await,
    }
}

/// Need special handling as the first term could start with a type filter.
/// for example Patient.name
async fn evaluate_first_term<'a>(
    term: &Term,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    match term {
        Term::Invocation(invocation) => match invocation {
            Invocation::Identifier(identifier) => {
                let type_filter = filter_by_type(&identifier.0, &context);
                if type_filter.values.is_empty() {
                    evaluate_invocation(invocation, context, config).await
                } else {
                    Ok(type_filter)
                }
            }
            _ => evaluate_invocation(invocation, context, config).await,
        },
        _ => evaluate_term(term, context, config).await,
    }
}

async fn evaluate_singular<'a>(
    expression: &[Term],
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    let mut current_context = context;

    let mut term_iterator = expression.iter();
    let first_term = term_iterator.next();
    if let Some(first_term) = first_term {
        current_context = evaluate_first_term(first_term, current_context, config.clone()).await?;
    }

    for term in term_iterator {
        current_context = evaluate_term(term, current_context, config.clone()).await?;
    }

    Ok(current_context)
}

async fn operation_2<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
    executor: impl Fn(
        Context<'a>,
        Context<'a>,
    )
        -> Pin<Box<dyn Future<Output = Result<Context<'a>, FHIRPathError>> + Send + 'a>>,
) -> Result<Context<'a>, FHIRPathError> {
    let left = evaluate_expression(left, context.clone(), config.clone()).await?;
    let right = evaluate_expression(right, context, config).await?;

    // If one of operands is empty per spec return an empty collection
    if left.values.is_empty() || right.values.is_empty() {
        return Ok(left.new_context_from(vec![]));
    }

    if left.values.len() != 1 || right.values.len() != 1 {
        return Err(FHIRPathError::OperationError(
            OperationError::InvalidCardinality,
        ));
    }

    executor(left, right).await
}

async fn operation_n<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
    executor: impl Fn(Context<'a>, Context<'a>) -> Result<Context<'a>, FHIRPathError>,
) -> Result<Context<'a>, FHIRPathError> {
    let left = evaluate_expression(left, context.clone(), config.clone()).await?;
    let right = evaluate_expression(right, context, config).await?;
    executor(left, right)
}

enum Cardinality {
    Zero,
    One,
    Many,
    Custom(usize, usize),
}

fn validate_arguments(
    ast_arguments: &[Expression],
    cardinality: &Cardinality,
) -> Result<(), FHIRPathError> {
    match cardinality {
        Cardinality::Zero => {
            if !ast_arguments.is_empty() {
                return Err(FHIRPathError::OperationError(
                    OperationError::InvalidCardinality,
                ));
            }
        }
        Cardinality::Custom(min, max) => {
            if ast_arguments.len() < *min || ast_arguments.len() > *max {
                return Err(FHIRPathError::OperationError(
                    OperationError::InvalidCardinality,
                ));
            }
        }
        Cardinality::One => {
            if ast_arguments.len() != 1 {
                return Err(FHIRPathError::OperationError(
                    OperationError::InvalidCardinality,
                ));
            }
        }
        Cardinality::Many => {}
    }
    Ok(())
}

fn derive_typename(expression_ast: &Expression) -> Result<String, FHIRPathError> {
    match expression_ast {
        Expression::Singular(ast) => match &ast[0] {
            Term::Invocation(Invocation::Identifier(type_id)) => Ok(type_id.0.clone()),
            _ => Err(FHIRPathError::FailedTypeNameDerivation),
        },
        Expression::Operation(_) => Err(FHIRPathError::FailedTypeNameDerivation),
    }
}

fn check_type_name(type_name: &str, type_to_check: &str) -> bool {
    match type_to_check {
        "Resource" | "DomainResource" => ResourceType::try_from(type_name).is_ok(),
        _ => type_name == type_to_check,
    }
}

fn check_type(value: &dyn MetaValue, type_to_check: &str) -> bool {
    let fhir_type_name = value.fhir_type();

    match fhir_type_name {
        // Special handling for reference which is to check the reference type.
        "Reference" => {
            if type_to_check == "Reference" {
                return true;
            } else if let Some(reference) = value.as_any().downcast_ref::<Reference>()
                && let Some(resource_type) = reference
                    .reference
                    .as_ref()
                    .and_then(|r| r.value.as_ref())
                    .and_then(|r| r.split('/').next())
            {
                return check_type_name(resource_type, type_to_check);
            }
            false
        }
        fhir_type_name => check_type_name(fhir_type_name, type_to_check),
    }
}

fn filter_by_type<'a>(type_name: &str, context: &Context<'a>) -> Context<'a> {
    context.new_context_from(
        context
            .values
            .iter()
            .filter(|v| check_type(**v, type_name))
            .copied()
            .collect(),
    )
}

#[derive(Debug, Reflect)]
#[fhir_type = "Element"]
struct Reflection {
    name: String,
}

async fn evaluate_function<'a>(
    function: &FunctionInvocation,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    match function.name.0.as_str() {
        "resolve" => Ok(context),
        "where" => evaluate_where(function, context, config).await,
        "ofType" | "as" => evaluate_of_type(function, &context),
        "count" => evaluate_count(function, &context),
        "upper" | "lower" => evaluate_case(function, &context),
        "empty" => evaluate_empty(function, &context),
        "join" => evaluate_join(function, context, config).await,
        "exists" => evaluate_exists(function, context, config).await,
        "children" => evaluate_children(function, &context),
        "repeat" => evaluate_repeat(function, context, config).await,
        "descendants" => evaluate_descendants(context, config).await,
        "type" => evaluate_type(function, &context),
        "first" => evaluate_first(function, &context),
        "getReferenceKey" => evaluate_get_reference_key(function, &context),
        "getResourceKey" => evaluate_get_resource_key(function, &context, config),

        _ => Err(FHIRPathError::NotImplemented(format!(
            "Function '{}' is not implemented",
            function.name.0
        ))),
    }
}

async fn evaluate_where<'a>(
    function: &FunctionInvocation,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::One)?;

    let where_condition = &function.arguments[0];
    let mut new_context = vec![];

    for value in &context.values {
        let result = evaluate_expression(
            where_condition,
            context.new_context_from(vec![*value]),
            config.clone(),
        )
        .await?;

        if result.values.len() > 1 {
            return Err(FHIRPathError::InternalError(
                "Where condition did not return a single value".to_string(),
            ));
        }

        // Empty result is treated as false.
        if !result.values.is_empty() && downcast_bool(result.values[0])? {
            new_context.push(*value);
        }
    }

    Ok(context.new_context_from(new_context))
}

fn evaluate_of_type<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::One)?;

    let type_name = derive_typename(&function.arguments[0])?;

    Ok(filter_by_type(&type_name, context))
}

fn evaluate_count<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Zero)?;

    let count: i64 = context
        .values
        .len()
        .try_into()
        .map_err(|_| FHIRPathError::OperationError(OperationError::SizeOverflow))?;

    Ok(
        context.new_context_from(vec![context.allocate_literal(FHIRInteger {
            value: Some(count),
            ..Default::default()
        })]),
    )
}

fn evaluate_case<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Zero)?;

    let op = function.name.0.as_str();

    if context.values.is_empty() {
        return Ok(context.new_context_from(vec![]));
    }

    if context.values.len() > 1 {
        return Err(FunctionError::InvalidCardinality(op.to_string(), context.values.len()).into());
    }

    let input = downcast_string(context.values[0])?;

    let transformed = match op {
        "upper" => input.to_uppercase(),
        "lower" => input.to_lowercase(),
        _ => unreachable!(),
    };

    Ok(
        context.new_context_from(vec![context.allocate_literal(FHIRString {
            value: Some(transformed),
            ..Default::default()
        })]),
    )
}

fn evaluate_empty<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Zero)?;

    Ok(
        context.new_context_from(vec![context.allocate_literal(FHIRBoolean {
            value: Some(context.values.is_empty()),
            ..Default::default()
        })]),
    )
}

async fn evaluate_join<'a>(
    function: &FunctionInvocation,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Custom(0, 1))?;

    let separator = if let Some(separator_expression) = function.arguments.first() {
        let separator_context =
            evaluate_expression(separator_expression, context.clone(), config).await?;

        if separator_context.values.len() != 1 {
            return Err(FHIRPathError::OperationError(
                OperationError::InvalidCardinality,
            ));
        }

        downcast_string(separator_context.values[0])?
    } else {
        String::new()
    };

    let joined = context
        .values
        .iter()
        .map(|v| downcast_string(*v))
        .collect::<Result<Vec<_>, _>>()?
        .join(&separator);

    Ok(
        context.new_context_from(vec![context.allocate_literal(FHIRString {
            value: Some(joined),
            ..Default::default()
        })]),
    )
}

async fn evaluate_exists<'a>(
    function: &FunctionInvocation,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Many)?;

    if function.arguments.len() > 1 {
        return Err(FunctionError::InvalidCardinality(
            "exists".to_string(),
            function.arguments.len(),
        )
        .into());
    }

    if let Some(condition) = function.arguments.first() {
        for value in &context.values {
            let result = evaluate_expression(
                condition,
                context.new_context_from(vec![*value]),
                config.clone(),
            )
            .await?;

            if result.values.len() > 1 {
                return Err(FHIRPathError::InternalError(
                    "Exists condition did not return a single value".to_string(),
                ));
            }

            if !result.values.is_empty() && downcast_bool(result.values[0])? {
                return Ok(
                    context.new_context_from(vec![context.allocate_literal(FHIRBoolean {
                        value: Some(true),
                        ..Default::default()
                    })]),
                );
            }
        }

        return Ok(
            context.new_context_from(vec![context.allocate_literal(FHIRBoolean {
                value: Some(false),
                ..Default::default()
            })]),
        );
    }

    Ok(
        context.new_context_from(vec![context.allocate_literal(FHIRBoolean {
            value: Some(!context.values.is_empty()),
            ..Default::default()
        })]),
    )
}

fn evaluate_children<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Zero)?;

    let children = context
        .values
        .iter()
        .flat_map(|value| {
            value
                .fields()
                .iter()
                .filter_map(|f| value.get_field(f).map(|v| v.flatten()))
                .flatten()
                .collect::<Vec<_>>()
        })
        .collect();

    Ok(context.new_context_from(children))
}

async fn evaluate_repeat<'a>(
    function: &FunctionInvocation,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::One)?;

    let projection = &function.arguments[0];
    let mut end_result = vec![];
    let mut cur = context;

    while !cur.values.is_empty() {
        cur = evaluate_expression(projection, cur, config.clone()).await?;
        end_result.extend_from_slice(cur.values.as_slice());
    }

    Ok(cur.new_context_from(end_result))
}

async fn evaluate_descendants<'a>(
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    let result = evaluate_expression(
        &Expression::Singular(vec![Term::Invocation(Invocation::Function(
            FunctionInvocation {
                name: Identifier("repeat".to_string()),
                arguments: vec![Expression::Singular(vec![Term::Invocation(
                    Invocation::Function(FunctionInvocation {
                        name: Identifier("children".to_string()),
                        arguments: vec![],
                    }),
                )])],
            },
        ))]),
        context,
        config,
    )
    .await?;

    Ok(result)
}

fn evaluate_type<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Zero)?;

    let mut next_ctx = Vec::with_capacity(context.values.len());

    for value in &context.values {
        let type_name = value.fhir_type();

        next_ctx.push(context.allocate_literal(Reflection {
            name: type_name.to_string(),
        }));
    }

    Ok(context.new_context_from(next_ctx))
}

fn evaluate_first<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Zero)?;

    match context.values.first() {
        Some(value) => Ok(context.new_context_from(vec![*value])),
        None => Ok(context.new_context_from(vec![])),
    }
}

fn evaluate_get_reference_key<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Custom(0, 1))?;

    let type_to_filter_by = if let Some(resource_type) = function.arguments.first() {
        Some(derive_typename(resource_type)?)
    } else {
        None
    };

    let ids = context
        .iter()
        .filter_map(|value| {
            let reference = value.as_any().downcast_ref::<Reference>()?;

            let mut pieces = reference
                .reference
                .as_ref()
                .and_then(|r| r.value.as_ref())
                .map(|r| r.split('/'))?;

            let resource_type = pieces.next()?;
            let id = pieces.next()?;

            if let Some(type_to_filter_by) = &type_to_filter_by
                && !check_type_name(resource_type, type_to_filter_by)
            {
                return None;
            }

            Some(FHIRId {
                value: Some(id.to_string()),
                ..Default::default()
            })
        })
        .collect::<Vec<_>>();

    let mut next_context = Vec::with_capacity(ids.len());

    for id in ids {
        next_context.push(context.allocate_literal(id));
    }

    Ok(context.new_context_from(next_context))
}

fn evaluate_get_resource_key<'a>(
    function: &FunctionInvocation,
    context: &Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    validate_arguments(&function.arguments, &Cardinality::Zero)?;

    let Some(id) = config.and_then(|c| c.resource_id.clone()) else {
        return Err(FHIRPathError::InternalError(
            "getResourceKey function requires resource_id in config".to_string(),
        ));
    };

    let resource_key = FHIRId {
        value: Some(id),
        ..Default::default()
    };

    Ok(context.new_context_from(vec![context.allocate_literal(resource_key)]))
}

fn equal_check<'b>(left: &Context<'b>, right: &Context<'b>) -> Result<bool, FHIRPathError> {
    if NUMBER_TYPES.contains(left.values[0].fhir_type())
        && NUMBER_TYPES.contains(right.values[0].fhir_type())
    {
        let left_value = downcast_number(left.values[0])?;
        let right_value = downcast_number(right.values[0])?;
        #[allow(clippy::float_cmp)]
        Ok(left_value == right_value)
    } else if STRING_TYPES.contains(left.values[0].fhir_type())
        && STRING_TYPES.contains(right.values[0].fhir_type())
    {
        let left_value = downcast_string(left.values[0])?;
        let right_value = downcast_string(right.values[0])?;
        Ok(left_value == right_value)
    } else if BOOLEAN_TYPES.contains(left.values[0].fhir_type())
        && BOOLEAN_TYPES.contains(right.values[0].fhir_type())
    {
        let left_value = downcast_bool(left.values[0])?;
        let right_value = downcast_bool(right.values[0])?;
        // Suppress clippy warning because strict equality comparison for float values
        // is intentional and required by the FHIRPath specification.
        #[allow(clippy::float_cmp)]
        Ok(left_value == right_value)
    } else {
        // https://hl7.org/fhirpath/N1/#conversion for implicit conversion rules todo.
        //
        // If types do not match return false.
        // Should consider implicit conversion rules here but for now
        // FPs like 'Patient.deceased.exists() and Patient.deceased != false' (deceased is either boolean or dateTime)
        // Should return false rather than error.
        Ok(false)
    }
}

async fn evaluate_operation<'a>(
    operation: &Operation,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    match operation {
        Operation::Add(left, right) => evaluate_add(left, right, context, config).await,
        Operation::Subtraction(left, right) => {
            evaluate_subtraction(left, right, context, config).await
        }
        Operation::Multiplication(left, right) => {
            evaluate_multiplication(left, right, context, config).await
        }
        Operation::Division(left, right) => evaluate_division(left, right, context, config).await,
        Operation::Equal(left, right) => evaluate_equal(left, right, context, config).await,
        Operation::NotEqual(left, right) => evaluate_not_equal(left, right, context, config).await,
        Operation::And(left, right) => evaluate_and(left, right, context, config).await,
        Operation::Or(left, right) => evaluate_or(left, right, context, config).await,
        Operation::Union(left, right) => evaluate_union(left, right, context, config).await,
        Operation::Is(expr, ty) => evaluate_is(expr, ty, context, config).await,
        Operation::As(expr, ty) => evaluate_as(expr, ty, context, config).await,
        Operation::XOr(left, right) => evaluate_xor(left, right, context, config).await,

        Operation::Modulo(_, _) => not_implemented("Modulo"),
        Operation::Polarity(_, _) => not_implemented("Polarity"),
        Operation::DivisionTruncated(_, _) => not_implemented("DivisionTruncated"),
        Operation::LessThan(left, right) => evaluate_less_than(left, right, context, config).await,
        Operation::GreaterThan(left, right) => {
            evaluate_greater_than(left, right, context, config).await
        }
        Operation::LessThanEqual(left, right) => {
            evaluate_less_than_equal(left, right, context, config).await
        }
        Operation::GreaterThanEqual(left, right) => {
            evaluate_greater_than_equal(left, right, context, config).await
        }
        Operation::Equivalent(_, _) => not_implemented("Equivalent"),
        Operation::NotEquivalent(_, _) => not_implemented("NotEquivalent"),
        Operation::In(_, _) => not_implemented("In"),
        Operation::Contains(_, _) => not_implemented("Contains"),
        Operation::Implies(_, _) => not_implemented("Implies"),
    }
}

fn not_implemented(name: &'static str) -> Result<Context<'static>, FHIRPathError> {
    Err(FHIRPathError::NotImplemented(name.to_string()))
}

async fn evaluate_add<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    operation_2(left, right, context, config, |left, right| {
        Box::pin(async move {
            if NUMBER_TYPES.contains(left.values[0].fhir_type())
                && NUMBER_TYPES.contains(right.values[0].fhir_type())
            {
                let left_value = downcast_number(left.values[0])?;
                let right_value = downcast_number(right.values[0])?;

                Ok(
                    left.new_context_from(vec![left.allocate_literal(FHIRDecimal {
                        value: Some(left_value + right_value),
                        ..Default::default()
                    })]),
                )
            } else if STRING_TYPES.contains(left.values[0].fhir_type())
                && STRING_TYPES.contains(right.values[0].fhir_type())
            {
                let left_string = downcast_string(left.values[0])?;
                let right_string = downcast_string(right.values[0])?;

                Ok(
                    left.new_context_from(vec![left.allocate_literal(FHIRString {
                        value: Some(left_string + &right_string),
                        ..Default::default()
                    })]),
                )
            } else {
                Err(FHIRPathError::OperationError(OperationError::TypeMismatch(
                    left.values[0].fhir_type(),
                    right.values[0].fhir_type(),
                )))
            }
        })
    })
    .await
}

async fn evaluate_numeric_binary<'a, F>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
    op: F,
) -> Result<Context<'a>, FHIRPathError>
where
    F: FnOnce(f64, f64) -> f64 + Copy + Send + 'static,
{
    operation_2(left, right, context, config, move |left, right| {
        Box::pin(async move {
            let left_value = downcast_number(left.values[0])?;
            let right_value = downcast_number(right.values[0])?;

            Ok(
                left.new_context_from(vec![left.allocate_literal(FHIRDecimal {
                    value: Some(op(left_value, right_value)),
                    ..Default::default()
                })]),
            )
        })
    })
    .await
}

async fn evaluate_numerical_comparison<'a, F>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
    op: F,
) -> Result<Context<'a>, FHIRPathError>
where
    F: FnOnce(f64, f64) -> bool + Copy + Send + 'static,
{
    operation_2(left, right, context, config, move |left, right| {
        Box::pin(async move {
            let left_value = downcast_number(left.values[0])?;
            let right_value = downcast_number(right.values[0])?;

            Ok(
                left.new_context_from(vec![left.allocate_literal(FHIRBoolean {
                    value: Some(op(left_value, right_value)),
                    ..Default::default()
                })]),
            )
        })
    })
    .await
}
async fn evaluate_subtraction<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_numeric_binary(left, right, context, config, |l, r| l - r).await
}

async fn evaluate_multiplication<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_numeric_binary(left, right, context, config, |l, r| l * r).await
}

async fn evaluate_division<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_numeric_binary(left, right, context, config, |l, r| l / r).await
}

async fn evaluate_less_than<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_numerical_comparison(left, right, context, config, |l, r| l < r).await
}

async fn evaluate_less_than_equal<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_numerical_comparison(left, right, context, config, |l, r| l <= r).await
}

async fn evaluate_greater_than<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_numerical_comparison(left, right, context, config, |l, r| l > r).await
}

async fn evaluate_greater_than_equal<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_numerical_comparison(left, right, context, config, |l, r| l >= r).await
}

async fn evaluate_boolean_binary<'a, F>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
    op: F,
) -> Result<Context<'a>, FHIRPathError>
where
    F: FnOnce(bool, bool) -> bool + Copy + Send + 'static,
{
    operation_2(left, right, context, config, move |left, right| {
        Box::pin(async move {
            let l = downcast_bool(left.values[0])?;
            let r = downcast_bool(right.values[0])?;

            Ok(
                left.new_context_from(vec![left.allocate_literal(FHIRBoolean {
                    value: Some(op(l, r)),
                    ..Default::default()
                })]),
            )
        })
    })
    .await
}

async fn evaluate_and<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_boolean_binary(left, right, context, config, |l, r| l && r).await
}

async fn evaluate_or<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_boolean_binary(left, right, context, config, |l, r| l || r).await
}

async fn evaluate_xor<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_boolean_binary(left, right, context, config, |l, r| l ^ r).await
}

async fn evaluate_equality<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
    negate: bool,
) -> Result<Context<'a>, FHIRPathError> {
    operation_2(left, right, context, config, move |left, right| {
        Box::pin(async move {
            let mut result = equal_check(&left, &right)?;

            if negate {
                result = !result;
            }

            Ok(
                left.new_context_from(vec![left.allocate_literal(FHIRBoolean {
                    value: Some(result),
                    ..Default::default()
                })]),
            )
        })
    })
    .await
}

async fn evaluate_equal<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_equality(left, right, context, config, false).await
}

async fn evaluate_not_equal<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_equality(left, right, context, config, true).await
}

async fn evaluate_union<'a>(
    left: &Expression,
    right: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    operation_n(left, right, context, config, |left, right| {
        let mut union = Vec::with_capacity(left.values.len() + right.values.len());
        union.extend(left.values.iter());
        union.extend(right.values.iter());

        Ok(left.new_context_from(union))
    })
    .await
}

async fn evaluate_type_operation<'a>(
    expression: &Expression,
    type_name: &QualifiedIdentifier,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
    return_context: bool,
) -> Result<Context<'a>, FHIRPathError> {
    let left = evaluate_expression(expression, context, config).await?;

    if left.values.len() > 1 {
        return Err(FHIRPathError::OperationError(
            OperationError::InvalidCardinality,
        ));
    }

    let Some(type_name) = type_name.0.first().map(|id| &id.0) else {
        return Ok(left.new_context_from(vec![]));
    };

    let filtered = filter_by_type(type_name, &left);

    if return_context {
        Ok(filtered)
    } else {
        Ok(
            left.new_context_from(vec![left.allocate_literal(FHIRBoolean {
                value: Some(!filtered.values.is_empty()),
                ..Default::default()
            })]),
        )
    }
}

async fn evaluate_is<'a>(
    expression: &Expression,
    type_name: &QualifiedIdentifier,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_type_operation(expression, type_name, context, config, false).await
}

async fn evaluate_as<'a>(
    expression: &Expression,
    type_name: &QualifiedIdentifier,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Result<Context<'a>, FHIRPathError> {
    evaluate_type_operation(expression, type_name, context, config, true).await
}

fn evaluate_expression<'a>(
    ast: &Expression,
    context: Context<'a>,
    config: Option<Arc<Config<'a>>>,
) -> Pin<Box<impl Future<Output = Result<Context<'a>, FHIRPathError>>>> {
    Box::pin(async move {
        match ast {
            Expression::Operation(operation) => {
                evaluate_operation(operation, context, config).await
            }
            Expression::Singular(singular_ast) => {
                evaluate_singular(singular_ast, context, config).await
            }
        }
    })
}

#[derive(Debug)]
pub enum ResolvedValue {
    Box(Box<dyn MetaValue>),
    Arc(Arc<dyn MetaValue>),
}

impl ResolvedValue {
    #[must_use]
    pub fn as_meta_value(&self) -> &dyn MetaValue {
        match self {
            ResolvedValue::Box(b) => &**b,
            ResolvedValue::Arc(a) => &**a,
        }
    }
}

pub struct Context<'a> {
    allocator: Arc<Mutex<allocators::bumpalo::Allocator>>,
    values: Vec<&'a dyn MetaValue>,
}

pub type ResolvedValueFuture = Pin<Box<dyn Future<Output = Option<ResolvedValue>> + Send>>;
pub type ResolveValueCallback = Box<dyn Fn(String) -> ResolvedValueFuture + Send + Sync>;

pub enum ExternalConstantResolver<'a> {
    Function(ResolveValueCallback),
    Variable(Arc<HashMap<String, &'a dyn MetaValue>>),
}

#[derive(Default)]
pub struct Config<'a> {
    // Used to resolve resource_id in getResourceKey for sql-on-fhir.
    resource_id: Option<String>,
    variable_resolver: Option<ExternalConstantResolver<'a>>,
}

impl<'a> Config<'a> {
    #[must_use]
    pub fn builder() -> Self {
        Config::default()
    }

    #[must_use]
    pub fn with_variable_resolver(mut self, resolver: ExternalConstantResolver<'a>) -> Self {
        self.variable_resolver = Some(resolver);
        self
    }

    #[must_use]
    pub fn with_resource_id(mut self, resource_id: String) -> Self {
        self.resource_id = Some(resource_id);
        self
    }
}

async fn resolve_external_constant<'a>(
    name: &str,
    resolver: Option<&ExternalConstantResolver<'a>>,
    context: Context<'a>,
) -> Result<Context<'a>, FHIRPathError> {
    let external_constant = match resolver {
        Some(ExternalConstantResolver::Function(func)) => {
            let result = func(name.to_string()).await;

            result.map(|result| context.allocate(result))
        }
        Some(ExternalConstantResolver::Variable(map)) => map.get(name).copied(),
        None => None,
    };

    if let Some(result) = external_constant {
        return Ok(context.new_context_from(vec![result]));
    }
    Ok(context.new_context_from(vec![]))
}

impl<'a> IntoIterator for &'a Context<'_> {
    type Item = &'a dyn haste_reflect::MetaValue;

    type IntoIter = std::boxed::Box<
        dyn std::iter::Iterator<Item = &'a (dyn haste_reflect::MetaValue + 'static)> + 'a,
    >;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

impl<'a> Context<'a> {
    fn new(
        values: Vec<&'a dyn MetaValue>,
        allocator: Arc<Mutex<allocators::bumpalo::Allocator>>,
    ) -> Self {
        Self { allocator, values }
    }
    fn new_context_from(&self, values: Vec<&'a dyn MetaValue>) -> Self {
        Self {
            allocator: self.allocator.clone(),
            values,
        }
    }
    fn allocate(&self, value: ResolvedValue) -> &'a dyn MetaValue {
        self.allocator
            .lock()
            .unwrap_or_else(std::sync::PoisonError::into_inner)
            .allocate_resolved(value)
    }

    fn allocate_literal<T: MetaValue>(&self, value: T) -> &'a dyn MetaValue {
        self.allocator
            .lock()
            .unwrap_or_else(std::sync::PoisonError::into_inner)
            .allocate_literal(value)
    }

    #[must_use]
    pub fn iter(&'a self) -> Box<dyn Iterator<Item = &'a dyn MetaValue> + 'a> {
        Box::new(self.values.iter().copied())
    }
}

impl Clone for Context<'_> {
    fn clone(&self) -> Self {
        Self {
            allocator: self.allocator.clone(),
            values: self.values.clone(),
        }
    }
}

pub struct FPEngine {}

static AST: LazyLock<DashMap<String, Arc<Expression>>> = LazyLock::new(DashMap::new);

fn get_ast(path: &str) -> Result<Arc<Expression>, FHIRPathError> {
    if let Some(expression_ast) = AST.get(path) {
        return Ok(expression_ast.clone());
    }

    let expression_ast = Arc::new(parser::parse(path)?);
    AST.insert(path.to_string(), expression_ast.clone());

    Ok(expression_ast)
}

impl Default for FPEngine {
    fn default() -> Self {
        Self::new()
    }
}

impl FPEngine {
    #[must_use]
    pub fn new() -> Self {
        Self {}
    }

    /// Evaluate a `FHIRPath` expression against a context.
    /// The context is a vector of references to `MetaValue` objects.
    /// The path is a `FHIRPath` expression.
    /// The result is a vector of references to `MetaValue` objects.
    ///
    /// # Errors
    ///
    /// Returns a [`FHIRPathError`] if the expression parsing fails (bad AST)
    /// or if the evaluation engine encounters an error during execution.
    pub async fn evaluate<'a, 'b>(
        &self,
        path: &str,
        values: Vec<&'a dyn MetaValue>,
    ) -> Result<Context<'b>, FHIRPathError>
    where
        'a: 'b,
    {
        let ast = get_ast(path)?;

        // Store created.
        let allocator: Arc<Mutex<allocators::bumpalo::Allocator>> =
            Arc::new(Mutex::new(allocators::bumpalo::Allocator::new()));

        let context = Context::new(values, allocator.clone());

        let result = evaluate_expression(&ast, context, None).await?;
        Ok(result)
    }

    /// Evaluate a `FHIRPath` expression against a context.
    /// The context is a vector of references to `MetaValue` objects.
    /// The path is a `FHIRPath` expression.
    /// The result is a vector of references to `MetaValue` objects.
    ///
    /// # Errors
    ///
    /// Returns a [`FHIRPathError`] if the expression parsing fails (bad AST)
    /// or if the evaluation engine encounters an error during execution.
    pub async fn evaluate_with_config<'a, 'b>(
        &self,
        path: &str,
        values: Vec<&'a dyn MetaValue>,
        config: Arc<Config<'b>>,
    ) -> Result<Context<'b>, FHIRPathError>
    where
        'a: 'b,
    {
        let ast = get_ast(path)?;

        // Store created.
        let allocator = Arc::new(Mutex::new(allocators::bumpalo::Allocator::new()));

        let context = Context::new(values, allocator.clone());

        let result = evaluate_expression(&ast, context, Some(config)).await?;

        Ok(result)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use haste_fhir_model::r4::{
        datetime::DateTime,
        generated::{
            resources::{
                Bundle, Group, GroupMember, Patient, PatientDeceasedTypeChoice, PatientLink,
                Resource, SearchParameter,
            },
            types::{
                Extension, ExtensionValueTypeChoice, FHIRDateTime, FHIRString, FHIRUri, HumanName,
                Identifier, Reference,
            },
        },
    };

    use haste_reflect_derive::Reflect;

    #[derive(Reflect, Debug)]
    #[fhir_type = "BackboneElement"]
    struct C {
        c: String,
    }

    #[derive(Reflect, Debug)]
    #[fhir_type = "BackboneElement"]
    struct B {
        b: Vec<C>,
    }

    #[derive(Reflect, Debug)]
    #[fhir_type = "BackboneElement"]
    struct A {
        a: Vec<B>,
    }

    fn load_search_parameters() -> Vec<SearchParameter> {
        let json = include_str!(
            "../../../../artifacts/r4/hl7-core/definitions/hl7/search-parameters.min.json"
        );
        let bundle = serde_json::from_str::<Bundle>(json).unwrap();

        bundle
            .entry
            .unwrap_or_default()
            .into_iter()
            .filter_map(|e| e.resource)
            .filter_map(|e| match *e {
                Resource::SearchParameter(sp) => Some(sp),
                _ => None,
            })
            .collect()
    }

    #[tokio::test]
    async fn filter_typechoice_test() {
        let patient = Patient {
            id: Some("patient-id".to_string()),
            deceased: Some(PatientDeceasedTypeChoice::Boolean(Box::new(FHIRBoolean {
                value: Some(true),
                ..Default::default()
            }))),
            ..Default::default()
        };

        let engine = FPEngine::new();
        let result = engine
            .evaluate("(Patient.deceased.ofType(dateTime))", vec![&patient])
            .await
            .unwrap();

        assert_eq!(result.values.len(), 0);

        let result = engine
            .evaluate("(Patient.deceased.ofType(boolean))", vec![&patient])
            .await
            .unwrap();

        let value = result.values[0];
        let boolean_value: &FHIRBoolean = value
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .expect("Failed to downcast to FHIRBoolean");

        assert_eq!(boolean_value.value, Some(true));

        let patient = Patient {
            id: Some("patient-id".to_string()),
            deceased: Some(PatientDeceasedTypeChoice::DateTime(Box::new(
                FHIRDateTime {
                    value: Some(DateTime::Year(1980)),
                    ..Default::default()
                },
            ))),
            ..Default::default()
        };

        let result = engine
            .evaluate("(Patient.deceased.ofType(boolean))", vec![&patient])
            .await
            .unwrap();

        assert_eq!(result.values.len(), 0);

        let result = engine
            .evaluate("(Patient.deceased.ofType(dateTime))", vec![&patient])
            .await
            .unwrap();

        assert_eq!(result.values.len(), 1);

        let value = result.values[0];
        let datetime_value: &FHIRDateTime = value
            .as_any()
            .downcast_ref::<FHIRDateTime>()
            .expect("Failed to downcast to FHIRDateTime");

        assert_eq!(datetime_value.value, Some(DateTime::Year(1980)));
    }

    #[tokio::test]
    async fn test_variable_resolution() {
        let engine = FPEngine::new();
        let patient = Patient {
            id: Some("my-patient".to_string()),
            ..Default::default()
        };
        let config = Arc::new(
            Config::builder().with_variable_resolver(ExternalConstantResolver::Variable(Arc::new(
                vec![("patient".to_string(), &patient as &dyn MetaValue)]
                    .into_iter()
                    .collect(),
            ))),
        );

        let result = engine
            .evaluate_with_config("%patient", vec![], config.clone())
            .await
            .unwrap();

        assert_eq!(result.values.len(), 1);
        let p = result.values[0].as_any().downcast_ref::<Patient>().unwrap();

        assert_eq!(p.id, patient.id);

        let result_failed = engine
            .evaluate_with_config("%nobody", vec![], config)
            .await
            .unwrap();

        assert_eq!(result_failed.values.len(), 0);
    }

    #[tokio::test]
    async fn test_where_clause() {
        let engine = FPEngine::new();
        let mut patient = Patient::default();
        let mut identifier = Identifier::default();
        let extension = Extension {
            id: None,
            url: "test-extension".to_string(),
            extension: None,
            value: Some(ExtensionValueTypeChoice::String(Box::new(FHIRString {
                id: None,
                extension: None,
                value: Some("example value".to_string()),
            }))),
        };
        identifier.value = Some(Box::new(FHIRString {
            id: None,
            extension: Some(vec![extension]),
            value: Some("12345".to_string()),
        }));
        patient.identifier_ = Some(vec![identifier]);

        let context = engine
            .evaluate(
                "$this.identifier.value.where($this.extension.value.exists())",
                vec![&patient],
            )
            .await;

        assert_eq!(context.unwrap().values.len(), 1);

        let context = engine
            .evaluate(
                "$this.identifier.value.where($this.extension.extension.exists())",
                vec![&patient],
            )
            .await;
        assert_eq!(context.unwrap().values.len(), 0);
    }

    #[tokio::test]
    async fn test_all_parameters() {
        let search_parameters = load_search_parameters();
        for param in &search_parameters {
            if let Some(expression) = &param.expression {
                let engine = FPEngine::new();
                let context = engine
                    .evaluate(expression.value.as_ref().unwrap().as_str(), vec![])
                    .await;

                if let Err(err) = context {
                    panic!(
                        "Failed to evaluate search parameter '{}': {}",
                        expression.value.as_ref().unwrap(),
                        err
                    );
                }
            }
        }
    }

    fn test_patient() -> Patient {
        let mut patient = Patient::default();
        let name = HumanName {
            given: Some(vec![FHIRString {
                id: None,
                extension: None,
                value: Some("Bob".to_string()),
            }]),
            ..Default::default()
        };
        let mrn_identifier = Identifier {
            value: Some(Box::new(FHIRString {
                id: None,
                extension: None,
                value: Some("mrn-12345".to_string()),
            })),
            system: Some(Box::new(FHIRUri {
                id: None,
                extension: None,
                value: Some("mrn".to_string()),
            })),
            ..Default::default()
        };
        let ssn_identifier = Identifier {
            value: Some(Box::new(FHIRString {
                id: None,
                extension: None,
                value: Some("ssn-12345".to_string()),
            })),
            system: Some(Box::new(FHIRUri {
                id: None,
                extension: None,
                value: Some("ssn".to_string()),
            })),
            ..Default::default()
        };

        patient.identifier_ = Some(vec![mrn_identifier, ssn_identifier]);
        patient.name = Some(vec![name]);
        patient
    }

    #[tokio::test]
    async fn indexing_tests() {
        let engine = FPEngine::new();
        let patient = test_patient();

        let given_name = engine
            .evaluate("$this.name.given[0]", vec![&patient])
            .await
            .unwrap();

        assert_eq!(given_name.values.len(), 1);
        let value = given_name.values[0];
        let name: &FHIRString = value
            .as_any()
            .downcast_ref::<FHIRString>()
            .expect("Failed to downcast to FHIRString");

        assert_eq!(name.value.as_deref(), Some("Bob"));

        let ssn_identifier = engine
            .evaluate("$this.identifier[1]", vec![&patient])
            .await
            .unwrap();

        assert_eq!(ssn_identifier.values.len(), 1);
        let value = ssn_identifier.values[0];
        let identifier: &Identifier = value
            .as_any()
            .downcast_ref::<Identifier>()
            .expect("Failed to downcast to Identifier");

        assert_eq!(
            identifier.value.as_ref().unwrap().value.as_deref(),
            Some("ssn-12345")
        );

        let all_identifiers = engine
            .evaluate("$this.identifier", vec![&patient])
            .await
            .unwrap();
        assert_eq!(all_identifiers.values.len(), 2);
    }

    #[tokio::test]
    async fn where_testing() {
        let engine = FPEngine::new();
        let patient = test_patient();

        let name_where_clause = engine
            .evaluate(
                "$this.name.given.where($this.value = 'Bob')",
                vec![&patient],
            )
            .await
            .unwrap();

        assert_eq!(name_where_clause.values.len(), 1);
        let value = name_where_clause.values[0];
        let name: &FHIRString = value
            .as_any()
            .downcast_ref::<FHIRString>()
            .expect("Failed to downcast to FHIRString");

        assert_eq!(name.value.as_deref(), Some("Bob"));

        let ssn_identifier_clause = engine
            .evaluate(
                "$this.identifier.where($this.system.value = 'ssn')",
                vec![&patient],
            )
            .await
            .unwrap();
        assert_eq!(ssn_identifier_clause.values.len(), 1);

        let ssn_identifier = ssn_identifier_clause.values[0]
            .as_any()
            .downcast_ref::<Identifier>()
            .expect("Failed to downcast to Identifier");

        assert_eq!(
            ssn_identifier.value.as_ref().unwrap().value.as_deref(),
            Some("ssn-12345")
        );
    }

    #[tokio::test]
    async fn test_equality() {
        let engine = FPEngine::new();

        // String tests
        let string_equal = engine.evaluate("'test' = 'test'", vec![]).await.unwrap();
        for r in &string_equal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(b);
        }
        let string_unequal = engine.evaluate("'invalid' = 'test'", vec![]).await.unwrap();
        for r in &string_unequal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(!b);
        }

        // Number tests
        let number_equal = engine.evaluate("12 = 12", vec![]).await.unwrap();
        for r in &number_equal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(b);
        }
        let number_unequal = engine.evaluate("13 = 12", vec![]).await.unwrap();
        for r in &number_unequal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(!b);
        }

        // Boolean tests
        let bool_equal = engine.evaluate("false = false", vec![]).await.unwrap();
        for r in &bool_equal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(b);
        }
        let bool_unequal = engine.evaluate("false = true", vec![]).await.unwrap();
        for r in &bool_unequal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(!b);
        }

        // Nested Equality tests
        let bool_equal = engine.evaluate("12 = 13 = false", vec![]).await.unwrap();
        for r in &bool_equal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(b);
        }
        let bool_unequal = engine.evaluate("12 = 13 = true", vec![]).await.unwrap();
        for r in &bool_unequal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(!b);
        }
        let bool_unequal = engine.evaluate("12 = (13 - 1)", vec![]).await.unwrap();
        for r in &bool_unequal {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();
            assert!(b);
        }
    }

    #[tokio::test]
    async fn test_string_concat() {
        let engine = FPEngine::new();
        let patient = test_patient();

        let simple_result = engine.evaluate("'Hello' + ' World'", vec![]).await.unwrap();
        for r in &simple_result {
            let s = r.as_any().downcast_ref::<FHIRString>().unwrap().clone();
            assert_eq!(s.value, Some("Hello World".to_string()));
        }

        let simple_result = engine
            .evaluate("$this.name.given + ' Miller'", vec![&patient])
            .await
            .unwrap();
        for r in &simple_result {
            let s = r.as_any().downcast_ref::<FHIRString>().unwrap().clone();
            assert_eq!(s.value, Some("Bob Miller".to_string()));
        }
    }

    #[tokio::test]
    async fn test_simple() {
        let root = A {
            a: vec![B {
                b: vec![C {
                    c: "whatever".to_string(),
                }],
            }],
        };

        let engine = FPEngine::new();
        let result = engine.evaluate("a.b.c", vec![&root]).await.unwrap();

        let strings: Vec<&String> = result
            .iter()
            .map(|r| r.as_any().downcast_ref::<String>().unwrap())
            .collect();

        assert_eq!(strings, vec!["whatever"]);
    }

    #[tokio::test]
    async fn allocation() {
        let engine = FPEngine::new();
        let result = engine.evaluate("'asdf'", vec![]).await.unwrap();

        for r in &result {
            let s = r.as_any().downcast_ref::<FHIRString>().unwrap().clone();

            assert_eq!(s.value, Some("asdf".to_string()));
        }
    }

    #[tokio::test]
    async fn order_operation() {
        let engine = FPEngine::new();
        let result = engine.evaluate("45 + 2  * 3", vec![]).await.unwrap();

        for r in &result {
            let s = r.as_any().downcast_ref::<FHIRDecimal>().unwrap().clone();

            assert_eq!(s.value, Some(51.0));
        }
    }

    #[tokio::test]
    async fn xor_operation() {
        let engine = FPEngine::new();
        let result = engine.evaluate("true xor true", vec![]).await.unwrap();

        for r in &result {
            let b = r
                .as_any()
                .downcast_ref::<FHIRBoolean>()
                .unwrap()
                .value
                .unwrap();

            assert!(!b);
        }
    }

    #[tokio::test]
    async fn domain_resource_filter() {
        let engine = FPEngine::new();

        let patient =
            serde_json::from_str::<Resource>(r#"{"id": "patient-id", "resourceType": "Patient"}"#)
                .unwrap();
        let result = engine
            .evaluate("Resource.id", vec![&patient])
            .await
            .unwrap();
        let ids: Vec<&String> = result
            .iter()
            .map(|r| r.as_any().downcast_ref::<String>().unwrap())
            .collect();

        assert_eq!(ids.len(), 1);
        assert_eq!(ids[0], "patient-id");

        let result2 = engine
            .evaluate("DomainResource.id", vec![&patient])
            .await
            .unwrap();
        let ids2: Vec<&String> = result2
            .iter()
            .map(|r| r.as_any().downcast_ref::<String>().unwrap())
            .collect();
        assert_eq!(ids2.len(), 1);
        assert_eq!(ids2[0], "patient-id");
    }

    #[tokio::test]
    async fn type_test() {
        let engine = FPEngine::new();
        let patient = Patient::default();

        let result = engine
            .evaluate("$this.type().name", vec![&patient])
            .await
            .unwrap();
        let ids: Vec<&String> = result
            .iter()
            .map(|r| r.as_any().downcast_ref::<String>().unwrap())
            .collect();

        assert_eq!(ids.len(), 1);
        assert_eq!(ids[0], "Patient");
    }

    #[tokio::test]
    async fn resolve_test() {
        let engine = FPEngine::new();
        let observation = serde_json::from_str::<Resource>(r#"
             {
                "resourceType": "Observation",
                "id": "f001",
                "text": {
                    "status": "generated",
                    "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\"><p><b>Generated Narrative with Details</b></p><p><b>id</b>: f001</p><p><b>identifier</b>: 6323 (OFFICIAL)</p><p><b>status</b>: final</p><p><b>code</b>: Glucose [Moles/volume] in Blood <span>(Details : {LOINC code '15074-8' = 'Glucose [Moles/volume] in Blood', given as 'Glucose [Moles/volume] in Blood'})</span></p><p><b>subject</b>: <a>P. van de Heuvel</a></p><p><b>effective</b>: 02/04/2013 9:30:10 AM --&gt; (ongoing)</p><p><b>issued</b>: 03/04/2013 3:30:10 PM</p><p><b>performer</b>: <a>A. Langeveld</a></p><p><b>value</b>: 6.3 mmol/l<span> (Details: UCUM code mmol/L = 'mmol/L')</span></p><p><b>interpretation</b>: High <span>(Details : {http://terminology.hl7.org/CodeSystem/v3-ObservationInterpretation code 'H' = 'High', given as 'High'})</span></p><h3>ReferenceRanges</h3><table><tr><td>-</td><td><b>Low</b></td><td><b>High</b></td></tr><tr><td>*</td><td>3.1 mmol/l<span> (Details: UCUM code mmol/L = 'mmol/L')</span></td><td>6.2 mmol/l<span> (Details: UCUM code mmol/L = 'mmol/L')</span></td></tr></table></div>"
                },
                "identifier": [
                    {
                    "use": "official",
                    "system": "http://www.bmc.nl/zorgportal/identifiers/observations",
                    "value": "6323"
                    }
                ],
                "status": "final",
                "code": {
                    "coding": [
                    {
                        "system": "http://loinc.org",
                        "code": "15074-8",
                        "display": "Glucose [Moles/volume] in Blood"
                    }
                    ]
                },
                "subject": {
                    "reference": "Patient/f001",
                    "display": "P. van de Heuvel"
                },
                "effectivePeriod": {
                    "start": "2013-04-02T09:30:10+01:00"
                },
                "issued": "2013-04-03T15:30:10+01:00",
                "performer": [
                    {
                    "reference": "Practitioner/f005",
                    "display": "A. Langeveld"
                    }
                ],
                "valueQuantity": {
                    "value": 6.3,
                    "unit": "mmol/l",
                    "system": "http://unitsofmeasure.org",
                    "code": "mmol/L"
                },
                "interpretation": [
                    {
                    "coding": [
                        {
                        "system": "http://terminology.hl7.org/CodeSystem/v3-ObservationInterpretation",
                        "code": "H",
                        "display": "High"
                        }
                    ]
                    }
                ],
                "referenceRange": [
                    {
                    "low": {
                        "value": 3.1,
                        "unit": "mmol/l",
                        "system": "http://unitsofmeasure.org",
                        "code": "mmol/L"
                    },
                    "high": {
                        "value": 6.2,
                        "unit": "mmol/l",
                        "system": "http://unitsofmeasure.org",
                        "code": "mmol/L"
                    }
                    }
                ]
                }
            "#).unwrap();

        let result = engine
            .evaluate(
                "Observation.subject.where(resolve() is Patient)",
                vec![&observation],
            )
            .await
            .unwrap();

        let references: Vec<&Reference> = result
            .iter()
            .map(|r| r.as_any().downcast_ref::<Reference>().unwrap())
            .collect();

        assert_eq!(references.len(), 1);
        assert_eq!(
            references[0].reference.as_ref().unwrap().value,
            Some("Patient/f001".to_string())
        );
    }

    #[tokio::test]
    async fn children_test() {
        let engine = FPEngine::new();
        let patient = Patient {
            name: Some(vec![HumanName {
                given: Some(vec![FHIRString {
                    value: Some("Alice".to_string()),
                    ..Default::default()
                }]),
                ..Default::default()
            }]),
            deceased: Some(PatientDeceasedTypeChoice::Boolean(Box::new(FHIRBoolean {
                value: Some(true),
                ..Default::default()
            }))),
            ..Default::default()
        };

        let result = engine
            .evaluate("$this.children()", vec![&patient])
            .await
            .unwrap();

        assert_eq!(result.values.len(), 2);
        assert_eq!(
            result
                .values
                .iter()
                .map(|v| v.fhir_type())
                .collect::<Vec<_>>(),
            vec!["HumanName", "boolean"]
        );
    }

    #[tokio::test]
    async fn repeat_test() {
        let engine = FPEngine::new();
        let patient = Patient {
            name: Some(vec![HumanName {
                given: Some(vec![FHIRString {
                    value: Some("Alice".to_string()),
                    ..Default::default()
                }]),
                ..Default::default()
            }]),
            deceased: Some(PatientDeceasedTypeChoice::Boolean(Box::new(FHIRBoolean {
                value: Some(true),
                ..Default::default()
            }))),
            ..Default::default()
        };

        let result = engine
            .evaluate("$this.name.given", vec![&patient])
            .await
            .unwrap();

        assert_eq!(result.values.len(), 1);

        assert_eq!(result.values[0].fhir_type(), "string");

        let result = engine
            .evaluate("$this.repeat(children())", vec![&patient])
            .await
            .unwrap();

        assert_eq!(
            result
                .values
                .iter()
                .map(|v| v.fhir_type())
                .collect::<Vec<_>>(),
            vec![
                "HumanName",
                "boolean",
                "string",
                "http://hl7.org/fhirpath/System.Boolean",
                "http://hl7.org/fhirpath/System.String"
            ]
        );
    }
    #[tokio::test]
    async fn descendants_test() {
        let engine = FPEngine::new();
        let patient = Patient {
            name: Some(vec![HumanName {
                given: Some(vec![FHIRString {
                    value: Some("Alice".to_string()),
                    ..Default::default()
                }]),
                ..Default::default()
            }]),
            deceased: Some(PatientDeceasedTypeChoice::Boolean(Box::new(FHIRBoolean {
                value: Some(true),
                ..Default::default()
            }))),
            ..Default::default()
        };
        let result = engine
            .evaluate("descendants()", vec![&patient])
            .await
            .unwrap();

        assert_eq!(
            result
                .values
                .iter()
                .map(|v| v.fhir_type())
                .collect::<Vec<_>>(),
            vec![
                "HumanName",
                "boolean",
                "string",
                "http://hl7.org/fhirpath/System.Boolean",
                "http://hl7.org/fhirpath/System.String"
            ]
        );
    }

    #[tokio::test]
    async fn descendants_test_filter() {
        let engine = FPEngine::new();
        let patient = Patient {
            link: Some(vec![PatientLink {
                other: Box::new(Reference {
                    reference: Some(Box::new(FHIRString {
                        value: Some("Patient/123".to_string()),
                        ..Default::default()
                    })),
                    ..Default::default()
                }),
                ..Default::default()
            }]),
            name: Some(vec![HumanName {
                given: Some(vec![FHIRString {
                    value: Some("Alice".to_string()),
                    ..Default::default()
                }]),
                ..Default::default()
            }]),
            deceased: Some(PatientDeceasedTypeChoice::Boolean(Box::new(FHIRBoolean {
                value: Some(true),
                ..Default::default()
            }))),
            ..Default::default()
        };
        let result = engine
            .evaluate("descendants()", vec![&patient])
            .await
            .unwrap();

        assert_eq!(
            result
                .values
                .iter()
                .map(|v| v.fhir_type())
                .collect::<Vec<_>>(),
            vec![
                "HumanName",
                "boolean",
                "BackboneElement",
                "string",
                "http://hl7.org/fhirpath/System.Boolean",
                "Reference",
                "http://hl7.org/fhirpath/System.String",
                "string",
                "http://hl7.org/fhirpath/System.String"
            ]
        );

        let result = engine
            .evaluate("descendants().ofType(Reference)", vec![&patient])
            .await
            .unwrap();

        assert_eq!(
            result
                .values
                .iter()
                .map(|v| v.fhir_type())
                .collect::<Vec<_>>(),
            vec!["Reference",]
        );

        let value = result.values[0]
            .as_any()
            .downcast_ref::<Reference>()
            .unwrap();

        assert_eq!(
            value.reference.as_ref().unwrap().value.as_ref().unwrap(),
            "Patient/123"
        );
    }

    #[tokio::test]
    async fn try_unsafe_set_from_ref() {
        let engine = FPEngine::new();
        let patient = Patient {
            link: Some(vec![PatientLink {
                other: Box::new(Reference {
                    reference: Some(Box::new(FHIRString {
                        value: Some("Patient/123".to_string()),
                        ..Default::default()
                    })),
                    ..Default::default()
                }),
                ..Default::default()
            }]),
            name: Some(vec![HumanName {
                given: Some(vec![FHIRString {
                    value: Some("Alice".to_string()),
                    ..Default::default()
                }]),
                ..Default::default()
            }]),
            deceased: Some(PatientDeceasedTypeChoice::Boolean(Box::new(FHIRBoolean {
                value: Some(true),
                ..Default::default()
            }))),
            ..Default::default()
        };

        let result = engine
            .evaluate("descendants().ofType(Reference)", vec![&patient])
            .await
            .unwrap();

        assert_eq!(
            result
                .values
                .iter()
                .map(|v| v.fhir_type())
                .collect::<Vec<_>>(),
            vec!["Reference",]
        );

        let value = result.values[0]
            .as_any()
            .downcast_ref::<Reference>()
            .unwrap();

        assert_eq!(
            value.reference.as_ref().unwrap().value.as_ref().unwrap(),
            "Patient/123"
        );

        // An example for use in transaction processing where we have a reference to an object
        // but need to modify it in place.
        unsafe {
            let r = std::ptr::from_ref::<Reference>(value);
            let mut_ptr = r.cast_mut();

            (*mut_ptr).reference = Some(Box::new(FHIRString {
                value: Some("Patient/456".to_string()),
                ..Default::default()
            }));
        }

        assert_eq!(
            value.reference.as_ref().unwrap().value.as_ref().unwrap(),
            "Patient/456"
        );

        assert_eq!(
            patient.link.as_ref().unwrap()[0]
                .other
                .reference
                .as_ref()
                .unwrap()
                .value
                .as_ref()
                .unwrap(),
            "Patient/456"
        );
    }

    #[tokio::test]
    async fn test_external_constant_function() {
        let engine = FPEngine::new();

        let config = Arc::new(Config::builder().with_variable_resolver(
            ExternalConstantResolver::Function(Box::new(|v| {
                Box::pin(async move {
                    match v.as_ref() {
                        "test_variable" => Some(ResolvedValue::Box(Box::new(Patient {
                            name: Some(vec![HumanName {
                                given: Some(vec![FHIRString {
                                    value: Some("Paul".to_string()),
                                    ..Default::default()
                                }]),
                                ..Default::default()
                            }]),
                            ..Default::default()
                        })
                            as Box<dyn MetaValue>)),
                        _ => None,
                    }
                })
            })),
        ));

        let result = engine
            .evaluate_with_config("%test_variable.name.given", vec![], config)
            .await
            .unwrap();

        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();

        assert_eq!(value.value.as_ref(), Some(&"Paul".to_string()));
    }

    #[tokio::test]
    async fn test_external_constant_function_reference() {
        let engine = FPEngine::new();

        let patient = Arc::new(Patient {
            name: Some(vec![HumanName {
                given: Some(vec![FHIRString {
                    value: Some("Paul".to_string()),
                    ..Default::default()
                }]),
                ..Default::default()
            }]),
            ..Default::default()
        });

        let resolver = {
            let patient = patient.clone();
            ExternalConstantResolver::Function(Box::new(move |v| {
                let patient = patient.clone();
                Box::pin(async move {
                    // let patient = patient.clone();
                    match v.as_ref() {
                        "test_variable" => Some(ResolvedValue::Arc(patient.clone())),
                        _ => None,
                    }
                })
            }))
        };

        let config = Arc::new(Config::builder().with_variable_resolver(resolver));

        let result = engine
            .evaluate_with_config("%test_variable.name.given", vec![], config)
            .await
            .unwrap();

        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();

        assert_eq!(value.value.as_ref(), Some(&"Paul".to_string()));
    }

    #[tokio::test]
    async fn test_upper_function() {
        let engine = FPEngine::new();

        let result = engine.evaluate("'hello'.upper()", vec![]).await.unwrap();
        assert_eq!(result.values.len(), 1);
        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();
        assert_eq!(value.value.as_deref(), Some("HELLO"));

        let result = engine.evaluate("'AbCd'.upper()", vec![]).await.unwrap();
        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();
        assert_eq!(value.value.as_deref(), Some("ABCD"));

        let result = engine.evaluate("'XYZ'.upper()", vec![]).await.unwrap();
        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();
        assert_eq!(value.value.as_deref(), Some("XYZ"));
    }

    #[tokio::test]
    async fn test_lower_function() {
        let engine = FPEngine::new();

        let result = engine.evaluate("'HELLO'.lower()", vec![]).await.unwrap();
        assert_eq!(result.values.len(), 1);
        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();
        assert_eq!(value.value.as_deref(), Some("hello"));

        let result = engine.evaluate("'AbCd'.lower()", vec![]).await.unwrap();
        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();
        assert_eq!(value.value.as_deref(), Some("abcd"));

        let result = engine.evaluate("'xyz'.lower()", vec![]).await.unwrap();
        let value = result.values[0]
            .as_any()
            .downcast_ref::<FHIRString>()
            .unwrap();
        assert_eq!(value.value.as_deref(), Some("xyz"));
    }

    #[tokio::test]
    async fn get_resource_key() {
        let engine = FPEngine::new();
        let fp_config = Config::builder().with_resource_id("asdf".to_string());

        let result = engine
            .evaluate_with_config("getResourceKey()", vec![], Arc::new(fp_config))
            .await
            .unwrap();

        let k = result.iter().collect::<Vec<_>>();

        assert_eq!(k.len(), 1);

        let s = k[0].as_any().downcast_ref::<FHIRId>().unwrap();
        assert_eq!(s.value.as_deref(), Some("asdf"));
    }

    #[tokio::test]
    async fn get_reference_key() {
        let engine = FPEngine::new();

        let group = Group {
            member: Some(vec![GroupMember {
                entity: Box::new(Reference {
                    reference: Some(Box::new("Patient/123".to_string().into())),
                    ..Default::default()
                }),
                ..Default::default()
            }]),
            ..Default::default()
        };

        let result = engine
            .evaluate("$this.member.entity.getReferenceKey(Patient)", vec![&group])
            .await
            .expect("Failed to evaluate getReferenceKey");

        let ids = result.iter().collect::<Vec<_>>();

        assert_eq!(ids.len(), 1);

        let s = ids[0].as_any().downcast_ref::<FHIRId>().unwrap();
        assert_eq!(s.value.as_deref(), Some("123"));

        let result = engine
            .evaluate("$this.member.entity.getReferenceKey(Group)", vec![&group])
            .await
            .expect("Failed to evaluate getReferenceKey");

        let ids = result.iter().collect::<Vec<_>>();
        assert_eq!(ids.len(), 0);

        let result = engine
            .evaluate("$this.member.entity.getReferenceKey()", vec![&group])
            .await
            .expect("Failed to evaluate getReferenceKey");

        let ids = result.iter().collect::<Vec<_>>();
        assert_eq!(ids.len(), 1);
        let s = ids[0].as_any().downcast_ref::<FHIRId>().unwrap();
        assert_eq!(s.value.as_deref(), Some("123"));
    }

    #[tokio::test]
    async fn exists_with_clause() {
        let patient = Patient {
            name: Some(vec![
                HumanName {
                    given: Some(vec![FHIRString {
                        value: Some("Alice".to_string()),
                        ..Default::default()
                    }]),
                    ..Default::default()
                },
                HumanName {
                    given: Some(vec![FHIRString {
                        value: Some("Matilda".to_string()),
                        ..Default::default()
                    }]),
                    ..Default::default()
                },
            ]),
            ..Default::default()
        };

        let engine = FPEngine::new();
        let result = engine
            .evaluate("$this.name.exists(given.exists())", vec![&patient])
            .await
            .unwrap();

        let result = result.iter().collect::<Vec<_>>();

        assert_eq!(result.len(), 1);
        let s = result[0].as_any().downcast_ref::<FHIRBoolean>().unwrap();
        assert_eq!(s.value, Some(true));

        let result = engine
            .evaluate("$this.name.exists(given.empty())", vec![&patient])
            .await
            .unwrap();

        let result = result.iter().collect::<Vec<_>>();
        assert_eq!(result.len(), 1);
        let s = result[0].as_any().downcast_ref::<FHIRBoolean>().unwrap();
        assert_eq!(s.value, Some(false));

        let result = engine
            .evaluate("$this.name.exists(given = 'Matilda')", vec![&patient])
            .await
            .unwrap();

        let result = result.iter().collect::<Vec<_>>();
        assert_eq!(result.len(), 1);
        let s = result[0].as_any().downcast_ref::<FHIRBoolean>().unwrap();
        assert_eq!(s.value, Some(true));

        let result = engine
            .evaluate("$this.name.exists(given = 'Jane')", vec![&patient])
            .await
            .unwrap();

        let result = result.iter().collect::<Vec<_>>();
        assert_eq!(result.len(), 1);
        let s = result[0].as_any().downcast_ref::<FHIRBoolean>().unwrap();
        assert_eq!(s.value, Some(false));
    }
    #[tokio::test]
    async fn test_first() {
        let engine = FPEngine::new();

        let group = Group {
            member: Some(vec![
                GroupMember {
                    entity: Box::new(Reference {
                        reference: Some(Box::new("Patient/1".to_string().into())),
                        ..Default::default()
                    }),
                    ..Default::default()
                },
                GroupMember {
                    entity: Box::new(Reference {
                        reference: Some(Box::new("Patient/2".to_string().into())),
                        ..Default::default()
                    }),
                    ..Default::default()
                },
            ]),
            ..Default::default()
        };

        let result = engine
            .evaluate("$this.member.entity.first()", vec![&group])
            .await
            .expect("Failed to evaluate first()");

        let references = result.iter().collect::<Vec<_>>();
        assert_eq!(references.len(), 1);

        let s = references[0].as_any().downcast_ref::<Reference>().unwrap();
        assert_eq!(
            s.reference.as_ref().unwrap().value,
            Some("Patient/1".to_string())
        );
    }

    #[tokio::test]
    async fn test_join() {
        let engine = FPEngine::new();

        let mut patient = test_patient();
        patient.name.as_mut().unwrap()[0]
            .given
            .as_mut()
            .unwrap()
            .push(FHIRString {
                value: Some("David".to_string()),
                ..Default::default()
            });

        let result = engine
            .evaluate("$this.name.given.join(',')", vec![&patient])
            .await
            .expect("Failed to evaluate join()");

        let joined_ = result.iter().collect::<Vec<_>>();
        assert_eq!(joined_.len(), 1);
        let s = joined_[0].as_any().downcast_ref::<FHIRString>().unwrap();
        assert_eq!(s.value, Some("Bob,David".to_string()));

        let result = engine
            .evaluate("$this.name.given.join()", vec![&patient])
            .await
            .expect("Failed to evaluate join()");

        let joined_ = result.iter().collect::<Vec<_>>();
        assert_eq!(joined_.len(), 1);
        let s = joined_[0].as_any().downcast_ref::<FHIRString>().unwrap();
        assert_eq!(s.value, Some("BobDavid".to_string()));

        let result = engine.evaluate("$this.name.join()", vec![&patient]).await;

        assert!(result.is_err());
    }

    #[tokio::test]
    async fn numerical_comparisons() {
        let engine = FPEngine::new();

        let result = engine
            .evaluate("5 > 5", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(false));

        let result = engine
            .evaluate("5 > 4", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(true));

        let result = engine
            .evaluate("5 >= 5", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(true));

        let result = engine
            .evaluate("4 >= 5", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(false));

        let result = engine
            .evaluate("6 <= 5", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(false));

        let result = engine
            .evaluate("6 <= 6", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(true));

        let result = engine
            .evaluate("6 < 6", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(false));

        let result = engine
            .evaluate("6 < 7", vec![])
            .await
            .expect("Failed to evaluate join()");

        assert_eq!(result.values.len(), 1);
        let b = result.values[0]
            .as_any()
            .downcast_ref::<FHIRBoolean>()
            .unwrap();
        assert_eq!(b.value, Some(true));
    }
}