# Präambel ####

# Pfade zu den beiden extern gepflegten Skripten, die den eigentlichen Datenzugriff
# uebernehmen. Diese App selbst spricht NIE direkt mit der formr-API und oeffnet NIE
# direkt die SQLite-Pseudonymdatenbank - das passiert ausschliesslich in diesen beiden
# Skripten (siehe Abschnitt 3 der Spezifikation).
PFAD_DOWNLOAD_SKRIPT  = "../API/get_data_bai.R"   # liefert beim Sourcen: daten_bai
PFAD_PSEUDONYM_SKRIPT = "../get_pseudo.R"     # liefert beim Sourcen: pseudo
AKZENT_FARBE          = "#8B2635"

# Pflicht-Disclaimer, der am Ende jedes Word-Exports erscheint (Abschnitt 8).
BAI_DISCLAIMER = paste0(
  "Diese Auswertung ist ein Hilfsmittel fuer klinisches Fachpersonal und ersetzt ",
  "keine klinische Diagnose. Die Interpretation obliegt der behandelnden Person."
)

library(shiny)
library(dplyr)
library(ggplot2)
library(officer)
library(haven)


# Infrastruktur ####

APP_VERZEICHNIS = normalizePath(getwd())

absPath = function(pfad) {
  if (grepl("^([A-Za-z]:[/\\\\]|/)", pfad)) return(pfad)
  file.path(APP_VERZEICHNIS, pfad)
}

PFAD_DOWNLOAD_SKRIPT  = normalizePath(absPath(PFAD_DOWNLOAD_SKRIPT),  mustWork = FALSE)
PFAD_PSEUDONYM_SKRIPT = normalizePath(absPath(PFAD_PSEUDONYM_SKRIPT), mustWork = FALSE)


# Helper ####

# Die vier Antwortoptionen des BAI in fester Reihenfolge, exakter formr-Choice-Wortlaut.
# Die Position in diesem Vektor minus 1 ist gleichzeitig die Kodierung
# (0 = "überhaupt nicht" ... 3 = "stark").
BAI_ANTWORTOPTIONEN = c(
  "überhaupt nicht",
  "wenig (Es stört mich nicht sehr)",
  "mittel (Es war sehr unangenehm, aber ich konnte es aushalten)",
  "stark (Ich konnte es kaum aushalten)"
)

# Formr-Itemlabels enthalten mitunter Markdown-Sternchen - fuer die Anzeige entfernen.
strip_stars = function(x) {
  if (is.null(x) || length(x) == 0) return(x)
  gsub("\\*\\*", "", as.character(x))
}

# Zentrale Recoding-Funktion (Spezifikation Abschnitt 2). Wandelt den rohen formr-Wert
# EINES Items fuer EINE Person in einen BAI-Wert 0-3 um. Es ist am echten formr-Export
# nicht verifiziert, ob die Spalte als Choice-Text (character) oder als 1-basierter
# Choice-Index (numerisch 1-4) vorliegt - beide Faelle werden hier abgedeckt.
#
# WICHTIG: Ob eine numerische Spalte der 1-4-Index-Konvention oder der bereits
# vorkodierten 0-3-Konvention folgt, wird anhand ALLER Werte der Spalte (ueber alle
# Faelle in daten_bai) bestimmt, nicht anhand des einzelnen Werts dieser Person. Ein
# einzelner Wert wie "1" waere sonst nicht eindeutig zwischen Choice-Index 1
# ("ueberhaupt nicht", Kodierung 0) und einem bereits vorkodierten Wert 1 ("wenig")
# unterscheidbar. Deshalb erhaelt die Funktion die gesamte Spalte (spalte_gesamt) als
# Referenz zusaetzlich zum Einzelwert dieser Person (roh_wert).
bai_recode_item = function(item_name, spalte_gesamt, roh_wert) {

  if (length(roh_wert) == 0 || is.na(roh_wert)) return(NA_integer_)

  if (is.character(spalte_gesamt)) {
    text = trimws(as.character(roh_wert))
    idx  = match(text, BAI_ANTWORTOPTIONEN)
    if (is.na(idx)) {
      stop(paste0(
        "Item '", item_name, "': unbekannter Antworttext >>", text, "<< ",
        "(erwartet wird einer der vier BAI-Antworttexte)."
      ))
    }
    return(idx - 1L)
  }

  if (is.numeric(spalte_gesamt)) {
    alle_werte = spalte_gesamt[!is.na(spalte_gesamt)]
    wert       = suppressWarnings(as.numeric(roh_wert))

    ist_index_kodierung = length(alle_werte) > 0 && all(alle_werte >= 1 & alle_werte <= 4)
    ist_vorkodiert       = length(alle_werte) > 0 && all(alle_werte >= 0 & alle_werte <= 3)

    if (ist_index_kodierung) {
      if (is.na(wert) || wert < 1 || wert > 4) {
        stop(paste0(
          "Item '", item_name, "': unerwarteter Rohwert >>", roh_wert, "<< ",
          "(Spalte folgt erkennbar der 1-4 Index-Kodierung)."
        ))
      }
      return(as.integer(round(wert)) - 1L)
    }

    if (ist_vorkodiert) {
      if (is.na(wert) || wert < 0 || wert > 3) {
        stop(paste0(
          "Item '", item_name, "': unerwarteter Rohwert >>", roh_wert, "<< ",
          "(Spalte folgt erkennbar der 0-3 Kodierung)."
        ))
      }
      return(as.integer(round(wert)))
    }

    stop(paste0(
      "Item '", item_name, "': Werte der Spalte liegen ausserhalb des erwarteten ",
      "Bereichs (weder durchgehend 1-4 noch durchgehend 0-3). Rohwert dieser Person: >>",
      roh_wert, "<<."
    ))
  }

  stop(paste0(
    "Item '", item_name, "': unerwarteter Spaltentyp (", class(spalte_gesamt)[1],
    "), weder Text noch Zahl."
  ))
}

