define "Initial Population":
  PCMaternal."Delivery Encounter With Age Range"

define "Denominator":
  "Singleton Delivery Encounters At 37 Plus Weeks Gravida 1 Parity 0, No Previous Births"

define "Denominator Exclusions":
  "Delivery Encounter With Abnormal Presentation, Genital Herpes, Placenta Previa, Vasa Previa Or Placenta Accreta Spectrum"

define "Numerator":
  "Delivery Encounter With Cesarean Birth"

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 "Encounter With Age Range":
 CQMCommon."Inpatient Encounter" InpatientEncounter
                      where AgeInYearsAt(date from start of InpatientEncounter.period) in Interval[ 8, 65 )

define "Delivery Encounter With Age Range":
  "Encounter With Age Range" EncounterWithAge
                with ["Procedure": "Delivery Procedures"] DeliveryProcedure
                such that DeliveryProcedure.status = 'completed'
                and DeliveryProcedure.performed.toInterval  ( ) starts during EncounterWithAge.hospitalizationWithEDOBTriageObservation ()

define "Variable Calculated Gestational Age":
 "Delivery Encounter With Age Range" DeliveryEncounter
    let CGA: DeliveryEncounter.calculatedGestationalAge()
    return {
      EncounterID: DeliveryEncounter.id,
      CalculatedCGA: CGA
    }

define fluent function hospitalizationWithEDOBTriageObservation (TheEncounter Encounter ):
  /*hospitalizationWithEDOBTriageObservation returns the total interval from the start of any immediately prior emergency department visit or OB Triage visit through the observation visit to the discharge of the given encounter*/
  TheEncounter Visit
    let ObsVisit: Last(["Encounter": "Observation Services"] LastObs
        where LastObs.period ends 1 hour or less on or before start of Visit.period
          and LastObs.status = 'finished'
        sort by 
        end of period
    ),
    VisitStart: Coalesce(start of ObsVisit.period, start of Visit.period),
    EDOBTriageVisit: Last(["Encounter": "ED Visit and OB Triage"] LastEDOBTriage
        where LastEDOBTriage.period ends 1 hour or less on or before VisitStart
          and LastEDOBTriage.status = 'finished'
        sort by 
        end of period
    )
    return Interval[Coalesce(start of EDOBTriageVisit.period, VisitStart), 
    end of Visit.period]

define fluent function calculatedGestationalAge (TheEncounter Encounter ):
  //Gestational Age = (280 -(Estimated Delivery Date minus Reference Date/Delivery Date))/7
 ( 280 - ( difference in days between TheEncounter.lastTimeOfDelivery () and TheEncounter.lastEstimatedDeliveryDate( )) ) div 7

define fluent function lastTimeOfDelivery (TheEncounter Encounter ):
  Last(["SimpleObservation": "Date and time of obstetric delivery"] TimeOfDelivery
      where TimeOfDelivery.value as DateTime is not null
        and TimeOfDelivery.status in { 'final', 'amended', 'corrected' }
        and TimeOfDelivery.effective.earliest () during TheEncounter.hospitalizationWithEDOBTriageObservation ()
        and TimeOfDelivery.value as DateTime during TheEncounter.hospitalizationWithEDOBTriageObservation()
      sort by effective.earliest()
  ).value as DateTime

define fluent function lastEstimatedDeliveryDate (TheEncounter Encounter ):
  /*This function identifies the last time the EDD was assessed 42 weeks or less prior to or on delivery and stores the result of that assessment.*/
  Last(["SimpleObservation": "Delivery date Estimated"] EstimatedDateOfDelivery
      where EstimatedDateOfDelivery.value as DateTime is not null
        and EstimatedDateOfDelivery.status in { 'final', 'amended', 'corrected' }
        and EstimatedDateOfDelivery.effective.earliest ( ) 42 weeks or less before or on TheEncounter.lastTimeOfDelivery ()
      sort by effective.earliest ( )
  ).value as DateTime

