import { test, after, mock } from 'node:test'
import assert from 'node:assert/strict'
import { existsSync, readFileSync } from 'node:fs'
import { startAppwriteMock } from './support/appwriteMock.js'
import { mailSink } from './support/mailSink.js'
import { schemaKeys } from './support/schema.js'
import { useTestEnv } from './support/testEnv.js'
import { TERMINE_COLLECTIONS, TERMINE_DATETIMES } from '../server/services/termine/schema.js'

// Nachbau von Appwrite fuer den Test avv_keine_ip_in_buchung (eine echte Buchung ueber halte); config erst danach importieren
const aw = await startAppwriteMock({
  schema: {
    portalFeatures: schemaKeys('portalFeatures'),
    termineConfig: schemaKeys('termineConfig'),
    termineBookings: schemaKeys('termineBookings'),
    termineClaims: schemaKeys('termineClaims'),
    termineOutbox: schemaKeys('termineOutbox'),
  },
  datetimes: TERMINE_DATETIMES,
  defaultLimit: 25,
})
after(() => aw.close())
useTestEnv({ appwriteUrl: aw.url, stripeUrl: 'http://127.0.0.1:1' })

const { config } = await import('../server/config.js')
const { featureConfig } = await import('../server/services/featureRegistry.js')
const { LOESCHFRIST_TAGE } = await import('../server/services/termine/frist.js')
const { ENTWURF_TAGE } = await import('../server/services/termine/entwuerfe.js')
const { normalisiereEinstellung } = await import('../server/services/termine/einstellungen.js')
const { datenschutzAbsatz } = await import('../server/services/termine/rechtstexte.js')
const { setMailTransportForTests } = await import('../server/services/mailer.js')
const { resetOutboxForTests, warteAufVersand } = await import('../server/services/termine/outbox.js')
const { speichereEinstellung, resetKontextForTests } = await import('../server/services/termine/kontext.js')
const { halte } = await import('../server/services/termine/ablauf.js')
const { loeschBezugsfeld } = await import('../server/services/termine/buchungen.js')
after(() => setMailTransportForTests(null))

// Vertragsunterlagen des Terminplaners als Markdown: Leistungsbeschreibung (Task F4), AVV (Task F5).
// Die Markdown-Dateien sind die Quelle der ausgelieferten Seiten (scripts/build-legal-html.mjs, Task F6).

const lies = (rel) => readFileSync(new URL(`../${rel}`, import.meta.url), 'utf8').replace(/\r/g, '')
const norm = (text) => text.replace(/\s+/g, ' ').trim()
const V = config.termine.avvVersion

// ----------------------------------------------------------------------------------------- Aufbau eines Dokuments

