import { test, after, beforeEach } from 'node:test'
import assert from 'node:assert/strict'
import os from 'node:os'
import path from 'node:path'
import { mkdtempSync, existsSync } from 'node:fs'
import { readdir, rm } from 'node:fs/promises'
import sharp from 'sharp'
import { startAppwriteMock } from './support/appwriteMock.js'
import { startFakeStripe } from './support/fakeStripe.js'
import { useTestEnv } from './support/testEnv.js'
import { schemaKeys } from './support/schema.js'
import { SHOP_DATETIMES } from '../server/services/shop/schema.js'

// Webshop C7: Verwaltungs-Routen /api/shop (Status, Einstellungen, Artikel, Rechtstexte, Oeffnen, Bilder), Kundenansicht
process.env.SHOP_UPLOAD_DIR = mkdtempSync(path.join(os.tmpdir(), 'shop-routes-'))
const aw = await startAppwriteMock({
  schema: {
    portalFeatures: schemaKeys('portalFeatures'),
    shopConfig: schemaKeys('shopConfig'),
    shopProducts: schemaKeys('shopProducts'),
    customerViewLog: schemaKeys('customerViewLog'),
  },
  datetimes: SHOP_DATETIMES,
})
const st = await startFakeStripe()
useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
const { config } = await import('../server/config.js')
const { startTestApp, send, post } = await import('./support/testApp.js')
const { customerCookie, kundenansichtCookie, viewAsCookie, seedFixtures, customers } = await import('./support/fixtures.js')
const { default: shopRoutes, resetShopRoutesForTests } = await import('../server/routes/shop.js')
const { kundenansichtGuard } = await import('../server/middleware/kundenansichtGuard.js')
const sf = await import('../server/services/siteFeatures.js')
const { deleteDocument, updateDocument } = await import('../server/services/appwriteAdmin.js')
const { shopPerSiteKey } = await import('../server/services/shop/kontext.js')
const { rechtstexteHash } = await import('../server/services/shop/rechtstexte.js')
const { STANDARD_EINSTELLUNGEN } = await import('../server/services/shop/einstellungen.js')

const app = await startTestApp({ '/': kundenansichtGuard, '/api/shop': shopRoutes })
after(() => Promise.all([app.close(), aw.close(), st.close()]))

seedFixtures(aw)
aw.seed('websiteProjects', { $id: 'pt1', customerId: 'c1', projectName: 'Töpferei', archived: false })
aw.seed('websiteProjects', { $id: 'pt2', customerId: 'c1', projectName: 'Zweiter Shop' })
aw.seed('websiteProjects', { $id: 'pt3', customerId: 'c2', projectName: 'Fremdes Projekt' })
aw.seed('websiteProjects', { $id: 'pt4', customerId: 'c1', projectName: 'Altprojekt', archived: true })

const cookie = customerCookie('c1')
const KV = { cookie: kundenansichtCookie({ customerId: 'c1' }), headers: { 'X-Kundenansicht': 'a'.repeat(32) } }
const EINSTELLUNGEN = {
  ...JSON.parse(JSON.stringify(STANDARD_EINSTELLUNGEN)),
  shopname: 'Töpferei Keramik',
  anbieter: { name: 'Töpferei Keramik', strasse: 'Hauptstraße 5', plz: '67655', ort: 'Kaiserslautern', land: 'DE', email: 'shop@toepferei.example', telefon: '', ustId: '' },
}
const TEXTE = {
  agb: 'Unsere AGB.',
  widerrufsbelehrung: 'Unsere Widerrufsbelehrung.',
  widerrufsformular: 'Unser Widerrufsformular.',
  impressumUrl: 'https://toepferei.example/impressum',
  datenschutzUrl: 'https://toepferei.example/datenschutz',
}
const ARTIKEL = { name: 'Tasse', preisCent: 1800 }

const q = (projectId = 'pt1') => `projectId=${projectId}`
const lesen = (pfad, projectId = 'pt1', opts = { cookie }) => send('GET', `/api/shop/${pfad}${pfad.includes('?') ? '&' : '?'}${q(projectId)}`, opts)
const schreiben = (method, pfad, body = {}, opts = { cookie }) => send(method, `/api/shop/${pfad}`, { ...opts, body: { projectId: 'pt1', ...body } })

async function aktiviere(projectId = 'pt1', state = 'active') {
  const feature = await sf.ensureFeatureDoc('c1', projectId, 'shop')
  await updateDocument(config.collections.portalFeatures, feature.$id, sf.stateFields(state))
  return sf.getFeatureDoc('c1', projectId, 'shop')
}
const shopConfigDoc = (feature) => aw.docs('shopConfig').get(feature.$id)
const dateien = async (siteKey) => (await readdir(path.join(process.env.SHOP_UPLOAD_DIR, siteKey)).catch(() => [])).sort()

async function png(w = 64, h = 48) {
  return sharp({ create: { width: w, height: h, channels: 3, background: '#c63' } }).png().toBuffer()
}
async function lade(buffer, { projectId = 'pt1', opts = { cookie }, type = 'application/octet-stream' } = {}) {
  const res = await fetch(`${app.url}/api/shop/bild?projectId=${projectId}`, {
    method: 'POST',
    headers: { 'content-type': type, ...(opts.cookie ? { cookie: opts.cookie } : {}), ...(opts.headers || {}) },
    body: buffer,
  })
  const text = await res.text()
  let body = text
  try {
    body = JSON.parse(text)
  } catch {
    /* Text */
  }
  return { status: res.status, body }
}