define fluent function lastEstimatedGestationalAge (TheEncounter Encounter ):
  Last(["SimpleObservation": "Estimated Gestational Age at Delivery"] EstimatedGestationalAge
  let EGATiming:  EstimatedGestationalAge.effective.earliest() where 
  (EGATiming 24 hours or less before or on TheEncounter.lastTimeOfDelivery () 
  and EstimatedGestationalAge.value is not null 
  and EstimatedGestationalAge.status in { 'final', 'amended', 'corrected' }) or 
      (EGATiming same day as TheEncounter.lastTimeOfDelivery () 
      and EGATiming during TheEncounter.hospitalizationWithEDOBTriageObservation() 
      and EstimatedGestationalAge.value is not null)
 sort by effective.earliest ())
         .value as Quantity

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 "Inpatient Encounter":
  [Encounter: "Encounter Inpatient"] EncounterInpatient
    where EncounterInpatient.status = 'finished'
      and EncounterInpatient.period ends during day of "Measurement Period"

/*  
@description: Returns the Condition resources referenced by the diagnosis element of the Encounter  
*/
define fluent function encounterDiagnosis(Encounter Encounter ):
  Encounter.reasonReference D
    return singleton from (([ConditionEncounterDiagnosis] union [ConditionProblemsHealthConcerns]) C where D.references(C.id))

/*
@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: Given an interval, return the starting point if the interval has a starting boundary specified,
otherwise, return the ending point
*/
define fluent function earliest(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>> ):
  (choice.toInterval()) period
    return
      if (period."hasStart"()) then start of period
      else end of period

/*
@description: Given an interval, return true if the interval has a starting boundary specified
(i.e. the start of the interval is not null and not the minimum DateTime value)
*/
define fluent function hasStart(period Interval<DateTime> ):
  not ( start of period is null
      or start of period = minimum DateTime
  )

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

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

define "Delivery Encounter With Calculated Gestational Age Greater Than Or Equal To 37 Weeks":
  PCMaternal."Delivery Encounter With Age Range" DeliveryEncounter
    where DeliveryEncounter.calculatedGestationalAge ( ) >= 37

define "Delivery Encounter With Estimated Gestational Age Greater Than Or Equal To 37 Weeks":
  PCMaternal."Delivery Encounter With Age Range" DeliveryEncounter
    where DeliveryEncounter.calculatedGestationalAge ( ) is null
      and DeliveryEncounter.lastEstimatedGestationalAge ( ) >= 37 weeks

define "Delivery Encounter With Gestational Age Greater Than Or Equal To 37 Weeks Based On Coding":
  PCMaternal."Delivery Encounter With Age Range" DeliveryEncounter
    let CGA: DeliveryEncounter.calculatedGestationalAge ( ),
    EGA: DeliveryEncounter.lastEstimatedGestationalAge ( )
    where CGA is null
      and EGA is null
      and ( DeliveryEncounter.reasonCode in "37 to 42 Plus Weeks Gestation"
          or DeliveryEncounter.encounterDiagnosis ( ).code in "37 to 42 Plus Weeks Gestation"
      )

define "Delivery Encounter With Gestational Age Greater Than Or Equal To 37 Weeks":
  "Delivery Encounter With Calculated Gestational Age Greater Than Or Equal To 37 Weeks"
    union "Delivery Encounter With Estimated Gestational Age Greater Than Or Equal To 37 Weeks"
    union "Delivery Encounter With Gestational Age Greater Than Or Equal To 37 Weeks Based On Coding"

define "Encounter With Singleton Delivery":
  PCMaternal."Delivery Encounter With Age Range" DeliveryEncounter
    where DeliveryEncounter.reasonCode in "Delivery of Singleton"
      or DeliveryEncounter.encounterDiagnosis ( ).code in "Delivery of Singleton"

define "Singleton Delivery Encounters At 37 Plus Weeks Gravida 1 Parity 0, No Previous Births":
  ( "Delivery Encounter With Gestational Age Greater Than Or Equal To 37 Weeks"
    intersect "Encounter With Singleton Delivery" ) SingletonEncounterGE37Weeks
    where ( ( SingletonEncounterGE37Weeks.lastGravida ( ) = 1 )
        or ( SingletonEncounterGE37Weeks.lastParity ( ) = 0 )
        or ( ( SingletonEncounterGE37Weeks.lastHistoryPretermBirth ( ) = 0 )
            and ( SingletonEncounterGE37Weeks.lastHistoryTermBirth ( ) = 0 )
        )
    )

define "Delivery Encounter With Cesarean Birth":
  "Singleton Delivery Encounters At 37 Plus Weeks Gravida 1 Parity 0, No Previous Births" ThirtySevenWeeksPlusEncounter
    with ["Procedure": "Cesarean Birth"] CSection
      such that CSection.performed.toInterval ( ) during ThirtySevenWeeksPlusEncounter.hospitalizationWithEDOBTriageObservation ( )
        and CSection.status = 'completed'

