import { test, after, beforeEach, afterEach, mock } from 'node:test'
import assert from 'node:assert/strict'
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_DATETIMES } from '../server/services/termine/schema.js'

// Betrieb im Portal: Aktionen auf Buchungen (annehmen, ablehnen, absagen, verschieben, nichterschienen, anonymisieren),
// Termine von Hand und Sperren. Aufbau wie test/termineAblaufVerwalten.test.js: Nachbau von Appwrite mit Schema
// (Standard-Limit 25), Mails in der Senke, feste Zeiten per Parameter.
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 { deleteDocument } = await import('../server/services/appwriteAdmin.js')
const { setMailTransportForTests } = await import('../server/services/mailer.js')
const { normalisiereEinstellung } = await import('../server/services/termine/einstellungen.js')
const { resetOutboxForTests, warteAufVersand } = await import('../server/services/termine/outbox.js')
const { hashToken, verwaltungsToken, buchungsNummer } = await import('../server/services/termine/token.js')
const { speichereEinstellung, resetKontextForTests } = await import('../server/services/termine/kontext.js')
const { zellenFuer, zellenId } = await import('../server/services/termine/zellen.js')
const { resetTermineLimitsForTests } = await import('../server/services/termine/limits.js')
const { halte, vorschau, bestaetige, kannWiderrufen, verschiebeGast } = await import('../server/services/termine/ablauf.js')
const { aktion, manuell, sperre, entsperre } = await import('../server/services/termine/ablaufBetrieb.js')
after(() => setMailTransportForTests(null))

const MIN = 60000
const JETZT = new Date('2026-10-05T08:00:00.000Z') // Montag, 10:00 Berlin (MESZ)
const TAG_NAH = '2026-10-12' // Montag, 7 Tage spaeter: Beginn innerhalb der Widerrufsfrist
const TAG_FERN = '2026-10-26' // Montag, 21 Tage spaeter (MEZ)
const KUNDE = 'c_kunde01'
const PROJEKT = 'p_projekt01'
const FEATURE = 'f_p_projekt01_termine'
const R1 = 'r_aaaaaaa1'
const R2 = 'r_aaaaaaa2'
const S_SOFORT = 's_bbbbbbb1' // Damenschnitt, 45 + 5 Minuten, 45 Euro, sofort
const S_ANFRAGE = 's_bbbbbbb2' // Besichtigung, 60 Minuten, ohne Preis, Anfrage
const ABSENDER_VORHER = config.smtp.from
const MODUS_VORHER = config.termine.mode
const BASIS_VORHER = config.publicBaseUrl

const iso = (date) => new Date(date).toISOString()
const plus = (date, ms) => new Date(new Date(date).getTime() + ms)

const feature = (id = FEATURE) => ({ $id: id, customerId: KUNDE, projectId: PROJEKT, featureKey: 'termine', state: 'active', enabled: true, siteKey: 'abcdefghijklmnop' })

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']] } },
    { id: R2, name: 'Ben', plan: { 1: [['09:00', '18:00']] } },
  ],
  leistungen: [
    { id: S_SOFORT, name: 'Damenschnitt', dauer: 45, pufferNach: 5, preisArt: 'fest', preisCent: 4500, buchungsart: 'sofort', ressourcen: [R1, R2] },
    { id: S_ANFRAGE, name: 'Besichtigung', dauer: 60, preisArt: 'keiner', buchungsart: 'anfrage', ressourcen: [R1, R2] },
  ],
  regeln: { raster: 15, vorlaufMin: 120, horizontTage: 90, absageBisStd: 24, maxOffeneJeEmail: 3, personWaehlbar: true },
  gastFelder: { telefon: 'optional', nachricht: 'optional', zusatz: [{ key: 'marke', label: 'Marke', typ: 'text', pflicht: false }] },
  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 einstellung = (over) => {
  const erg = normalisiereEinstellung(eingabeEinstellung(over), { now: JETZT })
  assert.equal(erg.fehler, undefined, JSON.stringify(erg.fehler))
  return erg.einstellung
}
const ctxMit = (e = einstellung(), id = FEATURE) => ({ feature: feature(id), project: { $id: PROJEKT, subdomain: 'salon' }, einstellung: e, version: 1 })

/** Gastformular wie in den Gast-Tests: Montag in 3 Wochen, 10:00, Verbraucher, Stornohaken gesetzt. */
const eingabe = (over = {}) => ({
  leistung: S_SOFORT,
  ressource: R1,
  tag: TAG_FERN,
  zeit: '10:00',
  name: 'Max Mustermann',
  email: 'max@example.com',
  telefon: '0171 1234567',
  nachricht: '',
  zusatz: {},
  erinnerung: false,
  zustimmungen: { storno: true, vorzeitig: false },
  ...over,
})

/** Eingabe fuer einen Termin von Hand (keine Zustimmungen). */
const handEingabe = (over = {}) => ({
  leistung: S_SOFORT,
  ressource: R1,
  tag: TAG_FERN,
  zeit: '10:00',
  name: 'Paula Telefon',
  email: '',
  telefon: '06301 555',
  nachricht: '',
  zusatz: {},
  bestaetigungSenden: false,
  ...over,
})

let sink
let log
/** Die Einstellung wird gespeichert, damit die Token-Funktionen (kontextPerFeature) sie finden. */
async function speichere(e = einstellung()) {
  resetKontextForTests()
  const doc = aw.docs('termineConfig').get(FEATURE)
  await speichereEinstellung(feature(), e, { version: doc ? doc.version : 0, now: JETZT })
  return ctxMit(e)
}

beforeEach(async () => {
  for (const collection of ['portalFeatures', 'termineConfig', 'termineBookings', 'termineClaims', 'termineOutbox', 'customers', 'websiteProjects']) {
    for (const id of aw.docs(collection).keys()) await deleteDocument(collection, id)
  }
  resetKontextForTests()
  resetOutboxForTests()
  resetTermineLimitsForTests()
  config.termine.mode = 'pilot'
  config.smtp.from = 'noreply@webklar.com'
  config.publicBaseUrl = 'https://project.webklar.com'
  sink = mailSink()
  setMailTransportForTests(sink)
  log = { error: mock.method(console, 'error', () => {}), warn: mock.method(console, 'warn', () => {}) }
  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' })
})
afterEach(async () => {
  await warteAufVersand()
  mock.restoreAll()
  config.termine.mode = MODUS_VORHER
  config.smtp.from = ABSENDER_VORHER
  config.publicBaseUrl = BASIS_VORHER
})

const buchungen = () => [...aw.docs('termineBookings').values()]
const buchung = (id) => aw.docs('termineBookings').get(id)
const claims = (bookingId) => [...aw.docs('termineClaims').values()].filter((c) => c.bookingId === bookingId)
const eintraege = () => [...aw.docs('termineOutbox').values()]
const arten = () => eintraege().map((d) => d.art).sort()
const entfalte = (ics) => ics.replace(/\r\n /g, '')
const claimsStand = () => JSON.stringify([...aw.docs('termineClaims').entries()])
const an = (liste, adresse) => liste.filter((m) => m.to.some((t) => t.address === adresse))
const zeitenIso = (zellen) => zellen.map((c) => iso(c.zelle)).sort()
const linkIn = (mail) => /termin\.html#m=([A-Za-z0-9_-]{43})/.exec(mail.text)?.[1]

/** Fehler eines Aufrufs (status, fehler, code); schlaegt fehl, wenn nichts geworfen wird. */
async function fehlerVon(fn) {
  try {
    await fn()
  } catch (err) {
    return err
  }
  assert.fail('es wurde kein Fehler geworfen')
}