/** Shop bis "bereit zum Oeffnen": active, Einstellungen, Rechtstexte bestaetigt, Stripe bereit, ein Artikel. */
async function machBereit({ mitArtikel = true } = {}) {
  const feature = await aktiviere()
  assert.equal((await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })).status, 200)
  if (mitArtikel) assert.equal((await schreiben('POST', 'produkte', { produkt: ARTIKEL })).status, 201)
  assert.equal((await schreiben('PUT', 'rechtstexte', { rechtstexte: TEXTE })).status, 200)
  const hash = (await lesen('rechtstexte')).body.hash
  assert.equal((await schreiben('POST', 'rechtstexte/bestaetigen', { hash })).status, 200)
  await updateDocument(config.collections.shopConfig, feature.$id, {
    stripeAccountId: 'acct_test1',
    stripeStatus: JSON.stringify({ charges_enabled: true, payouts_enabled: true, details_submitted: true, currently_due: [], past_due: [], disabled_reason: null, geheim: 'nie', geprueftAt: '2026-10-05T10:00:00.000Z' }),
  })
  return feature
}

let origin
beforeEach(async () => {
  origin ??= { mode: config.shop.mode, pilotEmails: config.shop.pilotEmails }
  config.shop.mode = 'pilot'
  config.shop.pilotEmails = [customers.c1.email]
  resetShopRoutesForTests()
  for (const col of ['portalFeatures', 'shopConfig', 'shopProducts', 'customerViewLog']) {
    for (const id of [...aw.docs(col).keys()]) await deleteDocument(config.collections[col], id)
  }
  await rm(process.env.SHOP_UPLOAD_DIR, { recursive: true, force: true })
  const { leereCache } = await import('../server/services/shop/kontext.js')
  leereCache()
})

// ---------------------------------------------------------------- Zugang

test('Zugang: ohne Session 401, ohne Projekt 400, fremdes oder unbekanntes Projekt 403, Schalter aus 409, Funktion nicht eingerichtet 409', async () => {
  await aktiviere()
  assert.equal((await send('GET', '/api/shop/einstellungen?projectId=pt1')).status, 401)
  assert.equal((await send('GET', '/api/shop/einstellungen', { cookie })).status, 400)
  assert.equal((await lesen('einstellungen', 'pt3')).status, 403)
  assert.equal((await lesen('einstellungen', 'gibtsnicht')).status, 403)
  for (const pfad of ['einstellungen', 'produkte', 'rechtstexte']) assert.equal((await lesen(pfad, 'pt2')).status, 409, `${pfad}: pt2 hat keine Funktion`)
  const keine = await lesen('einstellungen', 'pt2')
  assert.deepEqual([keine.body.code, keine.body.error], ['nicht_eingerichtet', 'Der Webshop ist für dieses Projekt noch nicht eingerichtet.'])
  config.shop.mode = 'off'
  const aus = await lesen('einstellungen')
  assert.deepEqual([aus.status, aus.body.code], [409, 'nicht_verfuegbar'])
  config.shop.mode = 'pilot'
  config.shop.pilotEmails = ['jemand@example.invalid']
  assert.equal((await lesen('produkte')).status, 409)
})

test('Zustaende: ordered und off => 409; disabled nur lesend; setup legt shopConfig an (ID = portalFeatures-ID, siteKey kopiert)', async () => {
  const feature = await aktiviere('pt1', 'ordered')
  assert.equal((await lesen('einstellungen')).status, 409)
  await updateDocument(config.collections.portalFeatures, feature.$id, sf.stateFields('setup'))
  assert.equal(aw.docs('shopConfig').size, 0)
  const setup = await lesen('einstellungen')
  assert.equal(setup.status, 200)
  assert.equal(setup.body.einstellungen.lieferzeit, '2–4 Werktage')
  assert.equal(setup.body.vollstaendig, false)
  const angelegt = shopConfigDoc(feature)
  assert.deepEqual([angelegt.customerId, angelegt.projectId, angelegt.siteKey], ['c1', 'pt1', feature.siteKey])
  assert.equal((await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })).status, 200, 'setup darf schreiben')

  await updateDocument(config.collections.portalFeatures, feature.$id, sf.stateFields('disabled'))
  for (const pfad of ['einstellungen', 'produkte', 'rechtstexte']) assert.equal((await lesen(pfad)).status, 200, `${pfad} lesbar`)
  for (const [m, pfad, body] of [
    ['PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN }], ['POST', 'produkte', { produkt: ARTIKEL }], ['PUT', 'rechtstexte', { rechtstexte: TEXTE }],
    ['POST', 'oeffnen', { offen: false }], ['POST', 'produkte/sortierung', { ids: [] }],
  ]) {
    const res = await schreiben(m, pfad, body)
    assert.deepEqual([res.status, res.body.code], [409, 'nicht_eingerichtet'], `${m} ${pfad}`)
  }
  assert.equal((await lesen('einstellungen', 'pt4')).status, 409)
})

test('archiviertes Projekt: Lesen ja (falls Funktion da), Schreiben 409 wie bei Bestellungen', async () => {
  const feature = await sf.ensureFeatureDoc('c1', 'pt4', 'shop')
  await updateDocument(config.collections.portalFeatures, feature.$id, sf.stateFields('active'))
  assert.equal((await lesen('einstellungen', 'pt4')).status, 200)
  const res = await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN, projectId: 'pt4' })
  assert.equal(res.status, 409)
})

// ---------------------------------------------------------------- Status

test('GET /status ohne Funktion: gleiche Form mit leeren Werten, legt nichts an', async () => {
  const res = await lesen('status')
  assert.equal(res.status, 200)
  assert.deepEqual(res.body, {
    verfuegbar: true, state: 'off', ticketWoid: null, anfrage: null, bereitschaft: null, geoeffnet: false, schalter: false, siteKey: null,
    snippet: null, vorschauUrl: null, stripe: { verbunden: false, status: null }, zahlen: null,
  })
  assert.equal(aw.docs('portalFeatures').size + aw.docs('shopConfig').size, 0)
  assert.equal((await lesen('status', 'pt3')).status, 403)
})

