betreuungs-cockpit/src/lib/pflege/verlauf.ts

import type { GesundheitsArt } from '@prisma/client'
import { tagesdatum } from '@/lib/fristen/datum'
import {
  abwesenheitstageJeJahr,
  tageEines,
  type AbwesenheitsEreignis,
} from '@/lib/pflege/abwesenheit'

/**
 * Auswertung des Gesundheitsverlaufs.
 *
 * Zwei Zahlen wandern in den Jahresbericht und in jeden
 * Hoeherstufungsantrag: Wie viele Exazerbationen gab es im Jahr, und wie
 * viele Tage lag die betreute Person im Krankenhaus. Beides ist bei einer
 * COPD der belastbare Beleg dafuer, dass sich der Zustand verschlechtert -
 * "es geht ihr schlechter" allein ueberzeugt keinen Gutachter.
 *
 * Reine Logik ohne Datenbank; die Beschreibungen der Ereignisse bleiben
 * verschluesselt und werden hier gar nicht angefasst.
 */

export type VerlaufEreignis = {
  datum: Date
  bisDatum: Date | null
  art: GesundheitsArt
  abwesenheitstage: number | null
  /** Titel im Klartext - er enthaelt keine Diagnose, nur eine Bezeichnung. */
  titel?: string
}

export type Verlaufsjahr = {
  jahr: number
  exazerbationen: number
  /** Exazerbationen, die zu einem Krankenhausaufenthalt gefuehrt haben. */
  krankenhausaufenthalte: number
  krankenhaustage: number
  abwesenheitstage: number
  stuerze: number
  ereignisseGesamt: number
}

/**
 * Exazerbationen je Kalenderjahr.
 *
 * Gezaehlt wird das Jahr des Beginns. Ein Schub, der ueber Silvester
 * laeuft, ist ein Ereignis und gehoert in das Jahr, in dem er begann.
 */
export function exazerbationenJeJahr(
  ereignisse: VerlaufEreignis[],
): { jahr: number; anzahl: number }[] {
  const jahre = new Map<number, number>()
  for (const ereignis of ereignisse) {
    if (ereignis.art !== 'EXAZERBATION') continue
    const jahr = tagesdatum(ereignis.datum).getUTCFullYear()
    jahre.set(jahr, (jahre.get(jahr) ?? 0) + 1)
  }
  return [...jahre.entries()]
    .map(([jahr, anzahl]) => ({ jahr, anzahl }))
    .sort((a, b) => b.jahr - a.jahr)
}

/**
 * Krankenhaustage je Kalenderjahr. Gerechnet wird wie bei den
 * Abwesenheitstagen: Tage zwischen Aufnahme und Entlassung, ueber den
 * Jahreswechsel aufgeteilt.
 */
export function krankenhaustageJeJahr(
  ereignisse: VerlaufEreignis[],
): { jahr: number; tage: number }[] {
  const nurKrankenhaus: AbwesenheitsEreignis[] = ereignisse
    .filter((e) => e.art === 'KRANKENHAUS')
    .map((e) => ({
      datum: e.datum,
      bisDatum: e.bisDatum,
      abwesenheitstage: e.abwesenheitstage,
      art: e.art,
    }))
  return abwesenheitstageJeJahr(nurKrankenhaus).map((j) => ({ jahr: j.jahr, tage: j.tage }))
}