/** Haelt und bestaetigt einen Termin; => { id, buchung (frisch gelesen), verwaltung (Verwaltungstoken), token, mailStart }. */
async function gebucht(ctx, over = {}, now = JETZT) {
  await warteAufVersand() // Mails frueherer Aufrufe sind raus, bevor der Index der neuen gilt
  const vorher = sink.sent.length
  const erg = await halte(ctx, eingabe(over), now)
  await warteAufVersand()
  assert.equal(erg.status, 'gehalten')
  const token = /termin\.html#v=([A-Za-z0-9_-]{43})/.exec(sink.sent[vorher].text)[1]
  const gehalten = buchungen().find((b) => b.verifyHash === hashToken(token))
  assert.ok(gehalten, 'Buchung zum Token')
  const mailStart = sink.sent.length
  await bestaetige(token, now)
  await warteAufVersand()
  return { id: gehalten.$id, buchung: buchung(gehalten.$id), verwaltung: verwaltungsToken(gehalten.$id), token, mailStart }
}

/** Fehler im Postausgang simulieren: jede neue Mail scheitert beim Einreihen (Appwrite 500). */
async function mitDefektemPostausgang(fn) {
  const echt = globalThis.fetch
  globalThis.fetch = async (url, optionen) => {
    if (/\/collections\/termineOutbox\/documents/.test(String(url)) && optionen?.method === 'POST') {
      return new Response(JSON.stringify({ message: 'Server error', code: 500, type: 'general_server_error' }), { status: 500, headers: { 'content-type': 'application/json' } })
    }
    return echt(url, optionen)
  }
  try {
    return await fn()
  } finally {
    globalThis.fetch = echt
  }
}

// ---------------------------------------------------------------- annehmen

test('annehmen: angefragt => bestaetigt mit angenommenAt, G02 (Block anfrage_angenommen) mit Einladung und demselben Verwaltungslink wie G03', async () => {
  const ctx = await speichere()
  const { id, verwaltung } = await gebucht(ctx, { leistung: S_ANFRAGE })
  assert.equal(buchung(id).status, 'angefragt')
  const g03 = an(sink.sent, 'max@example.com').find((m) => /Terminanfrage/.test(m.subject))
  assert.equal(linkIn(g03), verwaltung)
  const standZellen = claimsStand()
  const vorher = sink.sent.length

  const jetzt = plus(JETZT, 60 * MIN)
  assert.deepEqual(await aktion(ctx, id, { aktion: 'annehmen' }, jetzt), { status: 'bestaetigt' })
  await warteAufVersand()

  const nachher = buchung(id)
  assert.equal(nachher.status, 'bestaetigt')
  assert.equal(iso(nachher.angenommenAt), iso(jetzt))
  assert.equal(nachher.bestaetigtAt, undefined, 'der Vertrag kommt bei einer Anfrage erst mit der Annahme zustande')
  assert.equal(iso(nachher.updatedAt), iso(jetzt))
  assert.equal(claimsStand(), standZellen, 'die Zellen bleiben')
  assert.equal(kannWiderrufen(nachher, plus(jetzt, 2 * 24 * 60 * MIN)), true, 'die Widerrufsfrist laeuft ab der Annahme')

  const neu = sink.sent.slice(vorher)
  assert.equal(neu.length, 1, 'nur G02, kein K20/K21')
  const g02 = neu[0]
  assert.equal(g02.to[0].address, 'max@example.com')
  assert.equal(g02.subject, 'Ihr Termin bei Salon Müller am 26.10.2026')
  assert.match(g02.text, /Salon Müller hat Ihre Terminanfrage angenommen/)
  assert.equal(linkIn(g02), verwaltung, 'derselbe Verwaltungslink wie in G03')
  assert.equal(g02.icalEvent.method, 'REQUEST')
  const ics = entfalte(g02.icalEvent.content)
  assert.match(ics, /SEQUENCE:0\r\n/)
  assert.match(ics, new RegExp(`UID:${id}@termine.webklar.com`))
  assert.deepEqual(arten(), ['G01', 'G02', 'G03', 'K20'])

  // der Link aus der Mail funktioniert: Verwaltung zeigt den bestaetigten Termin
  assert.equal((await vorschau(verwaltung, jetzt)).status, 'bestaetigt')
})

test('annehmen: zweiter Klick meldet schon; nur Anfragen; eine Anfrage mit vergangenem Beginn nicht; nichts wird gesendet', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx, { leistung: S_ANFRAGE })
  await aktion(ctx, id, { aktion: 'annehmen' }, JETZT)
  await warteAufVersand()
  const mails = sink.sent.length
  assert.deepEqual(await aktion(ctx, id, { aktion: 'annehmen' }, plus(JETZT, MIN)), { status: 'bestaetigt', schon: true })
  await warteAufVersand()
  assert.equal(sink.sent.length, mails)

  // eine sofort gebuchte Leistung ist keine Anfrage
  const sofort = await gebucht(ctx, { email: 'zwei@example.com', zeit: '12:00' })
  const err = await fehlerVon(() => aktion(ctx, sofort.id, { aktion: 'annehmen' }, JETZT))
  assert.equal(err.status, 409)
  assert.equal(err.code, 'nicht_moeglich')
  assert.deepEqual(err.fehler, { _: 'Diese Anfrage ist nicht mehr offen.' })

  // Beginn schon vorbei (der Minutenjob hat die Anfrage noch nicht abgelehnt)
  const alt = await gebucht(ctx, { leistung: S_ANFRAGE, email: 'drei@example.com', zeit: '14:00' })
  const spaet = plus(new Date(alt.buchung.startsAt), MIN)
  const vorbei = await fehlerVon(() => aktion(ctx, alt.id, { aktion: 'annehmen' }, spaet))
  assert.equal(vorbei.status, 409)
  assert.equal(vorbei.code, 'vergangen')
  assert.equal(buchung(alt.id).status, 'angefragt')
})

// ---------------------------------------------------------------- ablehnen

test('ablehnen: abgelehnt, Zellen frei, G04 mit der Nachricht des Betriebs; die Zeit ist wieder buchbar', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx, { leistung: S_ANFRAGE })
  assert.equal(claims(id).length, 12)
  const vorher = sink.sent.length

  const jetzt = plus(JETZT, 30 * MIN)
  assert.deepEqual(await aktion(ctx, id, { aktion: 'ablehnen', nachricht: 'Am Montag sind wir im Urlaub.' }, jetzt), { status: 'abgelehnt' })
  await warteAufVersand()

  assert.equal(buchung(id).status, 'abgelehnt')
  assert.equal(iso(buchung(id).updatedAt), iso(jetzt))
  assert.equal(claims(id).length, 0)
  const neu = sink.sent.slice(vorher)
  assert.equal(neu.length, 1)
  assert.equal(neu[0].to[0].address, 'max@example.com')
  assert.equal(neu[0].subject, 'Ihre Terminanfrage bei Salon Müller – leider abgelehnt')
  assert.match(neu[0].text, /leider kann Salon Müller Ihre Terminanfrage nicht annehmen/)
  assert.match(neu[0].text, /Am Montag sind wir im Urlaub\./)
  assert.equal('icalEvent' in neu[0], false)

  assert.equal((await halte(ctx, eingabe({ leistung: S_ANFRAGE, email: 'zwei@example.com' }), jetzt)).status, 'gehalten')
  assert.deepEqual(await aktion(ctx, id, { aktion: 'ablehnen' }, plus(jetzt, MIN)), { status: 'abgelehnt', schon: true })
})

test('ablehnen: ohne Nachricht kein Nachrichtenblock; bestaetigte Termine lassen sich nicht ablehnen', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx, { leistung: S_ANFRAGE })
  const vorher = sink.sent.length
  await aktion(ctx, id, { aktion: 'ablehnen' }, JETZT)
  await warteAufVersand()
  assert.doesNotMatch(sink.sent[vorher].text, /Nachricht von/i)

  const sofort = await gebucht(ctx, { email: 'zwei@example.com', zeit: '12:00' })
  const err = await fehlerVon(() => aktion(ctx, sofort.id, { aktion: 'ablehnen' }, JETZT))
  assert.equal(err.code, 'nicht_moeglich')
  assert.equal(buchung(sofort.id).status, 'bestaetigt')
  assert.equal(claims(sofort.id).length, 10)
})