test('GET /status mit Shop: Bereitschaft, Snippet, Vorschau, Stripe ohne Konto-ID und fremde Felder, Zahlen; geoeffnet erst nach Oeffnen', async () => {
  const feature = await machBereit()
  const res = await lesen('status')
  assert.equal(res.status, 200)
  const b = res.body
  assert.deepEqual([b.verfuegbar, b.state, b.siteKey, b.schalter, b.geoeffnet], [true, 'active', feature.siteKey, false, false])
  assert.equal(b.bereitschaft.bereit, true)
  assert.deepEqual(b.bereitschaft.punkte.map((p) => [p.id, p.ok]), [['einbau', true], ['stripe', true], ['einstellungen', true], ['rechtstexte', true], ['artikel', true]])
  assert.equal(b.snippet, `<div data-webklar-shop="${feature.siteKey}"></div>\n<script src="${config.publicBaseUrl}/embed/shop.js" defer></script>`)
  assert.equal(b.vorschauUrl, `${config.publicBaseUrl}/shop/${feature.siteKey}`)
  assert.deepEqual(b.stripe, {
    verbunden: true,
    status: { charges_enabled: true, payouts_enabled: true, details_submitted: true, currently_due: [], past_due: [], disabled_reason: null, geprueftAt: '2026-10-05T10:00:00.000Z' },
  })
  assert.ok(!JSON.stringify(b).includes('acct_test1') && !JSON.stringify(b).includes('geheim'))
  assert.deepEqual(b.zahlen, { artikel: 1, aktiveArtikel: 1, offeneBestellungen: 0, bestellungen30: 0, umsatz30Cent: 0 })
  assert.equal(b.ticketWoid, null)

  assert.equal((await schreiben('POST', 'oeffnen', { offen: true })).status, 200)
  assert.equal((await lesen('status')).body.geoeffnet, true)
  assert.equal((await lesen('status')).body.schalter, true)
})

// ---------------------------------------------------------------- Einstellungen

test('Einstellungen: speichern, Version zaehlt, veraltete Version 409, Fehler je Feld 400', async () => {
  await aktiviere()
  const leer = await lesen('einstellungen')
  assert.equal(leer.body.version, 0)
  const gut = await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN, version: 0 })
  assert.equal(gut.status, 200)
  assert.deepEqual([gut.body.version, gut.body.vollstaendig, gut.body.einstellungen.shopname], [1, true, 'Töpferei Keramik'])
  assert.equal((await lesen('einstellungen')).body.einstellungen.anbieter.ort, 'Kaiserslautern')

  const veraltet = await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN, version: 0 })
  assert.deepEqual([veraltet.status, veraltet.body.code], [409, 'EINSTELLUNG_VERALTET'])
  assert.equal((await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })).status, 200, 'ohne Version keine Pruefung')

  const schlecht = await schreiben('PUT', 'einstellungen', { einstellungen: { ...EINSTELLUNGEN, akzent: 'rot' } })
  assert.equal(schlecht.status, 400)
  assert.ok(schlecht.body.fehler && Object.keys(schlecht.body.fehler).length > 0)
  assert.equal(schlecht.body.error, Object.values(schlecht.body.fehler)[0])
  assert.equal((await schreiben('PUT', 'einstellungen', { einstellungen: 'text' })).status, 400)
})

test('Einstellungen speichern leert den 30-s-Speicher von shopPerSiteKey', async () => {
  const feature = await aktiviere()
  await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })
  const vorher = await shopPerSiteKey(feature.siteKey)
  assert.equal(vorher.shop.einstellungen.shopname, 'Töpferei Keramik')
  await schreiben('PUT', 'einstellungen', { einstellungen: { ...EINSTELLUNGEN, shopname: 'Neu' } })
  assert.equal((await shopPerSiteKey(feature.siteKey)).shop.einstellungen.shopname, 'Neu')
})

// ---------------------------------------------------------------- Artikel

test('Artikel: anlegen 201, lesen, aendern, Fehler 400 je Feld, unbekannte ID 404, Kleinunternehmer-Steuer', async () => {
  await aktiviere()
  await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN }) // Kleinunternehmer => 0 %
  const neu = await schreiben('POST', 'produkte', { produkt: { ...ARTIKEL, kurz: 'Handgemacht', extra: 'ignoriert' } })
  assert.equal(neu.status, 201)
  const id = neu.body.produkt.id
  assert.deepEqual([neu.body.produkt.name, neu.body.produkt.preisCent, neu.body.produkt.steuersatz, neu.body.produkt.aktiv, neu.body.produkt.sort], ['Tasse', 1800, 0, true, 0])
  assert.equal(neu.body.produkt.extra, undefined)

  const liste = await lesen('produkte')
  assert.equal(liste.status, 200)
  assert.deepEqual(liste.body.produkte.map((p) => p.id), [id])
  assert.deepEqual([liste.body.maxArtikel, liste.body.maxBilder], [config.shop.maxArtikel, config.shop.maxBilder])

  const geaendert = await schreiben('PUT', `produkte/${id}`, { produkt: { ...ARTIKEL, name: 'Große Tasse', aktiv: false } })
  assert.equal(geaendert.status, 200)
  assert.deepEqual([geaendert.body.produkt.id, geaendert.body.produkt.name, geaendert.body.produkt.aktiv], [id, 'Große Tasse', false])
  assert.equal((await lesen('produkte')).body.produkte[0].aktiv, false)
  assert.equal(aw.docs('shopProducts').size, 1)

  const schlecht = await schreiben('POST', 'produkte', { produkt: { name: '', preisCent: -5 } })
  assert.equal(schlecht.status, 400)
  assert.ok(schlecht.body.fehler.name && schlecht.body.fehler.preisCent)
  assert.equal((await schreiben('POST', 'produkte', { produkt: 'text' })).status, 400)
  assert.equal((await schreiben('POST', 'produkte', {})).status, 400)
  assert.equal((await schreiben('PUT', 'produkte/gibtsnicht', { produkt: ARTIKEL })).status, 404)
  assert.equal((await schreiben('DELETE', 'produkte/gibtsnicht')).status, 404)
  assert.equal(aw.docs('shopProducts').size, 1)
})