/** Zerlegt eine Vertragsunterlage: h1, Kopfzeile und Abschnitte (## N. Titel) mit ihren Absätzen "(n) …". */
function lese(md) {
  const zeilen = md.split('\n')
  const h1 = zeilen.filter((z) => /^# /.test(z))
  const abschnitte = []
  let aktuell = null
  for (const zeile of zeilen) {
    const h2 = /^## (.+)$/.exec(zeile)
    if (h2) {
      aktuell = { titel: h2[1], zeilen: [] }
      abschnitte.push(aktuell)
    } else if (aktuell) {
      aktuell.zeilen.push(zeile)
    }
  }
  for (const a of abschnitte) {
    a.nummer = /^(\d+)\. /.exec(a.titel)?.[1] ?? null
    a.text = a.zeilen.join('\n')
    a.absaetze = [...a.text.matchAll(/^\((\d+)\) /gm)].map((m) => Number(m[1]))
  }
  return { h1, kopf: zeilen[2], abschnitte, md }
}

const LB_MD = lies('docs/rechtliches/leistungsbeschreibung-terminplaner.md')
const LB = lese(LB_MD)

const abschnitt = (doc, nummer) => doc.abschnitte.find((a) => a.nummer === String(nummer))

// ----------------------------------------------------------------------------------------- Leistungsbeschreibung

test('lb_aufbau: Titel, Kopf mit Fassung und die elf Abschnitte in fester Nummerierung', () => {
  assert.deepEqual(LB.h1, ['# Leistungsbeschreibung Terminplaner'])
  assert.equal(LB_MD.split('\n')[0], '# Leistungsbeschreibung Terminplaner')
  assert.equal(LB.kopf, `**Fassung ${V}** · Zusatzbedingungen zum Wartungs-Abo`)
  assert.deepEqual(LB.abschnitte.map((a) => a.titel), [
    '1. Geltung',
    '2. Leistung',
    '3. Nicht enthalten',
    '4. Voraussetzungen und Pflichten des Kunden',
    '5. Einrichtung und Preis',
    '6. Verfügbarkeit und Störungen',
    '7. Haftung für verpasste Termine',
    '8. Ende der Leistung',
    '9. Änderungen und Einstellung',
    '10. Widerruf',
    '11. Hinweise',
  ])
  // Absätze sind lückenlos nummeriert: (1), (2), …
  for (const a of LB.abschnitte) {
    assert.ok(a.absaetze.length >= 1, `${a.titel}: keine Absätze`)
    assert.deepEqual(a.absaetze, a.absaetze.map((_, i) => i + 1), `${a.titel}: Absätze nicht lückenlos`)
  }
})

test('lb_sauber: keine Platzhalter, Entwurfsmarken, Kommentare oder Kanzlei-Marker', () => {
  assert.doesNotMatch(LB_MD, /ENTWURF|Entwurf|Prüfpunkt|TODO|\{\{|\}\}|<!--|⚖|\bQ\d+\b/)
  assert.doesNotMatch(LB_MD, /\[|\]|…\s*$/m, 'offene Klammer oder Auslassung am Zeilenende')
  assert.doesNotMatch(LB_MD, /undefined|null|NaN/)
  assert.ok(!/```|^>|<[a-z]/im.test(LB_MD), 'nur die Markdown-Teilmenge: kein Codeblock, Zitat oder rohes HTML')
})

test('lb_festwerte: Preis, Umsatzsteuer-Hinweis, Voraussetzung Wartungs-Abo und die Sätze von Nr. 8 wörtlich', () => {
  const text = norm(LB_MD)
  assert.ok(text.includes('149 €'))
  assert.ok(text.includes('§ 19 UStG'))
  assert.ok(text.includes(config.ustHinweis), 'Nr. 5: Hinweis wörtlich aus config.ustHinweis')
  assert.ok(text.includes('ein Hosting-Abo genügt nicht'))
  assert.ok(text.includes('Zusatzbedingungen zum Wartungs-Abo'))
  const nr8 = norm(abschnitt(LB, 8).text)
  for (const satz of [
    'Mit dem Ende des Wartungs-Abos endet der Terminplaner. WEBklar schaltet ihn spätestens am folgenden Tag ab und informiert den Kunden per E-Mail. Das gilt auch bei einem Wechsel ins Hosting-Abo und beim Widerruf des Abschlusses oder eines Wechsels ins Wartungs-Abo.',
    'WEBklar löscht alle Termindaten und die Einstellungen 30 Tage nach dem Abschalten.',
    'Beginnt innerhalb dieser 30 Tage wieder ein Wartungs-Abo, schaltet WEBklar den Terminplaner mit den vorhandenen Daten und Einstellungen ohne weitere Kosten wieder ein. Nach der Löschung ist eine neue Einrichtung nötig (neuer Fragebogen, neuer Preis nach Nr. 5).',
    'Endet das Wartungs-Abo, bevor WEBklar den Terminplaner freigeschaltet hat, erstattet WEBklar den Einrichtungspreis vollständig.',
  ]) {
    assert.ok(nr8.includes(satz), `Nr. 8: Satz fehlt oder ist verändert: ${satz}`)
  }
  // Absatz 1, 3, 4, 5 stehen an der festgelegten Stelle
  const absatz = (n) => norm(abschnitt(LB, 8).text.split(/^\(\d+\) /m)[n])
  assert.ok(absatz(1).startsWith('Mit dem Ende des Wartungs-Abos endet der Terminplaner.'))
  assert.ok(absatz(3).startsWith('WEBklar löscht alle Termindaten'))
  assert.ok(absatz(4).startsWith('Beginnt innerhalb dieser 30 Tage'))
  assert.ok(absatz(5).startsWith('Endet das Wartungs-Abo, bevor'))
  // keine Einstellung ohne Grund
  assert.ok(norm(abschnitt(LB, 9).text).includes('Eine Einstellung ohne einen Grund nach Absatz 2 ist ausgeschlossen.'))
})

test('lb_preis_gleich_register: Preis der LB = priceLabel des Registers (Nr. 5)', () => {
  const nr5 = norm(abschnitt(LB, 5).text)
  const preis = /kostet (\d+ €) einmalig/.exec(nr5)
  assert.ok(preis, 'Nr. 5 nennt den Preis')
  assert.equal(preis[1], featureConfig('termine').priceLabel)
  assert.equal(config.termineSetup.amountCents, 14900)
  assert.equal(`${config.termineSetup.amountCents / 100} €`, preis[1])
  // der Preis steht nur einmal in der LB
  assert.equal(norm(LB_MD).split('149 €').length - 1, 1)
})

test('lb_fristen_gleich_code: 30 Tage bis zur Löschung = LOESCHFRIST_TAGE (termine/frist.js)', () => {
  assert.equal(LOESCHFRIST_TAGE, 30)
  const nr8 = norm(abschnitt(LB, 8).text)
  const loeschung = /löscht alle Termindaten und die Einstellungen (\d+) Tage nach dem Abschalten/.exec(nr8)
  const rueckkehr = /Beginnt innerhalb dieser (\d+) Tage wieder/.exec(nr8)
  assert.ok(loeschung && rueckkehr)
  assert.equal(Number(loeschung[1]), LOESCHFRIST_TAGE)
  assert.equal(Number(rueckkehr[1]), LOESCHFRIST_TAGE)
  // die Abschalt-Frist "spätestens am folgenden Tag" steht nur in Nr. 8 Abs. 1
  assert.equal(norm(LB_MD).split('spätestens am folgenden Tag').length - 1, 1)
})

/**
 * Verweise: "Nr. N [Abs. M]" auf diese LB (ohne Zusatz), "Nummer N des AVV Terminplaner", "Leistungsbeschreibung B Nr. N der
 * Abo-Bedingungen" und "§ N [Abs. M] der Abo-Bedingungen" müssen auf vorhandene Abschnitte zeigen.
 */
test('lb_verweise: jedes „Nr. N“ auf LB oder AVV und jedes „§ N der Abo-Bedingungen“ existiert', () => {
  const text = norm(LB_MD)

  // 1. Verweise auf diese Leistungsbeschreibung: "Nr. N", "Nr. N Abs. M", "nach Nr. N"
  const eigene = []
  for (const m of text.matchAll(/\bNr\. (\d+)(?: Abs\. (\d+))?(?! der Abo-Bedingungen)/g)) {
    const davor = text.slice(Math.max(0, m.index - 40), m.index)
    if (/Leistungsbeschreibung B $/.test(davor)) continue // Abo-Bedingungen, siehe unten
    eigene.push({ nr: m[1], abs: m[2], zitat: m[0] })
  }
  assert.ok(eigene.length >= 8, `zu wenige interne Verweise gefunden: ${eigene.length}`)
  for (const v of eigene) {
    const a = abschnitt(LB, v.nr)
    assert.ok(a, `„${v.zitat}“: Abschnitt ${v.nr} gibt es nicht`)
    if (v.abs) assert.ok(a.absaetze.includes(Number(v.abs)), `„${v.zitat}“: Absatz ${v.abs} gibt es nicht in Nr. ${v.nr}`)
  }

  // 2. Verweise auf den AVV Terminplaner (Vorbemerkung, Nr. 1 bis 12, Anlage): Nummernbereich; ist der AVV schon geschrieben, auch seine Überschriften
  const avvNummern = [...text.matchAll(/Nummer (\d+)(?: Abs\. (\d+))? (?:des )?AVV Terminplaner|AVV Terminplaner Nummer (\d+)(?: Abs\. (\d+))?/g)]
  assert.ok(avvNummern.length >= 2)
  const avvPfad = 'docs/rechtliches/avv-terminplaner.md'
  const avv = existsSync(new URL(`../${avvPfad}`, import.meta.url)) ? lese(lies(avvPfad)) : null
  for (const m of avvNummern) {
    const n = Number(m[1] ?? m[3])
    assert.ok(n >= 1 && n <= 12, `„${m[0]}“: der AVV hat Nr. 1 bis 12`)
    if (avv) assert.ok(abschnitt(avv, n), `„${m[0]}“: Abschnitt ${n} fehlt im AVV`)
  }

  // 3. Leistungsbeschreibung B Nr. 3 der Abo-Bedingungen: "Nicht enthalten" im Wartungs-Abo
  const abo = lies('public/abo-bedingungen.html')
  const wartung = abo.slice(abo.indexOf('<h2>Wartungs-Abo</h2>'), abo.indexOf('<h2 id="widerruf">'))
  assert.ok(wartung.includes('<h3>3. Nicht enthalten</h3>'))
  assert.ok(text.includes('Leistungsbeschreibung B Nr. 3 der Abo-Bedingungen („Rechtstexte … nicht enthalten“)'))
  assert.ok(/Texte, Bilder und Rechtstexte \(Impressum, Datenschutzerklärung\)/.test(wartung.replace(/<[^>]+>/g, '')))

  // 4. Paragrafen der Abo-Bedingungen: § N existiert, Absatz M existiert (Aufzählungspunkte bzw. Überschriften "(M) …" des Paragrafen)
  const paragrafen = [...text.matchAll(/§§? (\d+)(?: Abs\. (\d+)(?: und (\d+))?)?(?: und (\d+))? der Abo-Bedingungen/g)]
  assert.ok(paragrafen.length >= 7, `zu wenige Verweise auf die Abo-Bedingungen: ${paragrafen.length}`)
  const nummern = new Set()
  for (const m of paragrafen) {
    for (const n of [m[1], m[4]].filter(Boolean)) nummern.add(n)
    const start = abo.indexOf(`<h2 id="p${m[1]}">§ ${m[1]} `)
    assert.ok(start > 0, `„${m[0]}“: § ${m[1]} gibt es in den Abo-Bedingungen nicht`)
    const ende = abo.indexOf('<h2', start + 10)
    const stueck = abo.slice(start, ende)
    const anzahl = Math.max((stueck.match(/<li>/g) || []).length, (stueck.match(/<h3>\(\d+\)/g) || []).length)
    for (const abs of [m[2], m[3]].filter(Boolean)) {
      assert.ok(Number(abs) <= anzahl, `„${m[0]}“: § ${m[1]} hat keinen Absatz ${abs}`)
    }
  }
  // "§§ 12 und 13 der Abo-Bedingungen" nennt beide Paragrafen
  assert.ok(nummern.has('12') && nummern.has('13'))
  for (const n of ['3', '4', '5', '6', '12', '13']) assert.ok(nummern.has(n), `§ ${n} der Abo-Bedingungen wird zitiert`)
  // § 327r BGB und § 3 BFSG sind Gesetzesverweise, keine Verweise in die Abo-Bedingungen
  assert.ok(text.includes('§ 327r Abs. 3 BGB') && text.includes('§ 3 Abs. 3 BFSG'))

  // 5. Die Anlage zur Widerrufsbelehrung heißt wie die Überschrift der Datei
  const anlage = lies('docs/rechtliches/widerrufsbelehrung-funktionen.md').split('\n')[0].replace(/^# /, '')
  assert.ok(text.includes(`„${anlage}“`), 'Nr. 10 nennt die Anlage mit dem Titel der Widerrufsbelehrung')
})

test('lb_ohne_du: Dritte Person und Sie-Form, keine Du-Form', () => {
  assert.doesNotMatch(LB_MD, /\bdein|\bdu\b|\bdir\b|\bdich\b|\beuch\b|\beuer/i)
  assert.ok(/\bder Kunde\b/.test(LB_MD))
})

test('lb_bfsg_ohne_konformitaetszusage: keine Zusage, das Widget erfülle WCAG oder EN 301 549', () => {
  const nr11 = norm(abschnitt(LB, 11).text)
  assert.ok(nr11.includes('Eine Konformität nach WCAG 2.1 AA oder EN 301 549 sagt WEBklar nicht zu.'))
  assert.ok(nr11.includes('Ob der Kunde als Dienstleistungserbringer unter das BFSG fällt (Ausnahme für Kleinstunternehmen, § 3 Abs. 3 BFSG), entscheidet und prüft der Kunde.'))
  assert.ok(nr11.includes('Das Widget ist für die Bedienung mit Tastatur und Hilfstechniken gestaltet (Beschriftungen, Fokusführung, Fehlermeldungen als Live-Region).'))
  const alles = norm(LB_MD)
  assert.doesNotMatch(alles, /WCAG[^.]*\b(entspricht|erfüllt|erfüllen|barrierefrei|konform ist|sind konform)\b/i)
  assert.doesNotMatch(alles, /\b(entspricht|erfüllt|erfüllen)\b[^.]*(WCAG|EN 301 549|BFSG)/i)
  assert.doesNotMatch(alles, /vollständig barrierefrei|barrierefrei nach/i)
})

test('lb_inhalt: Rangfolge, Gästetexte, Gesundheitsbereich, Datenschutz-Absatz, Zahlung nur vor Ort', () => {
  const nr1 = norm(abschnitt(LB, 1).text)
  assert.ok(nr1.includes('Bei Widersprüchen geht für den Terminplaner diese Leistungsbeschreibung vor, in Datenschutzfragen der AVV Terminplaner.'))
  assert.ok(nr1.includes('Leistungsbeschreibung B Nr. 3 der Abo-Bedingungen („Rechtstexte … nicht enthalten“) gilt nicht für den Datenschutz-Absatz'))
  const nr2 = norm(abschnitt(LB, 2).text)
  assert.ok(nr2.includes('Bezahlt wird nur vor Ort.'))
  assert.ok(nr2.includes('Mustertexte der Standardkonfiguration'))
  for (const wort of ['geheimen Kalender-Link (ICS)', 'CSV-Datei', 'Missbrauchsschutz', 'Bestätigungslink', 'Erinnerung (nur mit seinem Haken)', 'Widerrufs']) {
    assert.ok(nr2.includes(wort), `Nr. 2 nennt ${wort}`)
  }
  const nr3 = norm(abschnitt(LB, 3).text)
  for (const wort of ['SMS', 'Online-Zahlung', 'Kalender-Abgleich', 'Konten für Gäste', 'Marketing-E-Mails', 'Gruppentermine', 'Mehrsprachigkeit', 'Gesundheitsbereich', 'zweites Widget', 'Sonderdesign', '§ 4 der Abo-Bedingungen']) {
    assert.ok(nr3.includes(wort), `Nr. 3 nennt ${wort}`)
  }
  const nr4 = norm(abschnitt(LB, 4).text)
  assert.ok(nr4.includes('Der Terminplaner ist nicht für Angebote im Gesundheitsbereich bestimmt'))
  assert.ok(nr4.includes('WEBklar darf die Einrichtung für eine solche Website ablehnen oder den Terminplaner dort abschalten.'))
  assert.ok(nr4.includes('Kinder unter 16 Jahren'))
  assert.ok(nr4.includes('wird nicht auf das Stundenkontingent angerechnet'))
  assert.ok(nr4.includes('Textbaustein'))
  // Keine Gesundheitsangaben anfordern: der Text fordert nirgends welche an
  assert.doesNotMatch(LB_MD, /Gesundheitsdaten (erfassen|speichern)|Diagnose|Patient/i)
  const nr5 = norm(abschnitt(LB, 5).text)
  for (const wort of ['Fragebogen', 'Einbau', 'Abnahme', 'Freischaltung', 'Stripe', 'Rechnung', 'keine verbindliche Zusage eines Termins', 'weder auf das Kontingent angerechnet noch damit bezahlt']) {
    assert.ok(nr5.includes(wort), `Nr. 5 nennt ${wort}`)
  }
  const nr7 = norm(abschnitt(LB, 7).text)
  assert.ok(nr7.includes('§ 13 Abs. 1 und 2 der Abo-Bedingungen'))
  const nr10 = norm(abschnitt(LB, 10).text)
  assert.ok(nr10.includes('Mit dem Widerruf endet der Terminplaner.'))
})

// ============================================================================================ AVV Terminplaner (Task F5)

const AVV_PFAD = 'docs/rechtliches/avv-terminplaner.md'
const AVV_MD = lies(AVV_PFAD)
const AVV = lese(AVV_MD)
const ABO = lies('public/abo-bedingungen.html')
const JOBS = lies('server/services/termine/jobs.js')
const OUTBOX = lies('server/services/termine/outbox.js')

const avvNr = (n) => norm(abschnitt(AVV, n).text)
const absatzTexte = (a) => a.text.split(/^\(\d+\) /m).slice(1).map(norm)

test('avv_aufbau: Titel, Kopf mit Fassung, Parteien, Vorbemerkung, Nr. 1 bis 12 und Anlage', () => {
  assert.deepEqual(AVV.h1, ['# Auftragsverarbeitungsvertrag Terminplaner (Art. 28 DSGVO)'])
  assert.equal(AVV_MD.split('\n')[0], '# Auftragsverarbeitungsvertrag Terminplaner (Art. 28 DSGVO)')
  assert.equal(AVV.kopf, `**Fassung ${V}**`)
  assert.equal(
    AVV_MD.split('\n')[4],
    'zwischen dem Kunden als Verantwortlichem („Kunde“) und der WEBklar GbR, Am Schwimmbad 10, 67722 Winnweiler, vertreten durch die Gesellschafter Kenso Grimm und Justin Klein, als Auftragsverarbeiter („WEBklar“).',
  )
  assert.deepEqual(AVV.abschnitte.map((a) => a.titel), [
    'Vorbemerkung: Abschluss und Verhältnis zu anderen Verträgen',
    '1. Gegenstand und Dauer',
    '2. Art und Zweck der Verarbeitung',
    '3. Datenarten und Betroffene',
    '4. Weisungen',
    '5. Vertraulichkeit',
    '6. Technische und organisatorische Maßnahmen',
    '7. Unterauftragsverarbeiter',
    '8. Unterstützung des Kunden, Betroffenenrechte',
    '9. Löschung und Rückgabe',
    '10. Nachweise und Kontrollen',
    '11. Pflichten des Kunden',
    '12. Haftung, Änderungen, Schlussbestimmungen',
    'Anlage: Technische und organisatorische Maßnahmen des Terminplaners (Art. 32 DSGVO)',
  ])
  // Absätze sind lückenlos nummeriert; Nr. 5 und Nr. 10 bestehen aus einem Absatz ohne Nummer, die Anlage ist eine Tabelle
  for (const a of AVV.abschnitte) {
    if (['5', '10'].includes(a.nummer) || a.titel.startsWith('Anlage:')) {
      assert.deepEqual(a.absaetze, [], `${a.titel}: kein nummerierter Absatz`)
    } else {
      assert.ok(a.absaetze.length >= 1, `${a.titel}: keine Absätze`)
      assert.deepEqual(a.absaetze, a.absaetze.map((_, i) => i + 1), `${a.titel}: Absätze nicht lückenlos`)
    }
  }
  // Vorbemerkung hat drei Absätze (Abschluss, Mitarbeiter, Verhältnis zu Anlage 1)
  assert.deepEqual(AVV.abschnitte[0].absaetze, [1, 2, 3])
})

test('avv_sauber: keine Platzhalter, Entwurfsmarken, Kommentare oder Kanzlei-Marker', () => {
  assert.doesNotMatch(AVV_MD, /ENTWURF|Entwurf|Prüfpunkt|TODO|\{\{|\}\}|<!--|⚖|\bQ\d+\b/)
  assert.doesNotMatch(AVV_MD, /\[|\]|…\s*$/m, 'offene Klammer oder Auslassung am Zeilenende')
  assert.doesNotMatch(AVV_MD, /undefined|null|NaN/)
  assert.ok(!/```|^>|<[a-z]/im.test(AVV_MD), 'nur die Markdown-Teilmenge: kein Codeblock, Zitat oder rohes HTML')
  // keine Du-Form: der AVV spricht vom Kunden in der dritten Person
  assert.doesNotMatch(AVV_MD, /\bdein|\bdu\b|\bdir\b|\bdich\b|\beuch\b|\beuer/i)
  assert.ok(/\bder Kunde\b/.test(AVV_MD))
  // Tabelle: genau zwei Zellen je Zeile, kein weiteres | im Zelleninhalt
  const zeilen = AVV_MD.split('\n').filter((z) => z.startsWith('|'))
  assert.ok(zeilen.length >= 13, 'Kopf, Trennzeile und die Zeilen der Anlage')
  for (const z of zeilen) assert.equal(z.split('|').length, 4, `Tabellenzeile mit mehr als zwei Zellen: ${z.slice(0, 40)}`)
  assert.equal(zeilen[0], '| Bereich | Maßnahmen |')
  assert.equal(zeilen[1], '|---|---|')
})

test('avv_unterauftragsverarbeiter: Nr. 7 nennt Hetzner mit Anschrift, Falkenstein und Nürnberg, kein Drittland', () => {
  const nr7 = avvNr(7)
  const abs1 = absatzTexte(abschnitt(AVV, 7))[0]
  assert.ok(abs1.includes('Hetzner Online GmbH, Industriestraße 25, 91710 Gunzenhausen'))
  assert.ok(abs1.includes('Falkenstein') && abs1.includes('Nürnberg'))
  assert.match(abs1, /Betrieb des Servers[\s\S]*Sicherung[\s\S]*Falkenstein[\s\S]*Versand der Buchungs-E-Mails[\s\S]*Webhostings[\s\S]*Nürnberg/)
  assert.ok(abs1.includes('Eine Übermittlung in Drittländer findet nicht statt.'))
  assert.doesNotMatch(nr7, /\bUSA\b|Vereinigte(n)? Staaten|Standardvertragsklauseln|Angemessenheitsbeschluss|Data Privacy Framework|Drittland(?!länder)/)
  // Muster Analyse-AVV Nr. 7: vier Wochen Vorlauf, zwei Wochen Widerspruch, Verpflichtung nach Art. 28 Abs. 4
  assert.ok(nr7.includes('mindestens vier Wochen vorher in Textform'))
  assert.ok(nr7.includes('innerhalb von zwei Wochen nach Zugang der Mitteilung aus wichtigem datenschutzrechtlichem Grund in Textform widersprechen'))
  assert.ok(nr7.includes('Art. 28 Abs. 4 DSGVO'))
  // Stripe betrifft nur den Vertrag zwischen Kunde und WEBklar
  assert.ok(nr7.includes('Die Zahlung der Einrichtung über Stripe betrifft nur den Vertrag zwischen dem Kunden und WEBklar.'))
  assert.ok(nr7.includes('Stripe ist deshalb kein Unterauftragsverarbeiter dieses Vertrags.'))
  // dieselben Orte wie Anlage 3 der Abo-Bedingungen (Server: Falkenstein, E-Mail-Postfächer/Webhosting: Nürnberg)
  assert.ok(ABO.includes('Hetzner Online GmbH, Industriestraße 25, 91710 Gunzenhausen'))
  assert.ok(ABO.includes('Deutschland (Rechenzentrum Falkenstein)') && ABO.includes('Deutschland (Rechenzentrum Nürnberg)'))
})

/** Die Konstante `const NAME = N * (STUNDE|TAG)_MS` aus einem Quelltext als { n, einheit }. */
function konstante(quelle, name) {
  const m = new RegExp(`const ${name} = (\\d+) \\* (STUNDE|TAG)_MS`).exec(quelle)
  assert.ok(m, `${name} fehlt im Quelltext`)
  return { n: Number(m[1]), einheit: m[2] === 'STUNDE' ? 'Stunden' : 'Tage' }
}

/** Eingabe einer gültigen Einstellung (wie test/termineAblaufGast.test.js, ohne aufbewahrungTage). */
const R1 = 'r_aaaaaaa1'
const S_SOFORT = 's_bbbbbbb1'
const eingabeEinstellung = (over = {}) => ({
  betrieb: {
    name: 'Salon Müller',
    email: 'info@salon.de',
    telefon: '06301 1234',
    adresse: 'Hauptstr. 1, 67722 Winnweiler',
    websiteUrl: 'https://salon.de',
    impressumUrl: 'https://salon.de/impressum',
    datenschutzUrl: 'https://salon.de/datenschutz',
  },
  anrede: 'sie',
  bundesland: 'RP',
  ressourcen: [{ id: R1, name: 'Anna', plan: { 1: [['09:00', '18:00']] } }],
  leistungen: [{ id: S_SOFORT, name: 'Damenschnitt', dauer: 45, pufferNach: 5, preisArt: 'fest', preisCent: 4500, buchungsart: 'sofort', ressourcen: [R1] }],
  regeln: { raster: 15, vorlaufMin: 120, horizontTage: 90, absageBisStd: 24, maxOffeneJeEmail: 3, personWaehlbar: true },
  gastFelder: { telefon: 'optional', nachricht: 'aus', zusatz: [] },
  erinnerung: { anbieten: true, stundenVorher: 24 },
  storno: { text: 'Kostenlose Absage bis 24 Stunden vor dem Termin.' },
  recht: { gaesteSind: 'verbraucher', freizeit: false },
  zahlung: { modus: 'vorort', vorOrtArten: ['bar', 'ec'] },
  ...over,
})
const JETZT = new Date('2026-10-05T08:00:00.000Z') // Montag, 10:00 Berlin
const einstellungMit = (over = {}) => normalisiereEinstellung(eingabeEinstellung(over), { now: JETZT })

test('avv_loeschfristen_gleich_code: Nr. 9 nennt genau die Fristen, die der Löschlauf anwendet', () => {
  const nr9 = avvNr(9)
  const zahlen = (re) => {
    const m = re.exec(nr9)
    assert.ok(m, `Nr. 9: Satz fehlt oder ist verändert: ${re}`)
    return m.slice(1).map(Number)
  }

  // (1) nicht bestätigt: 48 Stunden nach Ablauf der Bestätigungsfrist von 30 Minuten (jobs.js VERFALLEN_BEHALTEN_MS, config.termine.holdMinutes)
  const [verfall, haltezeit] = zahlen(/Nicht bestätigte Buchungen löscht WEBklar (\d+) Stunden nach Ablauf der Bestätigungsfrist von (\d+) Minuten\./)
  assert.deepEqual(konstante(JOBS, 'VERFALLEN_BEHALTEN_MS'), { n: verfall, einheit: 'Stunden' })
  assert.equal(config.termine.holdMinutes, haltezeit)

  // (2) abgesagt/abgelehnt: 30 Tage (jobs.js ABGESAGT_BEHALTEN_MS)
  const [abgesagt] = zahlen(/Abgesagte und abgelehnte Termine löscht WEBklar (\d+) Tage nach der Absage oder Ablehnung\./)
  assert.deepEqual(konstante(JOBS, 'ABGESAGT_BEHALTEN_MS'), { n: abgesagt, einheit: 'Tage' })

  // (3) bestätigt/erledigt: Vorgabe 90, einstellbar 14 bis 365 Tage nach Terminende (jobs.js AUFBEWAHRUNG_*, einstellungen.js)
  const [vorgabe, minimum, maximum] = zahlen(/die Vorgabe sind (\d+) Tage, einstellbar sind (\d+) bis (\d+) Tage\./)
  const konst = (name) => Number(new RegExp(`const ${name} = (\\d+)`).exec(JOBS)?.[1])
  assert.deepEqual([konst('AUFBEWAHRUNG_VORGABE'), konst('AUFBEWAHRUNG_MIN'), konst('AUFBEWAHRUNG_MAX')], [vorgabe, minimum, maximum])
  assert.equal(einstellungMit().einstellung.aufbewahrungTage, vorgabe, 'Vorgabe der Einstellung')
  for (const tage of [minimum, maximum]) assert.equal(einstellungMit({ aufbewahrungTage: tage }).einstellung.aufbewahrungTage, tage)
  for (const tage of [minimum - 1, maximum + 1]) assert.ok(einstellungMit({ aufbewahrungTage: tage }).fehler?.aufbewahrungTage, `${tage} Tage sind nicht erlaubt`)
  assert.ok(nr9.includes('gerechnet ab dem Ende des Termins'))

  // (4) Versandwarteschlange: gesendet 7 Tage, nicht zustellbar 48 Stunden (outbox.js GESENDET_BEHALTEN_MS, FEHLER_BEHALTEN_MS)
  const [gesendet, fehler] = zahlen(/löscht den Eintrag (\d+) Tage nach dem Versand\. E-Mails, die nicht zugestellt werden können, löscht WEBklar mit Empfängeradresse und Inhalt (\d+) Stunden nach dem endgültigen Fehlschlag\./)
  assert.deepEqual(konstante(OUTBOX, 'GESENDET_BEHALTEN_MS'), { n: gesendet, einheit: 'Tage' })
  assert.deepEqual(konstante(OUTBOX, 'FEHLER_BEHALTEN_MS'), { n: fehler, einheit: 'Stunden' })
  assert.ok(nr9.includes('leert WEBklar die Empfängeradresse und den Inhalt einer E-Mail nach dem Versand'))

  // (6) Abschalten: LOESCHFRIST_TAGE (termine/frist.js), dieselbe Zahl wie in der Leistungsbeschreibung Nr. 8
  const [abschalten] = zahlen(/löscht WEBklar alle Termindaten und die Einstellungen (\d+) Tage danach\./)
  assert.equal(abschalten, LOESCHFRIST_TAGE)
  assert.equal(LOESCHFRIST_TAGE, 30)
  assert.ok(JOBS.includes('LOESCHFRIST_TAGE * TAG_MS'), 'jobs.js rechnet mit LOESCHFRIST_TAGE')
  assert.ok(nr9.includes('Beginnt innerhalb dieser Frist wieder ein Wartungs-Abo, schaltet WEBklar den Terminplaner mit den vorhandenen Daten und Einstellungen wieder ein (Nr. 8 Abs. 4 der Leistungsbeschreibung).'))
  assert.ok(nr9.includes('kann der Kunde die Termine im Kundenportal als CSV-Datei exportieren'))

  // (7) Entwürfe: ENTWURF_TAGE (entwuerfe.js)
  const [entwurf] = zahlen(/Entwürfe aus dem Fragebogen, aus denen keine Bestellung geworden ist, löscht WEBklar (\d+) Tage nach der letzten Änderung\./)
  assert.equal(ENTWURF_TAGE, entwurf)

  // (8) Sicherung: bis zu sieben Tage (§ 3 Abs. 5 der Abo-Bedingungen)
  assert.ok(nr9.includes('Gelöschte Daten bleiben dort bis zu sieben Tage erhalten'))
  assert.ok(ABO.includes('Verfügbar sind jeweils die letzten sieben Tagessicherungen.'))

  // der Löschlauf läuft täglich und löscht nie vor der Frist (Deckel: der Rest folgt am nächsten Tag)
  assert.ok(nr9.includes('Der Löschlauf läuft täglich; gelöscht wird frühestens nach Ablauf der jeweiligen Frist.'))
  assert.ok(lies('server/index.js').includes('setInterval(termineTagesJob, 24 * 60 * 60 * 1000)'))
})

test('avv_gleich_datenschutz_absatz: Fristen und Orte stimmen mit dem Datenschutz-Absatz überein, den der Kunde veröffentlicht', () => {
  const { einstellung } = einstellungMit()
  const absatz = norm(datenschutzAbsatz(einstellung, 'sie'))
  assert.ok(absatz.includes(`Bestätigungslink gilt ${config.termine.holdMinutes} Minuten`))
  assert.ok(absatz.includes('löschen wir 48 Stunden nach Ablauf dieser Frist'))
  assert.ok(absatz.includes(`Bestätigte Termine löschen wir ${einstellung.aufbewahrungTage} Tage nach dem Termin`))
  assert.ok(absatz.includes('abgesagte oder abgelehnte Termine 30 Tage nach der Absage oder Ablehnung'))
  assert.ok(absatz.includes(`zum Beispiel weil unser Vertrag mit WEBklar endet, werden alle Termindaten ${LOESCHFRIST_TAGE} Tage nach dem Abschalten gelöscht`))
  assert.ok(absatz.includes('nicht zustellbare E-Mails nach 48 Stunden'))
  assert.ok(absatz.includes('Rechenzentren Falkenstein und Nürnberg') && absatz.includes('Eine Übermittlung in Drittländer findet nicht statt.'))
  assert.ok(absatz.includes('Der Server speichert sie kurzzeitig in Protokollen und löscht sie nach 14 Tagen'))
  // unbeantwortete Terminanfragen: derselbe Satz im Datenschutz-Absatz des Kunden und im AVV (Nr. 9 Abs. 2), und der Code tut es
  assert.ok(absatz.includes('Terminanfragen, die wir bis zum Terminbeginn nicht beantworten, behandeln wir als abgelehnt.'))
  const nr9abs2 = absatzTexte(abschnitt(AVV, 9))[1]
  assert.ok(nr9abs2.startsWith('Abgesagte und abgelehnte Termine löscht WEBklar 30 Tage nach der Absage oder Ablehnung.'))
  assert.ok(nr9abs2.includes('Terminanfragen, die der Kunde bis zum angefragten Terminbeginn nicht beantwortet, behandelt der Terminplaner als abgelehnt; die 30 Tage laufen dann ab diesem Zeitpunkt.'))
  assert.ok(JOBS.includes("angefragt mit Beginn in der Vergangenheit => abgelehnt vom System"), 'jobs.js lehnt verstrichene Anfragen ab')
  assert.equal(loeschBezugsfeld('angefragt'), undefined, 'eine Anfrage wird nie unmittelbar gelöscht, erst als abgelehnte nach 30 Tagen')
  assert.equal(loeschBezugsfeld('abgelehnt'), 'updatedAt', 'die 30 Tage laufen ab der letzten Änderung, also ab der Ablehnung durch das System')
  // der AVV nennt dieselben Zahlen
  const nr3 = avvNr(3)
  assert.ok(nr3.includes('In den Server-Protokollen stehen sie 14 Tage (Anlage 2 der Abo-Bedingungen).'))
})

test('avv_keine_ip_in_buchung: weder das Schema noch eine über halte gehaltene Buchung enthält IP-Adresse oder Browser-Kennzeichen', async () => {
  const nameIp = /^(ip|ipAdresse|clientIp|userAgent)$/i
  for (const [collection, def] of Object.entries(TERMINE_COLLECTIONS)) {
    const treffer = def.attributes.map((a) => a.key).filter((k) => nameIp.test(k))
    assert.deepEqual(treffer, [], `${collection}: Attribut für IP-Adresse oder Browser-Kennzeichen`)
  }
  // ein loses /ip/ träfe stripeSessionId und stripePaymentIntent: das Muster oben ist absichtlich genau
  assert.ok(TERMINE_COLLECTIONS.termineBookings.attributes.some((a) => a.key === 'stripeSessionId'))

  // eine echte gehaltene Buchung: der Nachweis trägt keinen Schlüssel ip oder userAgent (auch nicht verschachtelt)
  const KUNDE = 'c_kunde01'
  const PROJEKT = 'p_projekt01'
  const FEATURE = 'f_p_projekt01_termine'
  const vorher = { mode: config.termine.mode, from: config.smtp.from, basis: config.publicBaseUrl }
  const log = { error: mock.method(console, 'error', () => {}), warn: mock.method(console, 'warn', () => {}) }
  try {
    config.termine.mode = 'pilot'
    config.smtp.from = 'noreply@webklar.com'
    config.publicBaseUrl = 'https://project.webklar.com'
    resetKontextForTests()
    resetOutboxForTests()
    const sink = mailSink()
    setMailTransportForTests(sink)
    const feature = { $id: FEATURE, customerId: KUNDE, projectId: PROJEKT, featureKey: 'termine', state: 'active', enabled: true, siteKey: 'abcdefghijklmnop' }
    aw.seed('portalFeatures', feature)
    aw.seed('websiteProjects', { $id: PROJEKT, customerId: KUNDE, subdomain: 'salon' })
    aw.seed('customers', { $id: KUNDE, name: 'Silke Müller', email: 'silke@example.com' })
    const { einstellung, fehler } = einstellungMit()
    assert.equal(fehler, undefined)
    await speichereEinstellung(feature, einstellung, { version: 0, now: JETZT })
    const ctx = { feature, project: { $id: PROJEKT, subdomain: 'salon' }, einstellung, version: 1 }
    const erg = await halte(
      ctx,
      {
        leistung: S_SOFORT, ressource: 'egal', tag: '2026-10-26', zeit: '10:00', name: 'Max Mustermann', email: 'max@example.com',
        telefon: '', nachricht: '', zusatz: {}, erinnerung: true, zustimmungen: { storno: true, vorzeitig: false },
      },
      JETZT,
    )
    await warteAufVersand()
    assert.equal(erg.status, 'gehalten')
    const buchungen = [...aw.docs('termineBookings').values()]
    assert.equal(buchungen.length, 1)
    const nachweis = JSON.parse(buchungen[0].nachweis)
    assert.ok(nachweis.fassung && nachweis.datenschutz, 'der Nachweis enthält Fassung und Hash des Datenschutz-Hinweises')
    // genau die Bestandteile, die AVV Nr. 3 Abs. 1 und Nr. 8 Abs. 5 nennen: Fassung, Zeitpunkt, Knopftext, Anrede, Hashes (keine weiteren Klartexte)
    const erlaubt = new Set(['fassung', 'am', 'knopf', 'anrede', 'datenschutz', 'storno', 'widerruf', 'vorzeitig', 'erinnerung'])
    assert.deepEqual(Object.keys(nachweis).filter((k) => !erlaubt.has(k)), [])
    for (const k of ['fassung', 'am', 'knopf', 'anrede']) assert.equal(typeof nachweis[k], 'string', k)
    assert.deepEqual(Object.keys(nachweis.storno), ['version', 'hash', 'haken', 'am'])
    assert.deepEqual(Object.keys(nachweis.erinnerung), ['stunden', 'hash', 'am'])
    const schluessel = (wert) => (wert && typeof wert === 'object' ? Object.entries(wert).flatMap(([k, v]) => [k, ...schluessel(v)]) : [])
    assert.deepEqual(schluessel(nachweis).filter((k) => nameIp.test(k)), [])
    // der Nachweis hält Hashes, keine Texte: jeder Hash ist 64 Hexzeichen
    for (const hash of [nachweis.datenschutz, nachweis.storno?.hash, nachweis.widerruf?.hash, nachweis.erinnerung?.hash]) assert.match(hash, /^[0-9a-f]{64}$/)
    // auch sonst enthält kein Feld der Buchung eine Adresse der Form n.n.n.n
    assert.doesNotMatch(JSON.stringify(buchungen[0]), /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/)
  } finally {
    log.error.mock.restore()
    log.warn.mock.restore()
    setMailTransportForTests(null)
    config.termine.mode = vorher.mode
    config.smtp.from = vorher.from
    config.publicBaseUrl = vorher.basis
  }
})

/** Jedes Attribut einer Buchung ist in AVV Nr. 3 Abs. 1 genannt (Wortlaut) oder eine technische Kennung/Eigenschaft des Dienstes. */
const BUCHUNG_IM_AVV = {
  gastName: 'Name und E-Mail-Adresse', gastEmail: 'Name und E-Mail-Adresse', gastTelefon: 'Telefonnummer', gastNachricht: 'eine Nachricht', gastZusatz: 'Zusatzfelder',
  leistungName: 'die gebuchte Leistung', ressourceName: 'die Person oder der Platz', startsAt: 'der Termin', endsAt: 'der Termin', blockEndsAt: 'der Termin',
  status: 'der Status der Buchung mit den Zeitpunkten', heldUntil: 'der Status der Buchung mit den Zeitpunkten', bestaetigtAt: 'der Status der Buchung mit den Zeitpunkten',
  angenommenAt: 'der Status der Buchung mit den Zeitpunkten', abgesagtAt: 'der Status der Buchung mit den Zeitpunkten', abgesagtVon: 'der Status der Buchung mit den Zeitpunkten',
  widerrufenAt: 'der Status der Buchung mit den Zeitpunkten', createdAt: 'der Status der Buchung mit den Zeitpunkten', updatedAt: 'der Status der Buchung mit den Zeitpunkten',
  absageGrund: 'Absagegrund und Vermerke zu einer Absage oder einem Widerruf', nachweis: 'der Nachweis der Zustimmungen',
  preisCent: 'Preis, Zahlart, Zahlungsstatus und die Angabe, ob als Verbraucher gebucht wurde', zahlart: 'Preis, Zahlart, Zahlungsstatus und die Angabe, ob als Verbraucher gebucht wurde',
  zahlStatus: 'Preis, Zahlart, Zahlungsstatus und die Angabe, ob als Verbraucher gebucht wurde', verbraucher: 'Preis, Zahlart, Zahlungsstatus und die Angabe, ob als Verbraucher gebucht wurde',
  erinnerung: 'der Wunsch nach einer Erinnerung', erinnerungGesendetAt: 'der Wunsch nach einer Erinnerung',
}
const BUCHUNG_TECHNISCH = ['featureId', 'customerId', 'projectId', 'leistungId', 'ressourceId', 'preisArt', 'buchungsart', 'quelle', 'verifyHash', 'manageHash', 'stripeSessionId', 'stripePaymentIntent', 'icsSequenz']

test('avv_datenarten_decken_schema: jedes Attribut einer Buchung steht in Nr. 3 Abs. 1 oder ist eine technische Kennung', () => {
  const nr3abs1 = norm(absatzTexte(abschnitt(AVV, 3))[0])
  const attribute = TERMINE_COLLECTIONS.termineBookings.attributes.map((a) => a.key)
  const unbekannt = attribute.filter((k) => !Object.hasOwn(BUCHUNG_IM_AVV, k) && !BUCHUNG_TECHNISCH.includes(k))
  assert.deepEqual(unbekannt, [], 'neues Attribut der Buchung: in AVV Nr. 3 Abs. 1 aufnehmen oder als technisch einstufen')
  for (const [k, wort] of Object.entries(BUCHUNG_IM_AVV)) {
    assert.ok(attribute.includes(k), `${k} gibt es nicht mehr im Schema`)
    assert.ok(nr3abs1.includes(wort), `${k}: „${wort}“ fehlt in Nr. 3 Abs. 1`)
  }
  for (const k of BUCHUNG_TECHNISCH) assert.ok(attribute.includes(k), `${k} gibt es nicht mehr im Schema`)
})

test('avv_verweise_auf_lb: jedes „Nr. N Abs. M der Leistungsbeschreibung“ und jedes „Nummer N“ im AVV zeigt auf Vorhandenes', () => {
  const text = norm(AVV_MD)

  // 1. Verweise auf die Leistungsbeschreibung Terminplaner
  const lbVerweise = [...text.matchAll(/\b(?:Nr\.|Nummer) (\d+)(?: Abs\. (\d+))? der Leistungsbeschreibung/g)]
  assert.ok(lbVerweise.length >= 8, `zu wenige Verweise auf die Leistungsbeschreibung: ${lbVerweise.length}`)
  for (const m of lbVerweise) {
    const a = abschnitt(LB, m[1])
    assert.ok(a, `„${m[0]}“: Abschnitt ${m[1]} gibt es in der Leistungsbeschreibung nicht`)
    if (m[2]) assert.ok(a.absaetze.includes(Number(m[2])), `„${m[0]}“: Absatz ${m[2]} gibt es in Nr. ${m[1]} nicht`)
  }
  // der Wortlaut der Verweise passt zum Inhalt der Stelle
  const lb = (n, abs) => absatzTexte(abschnitt(LB, n))[abs - 1]
  assert.ok(lb(8, 1).startsWith('Mit dem Ende des Wartungs-Abos endet der Terminplaner.'), 'Nr. 1 Abs. 2: Nr. 8 Abs. 1')
  assert.ok(lb(8, 4).startsWith('Beginnt innerhalb dieser 30 Tage'), 'Nr. 9 Abs. 6: Rückkehr nach Nr. 8 Abs. 4')
  assert.ok(lb(8, 6).startsWith('Auf Wunsch des Kunden in Textform schaltet WEBklar den Terminplaner jederzeit ab.'), 'Nr. 4 Abs. 2: Nr. 8 Abs. 6')
  assert.ok(lb(4, 9).startsWith('Liegt die Datenschutzerklärung in der von WEBklar betreuten Website'), 'Nr. 11 Abs. 2: Datenschutz-Absatz')
  assert.ok(lb(4, 7).startsWith('Er informiert seine Beschäftigten'), 'Nr. 11 Abs. 3: Beschäftigte')
  assert.ok(lb(4, 3).startsWith('Der Terminplaner ist nicht für Angebote im Gesundheitsbereich bestimmt'), 'Nr. 11 Abs. 4: Gesundheitsbereich')
  assert.ok(lb(4, 6).startsWith('Er lässt die Texte der Haken und Hinweise im Widget unverändert.'), 'Nr. 11 Abs. 5: Haken unverändert')
  assert.ok(lb(9, 2).startsWith('WEBklar darf den Terminplaner für eine Website mit einer Frist von vier Wochen beenden'), 'Nr. 12 Abs. 3: Beenden')
  assert.ok(lb(9, 3).startsWith('Ist der Weiterbetrieb aus einem Grund nach Absatz 2 schon vor Ablauf der Frist nicht zulässig'), 'Nr. 12 Abs. 3: Aussetzen')

  // 2. Verweise innerhalb des AVV: „Nummer N [Abs. M]“ (ohne Zusatz „der Leistungsbeschreibung“)
  const eigene = [...text.matchAll(/\bNummer (\d+)(?: Abs\. (\d+))?(?! der Leistungsbeschreibung)/g)]
  assert.ok(eigene.length >= 6, `zu wenige interne Verweise: ${eigene.length}`)
  for (const m of eigene) {
    const a = abschnitt(AVV, m[1])
    assert.ok(a, `„${m[0]}“: Abschnitt ${m[1]} gibt es nicht`)
    if (m[2]) assert.ok(a.absaetze.includes(Number(m[2])), `„${m[0]}“: Absatz ${m[2]} gibt es in Nummer ${m[1]} nicht`)
  }
  // die Verweise der Leistungsbeschreibung auf den AVV zeigen auf Löschfristen (Nr. 9) und Änderungen (Nr. 12)
  assert.match(avvNr(9), /Löschung und Rückgabe|Nicht bestätigte Buchungen/)
  assert.match(avvNr(12), /neue Fassung/)

  // 3. Paragrafen und Anlagen der Abo-Bedingungen
  const paragrafen = [...text.matchAll(/§ (\d+)(?: Abs\. (\d+))? der Abo-Bedingungen/g)]
  assert.ok(paragrafen.length >= 3)
  for (const m of paragrafen) {
    const start = ABO.indexOf(`<h2 id="p${m[1]}">§ ${m[1]} `)
    assert.ok(start > 0, `„${m[0]}“: § ${m[1]} gibt es in den Abo-Bedingungen nicht`)
    const stueck = ABO.slice(start, ABO.indexOf('<h2', start + 10))
    const anzahl = Math.max((stueck.match(/<li>/g) || []).length, (stueck.match(/<h3>\(\d+\)/g) || []).length)
    if (m[2]) assert.ok(Number(m[2]) <= anzahl, `„${m[0]}“: § ${m[1]} hat keinen Absatz ${m[2]}`)
  }
  assert.deepEqual([...new Set(paragrafen.map((m) => m[1]))].sort(), ['13', '16', '3'])
  assert.ok(ABO.includes('id="avv"') && ABO.includes('id="tom"'), 'Anlage 1 und Anlage 2 der Abo-Bedingungen')
  assert.ok(text.includes('Anlage 1 der Abo-Bedingungen') && text.includes('Anlage 2 der Abo-Bedingungen'))
})

test('avv_ohne_analyse_bezug: Analyse-Kunden müssen nicht neu zustimmen, der AVV der Analyse bleibt unverändert', () => {
  // der Terminplaner-AVV ist ein eigenes Geschwister: kein Wort zur Analyse, kein Nachtrag
  assert.doesNotMatch(AVV_MD, /Analyse|Nachtrag|Zusatz zum|Änderung des Auftragsverarbeitungsvertrags/i)
  // der AVV der Analyse kennt den Terminplaner nicht und trägt weiter seine eigene Fassung
  const analyse = lies('docs/rechtliches/avv-website-analyse.md')
  assert.doesNotMatch(analyse, /Terminplaner|Termine/)
  assert.equal(analyse.split('\n')[2], `**Fassung ${config.analyse.avvVersion}**`)
  assert.notEqual(config.analyse.avvVersion, V, 'die Fassung der Analyse ändert sich nicht mit der des Terminplaners')
  // die beiden Dokumentsätze sind getrennt
  assert.notEqual(featureConfig('termine').avv, undefined)
  assert.ok(!String(featureConfig('termine').avv).includes('website-analyse'))
})

test('avv_inhalt: Abschluss, Zwecke ohne Eigennutz, Datenarten, Weisungen, Datenpanne, Änderungen', () => {
  const vorbemerkung = norm(AVV.abschnitte[0].text)
  assert.ok(vorbemerkung.includes('Das Portal speichert die Fassung, den Zeitpunkt, das Kundenkonto und die angemeldete Person.'))
  assert.ok(vorbemerkung.includes('Anschließend sendet WEBklar dem Kunden eine E-Mail, die beide Texte und die Widerrufsbelehrung in dieser Fassung als PDF enthält'))
  assert.ok(vorbemerkung.includes('Ein Mitarbeiter von WEBklar darf die Funktion nur einschalten, wenn der Kunde vorher in Textform'))
  // T1: In der Textform-Aktivierung trägt K16 nur Leistungsbeschreibung und AVV als PDF (ohne Widerrufsbelehrung, ohne Links): der Text verspricht nicht die E-Mail nach Absatz 1
  assert.ok(vorbemerkung.includes('Der Kunde erhält anschließend eine E-Mail mit diesen beiden Texten als PDF.'))
  assert.ok(!vorbemerkung.includes('E-Mail nach Absatz 1 anschließend'), 'der Satz verwies auf die Mail mit Belehrung und Links')
  assert.match(lies('server/routes/admin/funktionenAdmin.js'), /featureLegalAttachments\(key, \{ ohne: \['widerruf'\] \}\)/, 'K16 der Textform-Aktivierung (Terminplaner und Webshop): nur Leistungsbeschreibung und AVV')
  assert.ok(vorbemerkung.includes('Für den Terminplaner geht er Anlage 1 vor'))
  assert.ok(vorbemerkung.includes('Anlage 1 der Abo-Bedingungen'))

  const nr1 = avvNr(1)
  assert.ok(nr1.includes('Er endet mit dem Abschalten, spätestens mit dem Ende des Wartungs-Abos; den Terminplaner schaltet WEBklar dann spätestens am folgenden Tag ab'))
  assert.ok(nr1.includes('Die Pflichten aus diesem Vertrag gelten fort, bis alle Daten nach Nummer 9 gelöscht sind.'))

  const nr2 = avvNr(2)
  assert.ok(nr2.includes('WEBklar verwendet die Daten für keine eigenen Zwecke'))
  assert.ok(nr2.includes('WEBklar bildet keine Profile einzelner Gäste.'))
  assert.ok(nr2.includes('Missbrauch'))

  const nr3 = avvNr(3)
  for (const wort of [
    'Name und E-Mail-Adresse', 'Telefonnummer', 'Zusatzfelder', 'die gebuchte Leistung, die Person oder der Platz und der Termin', 'der Status der Buchung mit den Zeitpunkten',
    'Fassung der Gästetexte, Zeitpunkt, Text des Buchungsknopfs, Anrede und Hashes (Prüfsummen) der gezeigten Texte', 'der Wunsch nach einer Erinnerung', 'der Zustellstatus der E-Mails an den Gast',
    'Absagegrund und Vermerke zu einer Absage oder einem Widerruf', 'auch mit dem Namen aus einer Widerrufserklärung', 'Preis, Zahlart, Zahlungsstatus und die Angabe, ob als Verbraucher gebucht wurde',
    'Namen oder Bezeichnungen der Personen oder Plätze', 'Arbeitszeiten und Abwesenheiten', 'geheimer Kalender-Link',
  ]) assert.ok(nr3.includes(wort), `Nr. 3 nennt ${wort}`)
  assert.ok(nr3.includes('Besondere Kategorien personenbezogener Daten (Art. 9 DSGVO) werden nicht verarbeitet.'))
  assert.ok(nr3.includes('Mit der Buchung wird keine IP-Adresse und kein Browser-Kennzeichen gespeichert.'))
  assert.ok(nr3.includes('nur im Arbeitsspeicher des Servers'))
  assert.ok(nr3.includes('Der Terminplaner setzt keine Cookies und speichert nichts im Browser des Gastes.'))

  const nr4 = avvNr(4)
  assert.ok(nr4.includes('Mit der Bestellung weist der Kunde WEBklar an'))
  assert.ok(nr4.includes('Sonstige Weisungen erteilt der Kunde in Textform'))
  assert.ok(nr4.includes('Die Löschung auf Weisung nach Nummer 9 Abs. 6 setzt WEBklar immer um.'))

  const nr8 = avvNr(8)
  assert.ok(nr8.includes('Gastdaten löschen') && nr8.includes('CSV-Datei'))
  assert.ok(nr8.includes('möglichst innerhalb von 24 Stunden nach Kenntnis'))
  assert.ok(nr8.includes('bis drei Jahre nach dem Ende des Terminplaners'))
  assert.ok(nr8.includes('die Fassung der Gästetexte, den Zeitpunkt, den Text des Buchungsknopfs, die Anrede und Hashes der übrigen Texte'))
  assert.doesNotMatch(nr8, /nur den Zeitpunkt/)

  const nr11 = avvNr(11)
  assert.ok(nr11.includes('Art. 13 DSGVO') && nr11.includes('Datenschutz-Absatz') && nr11.includes('Beschäftigten'))
  assert.ok(nr11.includes('nicht im Gesundheitsbereich'))
  assert.ok(nr11.includes('Haken für die Erinnerung'))

  const nr12 = avvNr(12)
  assert.ok(nr12.includes('§ 13 der Abo-Bedingungen') && nr12.includes('Art. 82 DSGVO'))
  assert.ok(nr12.includes('mindestens sechs Wochen vor ihrem Wirksamwerden in Textform'))
  assert.ok(nr12.includes('Im Übrigen gilt § 16 der Abo-Bedingungen.'))
})

test('avv_ausnahmen_loeschung: Einrichtungs-Ticket bleibt (Nr. 9 Abs. 6, Anlage, LB Nr. 8 Abs. 3); fehlgeschlagene E-Mails behalten Adresse und Inhalt bis Nr. 9 Abs. 4 (Nr. 8 Abs. 2)', () => {
  // T2: das Einrichtungs-Ticket (workorders.details = Kurzfassung der Einstellungen, ticketDetails.js) wird beim Löschlauf nicht angefasst
  const ticket = 'Eine Ausnahme ist das Einrichtungs-Ticket, in dem WEBklar die Einrichtung als Arbeitsnachweis festhält: Es bleibt mit einer Kurzfassung der Einstellungen bestehen'
  const nr9 = avvNr(9)
  const abs6 = nr9.slice(nr9.indexOf('(6) '), nr9.indexOf('(7) '))
  assert.ok(abs6.includes(ticket))
  assert.ok(abs6.includes('(zum Beispiel Betriebsangaben, Namen der Leistungen, die ersten acht Namen der Personen oder Plätze und die Wünsche des Kunden zum Einbau) und enthält keine Daten von Gästen; dafür gilt die Datenschutzerklärung von WEBklar (Abschnitt 6).'))
  // Reihenfolge: erst die Löschung nach 30 Tagen, dann die Ausnahme, dann der Export; „Bis dahin“ hätte sich auf die Datenschutzerklärung beziehen lassen
  assert.ok(abs6.indexOf('30 Tage danach.') < abs6.indexOf(ticket) && abs6.indexOf(ticket) < abs6.indexOf('Bis zur Löschung kann der Kunde die Termine'))
  assert.ok(!abs6.includes('Bis dahin'))
  assert.ok(tomZeilen()['Löschung'].includes('das Einrichtungs-Ticket bleibt als Arbeitsnachweis mit einer Kurzfassung der Einstellungen bestehen und enthält keine Daten von Gästen (Nummer 9 Abs. 6)'))
  assert.ok(norm(abschnitt(LB, 8).text).includes('Eine Ausnahme ist das Einrichtungs-Ticket, in dem WEBklar die Einrichtung als Arbeitsnachweis festhält: Es bleibt mit einer Kurzfassung der Einstellungen bestehen und enthält keine Daten von Gästen (Nummer 9 Abs. 6 des AVV Terminplaner).'))
  // die Zahl „acht“ ist die der Kurzfassung (einbauanleitung.js KURZ_NAMEN); die Kurzfassung hat keinen Zugriff auf Buchungen (ticketDetails.js liest nur den Stand der Einstellungen)
  assert.match(lies('server/services/termine/einbauanleitung.js'), /const KURZ_NAMEN = 8\b/)
  assert.doesNotMatch(lies('server/services/termine/ticketDetails.js'), /termineBookings|buchungen\.js|gastName|gastEmail/)
  // Datenschutzerklärung Abschnitt 6 nennt die Arbeitsnachweise und die Aufbewahrung bis zur Verjährung
  const ds = norm(lies('public/datenschutz.html').replace(/<[^>]+>/g, ' '))
  assert.ok(ds.includes('unsere Arbeitsnachweise') && ds.includes('bis zum Ablauf der Verjährungsfrist (in der Regel drei Jahre)'))

  // T3: „Gastdaten löschen“ löscht nur Einträge im Status wartet (verwerfeWartende); Einträge im Status fehler behalten Adresse und Inhalt bis 48 Stunden nach dem Fehlschlag
  const nr8 = avvNr(8)
  assert.ok(nr8.includes('Dabei löscht WEBklar die E-Mails zu dieser Buchung, die noch auf den Versand warten, und die Links des Gastes werden ungültig.'))
  assert.ok(nr8.includes('E-Mails, deren Versand endgültig fehlgeschlagen ist, behalten Empfängeradresse und Inhalt, bis WEBklar sie nach Nummer 9 Abs. 4 löscht (48 Stunden nach dem Fehlschlag).'))
  assert.ok(!nr8.includes('Noch nicht versandte E-Mails zu dieser Buchung löscht WEBklar dabei'), 'der alte Satz versprach mehr, als verwerfeWartende löscht')
  const verwerfe = /export async function verwerfeWartende[\s\S]*?\n\}\n/.exec(OUTBOX)?.[0]
  assert.ok(verwerfe, 'verwerfeWartende')
  assert.ok(verwerfe.includes("Query.equal('status', 'wartet')") && !verwerfe.includes("'fehler'"), 'verwerfeWartende löscht nur den Status wartet')
  assert.match(OUTBOX, /const FEHLER_BEHALTEN_MS = 48 \* STUNDE_MS/)
  assert.ok(avvNr(9).includes('löscht WEBklar mit Empfängeradresse und Inhalt 48 Stunden nach dem endgültigen Fehlschlag'))
})

