define "Has Hospice Services":
  exists ( ( ( [Encounter: "Encounter Inpatient"] ).isEncounterPerformed() ) InpatientEncounter
      where FHIRHelpers.ToConcept(InpatientEncounter.hospitalization.dischargeDisposition) ~ "Hospice (HL7 discharge)"
        and FHIRHelpers.ToInterval(InpatientEncounter.period as FHIR.Period) ends during day of "Measurement Period"
  )
    or exists ( ( ( [Encounter: "Hospice Encounter"] ).isEncounterPerformed() ) HospiceEncounter
        where FHIRHelpers.ToInterval(HospiceEncounter.period as FHIR.Period) overlaps day of "Measurement Period"
    )
    or exists ( ( ( [ObservationGeneralAssessment: "Hospice care [Minimum Data Set]"] ).isAssessmentPerformed() ) HospiceAssessment
        where FHIRHelpers.ToConcept(HospiceAssessment.value as FHIR.CodeableConcept) ~ "Yes (qualifier value)"
          and HospiceAssessment.effective.toObservationEffectiveInterval() overlaps day of "Measurement Period"
    )
    or exists ( ( ( [ServiceRequest: "Hospice Care Ambulatory"] ).isInterventionOrder() ) HospiceOrder
        where FHIRHelpers.ToDateTime(HospiceOrder.authoredOn) during day of "Measurement Period"
    )
    or exists ( ( ( [Procedure: "Hospice Care Ambulatory"] ).isInterventionPerformed() ) HospicePerformed
        where HospicePerformed.performed.toPerformedInterval() overlaps day of "Measurement Period"
    )
    or exists ( ( (
        [ConditionProblemsHealthConcerns: "Hospice Diagnosis"]
          union [ConditionEncounterDiagnosis: "Hospice Diagnosis"]
    ).verified() ) HospiceCareDiagnosis
        where HospiceCareDiagnosis.prevalenceInterval() overlaps day of "Measurement Period"
    )

define "Has Frailty Device Order":
  exists (
    [DeviceRequest: "Frailty Device"] FrailtyDeviceOrder
      where FrailtyDeviceOrder.status in { 'active', 'completed' }
        and 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 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 FrailtyEncounter.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 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 DementiaMedication.status = 'active'
        and 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 or Older with Advanced Illness and Frailty":
  AgeInYearsAt(date from end of "Measurement Period") >= 66
    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"
    )

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 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 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 PalliativeEncounter.status = 'finished'
          and FHIRHelpers.ToInterval(PalliativeEncounter.period as FHIR.Period) overlaps day of "Measurement Period"
    )
    or exists (
      [Procedure: "Palliative Care Intervention"] PalliativeIntervention
        where PalliativeIntervention.status = 'completed'
          and PalliativeIntervention.performed.toPerformedInterval() overlaps day of "Measurement Period"
    )

define "Diabetic Retinopathy Overlapping Measurement Period":
  exists ( ( [ConditionProblemsHealthConcerns: "Diabetic Retinopathy"]
      union [ConditionEncounterDiagnosis: "Diabetic Retinopathy"]
  ).verified ( ) ) Retinopathy
    where Retinopathy.prevalenceInterval ( ) overlaps day of "Measurement Period"

define "Retinal Exam in Measurement Period":
  exists ( [Observation: "Retinal or Dilated Eye Exam"] RetinalExam
      where RetinalExam.status in { 'final', 'amended', 'corrected' }
        and exists ( RetinalExam.category ObservationCategory
            where FHIRHelpers.ToConcept(ObservationCategory) ~ "exam"
        )
        and RetinalExam.effective.toObservationEffectiveInterval() during day of "Measurement Period"
  )

define "Retinal Exam in Measurement Period or Year Prior":
  exists ( [Observation: "Retinal or Dilated Eye Exam"] RetinalExam
      where RetinalExam.status in { 'final', 'amended', 'corrected' }
        and exists ( RetinalExam.category ObservationCategory
            where FHIRHelpers.ToConcept(ObservationCategory) ~ "exam"
        )
        and RetinalExam.effective.toObservationEffectiveInterval() during day of Interval[start of "Measurement Period" - 1 year, end of "Measurement Period"]
  )

