define "Has Frailty Device Order":
  exists (
    [DeviceRequest: "Frailty Device"] FrailtyDeviceOrder
      where FHIRHelpers.ToString(FrailtyDeviceOrder.status) in { 'active', 'completed' }
        and FHIRHelpers.ToString(FrailtyDeviceOrder.intent) in {
          'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order'
        }
        and Interval[
          FHIRHelpers.ToDateTime(FrailtyDeviceOrder.authoredOn),
          FHIRHelpers.ToDateTime(FrailtyDeviceOrder.authoredOn)
        ] during day of "Measurement Period"
  )

define "Has Frailty Equipment Observation":
  exists (
    [Observation: "Medical equipment used"] EquipmentUsed
      where FHIRHelpers.ToString(EquipmentUsed.status) in { 'final', 'amended', 'corrected' }
        and EquipmentUsed.value is FHIR.CodeableConcept
        and FHIRHelpers.ToConcept(EquipmentUsed.value as FHIR.CodeableConcept) in "Frailty Device"
        and end of EquipmentUsed.observationEffectiveInterval() during day of "Measurement Period"
  )

define "Has Frailty Diagnosis":
  exists (
    [ConditionProblemsHealthConcerns: "Frailty Diagnosis"] FrailtyProblem
      where (
        FrailtyProblem.verificationStatus is null
          or FHIRHelpers.ToConcept(FrailtyProblem.verificationStatus) ~ "confirmed"
          or FHIRHelpers.ToConcept(FrailtyProblem.verificationStatus) ~ "unconfirmed"
          or FHIRHelpers.ToConcept(FrailtyProblem.verificationStatus) ~ "provisional"
          or FHIRHelpers.ToConcept(FrailtyProblem.verificationStatus) ~ "differential"
      )
        and FrailtyProblem.prevalenceInterval() overlaps day of "Measurement Period"
  )
    or exists (
      [ConditionEncounterDiagnosis: "Frailty Diagnosis"] FrailtyEncounterDiagnosis
        where (
          FrailtyEncounterDiagnosis.verificationStatus is null
            or FHIRHelpers.ToConcept(FrailtyEncounterDiagnosis.verificationStatus) ~ "confirmed"
            or FHIRHelpers.ToConcept(FrailtyEncounterDiagnosis.verificationStatus) ~ "unconfirmed"
            or FHIRHelpers.ToConcept(FrailtyEncounterDiagnosis.verificationStatus) ~ "provisional"
            or FHIRHelpers.ToConcept(FrailtyEncounterDiagnosis.verificationStatus) ~ "differential"
        )
          and FrailtyEncounterDiagnosis.prevalenceInterval() overlaps day of "Measurement Period"
    )

define "Has Frailty Encounter":
  exists (
    [Encounter: "Frailty Encounter"] FrailtyEncounter
      where System.Code {
          code: FHIRHelpers.ToString(FrailtyEncounter.status),
          system: 'http://hl7.org/fhir/encounter-status'
        } ~ "finished"
        and FHIRHelpers.ToInterval(FrailtyEncounter.period as FHIR.Period) overlaps day of "Measurement Period"
  )

define "Has Frailty Symptom Observation":
  exists (
    [Observation: "Frailty Symptom"] FrailtySymptom
      where FHIRHelpers.ToString(FrailtySymptom.status) in { 'preliminary', 'final', 'amended', 'corrected' }
        and FrailtySymptom.observationEffectiveInterval() overlaps day of "Measurement Period"
  )

define "Has Criteria Indicating Frailty":
  "Has Frailty Device Order"
    or "Has Frailty Equipment Observation"
    or "Has Frailty Diagnosis"
    or "Has Frailty Encounter"
    or "Has Frailty Symptom Observation"

