Allow usage of variable and context in answer expression

datacapture/src/main/java/com/google/android/fhir/datacapture/expressions/EnabledAnswerOptionsEvaluator.kt

@@ -48,7 +48,7 @@ import org.hl7.fhir.r4.model.ValueSet
  * @param questionnaireResponse the [QuestionnaireResponse] related to the [Questionnaire]
  * @param xFhirQueryResolver the [XFhirQueryResolver] to resolve resources based on the X-FHIR-Query
  * @param externalValueSetResolver the [ExternalAnswerValueSetResolver] to resolve value sets
- * externally/outside of the [Questionnaire]
+ *   externally/outside of the [Questionnaire]
  * @param questionnaireItemParentMap the [Map] of items parent
  * @param questionnaireLaunchContextMap the [Map] of launchContext names to their resource values
  */
@@ -68,7 +68,7 @@ internal class EnabledAnswerOptionsEvaluator(
       questionnaire,
       questionnaireResponse,
       questionnaireItemParentMap,
-      questionnaireLaunchContextMap
+      questionnaireLaunchContextMap,
     )
 
   private val answerValueSetMap =
@@ -94,13 +94,19 @@ internal class EnabledAnswerOptionsEvaluator(
     questionnaireResponseItem: QuestionnaireResponseItemComponent,
   ): Pair<
     List<Questionnaire.QuestionnaireItemAnswerOptionComponent>,
-    List<QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent>
+    List<QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent>,
   > {
+    val resolvedAnswerOptions =
+      answerOptions(
+        questionnaireItem,
+        questionnaireResponseItem,
+        questionnaireResponse,
+        questionnaireItemParentMap,
+      )
 
-    val resolvedAnswerOptions = answerOptions(questionnaireItem)
-
-    if (questionnaireItem.answerOptionsToggleExpressions.isEmpty())
+    if (questionnaireItem.answerOptionsToggleExpressions.isEmpty()) {
       return Pair(resolvedAnswerOptions, emptyList())
+    }
 
     val enabledQuestionnaireAnswerOptions =
       evaluateAnswerOptionsToggleExpressions(
@@ -121,29 +127,37 @@ internal class EnabledAnswerOptionsEvaluator(
   /**
    * In a `choice` or `open-choice` type question, the answer options are defined in one of the
    * three elements in the questionnaire:
-   *
    * - `Questionnaire.item.answerOption`: a list of permitted answers to the question
    * - `Questionnaire.item.answerValueSet`: a reference to a value set containing a list of
-   * permitted answers to the question
+   *   permitted answers to the question
    * - `Extension answer-expression`: an expression based extension which defines the x-fhir-query
-   * or fhirpath to evaluate permitted answer options
+   *   or fhirpath to evaluate permitted answer options
    *
    * Returns the answer options defined in one of the sources above. If the answer options are
    * defined in `Questionnaire.item.answerValueSet`, the answer value set will be expanded.
    */
   private suspend fun answerOptions(
     questionnaireItem: QuestionnaireItemComponent,
+    questionnaireResponseItem: QuestionnaireResponseItemComponent,
+    questionnaireResponse: QuestionnaireResponse,
+    questionnaireItemParentMap: Map<QuestionnaireItemComponent, QuestionnaireItemComponent>,
   ): List<Questionnaire.QuestionnaireItemAnswerOptionComponent> =
     when {
       questionnaireItem.answerOption.isNotEmpty() -> questionnaireItem.answerOption
       !questionnaireItem.answerValueSet.isNullOrEmpty() ->
         resolveAnswerValueSet(questionnaireItem.answerValueSet)
-      questionnaireItem.answerExpression != null -> resolveAnswerExpression(questionnaireItem)
+      questionnaireItem.answerExpression != null ->
+        resolveAnswerExpression(
+          questionnaireItem,
+          questionnaireResponseItem,
+          questionnaireResponse,
+          questionnaireItemParentMap,
+        )
       else -> emptyList()
     }
 
   private suspend fun resolveAnswerValueSet(
-    uri: String
+    uri: String,
   ): List<Questionnaire.QuestionnaireItemAnswerOptionComponent> {
     // If cache hit, return it
     if (answerValueSetMap.contains(uri)) {
@@ -164,7 +178,7 @@ internal class EnabledAnswerOptionsEvaluator(
               .filterNot { it.abstract || it.inactive }
               .map { component ->
                 Questionnaire.QuestionnaireItemAnswerOptionComponent(
-                  Coding(component.system, component.code, component.display)
+                  Coding(component.system, component.code, component.display),
                 )
               }
           }
@@ -185,6 +199,9 @@ internal class EnabledAnswerOptionsEvaluator(
   // https://build.fhir.org/ig/HL7/sdc/expressions.html#x-fhir-query-enhancements
   private suspend fun resolveAnswerExpression(
     item: QuestionnaireItemComponent,
+    responseItem: QuestionnaireResponseItemComponent,
+    questionnaireResponse: QuestionnaireResponse,
+    questionnaireItemParentMap: Map<QuestionnaireItemComponent, QuestionnaireItemComponent>,
   ): List<Questionnaire.QuestionnaireItemAnswerOptionComponent> {
     // Check cache first for database queries
     val answerExpression = item.answerExpression ?: return emptyList()
@@ -208,16 +225,16 @@ internal class EnabledAnswerOptionsEvaluator(
           options
         }
           ?: error(
-            "XFhirQueryResolver cannot be null. Please provide the XFhirQueryResolver via DataCaptureConfig."
+            "XFhirQueryResolver cannot be null. Please provide the XFhirQueryResolver via DataCaptureConfig.",
           )
       }
       answerExpression.isFhirPath -> {
-        val data = fhirPathEngine.evaluate(questionnaireResponse, answerExpression.expression)
+        val data = expressionEvaluator.evaluateExpression(item, responseItem, answerExpression)
         item.extractAnswerOptions(data)
       }
       else ->
         throw UnsupportedOperationException(
-          "${answerExpression.language} not supported for answer-expression yet"
+          "${answerExpression.language} not supported for answer-expression yet",
         )
     }
   }
@@ -232,18 +249,19 @@ internal class EnabledAnswerOptionsEvaluator(
         .map {
           val (expression, toggleOptions) = it
           val evaluationResult =
-            if (expression.isFhirPath)
+            if (expression.isFhirPath) {
               fhirPathEngine.convertToBoolean(
                 expressionEvaluator.evaluateExpression(
                   item,
                   questionnaireResponseItem,
                   expression,
-                )
+                ),
               )
-            else
+            } else {
               throw UnsupportedOperationException(
-                "${expression.language} not supported yet for answer-options-toggle-expression"
+                "${expression.language} not supported yet for answer-options-toggle-expression",
               )
+            }
           evaluationResult to toggleOptions
         }
         .partition { it.first }