define "Initial Population":
  AgeInYearsAt(date from start of "Measurement Period") >= 18
    and Count(AHA."Qualifying Outpatient Encounter During Measurement Period") >= 2
    and exists AHA."Heart Failure Outpatient Encounter"

define "Denominator":
  "Initial Population"
    and exists AHA."Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD"

define "Denominator Exclusions":
  AHA."Has Heart Transplant"
    or AHA."Has Heart Transplant Complications"
    or AHA."Has Left Ventricular Assist Device"
    or AHA."Has Left Ventricular Assist Device Complications"

define "Numerator":
  "Has Beta Blocker Therapy for LVSD Ordered"
    or "Is Currently Taking Beta Blocker Therapy for LVSD"

define "Denominator Exceptions":
  "Has Consecutive Heart Rates Less than 50"
    or "Has Medical or Patient Reason for Not Ordering Beta Blocker for LVSD"
    or "Has Arrhythmia Diagnosis"
    or "Has Hypotension Diagnosis"
    or "Has Asthma Diagnosis"
    or "Has Diagnosis of Allergy or Intolerance to Beta Blocker Therapy"
    or "Has Bradycardia Diagnosis"
    or "Has Allergy or Intolerance to Beta Blocker Therapy Ingredient"
    or "Atrioventricular Block without Cardiac Pacer"

define "SDE Sex":
  case
      when Patient.gender = 'male' then Code { code: 'M', system: 'http://hl7.org/fhir/v3/AdministrativeGender', display: 'Male' }
      when Patient.gender = 'female' then Code { code: 'F', system: 'http://hl7.org/fhir/v3/AdministrativeGender', display: 'Female' }
      else null
    end

define "SDE Sex":
  SDE."SDE Sex"

define "Heart Failure Outpatient Encounter":
  ( [Encounter: "Care Services in Long Term Residential Facility"]
      union [Encounter: "Home Healthcare Services"]
      union [Encounter: "Nursing Facility Visit"]
      union [Encounter: "Office Visit"]
      union [Encounter: "Outpatient Consultation"]
     ) QualifyingEncounter
    with [Condition: "Heart Failure"] HeartFailure
      such that HeartFailure.prevalenceInterval() overlaps QualifyingEncounter.period  
        and HeartFailure.isConfirmedActiveDiagnosis()
    where QualifyingEncounter.period during "Measurement Period"
      and QualifyingEncounter.isFinished()

/**
* Modified Moderate or Severe LVSD Findings defintion to return dates of findings due 
* to issues in Translator around union of unlike types: refer to 
* https://github.com/cqframework/clinical_quality_language/issues/1126
**/
define "Moderate or Severe LVSD Dates":
    ( [Observation: "Ejection Fraction"] EjectionFraction
        let dateOfFinding: start of ( EjectionFraction Fraction
                                 where Fraction.value as Quantity <= 40 '%'
                                   and Fraction.status in {'final', 'amended', 'corrected'} 
                                 return Fraction.effective.toInterval()
                                   )
        return dateOfFinding 
      )
    union
    ( 
        ( [Condition: "Moderate or Severe LVSD"]
            union ( [Condition: "Left ventricular systolic dysfunction (disorder)"] LVSDDiagnosis
                       where LVSDDiagnosis.severity in "Moderate or Severe"
                    ) 
          ) ModerateOrSevereLVSD
        let dateOfFinding: start of ( ModerateOrSevereLVSD LVSD
                                  where LVSD.isConfirmedActiveDiagnosis()
                                  return LVSD.prevalenceInterval()
                                )
        return dateOfFinding 
      )

define "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD":
    "Heart Failure Outpatient Encounter" HFOutpatientEncounter
        with "Moderate or Severe LVSD Dates" ModerateSevereLVSDDate
            such that ModerateSevereLVSDDate before end of HFOutpatientEncounter.period