# Itemtitel aus dem formr-Label der Spalte, mit Fallback, falls kein Label vorhanden ist.
bai_hole_item_titel = function(spalte, fallback) {
  lbl = attr(spalte, "label")
  if (is.null(lbl) || length(lbl) == 0 || is.na(lbl[1]) ||
      nchar(trimws(as.character(lbl[1]))) == 0) {
    return(fallback)
  }
  trimws(strip_stars(lbl[1]))
}

# Sucht die erste vorhandene, fuer diese Zeile nicht-NA Datumsspalte. Der genaue
# formr-Feldname fuer das Ausfuelldatum ist nicht verifiziert (siehe Abschnitt 8) -
# deshalb wird der Reihe nach eine Liste plausibler Kandidaten geprueft, statt blind
# einen Namen anzunehmen.
bai_finde_datumsspalte = function(daten, zeile) {
  kandidaten = c("ended", "created", "modified", "expired")
  for (k in kandidaten) {
    if (k %in% names(daten)) {
      wert = zeile[[k]][1]
      if (!is.null(wert) && !is.na(wert)) return(k)
    }
  }
  NA_character_
}

# Robustes Parsen eines Datumswerts zu POSIXct. Faellt bei nicht auswertbarem Format
# auf NULL zurueck (kein Rateergebnis), der Aufrufer entscheidet dann ueber einen
# sichtbaren Fallback auf das aktuelle Datum.
bai_parse_datum = function(roh_wert) {
  tryCatch({
    d = as.POSIXct(roh_wert)
    if (is.na(d)) return(NULL)
    d
  }, error = function(e) NULL)
}


# Datenaufbereitung ####

# Klassifikationstabelle des BAI (Abschnitt 5.4): vier Kategorien nach Gesamtscore
# (0-63). Zentral als Datenstruktur abgelegt, damit Gauge-Zonen, Bildschirmanzeige und
# Word-Export dieselbe Quelle verwenden - keine verstreute if-Kette an mehreren Stellen.
BAI_KLASSIFIKATION = data.frame(
  min   = c(0,  8,  16, 26),
  max   = c(7,  15, 25, 63),
  label = c("minimale Angst", "leichte Angst", "moderate Angst", "schwere Angst"),
  farbe = c("#2E7D32", "#F57F17", "#E65100", "#B71C1C"),
  stringsAsFactors = FALSE
)

# Zusaetzlicher dichotomer Cutoff (Abschnitt 5.5), unabhaengig von der vierstufigen
# Kategorie.
BAI_CUTOFF = 8

bai_klassifiziere = function(score) {
  if (is.na(score)) {
    return(list(text = "nicht berechenbar", bereich = "", farbe = "#888888"))
  }
  for (i in seq_len(nrow(BAI_KLASSIFIKATION))) {
    if (score >= BAI_KLASSIFIKATION$min[i] && score <= BAI_KLASSIFIKATION$max[i]) {
      return(list(
        text    = BAI_KLASSIFIKATION$label[i],
        bereich = paste0(BAI_KLASSIFIKATION$min[i], "-", BAI_KLASSIFIKATION$max[i], " Punkte"),
        farbe   = BAI_KLASSIFIKATION$farbe[i]
      ))
    }
  }
  list(text = "nicht klassifizierbar", bereich = "", farbe = "#888888")
}

bai_cutoff_hinweis = function(score) {
  if (is.na(score)) {
    return(list(ueberschritten = NA, text = "nicht berechenbar"))
  }
  if (score > BAI_CUTOFF) {
    list(
      ueberschritten = TRUE,
      text = paste0("Hinweis auf moegliche Angststoerung (Cutoff > ", BAI_CUTOFF,
                    ", Sensitivitaet .91 / Spezifitaet .92)")
    )
  } else {
    list(ueberschritten = FALSE, text = "kein Hinweis auf Cutoff-Ueberschreitung")
  }
}