define "Has Advanced Illness in Year Before or During Measurement Period":
  exists (
    [ConditionProblemsHealthConcerns: "Advanced Illness"] AdvancedIllnessProblem
      where (
        AdvancedIllnessProblem.verificationStatus is null
          or FHIRHelpers.ToConcept(AdvancedIllnessProblem.verificationStatus) ~ "confirmed"
          or FHIRHelpers.ToConcept(AdvancedIllnessProblem.verificationStatus) ~ "unconfirmed"
          or FHIRHelpers.ToConcept(AdvancedIllnessProblem.verificationStatus) ~ "provisional"
          or FHIRHelpers.ToConcept(AdvancedIllnessProblem.verificationStatus) ~ "differential"
      )
        and start of AdvancedIllnessProblem.prevalenceInterval() during day of Interval[
          start of "Measurement Period" - 1 year,
          end of "Measurement Period"
        ]
  )
    or exists (
      [ConditionEncounterDiagnosis: "Advanced Illness"] AdvancedIllnessEncounterDiagnosis
        where (
          AdvancedIllnessEncounterDiagnosis.verificationStatus is null
            or FHIRHelpers.ToConcept(AdvancedIllnessEncounterDiagnosis.verificationStatus) ~ "confirmed"
            or FHIRHelpers.ToConcept(AdvancedIllnessEncounterDiagnosis.verificationStatus) ~ "unconfirmed"
            or FHIRHelpers.ToConcept(AdvancedIllnessEncounterDiagnosis.verificationStatus) ~ "provisional"
            or FHIRHelpers.ToConcept(AdvancedIllnessEncounterDiagnosis.verificationStatus) ~ "differential"
        )
          and start of AdvancedIllnessEncounterDiagnosis.prevalenceInterval() during day of Interval[
            start of "Measurement Period" - 1 year,
            end of "Measurement Period"
          ]
    )

define "Has Dementia Medications in Year Before or During Measurement Period":
  exists (
    [MedicationRequest: "Dementia Medications"] DementiaMedication
      where FHIRHelpers.ToString(DementiaMedication.status) = 'active'
        and FHIRHelpers.ToString(DementiaMedication.intent) in {
          'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order'
        }
        and DementiaMedication.medicationRequestPeriod() overlaps day of Interval[
          start of "Measurement Period" - 1 year,
          end of "Measurement Period"
        ]
  )

define "Is Age 66 to 80 with Advanced Illness and Frailty or Is Age 81 or Older with Frailty":
  (
    AgeInYearsAt(date from end of "Measurement Period") in Interval[66, 80]
      and "Has Criteria Indicating Frailty"
      and (
        "Has Advanced Illness in Year Before or During Measurement Period"
          or "Has Dementia Medications in Year Before or During Measurement Period"
      )
  )
    or (
      AgeInYearsAt(date from end of "Measurement Period") >= 81
        and "Has Criteria Indicating Frailty"
    )

define "Is Age 66 or Older Living Long Term in a Nursing Home":
  AgeInYearsAt(date from end of "Measurement Period") >= 66
    and (
      (
        Last(
          [Observation: "Housing status"] HousingStatus
            where FHIRHelpers.ToString(HousingStatus.status) in { 'final', 'amended', 'corrected' }
              and end of HousingStatus.observationEffectiveInterval() on or before day of end of "Measurement Period"
               sort by end of observationEffectiveInterval() asc
        )
      ) LastHousingStatus
        where LastHousingStatus.value is FHIR.CodeableConcept
          and FHIRHelpers.ToConcept(LastHousingStatus.value as FHIR.CodeableConcept) ~ "Lives in nursing home (finding)"
    ) is not null

define "Has Palliative Care in the Measurement Period":
  exists (
    [ObservationGeneralAssessment: "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)"] PalliativeAssessment
      where FHIRHelpers.ToString(PalliativeAssessment.status) in { 'final', 'amended', 'corrected' }
        and PalliativeAssessment.effective.toObservationEffectiveInterval() overlaps day of "Measurement Period"
  )
    or exists (
      [ConditionProblemsHealthConcerns: "Palliative Care Diagnosis"] PalliativeProblem
        where (
          PalliativeProblem.verificationStatus is null
            or FHIRHelpers.ToConcept(PalliativeProblem.verificationStatus) ~ "confirmed"
            or FHIRHelpers.ToConcept(PalliativeProblem.verificationStatus) ~ "unconfirmed"
            or FHIRHelpers.ToConcept(PalliativeProblem.verificationStatus) ~ "provisional"
            or FHIRHelpers.ToConcept(PalliativeProblem.verificationStatus) ~ "differential"
        )
          and PalliativeProblem.prevalenceInterval() overlaps day of "Measurement Period"
    )
    or exists (
      [ConditionEncounterDiagnosis: "Palliative Care Diagnosis"] PalliativeEncounterDiagnosis
        where (
          PalliativeEncounterDiagnosis.verificationStatus is null
            or FHIRHelpers.ToConcept(PalliativeEncounterDiagnosis.verificationStatus) ~ "confirmed"
            or FHIRHelpers.ToConcept(PalliativeEncounterDiagnosis.verificationStatus) ~ "unconfirmed"
            or FHIRHelpers.ToConcept(PalliativeEncounterDiagnosis.verificationStatus) ~ "provisional"
            or FHIRHelpers.ToConcept(PalliativeEncounterDiagnosis.verificationStatus) ~ "differential"
        )
          and PalliativeEncounterDiagnosis.prevalenceInterval() overlaps day of "Measurement Period"
    )
    or exists (
      [Encounter: "Palliative Care Encounter"] PalliativeEncounter
        where System.Code {
            code: FHIRHelpers.ToString(PalliativeEncounter.status),
            system: 'http://hl7.org/fhir/encounter-status'
          } ~ "finished"
          and FHIRHelpers.ToInterval(PalliativeEncounter.period as FHIR.Period) overlaps day of "Measurement Period"
    )
    or exists (
      [Procedure: "Palliative Care Intervention"] PalliativeIntervention
        where System.Code {
            code: FHIRHelpers.ToString(PalliativeIntervention.status),
            system: 'http://hl7.org/fhir/event-status'
          } ~ "completed"
          and PalliativeIntervention.performed.toPerformedInterval() overlaps day of "Measurement Period"
    )