// ---------------------------------------------------------------- absagen

test('absagen: abgesagt von betrieb mit Grund, Zellen frei, G06 mit Betriebsname, Grund, Nachricht und Kalenderabsage; kein K21; keine Frist', async () => {
  const ctx = await speichere()
  const { id, buchung: b, mailStart } = await gebucht(ctx)
  assert.equal(claims(id).length, 10)

  // eine Stunde vor dem Termin: der Gast koennte nicht mehr absagen, der Betrieb schon
  const jetzt = plus(new Date(b.startsAt), -60 * MIN)
  assert.deepEqual(await aktion(ctx, id, { aktion: 'absagen', grund: 'Krankheit', nachricht: 'Gute Besserung wuenschen wir.' }, jetzt), { status: 'abgesagt' })
  await warteAufVersand()

  const nachher = buchung(id)
  assert.equal(nachher.status, 'abgesagt')
  assert.equal(nachher.abgesagtVon, 'betrieb')
  assert.equal(nachher.absageGrund, 'Krankheit')
  assert.equal(iso(nachher.abgesagtAt), iso(jetzt))
  assert.equal(nachher.widerrufenAt, undefined)
  assert.equal(claims(id).length, 0)

  const neu = sink.sent.slice(mailStart + 2) // G02 und K20 der Bestaetigung ausgenommen
  assert.equal(neu.length, 1, 'nur G06 an den Gast, kein K21')
  const g06 = neu[0]
  assert.equal(g06.to[0].address, 'max@example.com')
  assert.equal(g06.subject, 'Ihr Termin am 26.10.2026 wurde abgesagt')
  assert.match(g06.text, /Salon Müller/)
  assert.doesNotMatch(g06.text, /Sie selbst/)
  assert.match(g06.text, /Krankheit/)
  assert.match(g06.text, /Gute Besserung wuenschen wir\./)
  assert.equal(g06.icalEvent.method, 'CANCEL')
  assert.match(entfalte(g06.icalEvent.content), /SEQUENCE:1\r\n/)
  assert.deepEqual(arten(), ['G01', 'G02', 'G06', 'K20'])

  assert.deepEqual(await aktion(ctx, id, { aktion: 'absagen', grund: 'Krankheit' }, plus(jetzt, MIN)), { status: 'abgesagt', schon: true })
})

test('absagen: Grund ist Pflicht (400 Feld grund), zu lange Texte werden abgelehnt, nichts aendert sich', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx)
  const standZellen = claimsStand()
  const vorher = sink.sent.length
  for (const [feld, roh] of [
    ['grund', { aktion: 'absagen' }],
    ['grund', { aktion: 'absagen', grund: '   ' }],
    ['grund', { aktion: 'absagen', grund: 7 }],
    ['grund', { aktion: 'absagen', grund: 'x'.repeat(101) }],
    ['nachricht', { aktion: 'absagen', grund: 'Krankheit', nachricht: 'y'.repeat(501) }],
  ]) {
    const err = await fehlerVon(() => aktion(ctx, id, roh, JETZT))
    assert.equal(err.status, 400, JSON.stringify(roh).slice(0, 60))
    assert.deepEqual(Object.keys(err.fehler), [feld])
  }
  assert.equal(buchung(id).status, 'bestaetigt')
  assert.equal(claimsStand(), standZellen)
  await warteAufVersand()
  assert.equal(sink.sent.length, vorher)
})

test('absagen: eine Anfrage (nie eine Einladung erhalten) bekommt G06 ohne Kalenderdatei (R21); erledigte Termine lassen sich nicht absagen', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx, { leistung: S_ANFRAGE })
  const vorher = sink.sent.length
  await aktion(ctx, id, { aktion: 'absagen', grund: 'Betriebsstoerung' }, JETZT)
  await warteAufVersand()
  const g06 = sink.sent.slice(vorher)[0]
  assert.equal(g06.subject, 'Ihr Termin am 26.10.2026 wurde abgesagt')
  assert.equal('icalEvent' in g06, false)
  assert.equal(buchung(id).status, 'abgesagt')
  assert.equal(claims(id).length, 0)

  const zwei = await gebucht(ctx, { email: 'zwei@example.com', zeit: '12:00' })
  aw.seed('termineBookings', { ...buchung(zwei.id), status: 'erledigt' })
  const err = await fehlerVon(() => aktion(ctx, zwei.id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT))
  assert.equal(err.status, 409)
  assert.equal(err.code, 'nicht_moeglich')
})

// ---------------------------------------------------------------- verschieben

test('verschieben: wie beim Gast (10:00 -> 10:30 ueberlappend), Sequenz + 1, neue Zellen, G07 mit Einladung, kein K21', async () => {
  const ctx = await speichere()
  const { id, buchung: alt, mailStart } = await gebucht(ctx)
  const altZellen = zeitenIso(claims(id))

  const jetzt = plus(JETZT, 60 * MIN)
  const erg = await aktion(ctx, id, { aktion: 'verschieben', tag: TAG_FERN, zeit: '10:30' }, jetzt)
  await warteAufVersand()
  assert.equal(erg.status, 'bestaetigt')
  assert.match(erg.termin.datum, /26\.10\.2026/)
  assert.equal(erg.termin.zeit, '10:30')

  const nachher = buchung(id)
  assert.equal(iso(nachher.startsAt), '2026-10-26T09:30:00.000Z')
  assert.equal(iso(nachher.endsAt), '2026-10-26T10:15:00.000Z')
  assert.equal(iso(nachher.blockEndsAt), '2026-10-26T10:20:00.000Z')
  assert.equal(nachher.icsSequenz, alt.icsSequenz + 1)
  assert.equal(nachher.status, 'bestaetigt')
  const neuZellen = zeitenIso(zellenFuer(nachher.startsAt, nachher.blockEndsAt).map((z) => ({ zelle: z })))
  assert.deepEqual(zeitenIso(claims(id)), neuZellen)
  assert.notDeepEqual(zeitenIso(claims(id)), altZellen)

  const neu = sink.sent.slice(mailStart + 2)
  assert.equal(neu.length, 1)
  assert.equal(neu[0].subject, 'Ihr Termin wurde verschoben')
  assert.equal(neu[0].icalEvent.method, 'REQUEST')
  assert.match(entfalte(neu[0].icalEvent.content), /SEQUENCE:1\r\n/)
  assert.deepEqual(arten(), ['G01', 'G02', 'G07', 'K20'])
})

test('verschieben: der Betrieb darf in den Vorlauf, ueber den Horizont und in die Widerrufsfrist, der Gast nicht', async () => {
  const ctx = await speichere()
  const { id, verwaltung } = await gebucht(ctx) // TAG_FERN ohne Zustimmung zum vorzeitigen Beginn
  const zurueck = () => aktion(ctx, id, { aktion: 'verschieben', tag: TAG_FERN, zeit: '10:00' }, JETZT)

  // Vorlauf (120 Minuten): heute 11:00
  const vorlauf = await fehlerVon(() => verschiebeGast(verwaltung, { tag: '2026-10-05', zeit: '11:00' }, JETZT))
  assert.equal(vorlauf.code, 'SLOT_VERGEBEN')
  await aktion(ctx, id, { aktion: 'verschieben', tag: '2026-10-05', zeit: '11:00' }, JETZT)
  assert.equal(iso(buchung(id).startsAt), '2026-10-05T09:00:00.000Z')
  await zurueck()

  // Horizont (90 Tage)
  const weit = '2027-02-01'
  assert.equal((await fehlerVon(() => verschiebeGast(verwaltung, { tag: weit, zeit: '10:00' }, JETZT))).code, 'SLOT_VERGEBEN')
  await aktion(ctx, id, { aktion: 'verschieben', tag: weit, zeit: '10:00' }, JETZT)
  assert.equal(iso(buchung(id).startsAt), '2027-02-01T09:00:00.000Z')
  await zurueck()

  // Termin innerhalb der Widerrufsfrist ohne Zustimmung zum vorzeitigen Beginn
  assert.equal((await fehlerVon(() => verschiebeGast(verwaltung, { tag: TAG_NAH, zeit: '10:00' }, JETZT))).code, 'zustimmung_noetig')
  await aktion(ctx, id, { aktion: 'verschieben', tag: TAG_NAH, zeit: '10:00' }, JETZT)
  assert.equal(iso(buchung(id).startsAt), '2026-10-12T08:00:00.000Z')
  assert.equal(claims(id).length, 10)
})

