define "Initial Population":
    /***
    * Includes all Qualified VTE Encounters in which the patient was aged 18 or older at the start of the qualified VTE encounter.
    ***/
  
  "Qualified VTE Encounters During Measurement Period" QualifiedEncounter
    where AgeInYearsAt(date from start of QualifiedEncounter.period) >= 18

define "Denominator":
  "Initial Population"

define "Denominator Exclusions":
  "Qualified VTE Encounter With Hospice Services Within Previous 90 Days"
    union "Qualified VTE Encounter With Palliative Care Within Previous 90 Days"
    union "Qualified VTE Encounter With Other Qualified VTE Encounter Documented Within Previous 6 Months"

define "Numerator":
    /***
    * Includes all qualified VTE encounters in which the VTE diagnosis started greater than 24 hours after a qualifying PCP visit.
    ****/
  
  "Qualifying Delayed VTE Encounter"

define "SDE Sex":
  case
    when Patient.sex = '248153007' then "Male (finding)"
    when Patient.sex = '248152002' then "Female (finding)"
    else null
  end

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

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

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

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

/*
@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 "SDE Sex":
  SDE."SDE Sex"

define "Qualifying Performed Encounters":
  ( ["Encounter": "Office Visit"]
    union ["Encounter": "Outpatient Encounter"]
    union ["Encounter": "Encounter Inpatient"] ) Encounter
    where Encounter.status = 'finished'
      and Encounter.period starts during day of Interval[start of "Measurement Period" - 180 days, end of "Measurement Period"]

define "Qualifying Performed VTE Encounters":
  "Qualifying Performed Encounters" VTEEncounter
    where VTEEncounter.reasonCode in "VTE Diagnoses"
      or exists ( [ConditionEncounterDiagnosis: "VTE Diagnoses"] VTECondition
          where VTECondition.isConfirmedCondition ( )
            and VTEEncounter.reasonReference.references ( VTECondition )
      )

define "Qualifying Performed PCP Visits":
  ( ["Encounter": "Outpatient Encounter"]
    union ["Encounter": "Office Visit"] ) PCPVisit
    where PCPVisit.status = 'finished'
      and PCPVisit.period ends during day of Interval[start of "Measurement Period" - 210 days, end of "Measurement Period"]

define "Qualifying Performed PCP Visits With VTE Symptom":
  "Qualifying Performed PCP Visits" IndexPCPVisit
    where IndexPCPVisit.reasonCode in "VTE Symptoms"
      or exists ( [ConditionEncounterDiagnosis: "VTE Symptoms"] VTESymptomCondition
          where VTESymptomCondition.isVerified ( )
            and IndexPCPVisit.reasonReference.references ( VTESymptomCondition )
      )

define "Qualifying VTE Imaging Diagnostic Report":
  ["DiagnosticReportNote": "Imaging Related to VTE"] VTEDiagnosticReport
    where VTEDiagnosticReport.status in { 'final', 'amended', 'corrected' }

define "AntiCoagulant Therapy Ordered":
  ["MedicationRequest": "Anticoagulant Medications"] AntiCoagulant
    where AntiCoagulant.status in { 'active', 'completed' }
      and AntiCoagulant.intent = 'order'

define "Qualified VTE Encounters":
  from
    "Qualifying Performed VTE Encounters" VTEEncounter,
    "Qualifying Performed PCP Visits With VTE Symptom" IndexPCP,
    "Qualifying VTE Imaging Diagnostic Report" VTEStudy,
    "AntiCoagulant Therapy Ordered" AntiCoagulantOrdered
    where VTEStudy.effective.toInterval ( ) starts during day of VTEEncounter.period
      and ( AntiCoagulantOrdered.authoredOn 12 hours or less before VTEStudy.effective
          or AntiCoagulantOrdered.authoredOn 12 hours or less after VTEStudy.effective
      )
      and IndexPCP.period starts 30 days or less on or before VTEStudy.effective
    return VTEEncounter

define "Qualified VTE Encounters During Measurement Period":
  "Qualified VTE Encounters" QualifiedVTEEncounter
    where QualifiedVTEEncounter.period starts during day of "Measurement Period"

define "Qualifying Delayed VTE Encounter":
  "Qualified VTE Encounters During Measurement Period" DelayedVTEEncounter
    with "Qualifying Performed PCP Visits With VTE Symptom" IndexPCPVisit
      such that DelayedVTEEncounter.period starts during day of Interval[end of IndexPCPVisit.period + 2 day, end of IndexPCPVisit.period + 30 days]

define "Numerator":
    /***
    * Includes all qualified VTE encounters in which the VTE diagnosis started greater than 24 hours after a qualifying PCP visit.
    ****/
  
  "Qualifying Delayed VTE Encounter"