test('Artikel mit Regelbesteuerung: Steuersatz kommt aus den gespeicherten Einstellungen', async () => {
  await aktiviere()
  await schreiben('PUT', 'einstellungen', { einstellungen: { ...EINSTELLUNGEN, kleinunternehmer: false } })
  const res = await schreiben('POST', 'produkte', { produkt: { ...ARTIKEL, steuersatz: 7 } })
  assert.equal(res.body.produkt.steuersatz, 7)
})

test('Artikel gehoeren zu ihrem Shop: fremder Shop kann sie weder sehen noch aendern', async () => {
  await aktiviere()
  const neu = await schreiben('POST', 'produkte', { produkt: ARTIKEL })
  await aktiviere('pt2')
  assert.deepEqual((await lesen('produkte', 'pt2')).body.produkte, [])
  assert.equal((await schreiben('PUT', `produkte/${neu.body.produkt.id}`, { produkt: ARTIKEL, projectId: 'pt2' })).status, 404)
  assert.equal((await schreiben('DELETE', `produkte/${neu.body.produkt.id}`, {}, { cookie }) ).status, 200)
})

test('Sortierung: neue Reihenfolge, falsche Liste 400', async () => {
  await aktiviere()
  const ids = []
  for (const name of ['A', 'B', 'C']) ids.push((await schreiben('POST', 'produkte', { produkt: { name, preisCent: 100 } })).body.produkt.id)
  const res = await schreiben('POST', 'produkte/sortierung', { ids: [ids[2], ids[0], ids[1]] })
  assert.equal(res.status, 200)
  assert.deepEqual(res.body.produkte.map((p) => p.name), ['C', 'A', 'B'])
  assert.deepEqual((await lesen('produkte')).body.produkte.map((p) => p.name), ['C', 'A', 'B'])
  assert.equal((await schreiben('POST', 'produkte/sortierung', { ids: [ids[0]] })).status, 400)
  assert.equal((await schreiben('POST', 'produkte/sortierung', {})).status, 400)
})

// ---------------------------------------------------------------- Bilder

test('Bild hochladen: 201, Sidecar mit Shop und Kunde, Vorschau lesbar; Typfehler 415, zu gross 413, ohne Session 401, fremdes Projekt 403', async () => {
  const feature = await aktiviere()
  const res = await lade(await png(2000, 1000))
  assert.equal(res.status, 201)
  assert.deepEqual([res.body.w, res.body.h], [1600, 800])
  assert.match(res.body.imageId, /^[a-z0-9-]{36}$/)
  const dateiListe = await dateien(feature.siteKey)
  assert.deepEqual(dateiListe, [`${res.body.imageId}-l.webp`, `${res.body.imageId}-s.webp`, `${res.body.imageId}.json`].sort())
  const meta = JSON.parse(await (await import('node:fs/promises')).readFile(path.join(process.env.SHOP_UPLOAD_DIR, feature.siteKey, `${res.body.imageId}.json`), 'utf8'))
  assert.deepEqual([meta.customerId, meta.shopId, meta.claimed], ['c1', feature.$id, false])

  for (const datei of [`${res.body.imageId}-s.webp`, `${res.body.imageId}-l.webp`]) {
    const bild = await fetch(`${app.url}/api/shop/bild/pt1/${datei}`, { headers: { cookie } })
    assert.equal(bild.status, 200)
    assert.equal(bild.headers.get('content-type'), 'image/webp')
    assert.equal(bild.headers.get('x-content-type-options'), 'nosniff')
    assert.equal(bild.headers.get('cache-control'), 'private, max-age=3600')
    assert.equal((await sharp(Buffer.from(await bild.arrayBuffer())).metadata()).format, 'webp')
  }

  assert.equal((await lade(Buffer.from('%PDF-1.4 kein Bild'))).status, 415)
  assert.equal((await lade(await png(), { type: 'text/plain' })).status, 415, 'kein octet-stream')
  const zuGross = await lade(Buffer.alloc(8 * 1024 * 1024 + 1))
  assert.deepEqual([zuGross.status, zuGross.body.error], [413, 'Das Bild ist größer als 8 MB.'])
  assert.equal((await lade(await png(), { opts: {} })).status, 401)
  assert.equal((await lade(await png(), { projectId: 'pt3' })).status, 403)
  assert.equal((await lade(await png(), { projectId: 'pt2' })).status, 409, 'pt2 hat keine Funktion')
  assert.equal((await dateien(feature.siteKey)).length, 3, 'nichts Weiteres abgelegt')
})