define "Inpatient and ED Encounters":
  [Encounter: "Encounter Inpatient"]
    union [Encounter: "Emergency Department Evaluation and Management Visit"]

define "Qualifying Blood Pressure Reading":
  (
    [ObservationVitalSigns: "Blood pressure panel with all children optional"] BloodPressure
      without "Inpatient and ED Encounters" DisqualifyingEncounter
        such that System.Code {
            code: FHIRHelpers.ToString(DisqualifyingEncounter.status),
            system: 'http://hl7.org/fhir/encounter-status'
          } ~ "finished"
          and BloodPressure.effective.latest()
            during day of FHIRHelpers.ToInterval(DisqualifyingEncounter.period as FHIR.Period)
      where System.Code {
          code: FHIRHelpers.ToString(BloodPressure.status),
          system: 'http://hl7.org/fhir/observation-status'
        } in { "final", "amended", "corrected" }
        and BloodPressure.effective.latest() during day of "Measurement Period"
  )
    union (
      [ObservationVitalSigns: "Blood pressure panel with all children optional"] BloodPressure
        where System.Code {
            code: FHIRHelpers.ToString(BloodPressure.status),
            system: 'http://hl7.org/fhir/observation-status'
          } in { "final", "amended", "corrected" }
          and (
            BloodPressure.encounter is null
              or not (
                FHIRHelpers.ToCode(BloodPressure.encounter.getEncounter().class) in {
                  Common."emergency",
                  Common."inpatient encounter",
                  Common."inpatient acute",
                  Common."inpatient non-acute",
                  Common."pre-admission",
                  Common."short stay"
                }
              )
          )
          and BloodPressure.effective.latest() during day of "Measurement Period"
    )

define "Qualifying Systolic Blood Pressure Reading":
  "Qualifying Blood Pressure Reading"

define "Qualifying Diastolic Blood Pressure Reading":
  "Qualifying Blood Pressure Reading"

define "Blood Pressure Days":
  ( "Qualifying Diastolic Blood Pressure Reading" DBPExam
      return date from DBPExam.effective.latest ( )
  )
    intersect ( "Qualifying Systolic Blood Pressure Reading" SBPExam
        return date from SBPExam.effective.latest ( )
    )

define "Most Recent Blood Pressure Day":
  Last("Blood Pressure Days" BPDays
      sort asc
  )

define "Lowest Systolic Reading on Most Recent Blood Pressure Day":
  First("Qualifying Systolic Blood Pressure Reading" SBPReading
      where SBPReading.effective.latest() same day as "Most Recent Blood Pressure Day"
      return singleton from(SBPReading.component SBPComponent
          where SBPComponent.code ~ "Systolic blood pressure"
          return SBPComponent.value as Quantity
      )
      sort asc
  )

define "Has Systolic Blood Pressure Less Than 140":
  "Lowest Systolic Reading on Most Recent Blood Pressure Day" < 140 'mm[Hg]'

define "Lowest Diastolic Reading on Most Recent Blood Pressure Day":
  First("Qualifying Diastolic Blood Pressure Reading" DBPReading
      where DBPReading.effective.latest() same day as "Most Recent Blood Pressure Day"
      return singleton from(DBPReading.component DBPComponent
          where DBPComponent.code ~ "Diastolic blood pressure"
          return DBPComponent.value as Quantity
      )
      sort asc
  )

define "Has Diastolic Blood Pressure Less Than 90":
  "Lowest Diastolic Reading on Most Recent Blood Pressure Day" < 90 'mm[Hg]'