define "Has Beta Blocker Therapy for LVSD Ordered":
  exists ( [MedicationRequest: "Beta Blocker Therapy for LVSD"] BetaBlockerOrdered
      where BetaBlockerOrdered.isOrderedDuringHeartFailureOutpatientEncounter ( )
        and BetaBlockerOrdered.status in { 'active', 'completed' }
        and BetaBlockerOrdered.intent in { 'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order' }
  )

define "Is Currently Taking Beta Blocker Therapy for LVSD":
  exists ( ["MedicationRequest": "Beta Blocker Therapy for LVSD"] ActiveBetaBlocker
      where ActiveBetaBlocker.overlapsAfterHeartFailureOutpatientEncounter ( )
  )

define "Numerator":
  "Has Beta Blocker Therapy for LVSD Ordered"
    or "Is Currently Taking Beta Blocker Therapy for LVSD"

define "Qualifying Outpatient Encounter During Measurement Period":
    ( [Encounter: "Care Services in Long Term Residential Facility"]
              union [Encounter: "Home Healthcare Services"]
              union [Encounter: "Nursing Facility Visit"]
              union [Encounter: "Office Visit"]
              union [Encounter: "Outpatient Consultation"]
              union [Encounter: "Patient Provider Interaction"]
     ) ValidEncounter
      where ValidEncounter.period during "Measurement Period"
        and ValidEncounter.isFinished()

define "Initial Population":
  AgeInYearsAt(date from start of "Measurement Period") >= 18
    and Count(AHA."Qualifying Outpatient Encounter During Measurement Period") >= 2
    and exists AHA."Heart Failure Outpatient Encounter"

define "Denominator":
  "Initial Population"
    and exists AHA."Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD"

define "SDE Payer":
  [Coverage: type in "Payer"] Payer
    return {
      code: Payer.type,
      period: Payer.period
    }

define "SDE Payer":
  SDE."SDE Payer"

define "SDE Ethnicity":
  Patient.ethnicity E
    return Tuple {
      codes: { E.ombCategory } union E.detailed,
      display: E.text
    }

define "SDE Ethnicity":
  SDE."SDE Ethnicity"

define "Has Heart Transplant":
  exists (
          [Procedure: "Heart Transplant"] HeartTransplant
            with "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
              such that HeartTransplant.performed.toInterval() starts before end of ModerateOrSevereLVSDHFOutpatientEncounter.period
            where HeartTransplant.status = 'completed'
          )

define "Has Heart Transplant Complications":
  exists ( 
          [Condition: "Heart Transplant Complications"] HeartTransplantComplications
            with "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
              such that ( Coalesce( HeartTransplantComplications.recordedDate.toInterval(), HeartTransplantComplications.prevalenceInterval() ) ) starts before end of ModerateOrSevereLVSDHFOutpatientEncounter.period
            where HeartTransplantComplications.isConfirmedActiveDiagnosis()
          )

define "Has Left Ventricular Assist Device":
  exists (
            [Procedure: "Left Ventricular Assist Device Placement"] LVADOutpatient
              with "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
                such that LVADOutpatient.performed.toInterval() starts before end of ModerateOrSevereLVSDHFOutpatientEncounter.period
              where LVADOutpatient.status = 'completed'
            )

define "Has Left Ventricular Assist Device Complications":
  exists (
            [Condition: "Left Ventricular Assist Device Complications"] LVADComplications
              with "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
                such that ( Coalesce( LVADComplications.recordedDate.toInterval(), LVADComplications.prevalenceInterval() ) ) starts before end of ModerateOrSevereLVSDHFOutpatientEncounter.period  
              where LVADComplications.isConfirmedActiveDiagnosis()
          )

define "Denominator Exclusions":
  AHA."Has Heart Transplant"
    or AHA."Has Heart Transplant Complications"
    or AHA."Has Left Ventricular Assist Device"
    or AHA."Has Left Ventricular Assist Device Complications"

define "SDE Race":
  Patient.race R
    return Tuple {
      codes: R.ombCategory union R.detailed,
      display: R.text
    }