test('Bild-Vorschau: nur eigene Projekte, nur gueltige Dateinamen, nur vorhandene Bilder', async () => {
  const feature = await aktiviere()
  const { body } = await lade(await png())
  const url = (projekt, datei) => `${app.url}/api/shop/bild/${projekt}/${datei}`
  const hole = (projekt, datei, opts = { cookie }) => fetch(url(projekt, datei), { headers: opts.cookie ? { cookie: opts.cookie } : {} })
  assert.equal((await hole('pt1', `${body.imageId}-s.webp`, {})).status, 401)
  assert.equal((await hole('pt3', `${body.imageId}-s.webp`)).status, 403)
  assert.equal((await hole('pt1', `${body.imageId}-xl.webp`)).status, 404)
  assert.equal((await hole('pt1', `${body.imageId}.json`)).status, 404, 'Sidecar wird nicht ausgeliefert')
  assert.equal((await hole('pt1', '..%2F..%2Fetc%2Fpasswd')).status, 404)
  assert.equal((await hole('pt1', 'gibtsnicht-s.webp')).status, 404)
  assert.equal((await hole('pt1', `${body.imageId}-s.webp`, { cookie: customerCookie('c2') })).status, 403)
  // Datei ohne Sidecar gilt als nicht vorhanden
  await rm(path.join(process.env.SHOP_UPLOAD_DIR, feature.siteKey, `${body.imageId}.json`))
  assert.equal((await hole('pt1', `${body.imageId}-s.webp`)).status, 404)
})

test('Bilder: 40 Uploads je Stunde, der 41. wird mit 429 abgelehnt', async () => {
  await aktiviere()
  const klein = await png(8, 8)
  for (let i = 0; i < 40; i++) assert.equal((await lade(klein)).status, 201, `Upload ${i + 1}`)
  const zuViele = await lade(klein)
  assert.deepEqual([zuViele.status, zuViele.body.error], [429, 'Zu viele Bilder in kurzer Zeit. Bitte versuch es später wieder.'])
  assert.equal((await lade(klein, { opts: { cookie: customerCookie('c1') } })).status, 429)
})

test('Artikel mit Bildern: unbekannte oder fremde ID 400, Beanspruchen, Entfernen loescht, geteiltes Bild bleibt bis zuletzt, Loeschen des Artikels raeumt auf', async () => {
  const feature = await aktiviere()
  const a = (await lade(await png())).body.imageId
  const b = (await lade(await png())).body.imageId
  const c = (await lade(await png())).body.imageId
  const meta = async (id) => JSON.parse(await (await import('node:fs/promises')).readFile(path.join(process.env.SHOP_UPLOAD_DIR, feature.siteKey, `${id}.json`), 'utf8'))
  const da = (id) => existsSync(path.join(process.env.SHOP_UPLOAD_DIR, feature.siteKey, `${id}-l.webp`))

  const unbekannt = await schreiben('POST', 'produkte', { produkt: { ...ARTIKEL, bilder: [a, 'gibtsnicht'] } })
  assert.equal(unbekannt.status, 400)
  assert.ok(unbekannt.body.fehler.bilder)
  assert.equal(aw.docs('shopProducts').size, 0)
  assert.equal((await meta(a)).claimed, false, 'nichts beansprucht, wenn der Artikel nicht gespeichert wurde')

  // Bild eines anderen Shops
  const f2 = await aktiviere('pt2')
  const fremd = (await lade(await png(), { projectId: 'pt2' })).body.imageId
  const mitFremd = await schreiben('POST', 'produkte', { produkt: { ...ARTIKEL, bilder: [fremd] } })
  assert.equal(mitFremd.status, 400)
  assert.ok(existsSync(path.join(process.env.SHOP_UPLOAD_DIR, f2.siteKey, `${fremd}-l.webp`)))
  const mitPfad = await schreiben('POST', 'produkte', { produkt: { ...ARTIKEL, bilder: ['../x'] } })
  assert.equal(mitPfad.status, 400)

  const p1 = await schreiben('POST', 'produkte', { produkt: { ...ARTIKEL, bilder: [a, b] } })
  assert.equal(p1.status, 201)
  assert.deepEqual(p1.body.produkt.bilder, [a, b])
  assert.deepEqual(p1.body.produkt.bildUrls[0], { id: a, klein: `/api/shop/bild/pt1/${a}-s.webp`, gross: `/api/shop/bild/pt1/${a}-l.webp` })
  assert.equal((await meta(a)).claimed, true)
  assert.equal((await meta(b)).claimed, true)
  assert.equal((await meta(c)).claimed, false)
  const p2 = await schreiben('POST', 'produkte', { produkt: { name: 'Zweiter', preisCent: 500, bilder: [b] } })
  assert.equal(p2.status, 201)

  // a entfernen => weg; b entfernen aus p1, aber p2 nutzt es noch => bleibt
  const ohne = await schreiben('PUT', `produkte/${p1.body.produkt.id}`, { produkt: { ...ARTIKEL, bilder: [] } })
  assert.equal(ohne.status, 200)
  assert.equal(da(a), false)
  assert.equal(existsSync(path.join(process.env.SHOP_UPLOAD_DIR, feature.siteKey, `${a}.json`)), false)
  assert.equal(da(b), true, 'p2 nutzt b noch')
  assert.equal(da(c), true, 'unbenutzt hochgeladene Bilder raeumt nur der Nachtjob auf')

  // p2 loeschen => b weg
  assert.equal((await schreiben('DELETE', `produkte/${p2.body.produkt.id}`)).status, 200)
  assert.equal(da(b), false)
  assert.equal(aw.docs('shopProducts').size, 1)

  // Reihenfolge und Anzahl der Bilder bleiben, mehr als maxBilder abgelehnt
  const viele = []
  for (let i = 0; i < config.shop.maxBilder + 1; i++) viele.push((await lade(await png(8, 8))).body.imageId)
  const zuViele = await schreiben('PUT', `produkte/${p1.body.produkt.id}`, { produkt: { ...ARTIKEL, bilder: viele } })
  assert.equal(zuViele.status, 400)
  assert.ok(zuViele.body.fehler.bilder)
  const ok = await schreiben('PUT', `produkte/${p1.body.produkt.id}`, { produkt: { ...ARTIKEL, bilder: viele.slice(0, 2).reverse() } })
  assert.deepEqual(ok.body.produkt.bilder, viele.slice(0, 2).reverse())
})