define "Numerator":
  "Has Systolic Blood Pressure Less Than 140"
    and "Has Diastolic Blood Pressure Less Than 90"

define "Essential Hypertension Diagnosis":
  ( ( [ConditionProblemsHealthConcerns: "Essential Hypertension"]
      union [ConditionEncounterDiagnosis: "Essential Hypertension"]
  ).verified ( ) ) Hypertension
    where Hypertension.prevalenceInterval ( ) overlaps Interval[start of "Measurement Period", start of "Measurement Period" + 6 months )

define "Initial Population":
  AgeInYearsAt(end of "Measurement Period") in Interval[18, 85]
    and exists "Essential Hypertension Diagnosis"
    and exists AdultOutpatientEncounters."Qualifying Encounters"

define "Denominator":
  "Initial Population"

define "Pregnancy or Renal Diagnosis":
  ( ( [ConditionProblemsHealthConcerns: "Pregnancy"]
      union [ConditionEncounterDiagnosis: "Pregnancy"]
      union [ConditionProblemsHealthConcerns: "End Stage Renal Disease"]
      union [ConditionEncounterDiagnosis: "End Stage Renal Disease"]
      union [ConditionProblemsHealthConcerns: "Kidney Transplant Recipient"]
      union [ConditionEncounterDiagnosis: "Kidney Transplant Recipient"]
      union [ConditionProblemsHealthConcerns: "Chronic Kidney Disease, Stage 5"]
      union [ConditionEncounterDiagnosis: "Chronic Kidney Disease, Stage 5"]
  ).verified ( ) ) PregnancyESRDDiagnosis
    where PregnancyESRDDiagnosis.prevalenceInterval ( ) overlaps "Measurement Period"

define "End Stage Renal Disease Procedures":
  ( ([Procedure: "Kidney Transplant"]
      union [Procedure: "Dialysis Services"]
  ).isProcedurePerformed() ) ESRDProcedure
    where ESRDProcedure.performed.toPerformedInterval() ends on or before end of "Measurement Period"

define "End Stage Renal Disease Encounter":
  ( ([Encounter: "ESRD Monthly Outpatient Services"]).isEncounterPerformed() ) ESRDEncounter
    where FHIRHelpers.ToInterval(ESRDEncounter.period as FHIR.Period) starts on or before end of "Measurement Period"

define "Has Advanced Illness Frailty Exclusion":
  AIFrailLTCF."Is Age 66 to 80 with Advanced Illness and Frailty or Is Age 81 or Older with Frailty"

define "Has Long Term Care Exclusion":
  AIFrailLTCF."Is Age 66 or Older Living Long Term in a Nursing Home"

define "Has Palliative Care Exclusion":
  PalliativeCare."Has Palliative Care in the Measurement Period"

define "Denominator Exclusions":
  exists ( "Pregnancy or Renal Diagnosis" )
    or exists ( "End Stage Renal Disease Procedures" )
    or exists ( "End Stage Renal Disease Encounter" )
    or "Has Advanced Illness Frailty Exclusion"
    or "Has Long Term Care Exclusion"
    or "Has Palliative Care Exclusion"

define fluent function getEncounter(reference Reference):
  singleton from ( [Encounter] E
      where E.id = reference.reference.getId ( )
  )

define "Qualifying Encounters":
  (
    (
      [Encounter: "Office Visit"]
        union [Encounter: "Annual Wellness Visit"]
        union [Encounter: "Preventive Care Services Established Office Visit, 18 and Up"]
        union [Encounter: "Preventive Care Services Initial Office Visit, 18 and Up"]
        union [Encounter: "Home Healthcare Services"]
        union [Encounter: "Virtual Encounter"]
        union [Encounter: "Telephone Visits"]
    ).isQualifyingEncounterActive()
  ) ValidEncounter
    where FHIRHelpers.ToInterval(ValidEncounter.period as FHIR.Period) during day of "Measurement Period"

define fluent function isQualifyingEncounterActive(Enc List<Encounter>):
  Enc E
    where FHIRHelpers.ToString(E.status) in { 'finished', 'in-progress', 'onhold', 'arrived' }

define fluent function verified(
  conditions List<Choice<ConditionEncounterDiagnosis, ConditionProblemsHealthConcerns>>
):
  conditions C
    where C.verificationStatus is not null implies (
      FHIRHelpers.ToConcept(C.verificationStatus) ~ "confirmed"
        or FHIRHelpers.ToConcept(C.verificationStatus) ~ "unconfirmed"
        or FHIRHelpers.ToConcept(C.verificationStatus) ~ "provisional"
        or FHIRHelpers.ToConcept(C.verificationStatus) ~ "differential"
    )

