/*
Goal Identification: % of individuals 18 years of age and older with a complex care need 
who had a PCO goal identified resulting in completion of goal attainment scaling (GAS) 
or a Patient-Reported Outcome Measure (PROM) and development of an action plan.
*/

/*
@description: Includes individuals 18 years of age and older.
*/
define "Initial Population": {
  Patient person
    where AgeInYearsAt(start of "Measurement Period") >= 18
}

/*
@description: Initial Population individuals with a complex care need.
@comment: TODO - How do we determine "complex care need?"
*/
define "Denominator":
  "Initial Population"

/* 
... has a PCO goal identified resulting in completion of goal attainment scaling (GAS)
or a Patient-Reported Outcome Measure (PROM) and development of an action plan.
*/
define "Numerator":
  "Denominator" person where
    exists PCOLogic."PCO Goals During Measurement Period"
      and exists PCOLogic."Baseline Scores Before Follow-Up Period"

define "Denominator Exclusions":
  null

define "Denominator Exceptions":
  null

define "Well-Being Observations":
  [Observation] obs
    where obs.category in "Well-Being Categories"
      or obs.code in "Well-Being Domains"

// Returns a list of what matters Observations this Goal addresses.
define fluent function whatMattersObservations(goal Goal):
  flatten( goal.addresses GA
      return [Observation] obs
        where obs.id = GA.reference.getId()
          and obs.isWhatMatters()
  )

define fluent function isWhatMatters(obs Observation):
  exists( "Well-Being Observations" obs
    where exists(obs.category cat where cat = "What Matters category")
  )

define fluent function getId(uri String):
  Last(Split(uri, '/'))

/*
@description: Returns any extensions defined on the given resource with the specified url.
@comment: NOTE: Extensions are not the preferred approach, but are used as a way to access
content that is defined by extensions but not yet surfaced in the
CQL model info.
*/
define fluent function extensions(domainResource DomainResource, url String):
  domainResource.extension E
	  where E.url = url
		return E

define fluent function resolveGoals(references List<Reference>):
  flatten( references ref
    return [Goal] resource
      where resource.id = ref.reference.getId()
  )

// Returns a list of CarePlan that support this Goal.
define fluent function carePlans(goal Goal):
  [CarePlan] carePlan
    where exists ( carePlan.goal goalRef
        where goal.id = goalRef.reference.getId()
    )

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

define function ToDate(value date): value.value

define function ToDateTime(value dateTime): value.value

/* 
  A "PCO Goal" is any FHIR Goal that has a category in "What Matters Category" or "PCO Domain Categories"
      or that addresses a What Matters observation
  and has a start date.
*/
define "PCO Goals":
  [Goal] goal
    where (goal.category in WM."Well-Being Categories"
        or goal.category in "PCO Goal Domain Categories"
        or exists goal.whatMattersObservations())
      and (goal.start as FHIR.date) is not null

// Observations containing a GAS score.
define "GAS Scores":
  [Observation: "Goal Attainment Scaling (GAS) Score"]

// PCO Goals whose startDate falls within the Measurement Period
define "PCO Goals During Measurement Period":
  "PCO Goals" goal
    where (ToDateTime(goal.start as FHIR.date) during "Measurement Period")
      and (goal.hasGAS() or goal.hasPROM())
      and exists goal.carePlans()

// Observations containing a PROM score.
define "PROM Scores":
  [Observation: "PROM Target Measures"]

/* 
Baseline Scares are PCO score observations taken during the Measurement Period,
but before the follow-up period for its Goal. Default follow-up period is 
2 weeks to 6 months following the goal startDate.
*/
define "Baseline Scores Before Follow-Up Period":
  flatten( "PCO Goals During Measurement Period" goal
    let pcoScores: goal.pcoScores()
      return pcoScores score 
        let scoreDate: score.effective as FHIR.dateTime
        where (scoreDate during "Measurement Period")
          and (scoreDate before start of "Follow-Up Interval For"(goal))
  )

// where exists obs.performer.resolveRelatedPersons()

define fluent function hasGAS(goal Goal):
  exists goal.extensions('http://hl7.org/fhir/us/pco/StructureDefinition/pco-goal-attainment-scaling')
    or exists (goal.target target
      where target.measure = "Goal attainment scale"
    )
    or exists goal.gasScores()

// Returns a list of Observation including only GAS scores
define fluent function gasScores(goal Goal):
  "GAS Scores" score
    where score.focusGoals() contains goal

// Returns a list of Goal where focus includes the given Observation.
define fluent function focusGoals(obs Observation):
  obs.focus.resolveGoals()

/// Returns true if this Goal has a PROM code in its target.measure
define fluent function hasPROM(goal Goal):
  exists (goal.target target
    where target.measure in "PROM Target Measures"
  )

// Returns a list of Observation including both GAS and PROM scores
define fluent function pcoScores(goal Goal):
  goal.gasScores()
    union goal.promScores()

// Returns a list of Observation including only PROM scores
define fluent function promScores(goal Goal):
  "PROM Scores" score
    where score.focusGoals() contains goal

/*
Computes the follow-up interval for a Goal based on this measure's "Follow-Up Interval" parameter.
@return Interval<DateTime>
*/
define function "Follow-Up Interval For" (goal Goal):
  goal goal
    let startDate: ToDateTime(goal.start as FHIR.date)
      return Interval(startDate + start of "Follow-Up Interval", startDate + end of "Follow-Up Interval")