// ---------------------------------------------------------------- Rechtstexte

test('Rechtstexte GET: Entwurf leer, nichts bestaetigt, Muster, erzeugte Texte, Gewaehrleistung, Hash, Bestaetigungstext', async () => {
  const feature = await aktiviere()
  await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })
  const res = await lesen('rechtstexte')
  assert.equal(res.status, 200)
  const b = res.body
  assert.deepEqual(Object.keys(b).sort(), ['bestaetigt', 'bestaetigungText', 'entwurf', 'gewaehrleistung', 'hash', 'muster', 'versandUndZahlung', 'vollstaendig'])
  assert.deepEqual(b.entwurf, { agb: '', widerrufsbelehrung: '', widerrufsformular: '', impressumUrl: '', datenschutzUrl: '' })
  assert.equal(b.bestaetigt, null)
  assert.equal(b.vollstaendig, false)
  assert.match(b.hash, /^[0-9a-f]{64}$/)
  assert.equal(b.hash, rechtstexteHash(b.entwurf, (await lesen('einstellungen')).body.einstellungen))
  for (const k of ['agb', 'widerrufsbelehrung', 'widerrufsformular']) assert.ok(b.muster[k].length > 100, k)
  assert.ok(b.muster.agb.includes('Töpferei Keramik'))
  assert.ok(b.muster.widerrufsbelehrung.includes(`${config.publicBaseUrl}/shop/${feature.siteKey}/widerruf`))
  assert.ok(b.versandUndZahlung.includes('Versand'))
  assert.deepEqual([b.gewaehrleistung.bild, b.gewaehrleistung.text.startsWith('GESETZLICHE GEWÄHRLEISTUNG')], ['/img/gewaehrleistung-eu.webp', true])
  assert.match(b.bestaetigungText, /^Ich habe die Texte geprüft/)
})

test('Rechtstexte PUT: speichert den Entwurf, normalisiert, Fehler 400; Hash aendert sich mit dem Text', async () => {
  const feature = await aktiviere()
  const leer = (await lesen('rechtstexte')).body.hash
  const res = await schreiben('PUT', 'rechtstexte', { rechtstexte: { ...TEXTE, agb: '  Neue AGB  \r\n\r\n\r\n\r\nZeile', extra: 'x' } })
  assert.equal(res.status, 200)
  assert.equal(res.body.entwurf.agb, 'Neue AGB\n\nZeile')
  assert.equal(res.body.vollstaendig, true)
  assert.notEqual(res.body.hash, leer)
  assert.equal((await lesen('rechtstexte')).body.entwurf.widerrufsformular, 'Unser Widerrufsformular.')
  assert.equal(JSON.parse(shopConfigDoc(feature).rechtstexte).bestaetigt, null)

  const schlecht = await schreiben('PUT', 'rechtstexte', { rechtstexte: { ...TEXTE, impressumUrl: 'http://unsicher.example', datenschutzUrl: 'javascript:alert(1)' } })
  assert.equal(schlecht.status, 400)
  assert.ok(schlecht.body.fehler.impressumUrl && schlecht.body.fehler.datenschutzUrl)
  assert.equal((await schreiben('PUT', 'rechtstexte', { rechtstexte: 'text' })).status, 400)
  assert.equal((await schreiben('PUT', 'rechtstexte', {})).status, 400)
  const zuLang = await schreiben('PUT', 'rechtstexte', { rechtstexte: { ...TEXTE, agb: 'x'.repeat(30001) } })
  assert.equal(zuLang.status, 400)
  assert.equal((await lesen('rechtstexte')).body.entwurf.agb, 'Neue AGB\n\nZeile', 'Fehler aendert nichts')
})