define fluent function isProcedurePerformed(Proc List<Procedure>):
  Proc P
    where FHIRHelpers.ToString(P.status) = 'completed'

define fluent function isEncounterPerformed(Enc List<Encounter>):
  Enc E
    where FHIRHelpers.ToString(E.status) = 'finished'

/*
@description: Converts the given FHIR [Quantity](https://hl7.org/fhir/datatypes.html#Quantity) 
value to a CQL Quantity
@comment: If the given quantity has a comparator specified, a runtime error is raised. If the given quantity
has a system other than UCUM (i.e. `http://unitsofmeasure.org`) or CQL calendar units (i.e. `http://hl7.org/fhirpath/CodeSystem/calendar-units`)
an error is raised. For UCUM to calendar units, the `ToCalendarUnit` function is used.
@seealso: ToCalendarUnit
*/
define function ToQuantity(quantity FHIR.Quantity):
    case
        when quantity is null then null
        when quantity.value is null then null
        when quantity.comparator is not null then
            Message(null, true, 'FHIRHelpers.ToQuantity.ComparatorQuantityNotSupported', 'Error', 'FHIR Quantity value has a comparator and cannot be converted to a System.Quantity value.')
        when quantity.system is null or quantity.system.value = 'http://unitsofmeasure.org'
              or quantity.system.value = 'http://hl7.org/fhirpath/CodeSystem/calendar-units' then
            System.Quantity { value: quantity.value.value, unit: ToCalendarUnit(Coalesce(quantity.code.value, quantity.unit.value, '1')) }
        else
            Message(null, true, 'FHIRHelpers.ToQuantity.InvalidFHIRQuantity', 'Error', 'Invalid FHIR Quantity code: ' & quantity.unit.value & ' (' & quantity.system.value & '|' & quantity.code.value & ')')
    end

/*
@description: Converts a UCUM definite duration unit to a CQL calendar duration
unit using conversions specified in the [quantities](https://cql.hl7.org/02-authorsguide.html#quantities) 
topic of the CQL specification.
@comment: Note that for durations above days (or weeks), the conversion is understood to be approximate
*/
define function ToCalendarUnit(unit System.String):
    case unit
        when 'ms' then 'millisecond'
        when 's' then 'second'
        when 'min' then 'minute'
        when 'h' then 'hour'
        when 'd' then 'day'
        when 'wk' then 'week'
        when 'mo' then 'month'
        when 'a' then 'year'
        else unit
    end

define function ToString(value EncounterStatus): value.value

define function ToDateTime(value dateTime): value.value

/*
@description: Converts the given [Period](https://hl7.org/fhir/datatypes.html#Period)
value to a CQL DateTime Interval
@comment: If the start value of the given period is unspecified, the starting
boundary of the resulting interval will be open (meaning the start of the interval
is unknown, as opposed to interpreted as the beginning of time).
*/
define function ToInterval(period FHIR.Period):
    if period is null then
        null
    else
        if period."start" is null then
            Interval(period."start".value, period."end".value]
        else
            Interval[period."start".value, period."end".value]

define function ToDate(value date): value.value

define function ToString(value ObservationStatus): value.value

/*
@description: Converts the given FHIR [Coding](https://hl7.org/fhir/datatypes.html#Coding) value to a CQL Code.
*/
define function ToCode(coding FHIR.Coding):
    if coding is null then
        null
    else
        System.Code {
          code: coding.code.value,
          system: coding.system.value,
          version: coding.version.value,
          display: coding.display.value
        }

define function ToString(value string): value.value

/*
@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.
*/
define function ToConcept(concept FHIR.CodeableConcept):
    if concept is null then
        null
    else
        System.Concept {
            codes: concept.coding C return ToCode(C),
            display: concept.text.value
        }

define function ToString(value ProcedureStatus): value.value

define function ToString(value DeviceRequestStatus): value.value

define function ToString(value RequestIntent): value.value

define function ToDateTime(value instant): value.value

define function ToString(value MedicationRequestStatus): value.value

define function ToString(value MedicationRequestIntent): value.value

define function ToString(value UnitsOfTime): value.value