define "Autonomous Eye Exam in Measurement Period":
  exists ( [Observation: "Eye Diabetic retinopathy screening Autonomous artificial intelligence"] AutonomousEyeExam
      where AutonomousEyeExam.status in { 'final', 'amended', 'corrected' }
        and exists ( AutonomousEyeExam.category ObservationCategory
            where FHIRHelpers.ToConcept(ObservationCategory) ~ "exam"
        )
        and (
          FHIRHelpers.ToConcept(AutonomousEyeExam.value as FHIR.CodeableConcept) ~ "ETDRS Level 20 or lower, without macular edema"
            or FHIRHelpers.ToConcept(AutonomousEyeExam.value as FHIR.CodeableConcept) ~ "ETDRS Level 35 or higher, with or without macular edema"
        )
        and AutonomousEyeExam.effective.toObservationEffectiveInterval() during day of "Measurement Period"
  )

define "Has Left Eye Retinopathy":
  exists ( [Observation: "Left eye Diabetic retinopathy severity level by Ophthalmoscopy"] LeftEyeRetinopathy
      where LeftEyeRetinopathy.status in { 'final', 'amended', 'corrected' }
        and exists ( LeftEyeRetinopathy.category ObservationCategory
            where FHIRHelpers.ToConcept(ObservationCategory) ~ "exam"
        )
        and FHIRHelpers.ToConcept(LeftEyeRetinopathy.value as FHIR.CodeableConcept) in "Diabetic Retinopathy Severity Level"
        and LeftEyeRetinopathy.effective.toObservationEffectiveInterval() during day of "Measurement Period"
  )

define "Has Right Eye Retinopathy":
  exists ( [Observation: "Right eye Diabetic retinopathy severity level by Ophthalmoscopy"] RightEyeRetinopathy
      where RightEyeRetinopathy.status in { 'final', 'amended', 'corrected' }
        and exists ( RightEyeRetinopathy.category ObservationCategory
            where FHIRHelpers.ToConcept(ObservationCategory) ~ "exam"
        )
        and FHIRHelpers.ToConcept(RightEyeRetinopathy.value as FHIR.CodeableConcept) in "Diabetic Retinopathy Severity Level"
        and RightEyeRetinopathy.effective.toObservationEffectiveInterval() during day of "Measurement Period"
  )

define "Has Right Eye No Retinopathy in Year Prior":
  exists ( [Observation: "Right eye Diabetic retinopathy severity level by Ophthalmoscopy"] RightEyeNoRetinopathy
      where RightEyeNoRetinopathy.status in { 'final', 'amended', 'corrected' }
        and exists ( RightEyeNoRetinopathy.category ObservationCategory
            where FHIRHelpers.ToConcept(ObservationCategory) ~ "exam"
        )
        and FHIRHelpers.ToConcept(RightEyeNoRetinopathy.value as FHIR.CodeableConcept) ~ "No apparent retinopathy"
        and RightEyeNoRetinopathy.effective.toObservationEffectiveInterval() during day of Interval[start of "Measurement Period" - 1 year, end of "Measurement Period" - 1 year]
  )

define "Has Left Eye No Retinopathy in Year Prior":
  exists ( [Observation: "Left eye Diabetic retinopathy severity level by Ophthalmoscopy"] LeftEyeNoRetinopathy
      where LeftEyeNoRetinopathy.status in { 'final', 'amended', 'corrected' }
        and exists ( LeftEyeNoRetinopathy.category ObservationCategory
            where FHIRHelpers.ToConcept(ObservationCategory) ~ "exam"
        )
        and FHIRHelpers.ToConcept(LeftEyeNoRetinopathy.value as FHIR.CodeableConcept) ~ "No apparent retinopathy"
        and LeftEyeNoRetinopathy.effective.toObservationEffectiveInterval() during day of Interval[start of "Measurement Period" - 1 year, end of "Measurement Period" - 1 year]
  )

define "Retinal Exam Finding with Retinopathy Severity Level in Measurement Period":
  ( "Has Left Eye Retinopathy"
      and "Has Right Eye Retinopathy"
  )
    or ( "Has Left Eye Retinopathy"
        and "Has Right Eye No Retinopathy in Year Prior"
    )
    or ( "Has Right Eye Retinopathy"
        and "Has Left Eye No Retinopathy in Year Prior"
    )