test('verschieben: nie in die Vergangenheit, nie auf belegte Zellen, nie auf dieselbe Zeit; alles bleibt wie es war', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx)
  await gebucht(ctx, { email: 'zwei@example.com', zeit: '14:00' }) // R1 14:00-14:50
  const standZellen = claimsStand()
  const stand = JSON.stringify(buchung(id))
  const vorher = sink.sent.length

  for (const [roh, status, feld] of [
    [{ tag: '2026-10-05', zeit: '09:00' }, 409, 'zeit'], // heute, vor jetzt (10:00)
    [{ tag: '2026-10-04', zeit: '10:00' }, 409, 'zeit'], // gestern
    [{ tag: TAG_FERN, zeit: '14:15' }, 409, 'zeit'], // ueberlappt den Termin um 14:00
    [{ tag: TAG_FERN, zeit: '08:00' }, 409, 'zeit'], // vor der Oeffnung
    [{ tag: '2026-10-27', zeit: '10:00' }, 409, 'zeit'], // Dienstag, kein Plan
    [{ tag: TAG_FERN, zeit: '10:00' }, 400, 'zeit'], // dieselbe Zeit
    [{ tag: 'kaputt', zeit: '10:00' }, 400, 'tag'],
    [{ tag: TAG_FERN, zeit: '25:00' }, 400, 'zeit'],
  ]) {
    const err = await fehlerVon(() => aktion(ctx, id, { aktion: 'verschieben', ...roh }, JETZT))
    assert.equal(err.status, status, JSON.stringify(roh))
    assert.deepEqual(Object.keys(err.fehler), [feld], JSON.stringify(roh))
  }
  assert.equal(JSON.stringify(buchung(id)), stand)
  assert.equal(claimsStand(), standZellen)
  await warteAufVersand()
  assert.equal(sink.sent.length, vorher)
})

test('verschieben: eine Anfrage bekommt G07 ohne Kalenderdatei (R21), ein abgesagter Termin laesst sich nicht verschieben', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx, { leistung: S_ANFRAGE })
  const vorher = sink.sent.length
  await aktion(ctx, id, { aktion: 'verschieben', tag: TAG_FERN, zeit: '11:00' }, JETZT)
  await warteAufVersand()
  const g07 = sink.sent.slice(vorher)[0]
  assert.equal(g07.subject, 'Ihr Termin wurde verschoben')
  assert.equal('icalEvent' in g07, false)
  assert.equal(buchung(id).status, 'angefragt')

  await aktion(ctx, id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT)
  const err = await fehlerVon(() => aktion(ctx, id, { aktion: 'verschieben', tag: TAG_FERN, zeit: '12:00' }, JETZT))
  assert.equal(err.code, 'nicht_moeglich')
})

// ---------------------------------------------------------------- nichterschienen, anonymisieren

test('nichterschienen: vor Beginn 409, danach nichterschienen (Zellen frei); zweiter Klick meldet schon', async () => {
  const ctx = await speichere()
  const { id, buchung: b } = await gebucht(ctx)
  const standZellen = claimsStand()

  const err = await fehlerVon(() => aktion(ctx, id, { aktion: 'nichterschienen' }, JETZT))
  assert.equal(err.status, 409)
  assert.equal(err.code, 'vor_beginn')
  assert.deepEqual(err.fehler, { _: 'Das geht erst, wenn der Termin begonnen hat.' })
  assert.equal(buchung(id).status, 'bestaetigt')
  assert.equal(claimsStand(), standZellen)
  assert.equal((await fehlerVon(() => aktion(ctx, id, { aktion: 'nichterschienen' }, plus(new Date(b.startsAt), -1)))).code, 'vor_beginn')

  const beginn = new Date(b.startsAt)
  assert.deepEqual(await aktion(ctx, id, { aktion: 'nichterschienen' }, beginn), { status: 'nichterschienen' })
  assert.equal(buchung(id).status, 'nichterschienen')
  assert.equal(claims(id).length, 0)
  assert.deepEqual(await aktion(ctx, id, { aktion: 'nichterschienen' }, plus(beginn, MIN)), { status: 'nichterschienen', schon: true })

  // auch nach dem automatischen Erledigen noch moeglich; abgesagte Termine nicht
  const zwei = await gebucht(ctx, { email: 'zwei@example.com', zeit: '12:00' })
  aw.seed('termineBookings', { ...buchung(zwei.id), status: 'erledigt' })
  assert.deepEqual(await aktion(ctx, zwei.id, { aktion: 'nichterschienen' }, plus(new Date(zwei.buchung.endsAt), 90 * MIN)), { status: 'nichterschienen' })
  const drei = await gebucht(ctx, { email: 'drei@example.com', zeit: '14:00' })
  await aktion(ctx, drei.id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT)
  assert.equal((await fehlerVon(() => aktion(ctx, drei.id, { aktion: 'nichterschienen' }, plus(new Date(drei.buchung.startsAt), MIN)))).code, 'nicht_moeglich')
})

test('anonymisieren: Gastfelder leer ("Gelöscht"), Status und Zeiten bleiben, Links ungueltig, keine Erinnerung, keine Mail', async () => {
  const ctx = await speichere()
  const { id, buchung: b, verwaltung } = await gebucht(ctx, { erinnerung: true, nachricht: 'Bitte ohne Foehn.', zusatz: { marke: 'Wella' } })
  assert.equal(b.erinnerung, true)
  const vorher = sink.sent.length

  const jetzt = plus(JETZT, 5 * 24 * 60 * MIN)
  assert.deepEqual(await aktion(ctx, id, { aktion: 'anonymisieren' }, jetzt), { status: 'bestaetigt' })
  await warteAufVersand()
  const nachher = buchung(id)
  assert.equal(nachher.gastName, 'Gelöscht')
  for (const feld of ['gastEmail', 'gastTelefon', 'gastNachricht', 'gastZusatz', 'verifyHash', 'manageHash']) assert.equal(nachher[feld], '', feld)
  assert.equal(nachher.erinnerung, false)
  assert.equal(nachher.status, 'bestaetigt')
  assert.equal(iso(nachher.startsAt), iso(b.startsAt))
  assert.equal(iso(nachher.endsAt), iso(b.endsAt))
  assert.equal(claims(id).length, 10)
  assert.equal(sink.sent.length, vorher)
  assert.equal((await fehlerVon(() => vorschau(verwaltung, jetzt))).status, 404, 'der alte Link gilt nicht mehr')

  // zweiter Aufruf aendert nichts; ohne Adresse gehen weitere Aktionen ohne Mail durch
  assert.deepEqual(await aktion(ctx, id, { aktion: 'anonymisieren' }, plus(jetzt, MIN)), { status: 'bestaetigt' })
  await aktion(ctx, id, { aktion: 'absagen', grund: 'Krankheit' }, plus(jetzt, 2 * MIN))
  await warteAufVersand()
  assert.equal(sink.sent.length, vorher, 'ohne Adresse keine G06')
  assert.equal(log.error.mock.callCount(), 0)
})