/*
Now that we have a ToDaily function, we can approach calculation of the
duration of medication for an order. First, consider the definitions
for each element:
* 1 and only 1 dosageInstruction
* 1 and only 1 doseAndRate
* 1 timing with 1 repeat
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* doseQuantity or doseRange
* timeOfDay
* authoredOn: The date the prescription was written
* dispenseRequest.validityPeriod: Time period supply is authorized for
* dispenseRequest.quantity: amount of medication supplied per dispense
* dispenseRequest.numberOfRepeatsAllowed: number of refills authorized
* dispenseRequest.expectedSupplyDuration: number of days supply per dispense
* dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat
* dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat
* dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat
* dosageInstruction.timing.repeat.count: number of times to repeat
* dosageInstruction.timing.repeat.countMax: maximum number of times to repeat
* dosageInstruction.timing.repeat.frequency: event occurs frequency times per period
* dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period
* dosageInstruction.timing.repeat.period: event occurs frequency times per period
* dosageInstruction.timing.repeat.periodMax: upper limit of period
* dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a)
* dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*)
* dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...)
* dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD...
* dosageInstruction.asNeeded
* dosageInstruction.doseAndRate.doseQuantity
* dosageInstruction.doseAndRate.doseRange
If expectedSupplyDuration is present, then the duration is
    expectedSupplyDuration * (1 + numberOfRepeatsAllowed)
If expectedSupplyDuration is not present, then it must be calculated based on the quantity, dosage, and frequency:
    (quantity / (dosage * frequency)) * (1 + numberOfRepeatsAllowed)
    dosage: Coalesce(end of doseAndRate.doseRange, doseAndRate.doseQuantity)
    frequency: Coalesce(frequencyMax, frequency)
    period: Quantity(period, periodUnit)
If expectedSupplyDuration is not present and cannot be calculated, and the boundsPeriod is present (and completely specified), we can use that directly
    dosage.timing.repeat.boundsPeriod
This calculation results in a number of days, which can then be turned into a period by anchoring that to the
start of the validityPeriod or the authoredOn:
    Interval[earliestDispensable, earliestDispensable + expectedSupplyDuration - 1]
    earliestDispensable: Coalesce(start of validityPeriod, authoredOn)
The following function illustrates this completely:
*/

/*
Calculates the Medication Period for a single MedicationRequest.
MedicationRequest instances provided to this function are expected
to conform to the [MMEMedicationRequest](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationrequest.html)
profile, which expects:
* 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error
* 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error
* 1 timing with 1 repeat, missing timing or repeat elements will result in a null
* frequency, frequencyMax, defaulting to 1
* period, periodUnit, defaulting to 1 'd'
* timeOfDay
* doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null
Note that MedicationRequest status is not considered by this calculation, as the
list of MedicationRequest instances provided to this function should already have
considered appropriate statuses, depending on the use case, typically `completed`.
*/

define fluent function medicationRequestPeriod(sourceRequest "MedicationRequest"):
  sourceRequest R
    let
      dosage: singleton from R.dosageInstruction,
      doseAndRate: singleton from dosage.doseAndRate,
      timing: dosage.timing,
      frequency: Coalesce(timing.repeat.frequencyMax.value, timing.repeat.frequency.value, 1),
      period: Quantity(
        Coalesce(timing.repeat.period.value, 1.0),
        Coalesce(FHIRHelpers.ToString(timing.repeat.periodUnit), 'd')
      ),
      doseChoice: doseAndRate.dose,
      dose:
        case
          when doseChoice is FHIR.Range then FHIRHelpers.ToQuantity((doseChoice as FHIR.Range).high)
          when doseChoice is FHIR.SimpleQuantity then FHIRHelpers.ToQuantity(doseChoice as FHIR.SimpleQuantity)
          else null
        end,
      dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0),
      boundsPeriod: timingBoundsToInterval(timing.repeat.bounds),
      daysSupply:
        (convert FHIRHelpers.ToQuantity(R.dispenseRequest.expectedSupplyDuration as FHIR.Duration) to days).value,
      quantity: FHIRHelpers.ToQuantity(R.dispenseRequest.quantity as FHIR.Quantity),
      refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed.value, 0),
      startDate:
        Coalesce(
          date from start of boundsPeriod,
          date from FHIRHelpers.ToDateTime(R.authoredOn as FHIR.dateTime),
          date from start of FHIRHelpers.ToInterval(R.dispenseRequest.validityPeriod as FHIR.Period)
        ),
      totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills)
    return
      if startDate is not null and totalDaysSupplied is not null then
        Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ]
      else if startDate is not null and boundsPeriod."high" is not null then
        Interval[startDate, date from end of boundsPeriod]
      else
        null

/**********************************************************************/
/* Functions in this region are copied from opioid-mme-r4             */
/**********************************************************************/

define function Quantity(value Decimal, unit String):
  if value is not null then
    System.Quantity { value: value, unit: unit }
  else
    null