/** Die vollstaendige Jahresauswertung, wie sie auf /pflege/verlauf steht. */
export function verlaufAuswerten(ereignisse: VerlaufEreignis[]): Verlaufsjahr[] {
  const jahre = new Map<number, Verlaufsjahr>()

  const holen = (jahr: number): Verlaufsjahr => {
    let eintrag = jahre.get(jahr)
    if (!eintrag) {
      eintrag = {
        jahr,
        exazerbationen: 0,
        krankenhausaufenthalte: 0,
        krankenhaustage: 0,
        abwesenheitstage: 0,
        stuerze: 0,
        ereignisseGesamt: 0,
      }
      jahre.set(jahr, eintrag)
    }
    return eintrag
  }

  for (const ereignis of ereignisse) {
    const jahr = tagesdatum(ereignis.datum).getUTCFullYear()
    const eintrag = holen(jahr)
    eintrag.ereignisseGesamt += 1
    if (ereignis.art === 'EXAZERBATION') eintrag.exazerbationen += 1
    if (ereignis.art === 'STURZ') eintrag.stuerze += 1
    if (ereignis.art === 'KRANKENHAUS') eintrag.krankenhausaufenthalte += 1
  }

  for (const zeile of krankenhaustageJeJahr(ereignisse)) {
    holen(zeile.jahr).krankenhaustage = zeile.tage
  }

  const abwesend = abwesenheitstageJeJahr(
    ereignisse.map((e) => ({
      datum: e.datum,
      bisDatum: e.bisDatum,
      abwesenheitstage: e.abwesenheitstage,
      art: e.art,
    })),
  )
  for (const zeile of abwesend) {
    holen(zeile.jahr).abwesenheitstage = zeile.tage
  }

  return [...jahre.values()].sort((a, b) => b.jahr - a.jahr)
}

/**
 * Kurzer Satz fuer den Jahresbericht - fertig zum Hineinkopieren.
 * Bewusst nuechtern und ohne Diagnosen: Der Bericht geht ans Gericht,
 * nicht an die Krankenkasse.
 */
export function verlaufZusammenfassung(jahr: Verlaufsjahr): string {
  const teile: string[] = []
  if (jahr.exazerbationen > 0) {
    teile.push(
      jahr.exazerbationen === 1
        ? 'eine akute Verschlechterung der Atemwegserkrankung'
        : `${jahr.exazerbationen} akute Verschlechterungen der Atemwegserkrankung`,
    )
  }
  if (jahr.krankenhausaufenthalte > 0) {
    teile.push(
      `${jahr.krankenhausaufenthalte} Krankenhausaufenthalt${
        jahr.krankenhausaufenthalte === 1 ? '' : 'e'
      } mit insgesamt ${jahr.krankenhaustage} Tagen`,
    )
  }
  if (jahr.stuerze > 0) {
    teile.push(`${jahr.stuerze} dokumentierte${jahr.stuerze === 1 ? 'r' : ''} Sturz${jahr.stuerze === 1 ? '' : 'e'}`)
  }

  if (teile.length === 0) {
    return `Im Jahr ${jahr.jahr} wurden keine besonderen gesundheitlichen Ereignisse erfasst.`
  }

  return `Im Jahr ${jahr.jahr} sind dokumentiert: ${teile.join(', ')}.`
}

/**
 * Steigt die Zahl der Exazerbationen gegenueber dem Vorjahr? Genau das ist
 * das Argument fuer eine Neubegutachtung nach § 18 SGB XI.
 */
export function verschlechterungErkannt(
  jahre: Verlaufsjahr[],
  bezugsjahr: number,
): { erkannt: boolean; begruendung: string | null } {
  const aktuell = jahre.find((j) => j.jahr === bezugsjahr)
  const vorjahr = jahre.find((j) => j.jahr === bezugsjahr - 1)
  if (!aktuell || !vorjahr) return { erkannt: false, begruendung: null }

  const mehrSchuebe = aktuell.exazerbationen > vorjahr.exazerbationen
  const mehrTage = aktuell.krankenhaustage > vorjahr.krankenhaustage

  if (!mehrSchuebe && !mehrTage) return { erkannt: false, begruendung: null }

  const teile: string[] = []
  if (mehrSchuebe) {
    teile.push(
      `${vorjahr.exazerbationen} Exazerbationen im Jahr ${vorjahr.jahr} gegenüber ` +
        `${aktuell.exazerbationen} im Jahr ${aktuell.jahr}`,
    )
  }
  if (mehrTage) {
    teile.push(
      `${vorjahr.krankenhaustage} Krankenhaustage im Jahr ${vorjahr.jahr} gegenüber ` +
        `${aktuell.krankenhaustage} im Jahr ${aktuell.jahr}`,
    )
  }

  return {
    erkannt: true,
    begruendung:
      `Der erfasste Verlauf zeigt eine Zunahme: ${teile.join(' und ')}. ` +
      `Das kann eine erneute Begutachtung rechtfertigen.`,
  }
}

/** Summe der Tage eines einzelnen Ereignisses - fuer die Zeitstrahl-Zeile. */
export { tageEines }