test('Rechtstexte bestaetigen: falscher oder alter Hash 409, unvollstaendig 400, sonst Kopie mit Zeit, Person und Hash', async () => {
  const feature = await aktiviere()
  await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })
  const unvollstaendig = await schreiben('PUT', 'rechtstexte', { rechtstexte: { ...TEXTE, datenschutzUrl: '' } })
  const hashUnvollstaendig = unvollstaendig.body.hash
  const leer = await schreiben('POST', 'rechtstexte/bestaetigen', { hash: hashUnvollstaendig })
  assert.equal(leer.status, 400)
  assert.equal(shopConfigDoc(feature).rechtstexteHash || '', '')

  const voll = await schreiben('PUT', 'rechtstexte', { rechtstexte: TEXTE })
  const falsch = await schreiben('POST', 'rechtstexte/bestaetigen', { hash: 'abc' })
  assert.deepEqual([falsch.status, falsch.body.code], [409, 'texte_geaendert'])
  assert.match(falsch.body.error, /^Die Texte wurden inzwischen geändert/)
  assert.equal((await schreiben('POST', 'rechtstexte/bestaetigen', {})).status, 409)
  assert.equal((await schreiben('POST', 'rechtstexte/bestaetigen', { hash: hashUnvollstaendig })).status, 409, 'Hash des frueheren Entwurfs')

  const ok = await schreiben('POST', 'rechtstexte/bestaetigen', { hash: voll.body.hash })
  assert.equal(ok.status, 200)
  assert.deepEqual(ok.body.bestaetigt.texte, TEXTE)
  assert.equal(ok.body.bestaetigt.von, `${customers.c1.name} <${customers.c1.email}>`)
  assert.equal(ok.body.bestaetigt.aktuell, true)
  assert.ok(Math.abs(Date.now() - Date.parse(ok.body.bestaetigt.at)) < 10_000)
  const doc = shopConfigDoc(feature)
  assert.equal(doc.rechtstexteHash, voll.body.hash)
  assert.equal(doc.rechtstexteBestaetigtVon, `${customers.c1.name} <${customers.c1.email}>`)
  assert.equal(new Date(doc.rechtstexteBestaetigtAt).toISOString(), new Date(ok.body.bestaetigt.at).toISOString())
  const gespeichert = JSON.parse(doc.rechtstexte)
  assert.deepEqual(gespeichert.entwurf, TEXTE)
  assert.deepEqual([gespeichert.bestaetigt.texte, gespeichert.bestaetigt.hash], [TEXTE, voll.body.hash])
  assert.equal((await shopPerSiteKey(feature.siteKey)).shop.rechtstexte.bestaetigt.hash, voll.body.hash, 'Speicher wurde geleert')

  // Entwurf aendern: die bestaetigte Fassung bleibt, ist aber nicht mehr aktuell; Bereitschaft verlangt neue Bestaetigung
  const geaendert = await schreiben('PUT', 'rechtstexte', { rechtstexte: { ...TEXTE, agb: 'Geaenderte AGB' } })
  assert.deepEqual(geaendert.body.bestaetigt.texte, TEXTE)
  assert.equal(geaendert.body.bestaetigt.aktuell, false)
  assert.equal(geaendert.body.entwurf.agb, 'Geaenderte AGB')
  const stand = (await lesen('status')).body.bereitschaft.punkte.find((p) => p.id === 'rechtstexte')
  assert.equal(stand.ok, false)
  assert.equal((await schreiben('POST', 'rechtstexte/bestaetigen', { hash: voll.body.hash })).status, 409, 'alter Hash')
})

test('Rechtstexte: Hash haengt auch an den Einstellungen (Versand und Zahlung), eine Aenderung dort verlangt neue Bestaetigung', async () => {
  await aktiviere()
  await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })
  await schreiben('PUT', 'rechtstexte', { rechtstexte: TEXTE })
  const alt = (await lesen('rechtstexte')).body.hash
  await schreiben('PUT', 'einstellungen', { einstellungen: { ...EINSTELLUNGEN, versand: { ...EINSTELLUNGEN.versand, kostenCent: { DE: 690 } } } })
  const neu = (await lesen('rechtstexte')).body.hash
  assert.notEqual(alt, neu)
  assert.equal((await schreiben('POST', 'rechtstexte/bestaetigen', { hash: alt })).status, 409)
  assert.equal((await schreiben('POST', 'rechtstexte/bestaetigen', { hash: neu })).status, 200)
})

// ---------------------------------------------------------------- Oeffnen

test('Oeffnen: nur wenn bereit (sonst 409 mit Punkten), Schliessen immer, Speicher geleert, Eingabe geprueft', async () => {
  const feature = await machBereit({ mitArtikel: false })
  const nicht = await schreiben('POST', 'oeffnen', { offen: true })
  assert.deepEqual([nicht.status, nicht.body.code], [409, 'nicht_bereit'])
  assert.deepEqual(nicht.body.punkte.filter((p) => !p.ok).map((p) => p.id), ['artikel'])
  assert.ok(nicht.body.punkte.every((p) => typeof p.text === 'string'))
  assert.equal(shopConfigDoc(feature).geoeffnet !== true, true)
  assert.equal((await schreiben('POST', 'oeffnen', { offen: 'ja' })).status, 400)
  assert.equal((await schreiben('POST', 'oeffnen', {})).status, 400)

  await schreiben('POST', 'produkte', { produkt: ARTIKEL })
  const vorher = await shopPerSiteKey(feature.siteKey)
  assert.equal(vorher.shop.geoeffnet, false)
  const auf = await schreiben('POST', 'oeffnen', { offen: true })
  assert.equal(auf.status, 200)
  assert.deepEqual([auf.body.schalter, auf.body.geoeffnet, auf.body.bereitschaft.bereit], [true, true, true])
  assert.equal(shopConfigDoc(feature).geoeffnet, true)
  assert.match(shopConfigDoc(feature).geoeffnetAt, /^\d{4}-\d\d-\d\d/)
  assert.equal((await shopPerSiteKey(feature.siteKey)).shop.geoeffnet, true, 'Speicher geleert')

  const zu = await schreiben('POST', 'oeffnen', { offen: false })
  assert.deepEqual([zu.status, zu.body.schalter, zu.body.geoeffnet], [200, false, false])
  assert.equal((await shopPerSiteKey(feature.siteKey)).shop.geoeffnet, false)

  // Stripe faellt aus: Oeffnen scheitert, Schliessen geht trotzdem
  await updateDocument(config.collections.shopConfig, feature.$id, { stripeStatus: JSON.stringify({ charges_enabled: false }) })
  const stripeAus = await schreiben('POST', 'oeffnen', { offen: true })
  assert.deepEqual([stripeAus.status, stripeAus.body.punkte.filter((p) => !p.ok).map((p) => p.id)], [409, ['stripe']])
  assert.equal((await schreiben('POST', 'oeffnen', { offen: false })).status, 200)
})

// ---------------------------------------------------------------- Kundenansicht