define "SDE Race":
  SDE."SDE Race"

define "Has Consecutive Heart Rates Less than 50":
  exists ( from
      ["observation-heartrate"] HeartRate,
      AHA."Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
      let PriorHeartRate: Last(["observation-heartrate"] MostRecentPriorHeartRate
          where MostRecentPriorHeartRate.effective.toInterval() during ModerateOrSevereLVSDHFOutpatientEncounter.period
            and MostRecentPriorHeartRate.effective.toInterval() before HeartRate.effective.toInterval()
          sort by start of effective.toInterval()
      )
      where HeartRate.effective.toInterval ( ) during ModerateOrSevereLVSDHFOutpatientEncounter.period
        and HeartRate.status in { 'final', 'amended', 'corrected' }
        and HeartRate.value < 50 '/min'
        and PriorHeartRate.value < 50 '/min'
      return HeartRate
  )

define "Has Medical or Patient Reason for Not Ordering Beta Blocker for LVSD":
  exists ( ["MedicationNotRequested"] NoBetaBlockerOrdered
      with AHA."Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
        such that NoBetaBlockerOrdered.authoredOn during ModerateOrSevereLVSDHFOutpatientEncounter.period
      where NoBetaBlockerOrdered.medication in "Beta Blocker Therapy for LVSD"
        and ( NoBetaBlockerOrdered.reasonCode in "Medical Reason"
            or NoBetaBlockerOrdered.reasonCode in "Patient Reason"
        )
  )

define "Has Arrhythmia Diagnosis":
  exists ( [Condition: "Arrhythmia"] Arrhythmia
      where Arrhythmia.overlapsHeartFailureOutpatientEncounter ( )
        and Arrhythmia.isActive ( )
        and Arrhythmia.verificationStatus ~ QICoreCommon."confirmed"
  )

define "Has Hypotension Diagnosis":
  exists ( ["Condition": "Hypotension"] Hypotension
      where Hypotension.overlapsHeartFailureOutpatientEncounter ( )
        and Hypotension.isActive ( )
        and Hypotension.verificationStatus ~ QICoreCommon."confirmed"
  )

define "Has Asthma Diagnosis":
  exists ( [Condition: "Asthma"] Asthma
      where Asthma.overlapsHeartFailureOutpatientEncounter ( )
        and Asthma.isActive ( )
        and Asthma.verificationStatus ~ QICoreCommon."confirmed"
  )

define "Has Diagnosis of Allergy or Intolerance to Beta Blocker Therapy":
  exists ( ( ["Condition": "Allergy to Beta Blocker Therapy"]
      union ["Condition": "Intolerance to Beta Blocker Therapy"] ) BetaBlockerAllergyOrIntoleranceDiagnosis
      where BetaBlockerAllergyOrIntoleranceDiagnosis.overlapsAfterHeartFailureOutpatientEncounter ( )
        and BetaBlockerAllergyOrIntoleranceDiagnosis.isActive ( )
        and BetaBlockerAllergyOrIntoleranceDiagnosis.verificationStatus ~ QICoreCommon."confirmed"
  )

define "Has Bradycardia Diagnosis":
  exists ( [Condition: "Bradycardia"] Bradycardia
      where Bradycardia.overlapsHeartFailureOutpatientEncounter ( )
        and Bradycardia.isActive ( )
        and Bradycardia.verificationStatus ~ QICoreCommon."confirmed"
  )

define "Has Allergy or Intolerance to Beta Blocker Therapy Ingredient":
  exists ( ( [AllergyIntolerance: "Beta Blocker Therapy Ingredient"]
      union [AllergyIntolerance: "Substance with beta adrenergic receptor antagonist mechanism of action (substance)"] ) BetaBlockerAllergyIntolerance
      where BetaBlockerAllergyIntolerance.overlapsAfterHeartFailureOutpatientEncounter ( )
        and ( BetaBlockerAllergyIntolerance.clinicalStatus is null
            or BetaBlockerAllergyIntolerance.clinicalStatus ~ QICoreCommon."allergy-active"
        )
  )