test('anonymisieren: bei abgesagten Terminen bleibt updatedAt (die Loeschfrist laeuft weiter); eine Haltung bleibt unberuehrt', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx)
  await aktion(ctx, id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT)
  const abgesagtUm = iso(buchung(id).updatedAt)
  await aktion(ctx, id, { aktion: 'anonymisieren' }, plus(JETZT, 10 * 24 * 60 * MIN))
  assert.equal(buchung(id).status, 'abgesagt')
  assert.equal(buchung(id).gastName, 'Gelöscht')
  assert.equal(iso(buchung(id).updatedAt), abgesagtUm)

  await halte(ctx, eingabe({ email: 'zwei@example.com', zeit: '12:00' }), JETZT)
  const gehalten = buchungen().find((b) => b.status === 'gehalten')
  const err = await fehlerVon(() => aktion(ctx, gehalten.$id, { aktion: 'anonymisieren' }, JETZT))
  assert.equal(err.code, 'nicht_moeglich')
  assert.equal(buchung(gehalten.$id).gastEmail, 'zwei@example.com')
})

test('anonymisieren: absageGrund wird neutralisiert (auch der Vermerk "Widerruf erklärt von: <Name>"), Betriebsgründe ebenso', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx)
  const abgesagtUm = iso(plus(JETZT, MIN))
  // Vermerk einer Widerrufserklaerung nach Fristablauf (haltWiderrufFest): der Gast hat den Namen selbst getippt
  aw.seed('termineBookings', { ...buchung(id), absageGrund: 'Widerruf erklärt von: Max Mustermann am 20.10.2026, 11:00 Uhr (nach Fristablauf)', updatedAt: abgesagtUm })
  assert.match(buchung(id).absageGrund, /Max Mustermann/)
  await aktion(ctx, id, { aktion: 'anonymisieren' }, plus(JETZT, 5 * MIN))
  assert.equal(buchung(id).absageGrund, '')
  assert.doesNotMatch(JSON.stringify(buchung(id)), /Mustermann|max@example\.com/)

  // abgesagt vom Betrieb: der Grund war frei getippt und kann Namen enthalten; die Frist (updatedAt) bleibt
  const zwei = await gebucht(ctx, { email: 'zwei@example.com', zeit: '12:00' })
  await aktion(ctx, zwei.id, { aktion: 'absagen', grund: 'Frau Meier ist krank' }, JETZT)
  assert.equal(buchung(zwei.id).absageGrund, 'Frau Meier ist krank')
  const abgesagtZwei = iso(buchung(zwei.id).updatedAt)
  await aktion(ctx, zwei.id, { aktion: 'anonymisieren' }, plus(JETZT, 10 * 24 * 60 * MIN))
  assert.equal(buchung(zwei.id).absageGrund, '')
  assert.equal(buchung(zwei.id).status, 'abgesagt')
  assert.equal(iso(buchung(zwei.id).updatedAt), abgesagtZwei)
})

test('anonymisieren: noch nicht versandte Mails dieser Buchung (wartet) werden gelöscht; gesendete, fehlgeschlagene und fremde Einträge bleiben', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx)
  const { id: anderer } = await gebucht(ctx, { email: 'zwei@example.com', zeit: '12:00' })
  await warteAufVersand()
  const vorher = eintraege().length
  const voll = { featureId: FEATURE, art: 'G05', an: 'max@example.com', fromName: 'Salon Müller', subject: 'Erinnerung', html: '<p>Hallo Max Mustermann</p>', text: 'Hallo Max Mustermann', ics: '', icsMethod: '', versuche: 0, naechsterVersuch: iso(JETZT), fehler: '', createdAt: iso(JETZT) }
  aw.seed('termineOutbox', { ...voll, $id: 'o_wartet1', bookingId: id, status: 'wartet' })
  aw.seed('termineOutbox', { ...voll, $id: 'o_wartet2', bookingId: id, status: 'wartet', art: 'G03' })
  aw.seed('termineOutbox', { ...voll, $id: 'o_gesendet', bookingId: id, status: 'gesendet', an: '', html: '', text: '' })
  aw.seed('termineOutbox', { ...voll, $id: 'o_fehler', bookingId: id, status: 'fehler' })
  aw.seed('termineOutbox', { ...voll, $id: 'o_fremd', bookingId: anderer, status: 'wartet', an: 'zwei@example.com' })

  await aktion(ctx, id, { aktion: 'anonymisieren' }, plus(JETZT, 5 * MIN))
  const ids = eintraege().map((d) => d.$id)
  assert.ok(!ids.includes('o_wartet1') && !ids.includes('o_wartet2'), 'wartende Mails mit Adresse und Inhalt sind weg')
  assert.ok(ids.includes('o_gesendet') && ids.includes('o_fehler') && ids.includes('o_fremd'))
  assert.equal(eintraege().length, vorher + 3)
  assert.equal(buchung(id).gastName, 'Gelöscht')

  // zweiter Klick: nichts mehr zu loeschen, kein Fehler
  assert.deepEqual(await aktion(ctx, id, { aktion: 'anonymisieren' }, plus(JETZT, 6 * MIN)), { status: 'bestaetigt' })
  assert.equal(eintraege().length, vorher + 3)
})

// ---------------------------------------------------------------- aktion allgemein

test('aktion: fremde Funktion, Sperren, unbekannte Nummern und kaputte Eingaben aendern nichts', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx)
  const standZellen = claimsStand()
  const stand = JSON.stringify(buchung(id))

  const fremd = ctxMit(einstellung(), 'f_andere_funktion')
  const err = await fehlerVon(() => aktion(fremd, id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT))
  assert.equal(err.status, 404)
  assert.equal(err.code, 'unbekannt')
  assert.deepEqual(err.fehler, { _: 'Diesen Termin gibt es nicht.' })
  for (const falsch of ['gibt-es-nicht', '', null, undefined, 42, '../x', 'a'.repeat(40)]) {
    assert.equal((await fehlerVon(() => aktion(ctx, falsch, { aktion: 'absagen', grund: 'Krankheit' }, JETZT))).status, 404, String(falsch))
  }

  for (const roh of [undefined, null, 'absagen', [], {}, { aktion: 'loeschen' }, { aktion: 7 }]) {
    const e = await fehlerVon(() => aktion(ctx, id, roh, JETZT))
    assert.equal(e.status, 400, JSON.stringify(roh))
  }
  assert.equal(JSON.stringify(buchung(id)), stand)
  assert.equal(claimsStand(), standZellen)

  const s = await sperre(ctx, { ressource: R2, tag: TAG_FERN, von: '09:00', bis: '10:00', titel: 'Pause' }, JETZT)
  assert.equal((await fehlerVon(() => aktion(ctx, s.id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT))).status, 404, 'eine Sperre ist keine Buchung')
  assert.equal(buchung(s.id).status, 'bestaetigt')

  await assert.rejects(() => aktion(ctx, id, { aktion: 'anonymisieren' }, undefined), TypeError)
  await assert.rejects(() => aktion({ feature: ctx.feature }, id, { aktion: 'anonymisieren' }, JETZT), TypeError)
})

test('aktion: scheitert die Mail beim Einreihen, bleibt die Aenderung bestehen und der Fehler steht im Log', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx, { leistung: S_ANFRAGE })
  const erg = await mitDefektemPostausgang(() => aktion(ctx, id, { aktion: 'annehmen' }, JETZT))
  assert.deepEqual(erg, { status: 'bestaetigt' })
  assert.equal(buchung(id).status, 'bestaetigt')
  assert.ok(log.error.mock.calls.some((c) => /G02 nicht eingereiht/.test(String(c.arguments[0]))))
  assert.ok(!log.error.mock.calls.some((c) => /max@example\.com/.test(String(c.arguments[0]))), 'keine Adresse im Log')
})