erstelle_gauge_bai = function(score) {

  zonen = BAI_KLASSIFIKATION
  zonen$zone_pastell = c("#C8E6C9", "#FFF3C4", "#FFCC9C", "#FFCDD2")
  zonen$zone         = factor(zonen$label, levels = zonen$label)
  zonen$mitte        = (zonen$min + zonen$max) / 2
  zonen$zone_label   = paste0(zonen$label, "\n", zonen$min, "-", zonen$max)

  p = ggplot() +
    geom_rect(data = zonen,
              aes(xmin = min, xmax = max, ymin = 0, ymax = 1, fill = zone),
              colour = "white", linewidth = 1) +
    scale_fill_manual(values = setNames(zonen$zone_pastell, zonen$zone), guide = "none") +
    annotate("text", x = zonen$mitte, y = 0.5, label = zonen$zone_label,
             size = 2.7, colour = "#444444", fontface = "bold", lineheight = 0.9) +
    scale_x_continuous(limits = c(0, 63), expand = c(0, 0),
                        breaks = c(0, 8, 16, 26, 63)) +
    scale_y_continuous(limits = c(-0.25, 1.35), expand = c(0, 0)) +
    labs(x = "Summenscore (0-63)", y = NULL) +
    theme_minimal(base_size = 11) +
    theme(
      axis.text.y      = element_blank(),
      axis.ticks.y     = element_blank(),
      panel.grid       = element_blank(),
      plot.background  = element_rect(fill = "white", colour = NA),
      panel.background = element_rect(fill = "white", colour = NA),
      axis.line.x      = element_line(colour = "#cccccc", linewidth = 0.5),
      axis.text.x      = element_text(colour = "#666666", size = 9)
    )

  if (!is.na(score)) {
    p = p +
      geom_segment(aes(x = score, xend = score, y = -0.1, yend = 1.1),
                   colour = AKZENT_FARBE, linewidth = 2.5, lineend = "round") +
      annotate("text", x = score, y = 1.26, label = as.character(score),
               colour = AKZENT_FARBE, fontface = "bold", size = 4.2)
  }

  p
}


# UI ####