define "Numerator":
  "Delivery Encounter With Cesarean Birth"

define "Denominator":
  "Singleton Delivery Encounters At 37 Plus Weeks Gravida 1 Parity 0, No Previous Births"

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

define "Initial Population":
  PCMaternal."Delivery Encounter With Age Range"

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

define "Encounter With Abnormal Presentation":
  "Singleton Delivery Encounters At 37 Plus Weeks Gravida 1 Parity 0, No Previous Births" ThirtySevenWeeksPlusEncounter
    let LastAbnormalPresentation: Last(["SimpleObservation": "Abnormal Presentation"] AbnormalPresentation
        where AbnormalPresentation.effective.earliest() before or on ThirtySevenWeeksPlusEncounter.lastTimeOfDelivery()
          and AbnormalPresentation.status in { 'final', 'amended', 'corrected' }
        sort by effective.earliest()
    )
    where LastAbnormalPresentation.effective.earliest ( ) during ThirtySevenWeeksPlusEncounter.hospitalizationWithEDOBTriageObservation ( )
      or ThirtySevenWeeksPlusEncounter.encounterDiagnosis ( ).code in "Abnormal Presentation"
      or ThirtySevenWeeksPlusEncounter.reasonCode in "Abnormal Presentation"

define "Encounter With Genital Herpes, Placenta Previa, Vasa Previa Or Placenta Accreta Spectrum":
  "Singleton Delivery Encounters At 37 Plus Weeks Gravida 1 Parity 0, No Previous Births" ThirtySevenWeeksPlusEncounter
    where ( ThirtySevenWeeksPlusEncounter.encounterDiagnosis ( ).code in "Placenta Accreta Spectrum Previa or Vasa Previa"
        or ThirtySevenWeeksPlusEncounter.encounterDiagnosis ( ).code in "Genital Herpes"
        or ThirtySevenWeeksPlusEncounter.reasonCode in "Genital Herpes"
        or ThirtySevenWeeksPlusEncounter.reasonCode in "Placenta Accreta Spectrum Previa or Vasa Previa"
    )

define "Delivery Encounter With Abnormal Presentation, Genital Herpes, Placenta Previa, Vasa Previa Or Placenta Accreta Spectrum":
  "Encounter With Abnormal Presentation"
    union "Encounter With Genital Herpes, Placenta Previa, Vasa Previa Or Placenta Accreta Spectrum"

define "Denominator Exclusions":
  "Delivery Encounter With Abnormal Presentation, Genital Herpes, Placenta Previa, Vasa Previa Or Placenta Accreta Spectrum"

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

define "SDE Variable Calculated Gestational Age":
  PCMaternal."Variable Calculated Gestational Age"

define fluent function lastGravida(TheEncounter Encounter):
  Last(["SimpleObservation": "[#] Pregnancies"] Gravida
      where Gravida.value is not null
        and Gravida.status in { 'final', 'amended', 'corrected' }
        and Gravida.effective.earliest() 42 weeks or less before TheEncounter.lastTimeOfDelivery()
      sort by effective.earliest()
  ).value as Integer

define fluent function lastParity(TheEncounter Encounter):
  Last(["SimpleObservation": "[#] Parity"] Parity
      where Parity.effective.earliest() 42 weeks or less before TheEncounter.lastTimeOfDelivery()
        and Parity.status in { 'final', 'amended', 'corrected' }
        and Parity.value is not null
      sort by effective.earliest()
  ).value as Integer

define fluent function lastHistoryPretermBirth(TheEncounter Encounter):
  Last(["SimpleObservation": "[#] Births.preterm"] PretermBirth
      where PretermBirth.effective.earliest() 42 weeks or less before TheEncounter.lastTimeOfDelivery()
        and PretermBirth.status in { 'final', 'amended', 'corrected' }
        and PretermBirth.value is not null
      sort by effective.earliest()
  ).value as Integer

define fluent function lastHistoryTermBirth(TheEncounter Encounter):
  Last(["SimpleObservation": "[#] Births.term"] TermBirth
      where TermBirth.effective.earliest() 42 weeks or less before TheEncounter.lastTimeOfDelivery()
        and TermBirth.status in { 'final', 'amended', 'corrected' }
        and TermBirth.value is not null
      sort by effective.earliest()
  ).value as Integer