define "Initial Population":
    /***
    * Includes all Qualified VTE Encounters in which the patient was aged 18 or older at the start of the qualified VTE encounter.
    ***/
  
  "Qualified VTE Encounters During Measurement Period" QualifiedEncounter
    where AgeInYearsAt(date from start of QualifiedEncounter.period) >= 18

define "Denominator":
  "Initial Population"

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

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

define "Qualified VTE Encounter With Hospice Services Within Previous 90 Days":
  from
    "Qualified VTE Encounters" QualifiedVTEEncounter
    let NinetyDaysBeforeVTEEncounter: Interval[start of QualifiedVTEEncounter.period - 90 days, end of QualifiedVTEEncounter.period]
    where exists ( ["Encounter": "Encounter Inpatient"] InpatientEncounter
        where ( InpatientEncounter.hospitalization.dischargeDisposition ~ "Discharge to home for hospice care (procedure)"
            or InpatientEncounter.hospitalization.dischargeDisposition ~ "Discharge to healthcare facility for hospice care (procedure)"
        )
          and InpatientEncounter.period ends during day of NinetyDaysBeforeVTEEncounter
          and InpatientEncounter.status = 'finished'
    )
      or exists ( ["Encounter": "Hospice Encounter"] HospiceEncounter
          where HospiceEncounter.period overlaps day of NinetyDaysBeforeVTEEncounter
      )
      or exists ( ( [ObservationScreeningAssessment: "Hospice care [Minimum Data Set]"] ) HospiceAssessment
          where HospiceAssessment.value ~ "Yes (qualifier value)"
            and HospiceAssessment.effective.toInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
      )
      or exists ( ( [ServiceRequest: "Hospice Care Ambulatory"] ) HospiceOrder
          where HospiceOrder.authoredOn during day of NinetyDaysBeforeVTEEncounter
            and HospiceOrder.status in { 'active', 'completed' }
      )
      or exists ( ( [Procedure: "Hospice Care Ambulatory"] ) HospicePerformed
          where HospicePerformed.performed.toInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
      )
      or exists ( ( [ConditionEncounterDiagnosis: "Hospice Diagnosis"] ) HospiceCareDiagnosis
          where HospiceCareDiagnosis.prevalenceInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
            and HospiceCareDiagnosis.isVerified ( )
      )
      or exists ( ( [ConditionProblemsHealthConcerns: "Hospice Diagnosis"] ) HospiceCareConcern
          where HospiceCareConcern.prevalenceInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
            and HospiceCareConcern.isVerified ( )
      )

define "Qualified VTE Encounter With Palliative Care Within Previous 90 Days":
  from
    "Qualified VTE Encounters" QualifiedVTEEncounter
    let NinetyDaysBeforeVTEEncounter: Interval[start of QualifiedVTEEncounter.period - 90 days, end of QualifiedVTEEncounter.period]
    where exists ( ( [ObservationScreeningAssessment: "Functional Assessment of Chronic Illness Therapy - Palliative Care Questionnaire (FACIT-Pal)"] ) PalliativeAssessment
        where PalliativeAssessment.effective.toInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
          and PalliativeAssessment.status in { 'final', 'amended', 'corrected' }
    )
      or exists ( ( ( [ConditionEncounterDiagnosis: "Palliative Care Diagnosis"] ) ) PalliativeCareDiagnosis
          where PalliativeCareDiagnosis.prevalenceInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
            and PalliativeCareDiagnosis.isVerified ( )
      )
      or exists ( ( [ConditionProblemsHealthConcerns: "Palliative Care Diagnosis"] ) PalliativeCareConcern
          where PalliativeCareConcern.prevalenceInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
            and PalliativeCareConcern.isVerified ( )
      )
      or exists ( ( [Encounter: "Palliative Care Encounter"] ) PalliativeEncounter
          where PalliativeEncounter.period overlaps day of NinetyDaysBeforeVTEEncounter
      )
      or exists ( ( [Procedure: "Palliative Care Intervention"] ) PalliativeIntervention
          where PalliativeIntervention.performed.toInterval ( ) overlaps day of NinetyDaysBeforeVTEEncounter
      )