app_css = "
  body {
    font-family: 'Segoe UI', Helvetica, Arial, sans-serif;
    background-color: #f4f4f4;
    color: #222;
    font-size: 14px;
  }

  .app-header {
    background-color: #8B2635;
    color: white;
    padding: 15px 22px 13px;
    margin-bottom: 18px;
    border-radius: 5px;
  }
  .app-header h2 { margin: 0; font-size: 1.4em; font-weight: 700; }
  .app-header p  { margin: 4px 0 0; font-size: 0.87em; opacity: 0.88; }

  .input-panel {
    display: flex;
    align-items: flex-end;
    gap: 10px;
    background: white;
    border-radius: 6px;
    padding: 14px 18px;
    margin-bottom: 16px;
    box-shadow: 0 1px 4px rgba(0,0,0,0.09);
    flex-wrap: wrap;
  }
  .input-panel .form-group { margin-bottom: 0; }

  .btn-laden {
    background-color: #8B2635 !important;
    border-color: #7A2030 !important;
    color: white !important;
    font-weight: 600;
    padding: 6px 18px;
    border-radius: 4px;
    letter-spacing: 0.02em;
    white-space: nowrap;
  }
  .btn-laden:hover, .btn-laden:focus {
    background-color: #6E1E29 !important;
    border-color: #6E1E29 !important;
    outline: none;
    box-shadow: 0 0 0 2px rgba(139,38,53,0.3) !important;
  }

  .abschnitt-karte {
    background: white;
    border-radius: 6px;
    padding: 16px 20px;
    margin-bottom: 14px;
    box-shadow: 0 1px 4px rgba(0,0,0,0.09);
  }
  .abschnitt-titel {
    color: #8B2635;
    margin-top: 0;
    margin-bottom: 12px;
    font-size: 1em;
    font-weight: 700;
    letter-spacing: 0.01em;
  }

  .kopf-info {
    color: #555;
    font-size: 0.92em;
    padding-bottom: 10px;
    border-bottom: 1px solid #eee;
    margin-bottom: 8px;
  }
  .kopf-info b { color: #333; }

  .alert-warnung {
    background-color: #FFFDE7;
    border-left: 4px solid #F9A825;
    border-radius: 3px;
    padding: 9px 12px;
    margin-bottom: 10px;
    font-size: 0.88em;
    color: #555;
    line-height: 1.45;
  }

  .alert-fehler {
    background-color: #FEECEB;
    border-left: 4px solid #C62828;
    border-radius: 4px;
    padding: 13px 16px;
    margin-bottom: 12px;
  }
  .alert-fehler h4 { color: #C62828; margin-top: 0; margin-bottom: 8px; }
  .alert-fehler p, .alert-fehler li { color: #444; font-size: 0.92em; }

  .score-label  { font-size: 0.8em; color: #999; display: block; margin-bottom: 2px; }
  .score-zahl   { font-size: 3em; font-weight: 800; color: #8B2635; display: block;
                  line-height: 1.1; }
  .klasse-text  { font-size: 1.05em; font-weight: 700; display: block; margin-top: 4px; }
  .bereich-text { font-size: 0.8em; color: #888; display: block; margin-top: 2px; }

  .cutoff-badge {
    display: inline-block;
    margin-top: 10px;
    padding: 6px 12px;
    border-radius: 4px;
    font-size: 0.88em;
    font-weight: 600;
  }
  .cutoff-badge-ja   { background-color: #FEECEB; color: #B71C1C; border: 1px solid #F5C6C2; }
  .cutoff-badge-nein { background-color: #E8F5E9; color: #2E7D32; border: 1px solid #C8E6C9; }

  .item-zeile {
    display: flex;
    align-items: baseline;
    gap: 10px;
    padding: 7px 0;
    border-bottom: 1px solid #f0f0f0;
  }
  .item-zeile:last-child { border-bottom: none; }
  .item-nr   { font-weight: 700; color: #8B2635; min-width: 26px; flex-shrink: 0; }
  .item-text { flex: 1; color: #333; font-size: 0.92em; }

  .stufe-badge {
    display: inline-block;
    border-radius: 3px;
    padding: 2px 8px;
    font-size: 0.85em;
    font-weight: 700;
    min-width: 150px;
    text-align: center;
    flex-shrink: 0;
  }
  .stufe-badge-0 { background-color: #C8E6C9; color: #1B5E20; }
  .stufe-badge-1 { background-color: #FFCDD2; color: #B71C1C; }
  .stufe-badge-2 { background-color: #EF9A9A; color: #7B0000; }
  .stufe-badge-3 { background-color: #B71C1C; color: white;   }

  .start-hinweis {
    text-align: center;
    color: #bbb;
    padding: 40px 0;
    font-size: 0.95em;
  }
"

app_css = gsub("#8B2635", AKZENT_FARBE, app_css, fixed = TRUE)

ui = fluidPage(
  tags$head(
    tags$meta(charset = "UTF-8"),
    tags$style(HTML(app_css))
  ),

  div(class = "app-header",
    tags$h2("BAI Auswertung"),
    tags$p("Beck Angst-Inventar • Einzelfall-Auswertung")
  ),

  div(class = "input-panel",
    div(style = "min-width: 360px; white-space: nowrap;",
      textInput("pseudonym",
                 label = tagList(
                   "Pseudonym",
                   tags$span(style = "font-weight: normal; font-style: italic; font-size: 0.78em; color: #888; margin-left: 4px; white-space: nowrap;",
                             "optional, hat Vorrang vor Chiffre")
                 ),
                 placeholder = "optional", width = "340px")
    ),
    div(style = "min-width: 200px;",
      textInput("chiffre", label = "Patientenchiffre",
                placeholder = "z.B. P000123", width = "100%")
    ),
    actionButton("btn_suchen", "Auswerten", class = "btn btn-primary btn-laden"),
    div(style = "margin-left: auto;",
      downloadButton("download_word", "Word-Export (.docx)")
    )
  ),

  uiOutput("ergebnis_ui")
)


# Word-Export ####

erstelle_bai_docx = function(erg) {

  fmt_titel      = fp_text(color = AKZENT_FARBE, bold = TRUE,  font.size = 18)
  fmt_meta       = fp_text(color = "#555555",     bold = FALSE, font.size = 10)
  fmt_warn       = fp_text(color = "#B8860B",     italic = TRUE, font.size = 9)
  fmt_score_l    = fp_text(color = "#888888",     bold = FALSE, font.size = 10)
  fmt_score      = fp_text(color = AKZENT_FARBE,  bold = TRUE,  font.size = 22)
  fmt_klasse     = fp_text(color = erg$klasse$farbe, bold = TRUE, font.size = 12)
  fmt_cutoff     = fp_text(
    color     = if (isTRUE(erg$cutoff$ueberschritten)) "#B71C1C" else "#2E7D32",
    bold      = TRUE,
    font.size = 10
  )
  fmt_abschn     = fp_text(color = AKZENT_FARBE, bold = TRUE, font.size = 12, underlined = TRUE)
  fmt_item_nr    = fp_text(color = "#888888", bold = TRUE,  font.size = 10)
  fmt_item_tit   = fp_text(color = "#333333", bold = FALSE, font.size = 10)
  fmt_disclaimer = fp_text(color = "#888888", italic = TRUE, font.size = 9)

  stufe_bg = function(stufe) {
    c("#C8E6C9", "#FFCDD2", "#EF9A9A", "#B71C1C")[stufe + 1L]
  }
  stufe_fg = function(stufe) {
    if (stufe < 3L) "#333333" else "#FFFFFF"
  }

  doc = read_docx()

  doc = body_add_fpar(doc, fpar(ftext("BAI Auswertung", fmt_titel)))
  doc = body_add_fpar(doc, fpar(ftext(
    paste0("Chiffre: ", erg$chiffre,
           "     Ausfuelldatum: ", erg$ausfuelldatum,
           "     Erstellt: ", format(Sys.Date(), "%d.%m.%Y")),
    fmt_meta
  )))

  if (!is.null(erg$warnung_mehrfach)) {
    doc = body_add_fpar(doc, fpar(ftext(paste0("Hinweis: ", erg$warnung_mehrfach), fmt_warn)))
  }
  if (erg$n_fehlt > 0) {
    doc = body_add_fpar(doc, fpar(ftext(paste0(
      "Hinweis: ", erg$n_fehlt, " Item(s) ohne Angabe, mit dem Wert 0 in den ",
      "Summenscore eingerechnet."
    ), fmt_warn)))
  }

  doc = body_add_par(doc, "")

  doc = body_add_fpar(doc, fpar(
    ftext("Summenscore:  ", fmt_score_l),
    ftext(as.character(erg$gesamtscore), fmt_score)
  ))
  doc = body_add_fpar(doc, fpar(ftext(
    paste0(erg$klasse$text, "  (", erg$klasse$bereich, ")"), fmt_klasse
  )))
  doc = body_add_fpar(doc, fpar(ftext(erg$cutoff$text, fmt_cutoff)))

  doc = body_add_par(doc, "")

  doc = body_add_fpar(doc, fpar(ftext("Einzelitems (21 Items)", fmt_abschn)))

  for (it in erg$items) {
    doc = body_add_fpar(doc, fpar(
      ftext(sprintf("%2d.  ", it$nr), fmt_item_nr),
      ftext(paste0(it$titel, "  "), fmt_item_tit),
      ftext(paste0(" ", it$antwort_text, " "),
            fp_text(color         = stufe_fg(it$wert),
                    bold          = TRUE,
                    font.size     = 9,
                    shading.color = stufe_bg(it$wert)))
    ))
  }

  doc = body_add_par(doc, "")
  doc = body_add_fpar(doc, fpar(ftext(BAI_DISCLAIMER, fmt_disclaimer)))

  doc
}


# Server ####

server = function(input, output, session) {
  # --- pseudonym-support-injection v1 ---
  observe({
    query = parseQueryString(session$clientData$url_search)
    if (!is.null(query$pseudonym) && nchar(trimws(query$pseudonym)) > 0) {
      updateTextInput(session, "pseudonym", value = trimws(query$pseudonym))
    }
  })

  observe({
    query = parseQueryString(session$clientData$url_search)
    if (!is.null(query$chiffre) && nchar(trimws(query$chiffre)) > 0) {
      updateTextInput(session, "chiffre", value = toupper(trimws(query$chiffre)))
    }
  })

  # Die beiden externen Skripte werden bewusst NICHT beim App-Start gesourct, sondern
  # erst hier, beim Klick auf "Auswerten" (Source-bei-Klick-Muster, Abschnitt 3).
  ergebnis_r = eventReactive(input$btn_suchen, {

    chiffre = toupper(trimws(input$chiffre))

    if ((nchar(trimws(input$pseudonym)) == 0 && nchar(chiffre) == 0)) {
      return(list(typ = "leere_eingabe"))
    }

    if (!(nchar(trimws(input$pseudonym)) > 0 || grepl("^[A-Z][0-9]{6}$", chiffre))) {
      return(list(typ = "format_fehler", chiffre = chiffre))
    }

    pfadfehler = character(0)
    if (!file.exists(PFAD_DOWNLOAD_SKRIPT)) {
      pfadfehler = c(pfadfehler,
        paste0("Download-Skript nicht gefunden: >>", PFAD_DOWNLOAD_SKRIPT, "<<"))
    }
    if (!file.exists(PFAD_PSEUDONYM_SKRIPT)) {
      pfadfehler = c(pfadfehler,
        paste0("Pseudonym-Skript nicht gefunden: >>", PFAD_PSEUDONYM_SKRIPT, "<<"))
    }
    if (length(pfadfehler) > 0) {
      return(list(typ = "skript_fehler",
        meldung = paste("Bitte Pfade am Kopf der app.R anpassen:",
                        paste(pfadfehler, collapse = "\n"), sep = "\n")))
    }

    # Schritt 4: Download-Skript sourcen. Achtung: Rueckgabewert-Pattern exakt so, kein
    # `<=` statt `=` - das waere syntaktisch gueltig, aber semantisch ein stiller Bug.
    ok_download = tryCatch({
      source(PFAD_DOWNLOAD_SKRIPT, local = FALSE)
      list(ok = TRUE)
    }, error = function(e) list(ok = FALSE, msg = conditionMessage(e)))
    if (!ok_download$ok) {
      return(list(typ = "skript_fehler",
        meldung = paste0("Fehler im Download-Skript (",
                         basename(PFAD_DOWNLOAD_SKRIPT), "):\n", ok_download$msg)))
    }

    # Schritt 5: Ordner mit pseudonyme.db suchen, ausgehend vom Pseudonym-Skript-Ordner,
    # bis zu 5 Ebenen nach oben.
    db_ordner = local({
      ordner   = dirname(normalizePath(PFAD_PSEUDONYM_SKRIPT, mustWork = FALSE))
      gefunden = NULL
      for (i in 1:5) {
        if (file.exists(file.path(ordner, "pseudonyme.db"))) { gefunden = ordner; break }
        elternteil = dirname(ordner)
        if (elternteil == ordner) break
        ordner = elternteil
      }
      gefunden
    })
    if (is.null(db_ordner)) {
      return(list(typ = "skript_fehler",
        meldung = paste0(
          "pseudonyme.db nicht gefunden.\n",
          "Gesucht ausgehend vom Pseudonym-Skript-Ordner bis zu 5 Ebenen nach oben.\n",
          "Bitte sicherstellen, dass pseudonyme.db im selben oder einem ",
          "uebergeordneten Ordner liegt."
        )))
    }

    # Schritt 6+7: Arbeitsverzeichnis fuer die Dauer des Sourcens auf den DB-Ordner
    # setzen (das Pseudonym-Skript oeffnet die DB relativ) und danach zuverlaessig
    # zuruecksetzen. add = TRUE ist Pflicht, sonst wuerden ggf. bereits registrierte
    # on.exit()-Handler ueberschrieben statt ergaenzt.
    ok_pseudonym = tryCatch({
      alter_wd = getwd()
      on.exit(setwd(alter_wd), add = TRUE)
      setwd(db_ordner)
      source(PFAD_PSEUDONYM_SKRIPT, local = FALSE)
      if (nchar(trimws(input$pseudonym)) > 0) {
        .pw_wert = trimws(input$pseudonym)
        .pw_tab = get("pseudo", envir = .GlobalEnv)
        .pw_treffer = .pw_tab[.pw_tab$pseudonym == .pw_wert, ]
        if (nrow(.pw_treffer) > 0) chiffre = toupper(trimws(.pw_treffer$chiffre[1]))
      }
      list(ok = TRUE)
    }, error = function(e) list(ok = FALSE, msg = conditionMessage(e)))
    if (!ok_pseudonym$ok) {
      return(list(typ = "skript_fehler",
        meldung = paste0("Fehler im Pseudonym-Skript (",
                         basename(PFAD_PSEUDONYM_SKRIPT), "):\n", ok_pseudonym$msg)))
    }

    # Schritt 8: pruefen, ob beide Skripte tatsaechlich die erwarteten Objekte geliefert
    # haben.
    if (!exists("daten_bai", envir = .GlobalEnv)) {
      return(list(typ = "skript_fehler",
        meldung = paste0("Objekt 'daten_bai' fehlt nach dem Sourcen von:\n",
                         PFAD_DOWNLOAD_SKRIPT)))
    }
    if (!exists("pseudo", envir = .GlobalEnv)) {
      return(list(typ = "skript_fehler",
        meldung = paste0("Objekt 'pseudo' fehlt nach dem Sourcen von:\n",
                         PFAD_PSEUDONYM_SKRIPT)))
    }

    dat_bai = get("daten_bai", envir = .GlobalEnv)
    dat_ps  = get("pseudo",    envir = .GlobalEnv)

    # Schritt 9: Chiffre-Lookup. Kein Filter auf 'instrument' noetig, da diese App nur
    # Daten dieses einen BAI-Runs erhaelt (Abschnitt 3).
    ps_treffer = dat_ps[dat_ps$chiffre == chiffre, , drop = FALSE]
    if (nrow(ps_treffer) == 0) {
      return(list(typ = "chiffre_nicht_gefunden", chiffre = chiffre))
    }
    alle_session_ids = unique(as.character(ps_treffer$pseudonym))
    if (nchar(trimws(input$pseudonym)) > 0) alle_session_ids = trimws(input$pseudonym)

    if (!("session" %in% names(dat_bai))) {
      return(list(typ = "skript_fehler",
        meldung = paste0(
          "Spalte 'session' in 'daten_bai' nicht gefunden. Der erwartete Spaltenname ",
          "fuer die formr-Session-ID ist am echten Export noch nicht verifiziert - ",
          "bitte tatsaechlichen Spaltennamen in get_data_bai.R bzw. hier pruefen."
        )))
    }

    bai_treffer = dat_bai[dat_bai$session %in% alle_session_ids, , drop = FALSE]
    if (nrow(bai_treffer) == 0) {
      return(list(typ = "keine_daten", chiffre = chiffre))
    }

    # Mehrfachtreffer (Bogen mehrfach ausgefuellt): nicht stillschweigend den ersten
    # nehmen, sondern den neuesten (nach Ausfuelldatum) waehlen und sichtbar warnen.
    warnung_mehrfach = NULL
    if (nrow(bai_treffer) > 1) {
      n_ausfuell = nrow(bai_treffer)
      spalte_datum = bai_finde_datumsspalte(dat_bai, bai_treffer[1, , drop = FALSE])
      if (!is.na(spalte_datum)) {
        reihenfolge = order(
          vapply(seq_len(n_ausfuell), function(i) {
            d = bai_parse_datum(bai_treffer[[spalte_datum]][i])
            if (is.null(d)) -Inf else as.numeric(d)
          }, numeric(1)),
          decreasing = TRUE
        )
        bai_treffer = bai_treffer[reihenfolge, , drop = FALSE]
      }
      datum_neuestes = if (!is.na(spalte_datum)) {
        d = bai_parse_datum(bai_treffer[[spalte_datum]][1])
        if (!is.null(d)) format(d, "%d.%m.%Y %H:%M") else "unbekanntes Datum"
      } else "unbekanntes Datum"
      warnung_mehrfach = paste0(
        "Es wurden ", n_ausfuell, " Ausfuellungen gefunden, es wird die neueste vom ",
        datum_neuestes, " angezeigt."
      )
      bai_treffer = bai_treffer[1, , drop = FALSE]
    }

    zeile = bai_treffer[1, , drop = FALSE]

    spalte_datum = bai_finde_datumsspalte(dat_bai, zeile)
    datum_geparst = if (!is.na(spalte_datum)) bai_parse_datum(zeile[[spalte_datum]][1]) else NULL
    ausfuelldatum_fallback = is.null(datum_geparst)
    ausfuelldatum = if (!ausfuelldatum_fallback) format(datum_geparst, "%d.%m.%Y") else
      format(Sys.Date(), "%d.%m.%Y")
    ausfuelldatum_dateikennung = if (!ausfuelldatum_fallback) format(datum_geparst, "%Y%m%d") else
      format(Sys.Date(), "%Y%m%d")

    # 21 Items einlesen und rekodieren (0-3). Bei unerwarteten Rohwerten bricht
    # bai_recode_item() mit einer klaren Fehlermeldung ab (kein stilles NA).
    item_cols = sprintf("bai_%02d", 1:21)
    fehlende_item_spalten = item_cols[!(item_cols %in% names(dat_bai))]
    if (length(fehlende_item_spalten) > 0) {
      return(list(typ = "skript_fehler",
        meldung = paste0(
          "Folgende erwartete Item-Spalten fehlen in 'daten_bai': ",
          paste(fehlende_item_spalten, collapse = ", "), "."
        )))
    }

    recode_ergebnis = tryCatch({
      liste = lapply(seq_along(item_cols), function(i) {
        col           = item_cols[i]
        spalte_gesamt = dat_bai[[col]]
        roh_wert      = zeile[[col]][1]

        wert  = bai_recode_item(col, spalte_gesamt, roh_wert)
        titel = bai_hole_item_titel(spalte_gesamt, paste0("Item ", i))

        list(nr = i, titel = titel, wert = wert, fehlt = is.na(wert))
      })
      list(ok = TRUE, items = liste)
    }, error = function(e) list(ok = FALSE, msg = conditionMessage(e)))

    if (!recode_ergebnis$ok) {
      return(list(typ = "daten_fehler", meldung = recode_ergebnis$msg))
    }
    items = recode_ergebnis$items

    # Missing-Value-Regel (Abschnitt 5.2).
    n_fehlt = sum(vapply(items, `[[`, logical(1), "fehlt"))
    if (n_fehlt > 3) {
      return(list(typ = "zu_viele_fehlende_werte", n_fehlt = n_fehlt, chiffre = chiffre))
    }

    # Fehlende Items (1-3 Stueck) mit 0 in den Summenscore einrechnen.
    items = lapply(items, function(it) {
      if (it$fehlt) it$wert = 0L
      it
    })
    items = lapply(items, function(it) {
      it$antwort_text = if (it$fehlt) {
        paste0("(fehlend, als '", BAI_ANTWORTOPTIONEN[1], "' gewertet)")
      } else {
        BAI_ANTWORTOPTIONEN[it$wert + 1L]
      }
      it
    })

    gesamtscore = as.integer(sum(vapply(items, `[[`, integer(1), "wert")))
    klasse      = bai_klassifiziere(gesamtscore)
    cutoff      = bai_cutoff_hinweis(gesamtscore)

    list(
      typ                        = "ergebnis",
      chiffre                    = chiffre,
      ausfuelldatum              = ausfuelldatum,
      ausfuelldatum_fallback     = ausfuelldatum_fallback,
      ausfuelldatum_dateikennung = ausfuelldatum_dateikennung,
      warnung_mehrfach           = warnung_mehrfach,
      items                      = items,
      n_fehlt                    = n_fehlt,
      gesamtscore                = gesamtscore,
      klasse                     = klasse,
      cutoff                     = cutoff
    )
  })


  output$ergebnis_ui = renderUI({

    if (input$btn_suchen == 0) {
      return(div(class = "start-hinweis",
        "Patientenchiffre eingeben und auf \"Auswerten\" klicken."
      ))
    }

    erg = ergebnis_r()

    if (erg$typ == "skript_fehler") {
      return(div(class = "alert-fehler",
        tags$h4("Konfigurationsfehler"),
        tags$pre(style = "font-size:0.88em; white-space:pre-wrap;", erg$meldung)
      ))
    }

    if (erg$typ == "daten_fehler") {
      return(div(class = "alert-fehler",
        tags$h4("Datenfehler"),
        tags$p("Beim Verarbeiten der Item-Antworten ist ein unerwarteter Wert aufgetreten:"),
        tags$pre(style = "font-size:0.88em; white-space:pre-wrap;", erg$meldung)
      ))
    }

    if (erg$typ == "leere_eingabe") {
      return(div(class = "alert-warnung",
        "Bitte eine Patientenchiffre eingeben."
      ))
    }

    if (erg$typ == "format_fehler") {
      return(div(class = "alert-warnung",
        "Ungueltige Chiffre. Erwartet wird ein Grossbuchstabe gefolgt von 6 Ziffern, ",
        "z.B. P000123."
      ))
    }

    if (erg$typ == "chiffre_nicht_gefunden") {
      return(div(class = "alert-fehler",
        tags$h4("Chiffre nicht gefunden"),
        tags$p("Die Chiffre ", tags$b(paste0("«", erg$chiffre, "»")),
               " ist in der Pseudonymtabelle nicht vorhanden."),
        tags$p("Bitte Schreibweise pruefen oder Pseudonymtabelle aktualisieren.")
      ))
    }

    if (erg$typ == "keine_daten") {
      return(div(class = "alert-fehler",
        tags$h4("Kein BAI-Datensatz gefunden"),
        tags$p("Zur Chiffre ", tags$b(paste0("«", erg$chiffre, "»")),
               " existiert ein Pseudonymeintrag, aber kein Datensatz in ",
               tags$code("daten_bai"), "."),
        tags$p("Moegliche Ursachen: Bogen noch nicht ausgefuellt, ",
               "oder Daten noch nicht heruntergeladen.")
      ))
    }

    if (erg$typ == "zu_viele_fehlende_werte") {
      return(div(class = "alert-fehler",
        tags$h4("Zu viele fehlende Werte"),
        tags$p("Bei ", tags$b(paste0("«", erg$chiffre, "»")), " fehlen ", erg$n_fehlt,
               " von 21 Items."),
        tags$p("Der Bogen kann laut Auswertungsregel nicht ausgewertet werden ",
               "(zulaessig sind maximal 3 fehlende Items).")
      ))
    }

    # typ == "ergebnis"

    kopf_block = div(class = "abschnitt-karte",
      div(class = "kopf-info",
        tags$b("Chiffre: "), erg$chiffre, "  ",
        tags$b("Ausfuelldatum: "), erg$ausfuelldatum
      ),
      if (!is.null(erg$warnung_mehrfach))
        div(class = "alert-warnung", "⚠ Hinweis: ", erg$warnung_mehrfach),
      if (isTRUE(erg$ausfuelldatum_fallback))
        div(class = "alert-warnung",
            "⚠ Ausfuelldatum nicht in den Daten gefunden, Erstellungsdatum verwendet."),
      if (erg$n_fehlt > 0)
        div(class = "alert-warnung", "⚠ ", erg$n_fehlt,
            " Item(s) ohne Angabe, mit dem Wert 0 in den Summenscore eingerechnet.")
    )

    score_block = div(class = "abschnitt-karte",
      fluidRow(
        column(4,
          tags$span(class = "score-label", "Summenscore BAI"),
          tags$span(class = "score-zahl", as.character(erg$gesamtscore)),
          tags$span(class = "klasse-text",
            style = paste0("color:", erg$klasse$farbe, ";"),
            erg$klasse$text
          ),
          tags$span(class = "bereich-text", erg$klasse$bereich),
          tags$span(
            class = paste0("cutoff-badge ",
                           if (isTRUE(erg$cutoff$ueberschritten)) "cutoff-badge-ja" else "cutoff-badge-nein"),
            erg$cutoff$text
          )
        ),
        column(8,
          style = "padding-top: 6px;",
          plotOutput("gauge_plot", height = "110px")
        )
      )
    )

    item_zeilen = lapply(erg$items, function(it) {
      div(class = "item-zeile",
        div(class = "item-nr", paste0(it$nr, ".")),
        div(class = "item-text", it$titel),
        tags$span(class = paste0("stufe-badge stufe-badge-", it$wert), it$antwort_text)
      )
    })

    item_block = div(class = "abschnitt-karte",
      tags$h4(class = "abschnitt-titel", "Einzelitems (21 Items)"),
      div(item_zeilen)
    )

    tagList(kopf_block, score_block, item_block)
  })


  output$gauge_plot = renderPlot({
    req(input$btn_suchen > 0)
    erg = ergebnis_r()
    req(erg$typ == "ergebnis")
    erstelle_gauge_bai(erg$gesamtscore)
  }, bg = "white")


  output$download_word = downloadHandler(
    filename = function() {
      erg = ergebnis_r()
      if (is.null(erg) || erg$typ != "ergebnis") return("BAI_Auswertung.docx")
      chiffre_esc = gsub("[^A-Za-z0-9_-]", "_", erg$chiffre)
      # Dateiname mit dem Ausfuelldatum AUS DEN DATEN (nicht Sys.Date()), bereits beim
      # Einlesen robust geparst (Abschnitt 8) - kein erneutes, fehleranfaelliges
      # Reparsen des Anzeigetexts noetig.
      paste0("BAI_", chiffre_esc, "_", erg$ausfuelldatum_dateikennung, ".docx")
    },
    content = function(file) {
      req(ergebnis_r()$typ == "ergebnis")
      erg = ergebnis_r()
      doc = erstelle_bai_docx(erg)
      print(doc, target = file)
    }
  )
}


# Start ####

shinyApp(ui = ui, server = server)