define "Has Atrioventricular Block Diagnosis":
  exists ( [Condition: "Atrioventricular Block"] AtrioventricularBlock
      where AtrioventricularBlock.overlapsHeartFailureOutpatientEncounter ( )
        and AtrioventricularBlock.isActive ( )
        and AtrioventricularBlock.verificationStatus ~ QICoreCommon."confirmed"
  )

define "Has Diagnosis of Cardiac Pacer in Situ":
  exists ( ["Condition": "Cardiac Pacer in Situ"] CardiacPacerDiagnosis
      where CardiacPacerDiagnosis.overlapsAfterHeartFailureOutpatientEncounter ( )
        and CardiacPacerDiagnosis.isActive ( )
        and CardiacPacerDiagnosis.verificationStatus ~ QICoreCommon."confirmed"
  )

define "Has Cardiac Pacer Device Implanted":
  exists ( [Procedure: "Cardiac Pacer"] ImplantedCardiacPacer
      with AHA."Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
        such that ImplantedCardiacPacer.performed.toInterval ( ) starts before end of ModerateOrSevereLVSDHFOutpatientEncounter.period
      where ImplantedCardiacPacer.status = 'completed'
  )

define "Atrioventricular Block without Cardiac Pacer":
  "Has Atrioventricular Block Diagnosis"
    and not "Has Diagnosis of Cardiac Pacer in Situ"
    and not "Has Cardiac Pacer Device Implanted"

define "Denominator Exceptions":
  "Has Consecutive Heart Rates Less than 50"
    or "Has Medical or Patient Reason for Not Ordering Beta Blocker for LVSD"
    or "Has Arrhythmia Diagnosis"
    or "Has Hypotension Diagnosis"
    or "Has Asthma Diagnosis"
    or "Has Diagnosis of Allergy or Intolerance to Beta Blocker Therapy"
    or "Has Bradycardia Diagnosis"
    or "Has Allergy or Intolerance to Beta Blocker Therapy Ingredient"
    or "Atrioventricular Block without Cardiac Pacer"

define fluent function isOrderedDuringHeartFailureOutpatientEncounter(Order MedicationRequest): 
  exists ( "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
            where Order.authoredOn during day of ModerateOrSevereLVSDHFOutpatientEncounter.period
              and Order.status in {'active', 'completed'}
              and Order.intent in { 'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order' }
              and Order.doNotPerform is not true
          )

/*
@description: Returns an interval representing the normalized prevalence period of a given Condition.
@comment: Uses the ToInterval and ToAbatementInterval functions to determine the widest potential interval from
onset to abatement as specified in the given Condition. If the condition is active, the resulting interval will have
a closed ending boundary. If the condition is not active, the resulting interval will have an open ending boundary.
*/
define fluent function prevalenceInterval(condition Condition):
if condition.clinicalStatus ~ "active"
  or condition.clinicalStatus ~ "recurrence"
  or condition.clinicalStatus ~ "relapse" then
  Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]
else
  Interval[start of condition.onset.toInterval(), end of condition.abatementInterval())

define fluent function isConfirmedActiveDiagnosis(Condition Condition):
  ( Condition Diagnosis
    where Diagnosis.clinicalStatus ~ QICoreCommon."active"
        and not ( Diagnosis.verificationStatus ~ QICoreCommon."unconfirmed"
                     or Diagnosis.verificationStatus ~ QICoreCommon."refuted"
                     or Diagnosis.verificationStatus ~ QICoreCommon."entered-in-error" )
    ) is not null

define fluent function isFinished(Visit Encounter):
  Visit.status = 'finished'