/**
 * Fundstellen der Anlage TOM: jede Zeile der Tabelle nennt hier, wo im Code, in den Tests oder in den Abo-Bedingungen ihre
 * Aussage gesichert ist. { datei, hat } = die Datei enthält das Muster; { datei, nicht } = die Datei enthält es nicht.
 */
const TOM_FUNDSTELLEN = {
  'Übertragung': [
    { datei: 'server/config.js', hat: /publicBaseUrl: \(process\.env\.PORTAL_PUBLIC_URL \|\| 'https:\/\/project\.webklar\.com'\)/ },
    { datei: 'server/services/termine/einbauanleitung.js', hat: /beginnen mit https:\/\// },
    { datei: 'test/termineEmbedStatic.test.js', hat: /keine festen Fremdadressen im Code/ },
  ],
  'Speicher im Browser': [
    { datei: 'test/termineEmbedStatic.test.js', hat: /'sessionStorage', 'document\.cookie', 'indexedDB', 'document\.referrer'/ }, // termineEmbedStatic.test.js:24
    { datei: 'test/termineEmbedStatic.test.js', hat: /'resolvedOptions', 'getTimezoneOffset'/ },
    { datei: 'public/embed/termine.js', hat: /credentials: 'omit'/ },
    { datei: 'public/termin.js', nicht: /localStorage|sessionStorage|document\.cookie|indexedDB/ },
    { datei: 'public/termin.html', nicht: /localStorage|sessionStorage|document\.cookie|indexedDB/ },
    { datei: 'server/routes/publicTermine.js', nicht: /res\.cookie|Set-Cookie/i },
  ],
  'Zugriffskontrolle': [
    { datei: 'server/routes/termine.js', hat: /assertOwnProject\(customerId, projectId\)/ },
    { datei: 'server/routes/termine.js', hat: /ctx\.feature\.customerId !== customerId/ },
    { datei: 'server/routes/publicTermine.js', hat: /timingSafeEqual\(sha256\(r\.feedToken\), gegeben\)/ },
    { datei: 'server/routes/publicTermine.js', hat: /POST und Preflight nur von Seiten des Betriebs/ },
    { datei: 'server/services/termine/token.js', hat: /timingSafeEqual\(gegeben, erwartet\)/ },
  ],
  'Missbrauchsschutz': [
    { datei: 'server/routes/publicTermine.js', hat: /Honeypot kontakt_url und Formular-Token/ },
    { datei: 'server/routes/publicTermine.js', hat: /config\.termine\.minAntwortMs/ },
    { datei: 'server/services/termine/token.js', hat: /config\.termine\.formMinSekunden/ },
    { datei: 'server/services/termine/limits.js', hat: /const MAX_SCHLUESSEL = 10000/ },
    { datei: 'server/services/termine/limits.js', hat: /Ein Neustart des Prozesses leert alles/ },
    { datei: 'server/services/termine/outbox.js', hat: /Stundenbudget \(config\.termine\.mailsProStunde\)/ },
    { datei: 'server/services/termine/outbox.js', hat: /config\.termine\.mailsProFunktion/ },
  ],
  'Datenminimierung': [
    { datei: 'test/termineVertragsunterlagen.test.js', hat: /avv_keine_ip_in_buchung/ },
    { datei: 'server/services/termine/ablauf.js', hat: /datenschutz: sha256\(formularHinweis\(e\)\)/ },
    { datei: 'server/services/termine/einstellungen.js', hat: /wahl\(fehl, 'gastFelder\.telefon'/ },
    { datei: 'server/services/termine/outbox.js', hat: /status: 'gesendet',[\s\S]*?an: '',\s*html: '',\s*text: '',\s*ics: ''/ },
  ],
  'Trennung': [
    { datei: 'server/services/termine/schema.js', hat: /Eine Einstellung je Funktion; Dokument-ID = ID des portalFeatures-Dokuments/ },
    { datei: 'server/services/termine/schema.js', hat: /str\('featureId', 64\)/ },
    { datei: 'server/services/termine/buchungen.js', hat: /Query\.equal\('featureId', featureId\)/ },
    // die Hintergrundläufe arbeiten über alle Funktionen (Löschlauf ohne Funktionsfilter, Aufräumen der Warteschlange nach Status) und löschen Dokument für Dokument
    { datei: 'server/services/termine/buchungen.js', hat: /featureId === null \? \[\] : \[Query\.equal\('featureId', featureId\)\]/ },
    { datei: 'server/services/termine/outbox.js', hat: /Query\.equal\('status', \['gesendet', 'fehler', 'verworfen'\]\)/ },
  ],
  'Löschung': [
    { datei: 'server/index.js', hat: /setInterval\(termineTagesJob, 24 \* 60 \* 60 \* 1000\)/ },
    { datei: 'server/services/termine/jobs.js', hat: /Status und Bezugszeit noch einmal frisch geprueft/ },
    { datei: 'server/services/termine/jobs.js', hat: /im Zweifel wird nichts geloescht/ },
    { datei: 'server/services/termine/jobs.js', hat: /ABGESCHALTET_BEHALTEN_MS = LOESCHFRIST_TAGE \* TAG_MS/ },
    { datei: 'server/services/termine/entwuerfe.js', hat: /export const ENTWURF_TAGE = 90/ },
    { datei: 'server/services/termine/entwuerfe.js', hat: /const funktion = await holeOderNull\(config\.collections\.portalFeatures, id\)/ },
    // die Warteschlange löscht die gelisteten Einträge ohne erneutes Lesen (nur Buchungen, abgeschaltete Funktionen und Entwürfe lesen frisch)
    { datei: 'server/services/termine/outbox.js', hat: /await deleteDocument\(col\(\), eintrag\.\$id\)/ },
    // das Einrichtungs-Ticket (Kurzfassung der Einstellungen, ohne Daten von Gästen) bleibt als Arbeitsnachweis
    { datei: 'server/services/termine/ticketDetails.js', hat: /const \{ kurz \} = einbauanleitung\(/ },
    { datei: 'server/services/termine/einbauanleitung.js', hat: /const KURZ_NAMEN = 8 / },
  ],
  'Protokolle': [
    { datei: 'test/termineJobs.test.js', hat: /kein Gastname und keine Gastadresse im Log/ },
    { datei: 'test/termineBetrieb.test.js', hat: /keine Gastadresse und kein Gastname im Log/ },
    { datei: 'test/termineStatus.test.js', hat: /keine Gastadresse und kein Gastname im Log/ },
    { datei: 'public/abo-bedingungen.html', hat: /Server-Protokolle werden nach 14 Tagen gelöscht/ },
  ],
  'Datensicherung': [
    { datei: 'public/abo-bedingungen.html', hat: /Verfügbar sind jeweils die letzten sieben Tagessicherungen/ },
  ],
  'Rechenzentrum': [
    { datei: 'public/abo-bedingungen.html', hat: /Hetzner ist nach ISO\/IEC 27001 zertifiziert/ },
    { datei: 'public/abo-bedingungen.html', hat: /E-Mail-Postfächer \(Webhosting\)<\/td><td>Deutschland \(Rechenzentrum Nürnberg\)/ },
  ],
  'Organisation': [
    { datei: 'public/abo-bedingungen.html', hat: /Verpflichtung aller Beteiligten auf Vertraulichkeit/ },
    { datei: 'public/abo-bedingungen.html', hat: /Die Maßnahmen werden mindestens einmal im Jahr überprüft/ },
  ],
}

/** Die Zeilen der Anlage-Tabelle als { bereich: text }. */
function tomZeilen() {
  const anlage = AVV.abschnitte.find((a) => a.nummer === null && a.titel.startsWith('Anlage:'))
  assert.ok(anlage)
  const zeilen = anlage.zeilen.filter((z) => z.startsWith('|')).slice(2)
  return Object.fromEntries(zeilen.map((z) => {
    const [, bereich, text] = z.split('|').map((t) => t.trim())
    return [bereich, text]
  }))
}

test('avv_tom_fundstellen: jede Zeile der Anlage hat ihre Fundstellen im Code, in den Tests oder in den Abo-Bedingungen', () => {
  const zeilen = tomZeilen()
  assert.deepEqual(Object.keys(zeilen), Object.keys(TOM_FUNDSTELLEN), 'Zeilen der Anlage und Fundstellen-Tabelle stimmen überein (Reihenfolge eingeschlossen)')
  for (const [bereich, stellen] of Object.entries(TOM_FUNDSTELLEN)) {
    assert.ok(stellen.length >= 1, `${bereich}: keine Fundstelle`)
    assert.ok(zeilen[bereich].length > 40, `${bereich}: Text der Zeile fehlt`)
    for (const stelle of stellen) {
      const pfad = stelle.datei
      assert.ok(existsSync(new URL(`../${pfad}`, import.meta.url)), `${bereich}: ${pfad} gibt es nicht`)
      const quelle = lies(pfad)
      if (stelle.hat) assert.match(quelle, stelle.hat, `${bereich}: Fundstelle in ${pfad} fehlt (${stelle.hat})`)
      if (stelle.nicht) assert.doesNotMatch(quelle, stelle.nicht, `${bereich}: ${pfad} darf ${stelle.nicht} nicht enthalten`)
    }
  }
  // Aussagen mit Zahlen stehen in der Zeile und in der Fundstelle gleich
  assert.ok(zeilen['Protokolle'].includes('nach 14 Tagen gelöscht'))
  assert.ok(zeilen['Datensicherung'].includes('die letzten sieben Tagessicherungen'))
  assert.ok(zeilen['Rechenzentrum'].includes('ISO/IEC 27001') && zeilen['Rechenzentrum'].includes('Falkenstein und Nürnberg'))
  assert.ok(zeilen['Löschung'].includes('30 Tage nach dem Abschalten'))
  assert.ok(zeilen['Löschung'].includes('Vor der Löschung einer Buchung, einer abgeschalteten Funktion oder eines nicht bestellten Fragebogens wird der Zustand frisch gelesen'))
  assert.doesNotMatch(zeilen['Löschung'], /Vor jeder Löschung/)
  assert.ok(zeilen['Trennung'].includes('das Kundenportal und die öffentliche Schnittstelle lesen immer nur die Daten der jeweiligen Funktion.'))
  assert.ok(zeilen['Trennung'].includes('Die Hintergrundläufe (Löschung, Versand der E-Mails, Erinnerungen) gehen die Dokumente aller Funktionen nacheinander durch und schreiben jeweils nur in das Dokument, um das es geht.'))
  assert.doesNotMatch(zeilen['Trennung'], /Abfragen erfolgen nur je Funktion/)
  assert.ok(zeilen['Datenminimierung'].includes('der Fassung der Gästetexte, dem Zeitpunkt, dem Text des Buchungsknopfs, der Anrede und Hashes der übrigen gezeigten Texte'))
  assert.ok(zeilen['Speicher im Browser'].includes('keine Cookies'))
  assert.ok(zeilen['Zugriffskontrolle'].includes('konstanter Zeit'))
  assert.ok(zeilen['Organisation'].includes('Nummer 8 Abs. 3') && zeilen['Organisation'].includes('Nummer 8 Abs. 5'))
})