/*
 Goal is to get to number of days
 Two broad approaches to the calculation:
  1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered
  2) Based on relevant period, determine a covered interval and calculate the length of that interval in days
This topic covers several use cases and illustrates how to calculate Cumulative
Medication Duration for each type of medication resource using the supply and
frequency approach.
*/

/*
  For the first approach, we need to get from frequency to a frequency/day
  So we define ToDaily
*/

/*
  Calculates daily frequency given frequency within a period
*/
define function ToDaily(frequency System.Integer, period System.Quantity):
  case period.unit
    when 'h' then frequency * (24.0 / period.value)
    when 'min' then frequency * (24.0 / period.value) * 60
    when 's' then frequency * (24.0 / period.value) * 60 * 60
    when 'd' then frequency * (24.0 / period.value) / 24
    when 'wk' then frequency * (24.0 / period.value) / (24 * 7)
    when 'mo' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */
    when 'a' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */
    when 'hour' then frequency * (24.0 / period.value)
    when 'minute' then frequency * (24.0 / period.value) * 60
    when 'second' then frequency * (24.0 / period.value) * 60 * 60
    when 'day' then frequency * (24.0 / period.value) / 24
    when 'week' then frequency * (24.0 / period.value) / (24 * 7)
    when 'month' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */
    when 'year' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */
    when 'hours' then frequency * (24.0 / period.value)
    when 'minutes' then frequency * (24.0 / period.value) * 60
    when 'seconds' then frequency * (24.0 / period.value) * 60 * 60
    when 'days' then frequency * (24.0 / period.value) / 24
    when 'weeks' then frequency * (24.0 / period.value) / (24 * 7)
    when 'months' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */
    when 'years' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */
    else Message(null, true, 'CMDLogic.ToDaily.UnknownUnit', ErrorLevel, 'Unknown unit ' & period.unit)
  end

/*
@description: Normalizes Timing.repeat.bounds (Duration | Range | Period) to Interval<DateTime>.
@deprecated: Use AtriusCommon.toTimingBoundsInterval(); retained for include compatibility.
*/
define function timingBoundsToInterval(bounds Choice<FHIR.Duration, FHIR.Range, FHIR.Period>):
  bounds.toTimingBoundsInterval()

/*
@description: Given a FHIR timing choice, returns the latest relevant System.DateTime.
*/
define fluent function latest(choice Choice<FHIR.dateTime, FHIR.Age, FHIR.Period, FHIR.Range, FHIR.string>):
  (choice.toConditionTimingInterval()) period
    return if period.hasEnd() then end of period else start of period

/*
@description: Normalizes condition/allergy timing [x] (onset, abatement) to Interval<DateTime>.
@comment: Choice order matches AtriusIn modelinfo: dateTime | Age | Period | Range | string.
*/
define fluent function toConditionTimingInterval(choice Choice<FHIR.dateTime, FHIR.Age, FHIR.Period, FHIR.Range, FHIR.string>):
  case
    when choice is FHIR.dateTime then
      Interval[
        FHIRHelpers.ToDateTime(choice as FHIR.dateTime),
        FHIRHelpers.ToDateTime(choice as FHIR.dateTime)
      ]
    when choice is FHIR.Period then
      FHIRHelpers.ToInterval(choice as FHIR.Period)
    when choice is FHIR.Age then
      Interval[
        FHIRHelpers.ToDate(Patient.birthDate) + ToAgeQuantity(choice as FHIR.Age),
        FHIRHelpers.ToDate(Patient.birthDate) + ToAgeQuantity(choice as FHIR.Age) + 1 year
      )
    when choice is FHIR.Range then
      Interval[
        FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((choice as FHIR.Range).low),
        FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((choice as FHIR.Range).high) + 1 year
      ]
    else
      null as Interval<DateTime>
  end

define function ToAgeQuantity(age FHIR.Age):
  FHIRHelpers.ToQuantity(age as FHIR.Quantity)

/*
@description: Given an interval, returns true if the interval has an ending boundary specified
(i.e. the end of the interval is not null and not the maximum DateTime value)
*/
define fluent function hasEnd(period Interval<DateTime>):
  not (end of period is null or end of period = maximum DateTime)

/*
@description: Returns the tail of the given uri (i.e. everything after the last slash in the URI).
@comment: This function can be used to determine the logical id of a given resource. It can be used in
a single-server environment to trace references. However, this function does not attempt to resolve
or distinguish the base of the given url, and so cannot be used safely in multi-server environments.
*/
define fluent function getId(uri String):
  Last(Split(uri, '/'))

