// UI-Testserver des Buchungskalenders (fuer test/ui/unterkunft.ui.mjs): die echten Express-Router (/api/public/unterkunft/v1,
// /api/shop/stripe-webhook (leitet Buchungskalender-Ereignisse weiter), /api/unterkunft, /api/funktionen), die Seiten /unterkunft/... samt
// iCal-Export und public/ als statische Dateien, dahinter der Nachbau von Appwrite und Stripe (Connect) aus test/support/ und eine Mail-Senke.
// Nichts verlaesst den Rechner (useTestEnv erlaubt nur 127.0.0.1). Muster: test/ui/shopTestServer.mjs.
//
// Aufruf in einem Skript (KEINE Server-Module vorher importieren, config.js liest die Umgebung beim ersten Import):
//   import { startUnterkunftUiServer } from './unterkunftTestServer.mjs'
//   const srv = await startUnterkunftUiServer()
//   ... srv.url, srv.portalUrl, srv.kundenUrl, srv.sink.sent, srv.st (Stripe-Nachbau), srv.aw (Appwrite-Nachbau) ...
//   await srv.stop()   // erst den Browser schliessen, dann den Server
//
// Adressen: Der Server lauscht auf srv.url (http://127.0.0.1:PORT). Das Portal heisst fuer Server und Browser srv.portalUrl
// (https://project.webklar.test = config.publicBaseUrl); das Skript leitet diese Adresse im Browser per page.route an srv.url um.
// Die Website des Vermieters heisst srv.kundenUrl (liveDomain des Projekts); ihre Seiten liefert das Skript per page.route.
// Uhr: echte Uhr (Server und Browser).
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import express from 'express'
import { startAppwriteMock } from '../support/appwriteMock.js'
import { startFakeStripe } from '../support/fakeStripe.js'
import { mailSink } from '../support/mailSink.js'
import { schemaKeys } from '../support/schema.js'
import { useTestEnv } from '../support/testEnv.js'

const PUBLIC_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../public')

export const PORTAL_URL = 'https://project.webklar.test'
export const KUNDEN_URL = 'https://www.donau-home.example'
export const KUNDE = 'c1'
export const PROJEKT = 'p1'
export const FEATURE = 'f_p1_unterkunft'
export const SITE_KEY = 'donauhomeukwxyz2'
export const CONNECT_SECRET = 'whsec_connect_ui_test'
export const KUNDEN_EMAIL = 'mimi@donau-home.example'
export const KUNDEN_NAME = 'Mimi Donau'

const SAMMLUNGEN = [
  'portalFeatures', 'ukEinstellungen', 'ukUnterkuenfte', 'ukPreise', 'ukSperren', 'ukAnfragen', 'ukRechnungen',
  'shopConfig', 'shopProducts', 'shopOrders', 'shopWiderrufe', 'shopRechtstexteArchiv', 'termineOutbox', 'featureConsents', 'subscriptions',
]