define "Retinal Exam Finding with No Retinopathy Severity Level in Year Prior":
  ( "Has Left Eye No Retinopathy in Year Prior"
      and "Has Right Eye No Retinopathy in Year Prior"
  )

define "Numerator":
  ( "Diabetic Retinopathy Overlapping Measurement Period"
      and ( "Retinal Exam in Measurement Period" )
  )
    or ( not ( "Diabetic Retinopathy Overlapping Measurement Period" )
        and ( "Retinal Exam in Measurement Period or Year Prior" )
    )
    or "Autonomous Eye Exam in Measurement Period"
    or "Retinal Exam Finding with Retinopathy Severity Level in Measurement Period"
    or "Retinal Exam Finding with No Retinopathy Severity Level in Year Prior"

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: "Ophthalmological Services"]
      union [Encounter: "Telephone Visits"]
  ).isEncounterPerformed ( ) ) ValidEncounters
    where ValidEncounters.period during day of "Measurement Period"

define "Initial Population":
  AgeInYearsAt(date from
    end of "Measurement Period"
  ) in Interval[18, 75]
    and exists ( "Qualifying Encounters" )
    and exists ( ( ( [ConditionEncounterDiagnosis: "Diabetes"] ).verified ( ) ) DiabetesDx
        where DiabetesDx.prevalenceInterval ( ) overlaps day of "Measurement Period"
    )

define "Denominator":
  "Initial Population"

define "Bilateral Absence of Eyes":
  exists ( ( [ConditionProblemsHealthConcerns: "Anophthalmos of bilateral eyes (disorder)"]
      union [ConditionEncounterDiagnosis: "Anophthalmos of bilateral eyes (disorder)"]
  ).verified ( ) ) BilateralAbsenceEyes
    where BilateralAbsenceEyes.prevalenceInterval ( ) starts on or before day of end of "Measurement Period"

define "Denominator Exclusions":
  Hospice."Has Hospice Services"
    or AIFrailLTCF."Is Age 66 or Older with Advanced Illness and Frailty"
    or AIFrailLTCF."Is Age 66 or Older Living Long Term in a Nursing Home"
    or PalliativeCare."Has Palliative Care in the Measurement Period"
    or "Bilateral Absence of Eyes"

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 isEncounterPerformed(Enc List<Encounter>):
  Enc E
    where E.status = 'finished'

define fluent function isAssessmentPerformed(Obs List<Observation>):
  Obs O
    where O.status in { 'final', 'amended', 'corrected' }

define fluent function isInterventionOrder(ServiceRequest List<ServiceRequest>):
  ServiceRequest S
    where S.status in { 'active', 'completed' }
      and S.intent in {
        'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order'
      }

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

/*
@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
        }

/*
@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 ObservationStatus): value.value

define function ToString(value EncounterStatus): 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 ToString(value ServiceRequestStatus): value.value

define function ToString(value ServiceRequestIntent): value.value

define function ToDateTime(value dateTime): value.value

define function ToString(value ProcedureStatus): value.value

define function ToString(value DeviceRequestStatus): value.value

define function ToString(value RequestIntent): value.value

define function ToString(value string): value.value

define function ToString(value MedicationRequestStatus): value.value

define function ToString(value MedicationRequestIntent): value.value

define function ToString(value UnitsOfTime): value.value

/*
@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

/*
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(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: 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"

define fluent function toConditionTimingInterval(choice Choice<FHIR.dateTime, FHIR.Age, FHIR.Period, FHIR.Range, FHIR.string>):
  choice.toInterval()

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

define fluent function toObservationEffectiveInterval(choice Choice<FHIR.dateTime, FHIR.Period, FHIR.Timing, FHIR.instant>):
  choice.toInterval()

define fluent function toPerformedInterval(performed Choice<FHIR.dateTime, FHIR.Period, FHIR.string, FHIR.Age, FHIR.Range>):
  performed.toInterval()

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

define fluent function toTimingBoundsInterval(bounds Choice<FHIR.Duration, FHIR.Range, FHIR.Period>):
  bounds.toInterval()