test('Kundenansicht: Einstellungen, Artikel, Rechtstexte-Entwurf und Bilder erlaubt und protokolliert; Lesen ebenfalls', async () => {
  const feature = await aktiviere()
  assert.equal((await lesen('einstellungen', 'pt1', KV)).status, 200)
  assert.equal((await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN }, KV)).status, 200)
  const neu = await schreiben('POST', 'produkte', { produkt: ARTIKEL }, KV)
  assert.equal(neu.status, 201)
  const id = neu.body.produkt.id
  assert.equal((await schreiben('PUT', `produkte/${id}`, { produkt: { ...ARTIKEL, name: 'Kanne' } }, KV)).status, 200)
  assert.equal((await schreiben('POST', 'produkte/sortierung', { ids: [id] }, KV)).status, 200)
  assert.equal((await schreiben('PUT', 'rechtstexte', { rechtstexte: TEXTE }, KV)).status, 200)
  const bild = await lade(await png(), { opts: KV })
  assert.equal(bild.status, 201)
  assert.equal((await schreiben('DELETE', `produkte/${id}`, {}, KV)).status, 200)
  assert.equal((await dateien(feature.siteKey)).length, 3, 'das hochgeladene Bild gehoert keinem Artikel und wartet auf den Nachtjob')

  const eintraege = [...aw.docs('customerViewLog').values()]
  assert.ok(eintraege.every((e) => e.action === 'shop_aenderung' && e.staffName === 'Andrej' && e.customerId === 'c1'))
  assert.deepEqual(eintraege.map((e) => e.detail).sort(), [
    'Artikel angelegt: Tasse', 'Artikel geändert: Kanne', 'Artikel gelöscht: Kanne', 'Artikel sortiert', 'Bild hochgeladen',
    'Einstellungen gespeichert', 'Rechtstexte-Entwurf gespeichert',
  ].sort())
}) 

test('Kundenansicht: Anfrage, Oeffnen und Bestaetigen sind gesperrt (Waechter), Stripe-Pfade auch', async () => {
  await machBereit()
  const hash = (await lesen('rechtstexte')).body.hash
  for (const [pfad, body] of [['oeffnen', { offen: true }], ['rechtstexte/bestaetigen', { hash }], ['anfrage', {}], ['stripe/verbinden', {}]]) {
    const res = await schreiben('POST', pfad, body, KV)
    assert.deepEqual([res.status, res.body.code], [403, 'view_blocked'], pfad)
  }
  assert.equal(shopConfigDoc(await sf.getFeatureDoc('c1', 'pt1', 'shop')).geoeffnet !== true, true)
})

test('Kundenansicht: der Router sperrt Oeffnen und Bestaetigen selbst, auch ohne Waechter (alte Ansicht und Kundenansicht)', async () => {
  await machBereit()
  const hash = (await lesen('rechtstexte')).body.hash
  const express = (await import('express')).default
  const { sessionMiddleware } = await import('../server/middleware/session.js')
  const roh = express()
  roh.use(sessionMiddleware())
  roh.use(express.json())
  roh.use('/api/shop', shopRoutes)
  const server = await new Promise((resolve) => {
    const s = roh.listen(0, '127.0.0.1', () => resolve(s))
  })
  try {
    const url = `http://127.0.0.1:${server.address().port}`
    for (const [pfad, body] of [['/api/shop/oeffnen', { projectId: 'pt1', offen: true }], ['/api/shop/rechtstexte/bestaetigen', { projectId: 'pt1', hash }]]) {
      for (const c of [kundenansichtCookie({ customerId: 'c1' }), viewAsCookie('c1')]) {
        const res = await fetch(url + pfad, { method: 'POST', headers: { 'content-type': 'application/json', cookie: c }, body: JSON.stringify(body) })
        assert.equal(res.status, 403, pfad)
        assert.equal((await res.json()).error, 'In der Kundenansicht kann das nicht geändert werden.')
      }
    }
  } finally {
    await new Promise((resolve) => server.close(resolve))
  }
  assert.equal(JSON.parse(shopConfigDoc(await sf.getFeatureDoc('c1', 'pt1', 'shop')).rechtstexte).bestaetigt.hash, hash, 'unveraendert')
  assert.equal(shopConfigDoc(await sf.getFeatureDoc('c1', 'pt1', 'shop')).geoeffnet !== true, true)
})

// ---------------------------------------------------------------- Rate-Limit und Fehler

test('Schreib-Limit: 300 je Stunde und Kunde, danach 429; Lesen zaehlt nicht; anderer Kunde unberuehrt', async () => {
  await aktiviere()
  for (let i = 0; i < 300; i++) {
    const res = await send('POST', '/api/shop/oeffnen', { cookie, body: { projectId: 'pt1' } })
    assert.equal(res.status, 400, `Aufruf ${i + 1}`)
  }
  const zuViele = await send('POST', '/api/shop/oeffnen', { cookie, body: { projectId: 'pt1', offen: false } })
  assert.deepEqual([zuViele.status, zuViele.body.error], [429, 'Zu viele Änderungen in kurzer Zeit. Bitte versuch es in einer Stunde wieder.'])
  assert.equal((await schreiben('PUT', 'einstellungen', { einstellungen: EINSTELLUNGEN })).status, 429)
  assert.equal((await lesen('einstellungen')).status, 200)
  assert.equal((await lesen('status')).status, 200)
  assert.equal((await schreiben('POST', 'oeffnen', { offen: false }, { cookie: customerCookie('c2') })).status !== 429, true)
})

test('Fehlertexte von Appwrite verlassen den Server nie (500 ohne Rohtext)', async () => {
  await aktiviere()
  aw.failNext({ collection: 'shopProducts', method: 'GET', status: 500, message: 'GEHEIM interner Appwrite-Text' })
  const res = await lesen('produkte')
  assert.equal(res.status, 500)
  assert.deepEqual(res.body, { error: 'Interner Serverfehler' })
  assert.equal((await lesen('produkte')).status, 200)
})