export async function startUnterkunftUiServer() {
  const { UNTERKUNFT_DATETIMES } = await import('../../server/services/unterkunft/schema.js')
  const { SHOP_DATETIMES } = await import('../../server/services/shop/schema.js')
  const { TERMINE_DATETIMES } = await import('../../server/services/termine/schema.js')
  const aw = await startAppwriteMock({
    schema: Object.fromEntries(SAMMLUNGEN.map((n) => [n, schemaKeys(n)])),
    datetimes: { ...SHOP_DATETIMES, ...TERMINE_DATETIMES, ...UNTERKUNFT_DATETIMES },
    defaultLimit: 25,
  })
  const st = await startFakeStripe()
  useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })

  const { config } = await import('../../server/config.js')
  const { startTestApp, postWebhook, sessionCookie } = await import('../support/testApp.js')
  const { setMailTransportForTests } = await import('../../server/services/mailer.js')
  const { deleteDocument } = await import('../../server/services/appwriteAdmin.js')
  const { default: publicRoutes, setzeUhrFuerTests } = await import('../../server/routes/publicUnterkunft.js')
  const { default: unterkunftRoutes, resetUnterkunftRoutesForTests } = await import('../../server/routes/unterkunft.js')
  const { default: shopWebhookRoutes } = await import('../../server/routes/shopWebhook.js')
  const { default: funktionenRoutes } = await import('../../server/routes/funktionen.js')
  const { unterkunftSeiteRouter, resetUnterkunftSeiteForTests } = await import('../../server/routes/unterkunftSeite.js')
  const { legalRouter } = await import('../../server/services/legalDocs.js')
  const { leereCache } = await import('../../server/services/unterkunft/kontext.js')
  const mails = await import('../../server/services/unterkunft/mails.js')
  const zahlung = await import('../../server/services/unterkunft/zahlung.js')
  const { resetOutboxForTests, warteAufVersand } = await import('../../server/services/termine/outbox.js')
  const { resetTermineLimitsForTests } = await import('../../server/services/termine/limits.js')

  // Reihenfolge wie server/index.js: /embed (CORS), /rechtliches, Buchungskalender-Seiten, public/
  const statisch = express.Router()
  statisch.use('/embed/', (_req, res, next) => {
    res.set('Access-Control-Allow-Origin', '*')
    next()
  })
  statisch.use('/rechtliches', legalRouter())
  statisch.use(unterkunftSeiteRouter())
  statisch.use(express.static(PUBLIC_DIR))

  const app = await startTestApp({
    '/api/public/unterkunft/v1': publicRoutes,
    '/api/shop/stripe-webhook': shopWebhookRoutes,
    '/api/unterkunft': unterkunftRoutes,
    '/api/funktionen': funktionenRoutes,
    '/': statisch,
  })
  const uploadDir = await mkdtemp(path.join(tmpdir(), 'unterkunft-ui-'))

  const vorher = {
    unterkunft: { ...config.unterkunft },
    shopMode: config.shop.mode,
    shopPilot: config.shop.pilotEmails,
    connectWebhookSecret: config.shop.connectWebhookSecret,
    uploadDir: config.shop.uploadDir,
    publicBaseUrl: config.publicBaseUrl,
    smtpFrom: config.smtp.from,
  }
  const col = (name) => config.collections[name]
  const json = (name, wert) => (typeof wert === 'string' ? JSON.parse(wert) : wert)

  const srv = {
    url: app.url,
    portalUrl: PORTAL_URL,
    kundenUrl: KUNDEN_URL,
    KUNDE, PROJEKT, FEATURE, SITE_KEY,
    aw, st, config, mails, zahlung,
    sink: null,
    warteAufVersand,

    /** Cookie des Portal-Kunden (c1) fuer context.addCookies([...]): { name, value, url }. */
    async portalCookie() {
      const roh = sessionCookie({ customerId: KUNDE, appwriteUserId: `u_${KUNDE}`, name: KUNDEN_NAME, email: KUNDEN_EMAIL })
      const i = roh.indexOf('=')
      return { name: roh.slice(0, i), value: roh.slice(i + 1), url: PORTAL_URL }
    },

    // ---------------------------------------------------------------- Dokumente lesen (JSON-Felder geparst)
    einstellungen() { return [...aw.docs('ukEinstellungen').values()][0] ?? null },
    unterkuenfte() { return [...aw.docs('ukUnterkuenfte').values()] },
    preise() { return [...aw.docs('ukPreise').values()].map((d) => ({ ...d, staffeln: json('staffeln', d.staffeln) })) },
    sperren() { return [...aw.docs('ukSperren').values()] },
    anfragen() {
      return [...aw.docs('ukAnfragen').values()].map((d) => ({
        ...d, gast: json('gast', d.gast), rechnungsadresse: json('r', d.rechnungsadresse), posten: json('p', d.posten), summen: json('s', d.summen),
      }))
    },
    anfrage(id) { return srv.anfragen().find((a) => a.$id === id) ?? null },
    rechnungen() { return [...aw.docs('ukRechnungen').values()].map((d) => ({ ...d, inhalt: json('i', d.inhalt) })) },
    outbox() { return [...aw.docs('termineOutbox').values()] },
    /** Mails der Senke; mit Teiltext des Betreffs filtern. Vorher warteAufVersand() (die Warteschlange sendet im Hintergrund). */
    mailsMit(betreff) { return srv.sink.sent.filter((m) => !betreff || String(m.subject).includes(betreff)) },
    /** Arten der bisher eingereihten Gastmails (G16 ...) in Reihenfolge. */
    gastArten() { return mails._aufrufe.filter((a) => a.an === 'gast').map((a) => a.art) },
    vermieterArten() { return mails._aufrufe.filter((a) => a.an === 'vermieter').map((a) => a.template) },

    // ---------------------------------------------------------------- Stripe (Haendlerkonto des Vermieters)
    kontoId() { return srv.einstellungen()?.stripeAccountId ?? null },
    /** Das Konto nimmt Zahlungen an (wie nach dem Onboarding bei Stripe). */
    kontoFreigeben(patch = {}) {
      const id = srv.kontoId()
      if (!id) throw new Error('kein Stripe-Konto angelegt')
      return st.setAccount(id, { charges_enabled: true, payouts_enabled: true, details_submitted: true, requirements: { currently_due: [], past_due: [], disabled_reason: null }, ...patch })
    },
    kassenSitzungen() { return [...st.accountSessions(srv.kontoId()).values()] },
    erstattungen() { return [...st.refunds(srv.kontoId()).values()] },
    /** Sitzung des Gastes als bezahlt abschliessen (Stripe-Nachbau); liefert die Sitzung, wie sie der Webhook traegt. */
    bezahleKasse(sessionId, { zahlung: pi = 'pi_uk_ui_1', betrag } = {}) {
      const acct = srv.kontoId()
      const sitzung = st.accountSessions(acct).get(sessionId)
      if (!sitzung) throw new Error(`keine Sitzung ${sessionId}`)
      const summe = betrag ?? sitzung.line_items?.[0]?.price_data?.unit_amount ?? srv.anfragen().find((a) => a.stripeSessionId === sessionId)?.summen?.bruttoCent ?? null
      st.setPaymentIntent(acct, pi, { amount: summe })
      return st.completeSession(acct, sessionId, { payment_status: 'paid', amount_total: summe, payment_intent: pi, payment_method_types: ['card'] })
    },
    /** Signiertes Connect-Ereignis an POST /api/shop/stripe-webhook -> { status, body }. */
    sendeConnect(type, objekt, { account } = {}) {
      const event = { id: `evt_${Math.random().toString(36).slice(2)}`, object: 'event', type, livemode: false, account: account ?? srv.kontoId(), data: { object: objekt } }
      return postWebhook(event, { path: '/api/shop/stripe-webhook', secret: CONNECT_SECRET })
    },

    leereCache() { leereCache() },

    /** Eine freigegebene (reservierte, noch nicht gebuchte) Anfrage ueber die Dienste anlegen (Kalenderfarbe „reserviert“); liefert { id, token }. */
    async reserviere({ unterkunftId, von, bis, personen = 2, name = 'Rita Reserviert', email = 'rita@example.com' }) {
      const ab = await import('../../server/services/unterkunft/ablauf.js')
      const { unterkunftPerSiteKey } = await import('../../server/services/unterkunft/kontext.js')
      const ctx = await unterkunftPerSiteKey(SITE_KEY)
      const a = await ab.legeAnfrageAn(ctx, { unterkunftId, von, bis, personen, gast: { name, firma: '', email, telefon: '', nachricht: '' } }, { now: new Date(), ipHash: 'ui' })
      const { token } = await ab.gibFrei(ctx, a.$id, { now: new Date() })
      return { id: a.$id, token }
    },

    /** Alles auf Anfang: Dokumente loeschen, Zwischenspeicher leeren, neue Senke; Kunde c1, Projekt p1, Funktion 'unterkunft' aktiv, Schalter on. */
    async zuruecksetzen() {
      await warteAufVersand()
      for (const sammlung of [...SAMMLUNGEN, 'customers', 'websiteProjects', 'workorders']) {
        for (const id of [...aw.docs(sammlung).keys()]) await deleteDocument(col(sammlung) ?? sammlung, id)
      }
      st.checkoutSessions.clear()
      st.invoices.clear()
      st.calls.length = 0
      leereCache()
      resetOutboxForTests()
      resetTermineLimitsForTests()
      resetUnterkunftRoutesForTests()
      resetUnterkunftSeiteForTests()
      zahlung.leereAbgleichFuerTests()
      mails._aufrufe.length = 0
      setzeUhrFuerTests(() => new Date())
      Object.assign(config.unterkunft, { mode: 'on', minAntwortMs: 0, formMinSekunden: 0 })
      config.shop.mode = 'pilot'
      config.shop.pilotEmails = ['*']
      config.shop.connectWebhookSecret = CONNECT_SECRET
      config.shop.uploadDir = uploadDir
      config.smtp.from = 'noreply@webklar.com'
      config.publicBaseUrl = PORTAL_URL
      srv.sink = mailSink()
      setMailTransportForTests(srv.sink)
      aw.seed('websiteProjects', {
        $id: PROJEKT, customerId: KUNDE, projectName: 'Donau Home', subdomain: 'donau-home', liveDomain: new URL(KUNDEN_URL).host,
      })
      aw.seed('customers', { $id: KUNDE, appwriteUserId: `u_${KUNDE}`, name: KUNDEN_NAME, email: KUNDEN_EMAIL, status: 'active', portalAccessEnabled: true })
      aw.seed('portalFeatures', {
        $id: FEATURE, customerId: KUNDE, projectId: PROJEKT, featureKey: 'unterkunft', siteKey: SITE_KEY, state: 'active', enabled: true,
      })
    },

    /** Beendet Server und Nachbauten (zuerst den Browser schliessen) und stellt config wieder her. */
    async stop() {
      await warteAufVersand().catch(() => {})
      setMailTransportForTests(null)
      Object.assign(config.unterkunft, vorher.unterkunft)
      Object.assign(config.shop, { mode: vorher.shopMode, pilotEmails: vorher.shopPilot, connectWebhookSecret: vorher.connectWebhookSecret, uploadDir: vorher.uploadDir })
      config.publicBaseUrl = vorher.publicBaseUrl
      config.smtp.from = vorher.smtpFrom
      let frist = null
      const geschlossen = app.close()
      app.server.closeAllConnections?.() // offene Verbindungen des Browsers (Keep-Alive) halten close() sonst auf
      await Promise.race([geschlossen, new Promise((resolve) => { frist = setTimeout(resolve, 3000) })])
      clearTimeout(frist)
      await Promise.all([aw.close(), st.close()])
      await rm(uploadDir, { recursive: true, force: true })
    },
  }

  await srv.zuruecksetzen()
  return srv
}