test('aktion: parallele Aktionen auf dieselbe Buchung ergeben genau einen Endzustand', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx, { leistung: S_ANFRAGE })
  const erg = await Promise.allSettled([
    aktion(ctx, id, { aktion: 'annehmen' }, JETZT),
    aktion(ctx, id, { aktion: 'ablehnen' }, JETZT),
    aktion(ctx, id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT),
  ])
  await warteAufVersand()
  const gut = erg.filter((e) => e.status === 'fulfilled' && !e.value.schon)
  assert.equal(gut.length >= 1, true)
  const endzustand = buchung(id).status
  assert.ok(['bestaetigt', 'abgelehnt', 'abgesagt'].includes(endzustand))
  // genau die Mail zum Endzustand plus hoechstens die der Annahme, wenn danach abgesagt wurde
  const gast = arten().filter((a) => ['G02', 'G04', 'G06'].includes(a))
  assert.ok(gast.length >= 1 && gast.length <= 2, gast.join(','))
  if (endzustand === 'abgelehnt') assert.deepEqual(gast, ['G04'])
  if (endzustand !== 'bestaetigt') assert.equal(claims(id).length, 0)
})

// ---------------------------------------------------------------- manuell

test('manuell: quelle manuell, bestaetigt, kein Verbraucher, Zellen, ohne Haken keine Mail', async () => {
  const ctx = await speichere()
  const erg = await manuell(ctx, handEingabe({ email: 'paula@example.com', zusatz: { marke: 'Schwarzkopf' } }), JETZT)
  await warteAufVersand()
  assert.equal(erg.status, 'bestaetigt')
  assert.equal(erg.nummer, buchungsNummer(erg.id))

  const b = buchung(erg.id)
  assert.equal(b.quelle, 'manuell')
  assert.equal(b.status, 'bestaetigt')
  assert.equal(b.verbraucher, false)
  assert.equal(b.featureId, FEATURE)
  assert.equal(b.customerId, KUNDE)
  assert.equal(b.projectId, PROJEKT)
  assert.equal(b.leistungId, S_SOFORT)
  assert.equal(b.leistungName, 'Damenschnitt')
  assert.equal(b.ressourceId, R1)
  assert.equal(b.ressourceName, 'Anna')
  assert.equal(iso(b.startsAt), '2026-10-26T09:00:00.000Z')
  assert.equal(iso(b.endsAt), '2026-10-26T09:45:00.000Z')
  assert.equal(iso(b.blockEndsAt), '2026-10-26T09:50:00.000Z')
  assert.equal(b.gastName, 'Paula Telefon')
  assert.equal(b.gastEmail, 'paula@example.com')
  assert.equal(b.gastTelefon, '06301 555')
  assert.deepEqual(JSON.parse(b.gastZusatz), { marke: 'Schwarzkopf' })
  assert.equal(b.erinnerung, false)
  assert.equal(iso(b.bestaetigtAt), iso(JETZT))
  assert.equal(b.manageHash, hashToken(verwaltungsToken(erg.id)))
  assert.equal(b.icsSequenz, 0)
  assert.equal(b.preisCent, 4500)
  assert.equal(claims(erg.id).length, 10)
  assert.equal(kannWiderrufen(b, JETZT), false, 'ein Handeintrag hat kein Widerrufsrecht')
  assert.equal(sink.sent.length, 0, 'ohne Haken keine Gastmail (und kein K20 an den Betrieb)')
  assert.equal(eintraege().length, 0)

  // die Zeit ist belegt
  assert.equal((await fehlerVon(() => halte(ctx, eingabe({ email: 'zwei@example.com', zustimmungen: { storno: true, vorzeitig: false } }), JETZT))).code, 'SLOT_VERGEBEN')
})

test('manuell: mit Haken und Adresse geht G02 mit Einladung und funktionierendem Verwaltungslink, ohne Widerrufsbelehrung', async () => {
  const ctx = await speichere()
  const erg = await manuell(ctx, handEingabe({ email: ' Paula@Example.com ', bestaetigungSenden: true }), JETZT)
  await warteAufVersand()
  assert.equal(buchung(erg.id).gastEmail, 'paula@example.com')
  assert.equal(sink.sent.length, 1)
  const g02 = sink.sent[0]
  assert.equal(g02.to[0].address, 'paula@example.com')
  assert.equal(g02.subject, 'Ihr Termin bei Salon Müller am 26.10.2026')
  assert.doesNotMatch(g02.text, /angenommen/)
  assert.doesNotMatch(g02.text, /Widerruf/)
  assert.equal(g02.icalEvent.method, 'REQUEST')
  assert.match(entfalte(g02.icalEvent.content), /SEQUENCE:0\r\n/)
  assert.deepEqual(arten(), ['G02'])
  const link = linkIn(g02)
  assert.equal(link, verwaltungsToken(erg.id))
  const v = await vorschau(link, JETZT)
  assert.equal(v.art, 'verwalten')
  assert.equal(v.aktionen.widerrufen, false)
})

test('manuell: der Haken "Bestaetigung senden" braucht eine Adresse (400 Feld email, nichts angelegt); ohne Haken geht der Eintrag ohne Adresse', async () => {
  const ctx = await speichere()
  for (const email of [undefined, null, '', '   ']) {
    const err = await fehlerVon(() => manuell(ctx, handEingabe({ email, bestaetigungSenden: true }), JETZT))
    assert.equal(err.status, 400)
    assert.deepEqual(err.fehler, { email: 'Für die Bestätigung braucht der Gast eine E-Mail-Adresse.' })
  }
  assert.equal(buchungen().length, 0)
  assert.equal(aw.docs('termineClaims').size, 0)

  const erg = await manuell(ctx, handEingabe({ bestaetigungSenden: false }), JETZT)
  await warteAufVersand()
  assert.equal(buchung(erg.id).gastEmail, '')
  assert.equal(sink.sent.length, 0)
  assert.equal(log.error.mock.callCount(), 0)
  // ohne Adresse gehen auch spaetere Aktionen ohne Mail durch
  await aktion(ctx, erg.id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT)
  await warteAufVersand()
  assert.equal(sink.sent.length, 0)
  assert.equal(buchung(erg.id).status, 'abgesagt')
})

test('manuell: Pflicht ist nur der Name; E-Mail, Telefon, Nachricht und Zusatzfelder sind freiwillig, egal was gastFelder fuer Gaeste verlangt', async () => {
  const pflicht = await speichere(einstellung({
    gastFelder: { telefon: 'pflicht', nachricht: 'pflicht', zusatz: [{ key: 'marke', label: 'Marke', typ: 'text', pflicht: true }] },
  }))
  // nur der Name
  const nurName = await manuell(pflicht, { leistung: S_SOFORT, ressource: R1, tag: TAG_FERN, zeit: '10:00', name: 'Laufkunde' }, JETZT)
  const b = buchung(nurName.id)
  assert.equal(b.gastName, 'Laufkunde')
  for (const feld of ['gastEmail', 'gastTelefon', 'gastNachricht', 'gastZusatz']) assert.equal(b[feld], '', feld)
  // ohne Name geht es nicht, auch wenn alles andere da ist
  const err = await fehlerVon(() => manuell(pflicht, handEingabe({ name: '', email: 'a@example.com', zeit: '11:00' }), JETZT))
  assert.deepEqual(Object.keys(err.fehler), ['name'])

  // ausgeschaltete Felder (aus) nehmen Eingaben des Betriebs trotzdem an
  const aus = await speichere(einstellung({ gastFelder: { telefon: 'aus', nachricht: 'aus', zusatz: [{ key: 'marke', label: 'Marke', typ: 'text', pflicht: false }] } }))
  const mitAllem = await manuell(aus, handEingabe({ zeit: '12:00', nachricht: 'Kommt mit Hund.', zusatz: { marke: 'Wella' } }), JETZT)
  assert.equal(buchung(mitAllem.id).gastTelefon, '06301 555')
  assert.equal(buchung(mitAllem.id).gastNachricht, 'Kommt mit Hund.')
  assert.deepEqual(JSON.parse(buchung(mitAllem.id).gastZusatz), { marke: 'Wella' })

  // was angegeben ist, wird geprueft
  for (const [feld, over] of [
    ['telefon', { telefon: 'abc' }],
    ['nachricht', { nachricht: 'n'.repeat(501) }],
    ['zusatz.marke', { zusatz: { marke: 'm'.repeat(201) } }],
    ['zusatz', { zusatz: { unbekannt: 'x' } }],
    ['email', { email: 'kein-postfach' }],
  ]) {
    const e = await fehlerVon(() => manuell(aus, handEingabe({ zeit: '14:00', ...over }), JETZT))
    assert.equal(e.status, 400, feld)
    assert.ok(Object.keys(e.fehler).includes(feld), `${feld}: ${JSON.stringify(e.fehler)}`)
  }
  assert.equal(buchungen().length, 2)
})