/*
@description: Returns an interval representing the normalized prevalence period of a given Condition.
*/
define fluent function prevalenceInterval(condition Choice<ConditionEncounterDiagnosis, ConditionProblemsHealthConcerns>):
  if condition.isActive() then
    Interval[start of condition.onset.toConditionTimingInterval(), end of condition.abatementInterval()]
  else
    (end of condition.abatementInterval()) abatementDate
      return if abatementDate is null then
        Interval[start of condition.onset.toConditionTimingInterval(), abatementDate)
      else
        Interval[start of condition.onset.toConditionTimingInterval(), abatementDate]

/*
@description: Returns true if the given condition has a clinical status of active, recurrence, or relapse
*/
define fluent function isActive(condition Choice<ConditionEncounterDiagnosis, ConditionProblemsHealthConcerns>):
  FHIRHelpers.ToConcept(condition.clinicalStatus) ~ "active"
    or FHIRHelpers.ToConcept(condition.clinicalStatus) ~ "recurrence"
    or FHIRHelpers.ToConcept(condition.clinicalStatus) ~ "relapse"

/*
@description: Returns an interval representing the normalized abatement of a given Condition.
*/
define fluent function abatementInterval(condition Choice<ConditionEncounterDiagnosis, ConditionProblemsHealthConcerns>):
  condition.abatement.toConditionTimingInterval()

/*
=== Interval helpers (AtriusIn) ===

Three layers — do not mix them:

1. FHIRHelpers.ToInterval(single FHIR type)
   Period | Quantity | Range → Interval<DateTime>
   Use only when the element is a known single type (often after `as FHIR.Period`).

2. AtriusCommon choice → interval (fluent on [x] elements)
   toPerformedInterval()           Procedure.performed[x]
   toConditionTimingInterval()       Condition.onset/abatement[x], AllergyIntolerance.onset[x]
   toObservationEffectiveInterval()  Observation.effective[x]
   toTimingBoundsInterval()          Timing.repeat.bounds[x]

3. AtriusCommon resource helpers (fluent on whole resources)
   abatementInterval(), prevalenceInterval(), observationEffectiveInterval()

QICoreCommon uses one toInterval() because QI-Core modelinfo maps [x] to System types.
AtriusIn keeps FHIR structural types — separate names avoid CQL overload ambiguity.
*/

/*
@description: Normalizes Procedure.performed[x] to Interval<DateTime> (AtriusIn Procedure modelinfo choice order).
*/
define fluent function toPerformedInterval(performed Choice<FHIR.dateTime, FHIR.Period, FHIR.string, FHIR.Age, FHIR.Range>):
  case
    when performed is FHIR.Period then FHIRHelpers.ToInterval(performed as FHIR.Period)
    when performed is FHIR.dateTime then
      Interval[
        FHIRHelpers.ToDateTime(performed as FHIR.dateTime),
        FHIRHelpers.ToDateTime(performed as FHIR.dateTime)
      ]
    else null as Interval<DateTime>
  end

/*
@description: Normalizes Observation.effective[x] for any Observation retrieve.
*/
define fluent function observationEffectiveInterval(observation Observation):
  observation.effective.toObservationEffectiveInterval()

/*
@description: Normalizes Observation.effective[x] to Interval<DateTime>.
*/
define fluent function toObservationEffectiveInterval(choice Choice<FHIR.dateTime, FHIR.Period, FHIR.Timing, FHIR.instant>):
  case
    when choice is FHIR.dateTime then
      Interval[
        FHIRHelpers.ToDateTime(choice as FHIR.dateTime),
        FHIRHelpers.ToDateTime(choice as FHIR.dateTime)
      ]
    when choice is FHIR.Period then
      FHIRHelpers.ToInterval(choice as FHIR.Period)
    when choice is FHIR.instant then
      Interval[
        FHIRHelpers.ToDateTime(choice as FHIR.instant),
        FHIRHelpers.ToDateTime(choice as FHIR.instant)
      ]
    else
      null as Interval<DateTime>
  end

/*
@description: Normalizes Timing.repeat.bounds (Duration | Range | Period) to Interval<DateTime>.
@comment: Only Period yields calendar bounds; Duration/Range are relative without an anchor here.
*/
define fluent function toTimingBoundsInterval(bounds Choice<FHIR.Duration, FHIR.Range, FHIR.Period>):
  case
    when bounds is FHIR.Period then
      FHIRHelpers.ToInterval(bounds as FHIR.Period)
    else
      null as Interval<DateTime>
  end