/*
@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval
@comment: Normalizes a choice type of DateTime, Quanitty, Interval<DateTime>, or Interval<Quantity> types
to an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible
representations for timing-valued elements in QICore, allowing this function to be used across any resource.
The input can be provided as a DateTime, Quantity, Interval<DateTime> or Interval<Quantity>.
The intent of this function is to provide a clear and concise mechanism to treat single
elements that have multiple possible representations as intervals so that logic doesn't have to account
for the variability. More complex calculations (such as medication request period or dispense period
calculation) need specific guidance and consideration. That guidance may make use of this function, but
the focus of this function is on single element calculations where the semantics are unambiguous.
If the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.
If the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,
and the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.
If the input is a DateTime Interval, the result is the input.
If the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result
is a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending
immediately before one year later than the date the patient turned the age given as the end of the quantity interval.
Any other input will reslt in a null DateTime Interval
*/
define fluent function toInterval(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>>):
  case
	  when choice is DateTime then
    	Interval[choice as DateTime, choice as DateTime]
		when choice is Interval<DateTime> then
  		choice as Interval<DateTime>
		when choice is Quantity then
		  Interval[Patient.birthDate + (choice as Quantity),
			  Patient.birthDate + (choice as Quantity) + 1 year)
		when choice is Interval<Quantity> then
		  Interval[Patient.birthDate + (choice.low as Quantity),
			  Patient.birthDate + (choice.high as Quantity) + 1 year)
		else
			null as Interval<DateTime>
	end

define fluent function overlapsAfterHeartFailureOutpatientEncounter(Event Choice<Condition, Procedure, AllergyIntolerance, MedicationRequest, "observation-heartrate">): 
  exists ( "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
            where 
              case
                when Event is Condition then 
                  Event.prevalenceInterval() overlaps after day of ModerateOrSevereLVSDHFOutpatientEncounter.period
                    and Event.isConfirmedActiveDiagnosis()
                when Event is Procedure then
                  Event.performed.toInterval() overlaps after day of ModerateOrSevereLVSDHFOutpatientEncounter.period
                    and Event.status = 'completed'
                when Event is AllergyIntolerance then
                  Interval[start of Event.onset.toInterval(), Event.lastOccurrence] overlaps after day of ModerateOrSevereLVSDHFOutpatientEncounter.period
                    and Event.clinicalStatus ~ QICoreCommon."allergy-active"
                    and not (Event.verificationStatus ~ QICoreCommon."allergy-unconfirmed"
                        or Event.verificationStatus ~ QICoreCommon."allergy-refuted"
                        or Event.verificationStatus ~ "allergy-entered-in-error")
                when Event is MedicationRequest then
                  First( ( collapse (Event.dosageInstruction.timing.repeat.bounds DoseTime
                                        return DoseTime.toInterval()) ) DrugPeriods
                           sort by start of $this ) overlaps after day of ModerateOrSevereLVSDHFOutpatientEncounter.period 
                    and Event.status in { 'active', 'completed' } 
                    and Event.intent in { 'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order' }
                    and Event.doNotPerform is not true
                when Event is "observation-heartrate" then
                  Event.effective.toInterval() overlaps after day of ModerateOrSevereLVSDHFOutpatientEncounter.period
                    and Event.status in {'final', 'amended', 'corrected'}
                else false
              end
          )

define function ToString(value uri): 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
        }

/*
@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 fluent function overlapsHeartFailureOutpatientEncounter(Diagnosis Condition): 
  exists ( "Heart Failure Outpatient Encounter with History of Moderate or Severe LVSD" ModerateOrSevereLVSDHFOutpatientEncounter
            where Diagnosis.prevalenceInterval() overlaps day of ModerateOrSevereLVSDHFOutpatientEncounter.period
              and Diagnosis.isConfirmedActiveDiagnosis()
          )

/* Candidates for FHIRCommon */

/*
@description: Returns true if the given condition has a clinical status of active, recurrence, or relapse
*/
define fluent function isActive(condition Condition):
  condition.clinicalStatus ~ "active"
    or condition.clinicalStatus ~ "recurrence"
    or condition.clinicalStatus ~ "relapse"