test('manuell: Pruefung wie beim Gast, aber ohne Zustimmungen; Adresse freiwillig, aber wenn angegeben gueltig', async () => {
  const ctx = await speichere()
  // Storno-Haken und Zustimmung zum vorzeitigen Beginn entfallen (Termin in 7 Tagen, mit Preis, Verbraucher-Betrieb)
  assert.equal((await manuell(ctx, handEingabe({ tag: TAG_NAH }), JETZT)).status, 'bestaetigt')

  for (const [feld, over] of [
    ['name', { name: '  ' }],
    ['name', { name: 'N'.repeat(101) }],
    ['email', { email: 'kein-postfach' }],
    ['email', { email: 'a@example.com, b@example.com' }],
    ['email', { email: 5 }],
    ['leistung', { leistung: 's_gibtesnicht' }],
    ['ressource', { ressource: 'r_gibtesnicht' }],
    ['tag', { tag: '2026-02-30' }],
    ['zeit', { zeit: '25:61' }],
    ['telefon', { telefon: 'abc' }],
    ['nachricht', { nachricht: 'n'.repeat(501) }],
    ['zusatz', { zusatz: { unbekannt: 'x' } }],
    ['bestaetigungSenden', { bestaetigungSenden: 'ja' }],
  ]) {
    const err = await fehlerVon(() => manuell(ctx, handEingabe({ zeit: '15:00', ...over }), JETZT))
    assert.equal(err.status, 400, feld)
    assert.ok(Object.keys(err.fehler).includes(feld), `${feld}: ${JSON.stringify(err.fehler)}`)
  }
  for (const roh of [undefined, null, 'x', []]) assert.equal((await fehlerVon(() => manuell(ctx, roh, JETZT))).status, 400)
  assert.equal(buchungen().length, 1, 'nur der gueltige Eintrag')
  await assert.rejects(() => manuell(ctx, handEingabe(), undefined), TypeError)
  await assert.rejects(() => manuell({ feature: ctx.feature }, handEingabe(), JETZT), TypeError)
})

test('manuell: ohne Vorlauf und Horizont, nie in der Vergangenheit, nie ausserhalb der Oeffnung, nie auf belegten Zellen', async () => {
  const ctx = await speichere()
  // Vorlauf (120 Minuten): heute 11:00 geht; Horizont (90 Tage): Februar geht
  assert.equal((await manuell(ctx, handEingabe({ tag: '2026-10-05', zeit: '11:00' }), JETZT)).status, 'bestaetigt')
  assert.equal((await manuell(ctx, handEingabe({ tag: '2027-02-01', zeit: '10:00' }), JETZT)).status, 'bestaetigt')

  const vorher = buchungen().length
  const standZellen = claimsStand()
  for (const over of [
    { tag: '2026-10-05', zeit: '09:00' }, // vergangen
    { tag: '2026-10-04', zeit: '10:00' }, // gestern
    { tag: '2026-10-27', zeit: '10:00' }, // Dienstag, kein Plan
    { tag: TAG_FERN, zeit: '08:45' }, // vor der Oeffnung
    { tag: TAG_FERN, zeit: '10:07' }, // nicht im Raster
    { tag: '2026-10-05', zeit: '11:15' }, // ueberlappt den Termin um 11:00
  ]) {
    const err = await fehlerVon(() => manuell(ctx, handEingabe(over), JETZT))
    assert.equal(err.status, 409, JSON.stringify(over))
    assert.equal(err.code, 'SLOT_VERGEBEN')
    assert.deepEqual(Object.keys(err.fehler), ['zeit'])
  }
  assert.equal(buchungen().length, vorher)
  assert.equal(claimsStand(), standZellen)
})

test('manuell: "egal" waehlt die Person mit den wenigsten Terminen des Tages', async () => {
  const ctx = await speichere()
  const a = await manuell(ctx, handEingabe({ zeit: '09:00' }), JETZT) // R1
  assert.equal(buchung(a.id).ressourceId, R1)
  const b = await manuell(ctx, handEingabe({ ressource: 'egal', zeit: '10:00' }), JETZT)
  assert.equal(buchung(b.id).ressourceId, R2)
  assert.equal(buchung(b.id).ressourceName, 'Ben')
})

test('manuell: ein Konflikt beim Belegen der Zellen (409) raeumt die Buchung wieder weg', async () => {
  const ctx = await speichere()
  // Zelle um 10:00 gehoert einer fremden, bestaetigten Buchung, die der Tagesabruf nicht sieht (anderer Tag in der Datenbank)
  aw.seed('termineBookings', {
    $id: 'fremd-0001',
    featureId: FEATURE,
    ressourceId: R1,
    status: 'bestaetigt',
    startsAt: '2026-12-01T09:00:00.000Z',
    endsAt: '2026-12-01T09:45:00.000Z',
    blockEndsAt: '2026-12-01T09:50:00.000Z',
  })
  aw.seed('termineClaims', {
    $id: zellenId(FEATURE, R1, '2026-10-26T09:00:00.000Z'),
    featureId: FEATURE,
    ressourceId: R1,
    bookingId: 'fremd-0001',
    zelle: '2026-10-26T09:00:00.000Z',
    bis: '2026-10-26T09:50:00.000Z',
  })
  const err = await fehlerVon(() => manuell(ctx, handEingabe(), JETZT))
  assert.equal(err.status, 409)
  assert.equal(err.code, 'SLOT_VERGEBEN')
  assert.deepEqual(buchungen().map((b) => b.$id), ['fremd-0001'], 'keine Reste der gescheiterten Buchung')
  assert.equal(aw.docs('termineClaims').size, 1)
})

test('manuell: eine Belegung ueber 500 Minuten wird abgelehnt (400 Feld leistung), bevor etwas angelegt wird', async () => {
  const e = einstellung()
  const lang = { ...e, leistungen: e.leistungen.map((l) => (l.id === S_SOFORT ? { ...l, dauer: 480, pufferNach: 25 } : l)) }
  const ctx = ctxMit(lang)
  const err = await fehlerVon(() => manuell(ctx, handEingabe({ zeit: '09:00' }), JETZT))
  assert.equal(err.status, 400)
  assert.deepEqual(Object.keys(err.fehler), ['leistung'])
  assert.equal(buchungen().length, 0)
})

// ---------------------------------------------------------------- Sperren

test('sperre: 09:00 bis 17:30 sind 510 Minuten => 400 Feld bis mit dem Hinweis auf Abwesenheiten; 500 Minuten gehen', async () => {
  const ctx = await speichere()
  const err = await fehlerVon(() => sperre(ctx, { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '17:30', titel: 'Fortbildung' }, JETZT))
  assert.equal(err.status, 400)
  assert.deepEqual(err.fehler, { bis: 'Eine Sperre kann höchstens 8 Stunden 20 Minuten dauern. Für ganze Tage nutze Abwesenheiten.' })
  assert.equal((await fehlerVon(() => sperre(ctx, { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '17:25' }, JETZT))).status, 400)
  assert.equal(buchungen().length, 0)
  assert.equal(aw.docs('termineClaims').size, 0)

  const ok = await sperre(ctx, { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '17:20', titel: 'Fortbildung' }, JETZT)
  assert.equal(ok.status, 'bestaetigt')
  assert.equal(claims(ok.id).length, 100)
})