define "Qualified VTE Encounter With Other Qualified VTE Encounter Documented Within Previous 6 Months":
  "Qualified VTE Encounters" CurrentQualifiedVTE
    with "Qualified VTE Encounters" PreviousQualifiedVTE
      such that PreviousQualifiedVTE.period starts 6 months or less before start of CurrentQualifiedVTE.period

define "Denominator Exclusions":
  "Qualified VTE Encounter With Hospice Services Within Previous 90 Days"
    union "Qualified VTE Encounter With Palliative Care Within Previous 90 Days"
    union "Qualified VTE Encounter With Other Qualified VTE Encounter Documented Within Previous 6 Months"

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

/*

/*
@description: Returns true if the given Condition is confirmed
*/


define fluent function isConfirmedCondition(condition ConditionEncounterDiagnosis):
  condition.verificationStatus ~ QICoreCommon."confirmed"

/*
@description: Returns true if the given condition either has no verification status or has a verification status of confirmed, unconfirmed, provisional, or differential
*/


define fluent function isVerified(condition Choice<ConditionEncounterDiagnosis, ConditionProblemsHealthConcerns>):
  condition.verificationStatus is not null implies ( condition.verificationStatus ~ QICoreCommon."confirmed"
      or condition.verificationStatus ~ QICoreCommon."unconfirmed"
      or condition.verificationStatus ~ QICoreCommon."provisional"
      or condition.verificationStatus ~ QICoreCommon."differential"
  )

/*
@description: Returns true if any of the given references are to the given resource
@comment: Returns true if the `id` element of the given resource exactly equals the tail of any of the given references.
NOTE: This function assumes resources from the same source server.
*/
define fluent function references(references List<Reference>, resource Resource):
  exists (references R where R.references(resource))

/*
@description: Returns true if the given reference is to the given resource
@comment: Returns true if the `id` element of the given resource exactly equals the tail of the given reference.
NOTE: This function assumes resources from the same source server.
*/
define fluent function references(reference Reference, resource Resource):
  resource.id = Last(Split(reference.reference, '/'))

/*
@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.
If the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval
*/
define fluent function toInterval(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>, Timing>):
  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)
		when choice is Timing then
      Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval<DateTime>
		else
			null as Interval<DateTime>
	end

/*
@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, or has an abatement date the resulting 
interval will have a closed ending boundary. Otherwise, the resulting interval will have an open ending boundary.
*/
define fluent function prevalenceInterval(condition Choice<"ConditionEncounterDiagnosis", "ConditionProblemsHealthConcerns">):
if condition.clinicalStatus ~ "active"
  or condition.clinicalStatus ~ "recurrence"
  or condition.clinicalStatus ~ "relapse" then
  Interval[start of condition.onset.toInterval(), end of condition.abatementInterval()]
else
    (end of condition.abatementInterval()) abatementDate
    return if abatementDate is null then
      Interval[start of condition.onset.toInterval(), abatementDate)
    else
      Interval[start of condition.onset.toInterval(), abatementDate]

/*
@description: Returns an interval representing the normalized abatement of a given Condition.
@comment: If the abatement element of the Condition is represented as a DateTime, the result
is an interval beginning and ending on that DateTime.
If the abatement is represented as a Quantity, the quantity is expected to be a calendar-duration and is interpreted as the age of the patient. The
result is an interval from the date the patient turned that age to immediately before one year later.
If the abatement is represented as a Quantity Interval, the quantities are expected to be calendar-durations and are interpreted as an age range during
which the abatement occurred. The result is an interval from the date the patient turned the starting age of the quantity interval, and ending immediately
before one year later than the date the patient turned the ending age of the quantity interval.
*/
define fluent function abatementInterval(condition Choice<"ConditionEncounterDiagnosis", "ConditionProblemsHealthConcerns">):
	if condition.abatement is DateTime then
	  Interval[condition.abatement as DateTime, condition.abatement as DateTime]
	else if condition.abatement is Quantity then
		Interval[Patient.birthDate + (condition.abatement as Quantity),
			Patient.birthDate + (condition.abatement as Quantity) + 1 year)
	else if condition.abatement is Interval<Quantity> then
	  Interval[Patient.birthDate + (condition.abatement.low as Quantity),
		  Patient.birthDate + (condition.abatement.high as Quantity) + 1 year)
	else if condition.abatement is Interval<DateTime> then
	  Interval[condition.abatement.low, condition.abatement.high)
	else null as Interval<DateTime>