test('sperre: 09:00 bis 13:00 ist eine bestaetigte Buchung ohne Gast und blockiert die Slots dieser Ressource', async () => {
  const ctx = await speichere()
  const erg = await sperre(ctx, { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '13:00', titel: 'Fortbildung' }, JETZT)
  await warteAufVersand()
  const b = buchung(erg.id)
  assert.equal(b.quelle, 'sperre')
  assert.equal(b.status, 'bestaetigt')
  assert.equal(b.leistungName, 'Fortbildung')
  assert.equal(b.ressourceId, R1)
  assert.equal(b.ressourceName, 'Anna')
  assert.equal(iso(b.startsAt), '2026-10-26T08:00:00.000Z')
  assert.equal(iso(b.endsAt), '2026-10-26T12:00:00.000Z')
  assert.equal(iso(b.blockEndsAt), '2026-10-26T12:00:00.000Z')
  assert.equal(b.gastName, undefined)
  assert.equal(b.gastEmail, undefined)
  assert.equal(b.verbraucher, false)
  assert.equal(claims(erg.id).length, 48)
  assert.equal(eintraege().length, 0, 'eine Sperre schickt keine Mail')

  // R1 ist gesperrt, R2 nicht; um 13:00 ist R1 wieder frei
  for (const zeit of ['09:00', '10:00', '12:00']) {
    const err = await fehlerVon(() => halte(ctx, eingabe({ zeit, email: `x${zeit.slice(0, 2)}@example.com` }), JETZT))
    assert.equal(err.code, 'SLOT_VERGEBEN', zeit)
  }
  assert.equal((await halte(ctx, eingabe({ zeit: '10:00', ressource: R2, email: 'ben@example.com' }), JETZT)).status, 'gehalten')
  assert.equal((await halte(ctx, eingabe({ zeit: '13:00', email: 'dreizehn@example.com' }), JETZT)).status, 'gehalten')
  // "egal" weicht auf die freie Person aus
  assert.equal((await halte(ctx, eingabe({ zeit: '11:00', ressource: 'egal', email: 'egal@example.com' }), JETZT)).status, 'gehalten')
  assert.equal(buchungen().find((x) => x.gastEmail === 'egal@example.com').ressourceId, R2)
})

test('sperre: Titel (Vorgabe "Gesperrt"), Ressource, Tag und Uhrzeiten in 5-Minuten-Schritten werden geprueft', async () => {
  const ctx = await speichere()
  const gut = { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '10:00' }
  const ohneTitel = await sperre(ctx, gut, JETZT)
  assert.equal(buchung(ohneTitel.id).leistungName, 'Gesperrt')
  const bis24 = await sperre(ctx, { ressource: R2, tag: TAG_FERN, von: '20:00', bis: '24:00', titel: '  Nachtruhe  ' }, JETZT)
  assert.equal(buchung(bis24.id).leistungName, 'Nachtruhe')
  assert.equal(iso(buchung(bis24.id).endsAt), '2026-10-26T23:00:00.000Z')

  const vorher = buchungen().length
  for (const [feld, over] of [
    ['ressource', { ressource: 'r_gibtesnicht' }],
    ['ressource', { ressource: undefined }],
    ['tag', { tag: '2026-13-01' }],
    ['von', { von: '09:03' }],
    ['von', { von: '9:00' }],
    ['von', { von: '24:00' }],
    ['bis', { bis: '10:07' }],
    ['bis', { bis: undefined }],
    ['bis', { von: '10:00', bis: '10:00' }], // Ende nicht nach Beginn
    ['bis', { von: '10:00', bis: '09:00' }],
    ['bis', { tag: '2026-10-05', von: '08:00', bis: '09:00' }], // endet in der Vergangenheit
    ['von', { tag: '2026-03-29', von: '02:30', bis: '04:00' }], // Luecke der Maerz-Umstellung
    ['titel', { titel: 't'.repeat(121) }],
  ]) {
    const err = await fehlerVon(() => sperre(ctx, { ...gut, ...over }, JETZT))
    assert.equal(err.status, 400, feld)
    assert.ok(Object.keys(err.fehler).includes(feld), `${feld}: ${JSON.stringify(err.fehler)}`)
  }
  for (const roh of [undefined, null, 'x', []]) assert.equal((await fehlerVon(() => sperre(ctx, roh, JETZT))).status, 400)
  assert.equal(buchungen().length, vorher)

  // eine Sperre darf schon laufen (Beginn vor jetzt, Ende danach)
  assert.equal((await sperre(ctx, { ressource: R1, tag: '2026-10-05', von: '09:00', bis: '12:00' }, JETZT)).status, 'bestaetigt')
  await assert.rejects(() => sperre(ctx, gut, undefined), TypeError)
  await assert.rejects(() => sperre({ feature: ctx.feature }, gut, JETZT), TypeError)
})

test('sperre: ueber einem Termin oder einer anderen Sperre 409 (Feld von), ohne Reste; erst absagen, dann sperren', async () => {
  const ctx = await speichere()
  const { id } = await gebucht(ctx) // R1 10:00-10:50
  const standZellen = claimsStand()
  const vorher = buchungen().length

  const err = await fehlerVon(() => sperre(ctx, { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '13:00' }, JETZT))
  assert.equal(err.status, 409)
  assert.equal(err.code, 'SLOT_VERGEBEN')
  assert.deepEqual(err.fehler, { von: 'In dieser Zeit gibt es schon einen Termin oder eine Sperre.' })
  assert.equal(buchungen().length, vorher)
  assert.equal(claimsStand(), standZellen)

  // die andere Person ist frei
  const r2 = await sperre(ctx, { ressource: R2, tag: TAG_FERN, von: '09:00', bis: '13:00' }, JETZT)
  assert.equal((await fehlerVon(() => sperre(ctx, { ressource: R2, tag: TAG_FERN, von: '12:30', bis: '14:00' }, JETZT))).status, 409)
  assert.equal(claims(r2.id).length, 48)

  await aktion(ctx, id, { aktion: 'absagen', grund: 'Krankheit' }, JETZT)
  assert.equal((await sperre(ctx, { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '13:00' }, JETZT)).status, 'bestaetigt')
})

test('entsperre: loescht die Sperre samt Zellen, die Zeit ist wieder buchbar; nur Sperren der eigenen Funktion', async () => {
  const ctx = await speichere()
  const s = await sperre(ctx, { ressource: R1, tag: TAG_FERN, von: '09:00', bis: '13:00', titel: 'Fortbildung' }, JETZT)
  const { id } = await gebucht(ctx, { ressource: R2, email: 'ben@example.com' })
  assert.equal(claims(s.id).length, 48)

  // fremde Funktion, normale Buchung, unbekannte und kaputte Nummern
  for (const [kontext, bid] of [[ctxMit(einstellung(), 'f_andere_funktion'), s.id], [ctx, id], [ctx, 'gibt-es-nicht'], [ctx, ''], [ctx, null], [ctx, '../x']]) {
    const err = await fehlerVon(() => entsperre(kontext, bid))
    assert.equal(err.status, 404, String(bid))
    assert.deepEqual(err.fehler, { _: 'Diese Sperre gibt es nicht.' })
  }
  assert.equal(buchung(s.id).status, 'bestaetigt')
  assert.equal(buchung(id).status, 'bestaetigt')

  assert.deepEqual(await entsperre(ctx, s.id), { status: 'entsperrt' })
  assert.equal(buchung(s.id), undefined)
  assert.equal(claims(s.id).length, 0)
  assert.equal(claims(id).length, 10, 'andere Zellen bleiben')
  assert.equal((await halte(ctx, eingabe({ zeit: '10:00', email: 'neu@example.com' }), JETZT)).status, 'gehalten')
  assert.equal((await fehlerVon(() => entsperre(ctx, s.id))).status, 404)
  await assert.rejects(() => entsperre({ feature: ctx.feature }, s.id), TypeError)
})