import { config } from '../../config.js'
import { createDocument, getDocument, updateDocument } from '../appwriteAdmin.js'
import { analyseHosts } from '../analyse.js'
import { withLocks } from '../keyedLock.js'
import { findActiveBySiteKey } from '../siteFeatures.js'
import { fehlendePflichtangaben } from './einstellungen.js'
import { termineAus } from './schalter.js'
import { pruefeNow, pruefeText } from './util.js'

/**
 * Kontext einer Terminplaner-Funktion (Spezifikation 2026-10-02-terminplaner-design.md, Abschnitte 2 und 8) und
 * Speicher der Betriebs-Einstellung (termineConfig, Dokument-ID = ID des portalFeatures-Dokuments).
 *
 * ctx = { feature, project, einstellung, version }
 *   feature       portalFeatures-Dokument (featureKey 'termine')
 *   project       websiteProjects-Dokument oder null (Projekt fehlt)
 *   einstellung   gespeicherte Einstellung (Objekt) oder null (noch nie gespeichert / unlesbar)
 *   version       Zaehler fuer die optimistische Sperre (0 = noch nie gespeichert; bei unlesbarem JSON die Version des Dokuments)
 * Ein ctx ist nur zum Lesen: kontextPerSiteKey gibt innerhalb von 30 Sekunden dasselbe Objekt zurueck.
 *
 * - kontextPerSiteKey (oeffentliche Schnittstelle): nur Funktionen im Zustand active und nur mit gespeicherter
 *   Einstellung, in der die Pflichtangaben fuer Gaeste stehen (fehlendePflichtangaben, Ruling R41: ein Entwurf aus einer
 *   Vorlage ist noch nicht buchbar); Modus off => null ohne jede Abfrage. Treffer und Fehlschlaege werden 30 Sekunden je siteKey im Speicher
 *   gehalten (Zustandswechsel der Funktion wirken so mit hoechstens 30 Sekunden Verzoegerung); speichereEinstellung
 *   leert den Speicher. Eine Abfrage, die waehrend eines Speicherns lief, landet nie im Speicher (generation).
 * - kontextPerFeature (Portal, Gaesteseiten per Token): active und disabled (Gaeste duerfen weiter absagen und widerrufen),
 *   ohne Speicher; liefert auch ohne gespeicherte Einstellung einen ctx (einstellung null, version 0).
 * Fehlt eine Collection (404 collection_not_found), wird der Fehler weitergereicht und nicht als "nicht gefunden" gelesen.
 */

const FUNKTION = 'termine'
const SITE_KEY_RE = /^[a-z2-7]{16}$/
const CACHE_MS = 30 * 1000
const CACHE_MAX = 10000

const cache = new Map()
/** Wird mit jedem Speichern erhoeht: eine Abfrage, die davor begann, darf ihr Ergebnis nicht mehr merken. */
let generation = 0

const istObjekt = (wert) => wert !== null && typeof wert === 'object' && !Array.isArray(wert)

/** 404 "Dokument fehlt" (nicht: Collection oder Datenbank fehlt). */
const dokumentFehlt = (err) => err?.status === 404 && err.type !== 'collection_not_found' && err.type !== 'database_not_found'

async function holeOderNull(collectionId, id) {
  try {
    return await getDocument(collectionId, id)
  } catch (err) {
    if (dokumentFehlt(err)) return null
    throw err
  }
}

/**
 * { einstellung, version } aus einem termineConfig-Dokument. Unlesbares JSON (mit Log) ergibt einstellung null, die Version
 * des Dokuments bleibt: wer die kaputte Einstellung ueberschreiben will, speichert mit genau dieser Version.
 */
function liesDokument(doc) {
  const version = Number.isInteger(doc.version) ? doc.version : 0
  try {
    const einstellung = JSON.parse(doc.einstellung)
    if (!istObjekt(einstellung)) throw new Error('kein Objekt')
    return { einstellung, version }
  } catch (err) {
    console.error(`[termine-kontext] Einstellung ${doc.$id} ist unlesbar: ${err.message}`)
    return { einstellung: null, version }
  }
}

/**
 * Die gespeicherte Einstellung einer Funktion.
 * @param {string} featureId ID des portalFeatures-Dokuments
 * @returns {Promise<{ einstellung: object, version: number }|null>} null, wenn es noch keine (lesbare) gibt
 */
export async function ladeEinstellung(featureId) {
  pruefeText(featureId, 'featureId')
  const doc = await holeOderNull(config.collections.termineConfig, featureId)
  const gelesen = doc ? liesDokument(doc) : null
  return gelesen?.einstellung ? gelesen : null
}

async function baueKontext(feature) {
  const [project, doc] = await Promise.all([
    feature.projectId ? holeOderNull(config.collections.websiteProjects, feature.projectId) : null,
    holeOderNull(config.collections.termineConfig, feature.$id),
  ])
  const gelesen = doc ? liesDokument(doc) : null
  return { feature, project, einstellung: gelesen?.einstellung ?? null, version: gelesen?.version ?? 0 }
}

/**
 * Kontext fuer die oeffentliche Schnittstelle: aktive Funktion 'termine' mit diesem siteKey und gespeicherter Einstellung.
 * @param {string} siteKey
 * @param {Date} [now] Zeitpunkt fuer den 30-Sekunden-Speicher
 * @returns {Promise<object|null>} null bei Modus off, ungueltigem oder unbekanntem siteKey, anderem Zustand als active
 *   und fehlender Einstellung
 */
export async function kontextPerSiteKey(siteKey, now = new Date()) {
  if (termineAus()) return null
  if (typeof siteKey !== 'string' || !SITE_KEY_RE.test(siteKey)) return null
  const nowMs = pruefeNow(now, 'kontextPerSiteKey')
  const gemerkt = cache.get(siteKey)
  if (gemerkt && gemerkt.bis > nowMs) return gemerkt.ctx

  const stand = generation
  const feature = await findActiveBySiteKey(siteKey, FUNKTION)
  let ctx = feature ? await baueKontext(feature) : null
  if (ctx && (!ctx.einstellung || fehlendePflichtangaben(ctx.einstellung).length > 0)) ctx = null
  if (stand === generation) merke(siteKey, ctx, nowMs)
  return ctx
}

function merke(siteKey, ctx, nowMs) {
  if (cache.size >= CACHE_MAX) {
    for (const [key, eintrag] of cache) if (eintrag.bis <= nowMs) cache.delete(key)
    if (cache.size >= CACHE_MAX) cache.delete(cache.keys().next().value)
  }
  cache.set(siteKey, { bis: nowMs + CACHE_MS, ctx })
}

/**
 * Kontext fuer Portal und Gaesteseiten (Token): Funktion 'termine' im Zustand active oder disabled, ohne Speicher.
 * @param {string} featureId ID des portalFeatures-Dokuments
 * @returns {Promise<object|null>} null bei Modus off, unbekannter ID, anderer Funktion oder anderem Zustand
 */
export async function kontextPerFeature(featureId) {
  if (termineAus()) return null
  if (typeof featureId !== 'string' || featureId === '') return null
  const feature = await holeOderNull(config.collections.portalFeatures, featureId)
  if (!feature || feature.featureKey !== FUNKTION || !['active', 'disabled'].includes(feature.state)) return null
  return baueKontext(feature)
}

const veraltet = () =>
  Object.assign(new Error('Die Einstellungen wurden inzwischen geändert. Bitte neu laden.'), {
    status: 409,
    code: 'EINSTELLUNG_VERALTET',
  })

/**
 * Speichert die (bereits geprueften) Einstellungen. Optimistisch gesperrt: version ist die Version, auf der die
 * Aenderung beruht (0 = noch nie gespeichert); weicht sie von der gespeicherten ab, passiert nichts und es folgt
 * { status: 409, code: 'EINSTELLUNG_VERALTET' }. Lesen, Pruefen und Schreiben laufen unter der Sperre
 * termine-cfg:<featureId>. Danach ist der Speicher von kontextPerSiteKey leer.
 * Statt der Einstellung darf eine Funktion `async (bisher) => einstellung` uebergeben werden (Ruling R40): sie laeuft
 * INNERHALB der Sperre nach der Versionspruefung, bekommt die gespeicherte Einstellung (Objekt) oder null und liefert die
 * zu speichernde; sie darf werfen (der Fehler geht unveraendert durch, es wird nichts geschrieben). So laufen Pruefungen,
 * die den gespeicherten Stand und die Buchungen brauchen (Entfernen mit kuenftigen Terminen), unter derselben Sperre wie
 * das Schreiben. version null ueberspringt die Versionspruefung (nur fuer Aenderungen, die auf dem aktuellen Stand
 * aufbauen, z. B. neuer Kalender-Link); die Version zaehlt trotzdem hoch.
 * @param {{ $id: string, customerId: string, projectId: string }} feature portalFeatures-Dokument
 * @param {object|((bisher: object|null) => object|Promise<object>)} einstellungOderFn
 * @param {{ version: number|null, by?: string, now?: Date }} optionen
 * @returns {Promise<{ einstellung: object, version: number }>} wie gespeichert, mit der neuen Version
 */
export async function speichereEinstellung(feature, einstellungOderFn, { version, by = '', now = new Date() } = {}) {
  pruefeText(feature?.$id, 'feature.$id')
  const alsFunktion = typeof einstellungOderFn === 'function'
  if (!alsFunktion && !istObjekt(einstellungOderFn)) throw new TypeError('einstellung fehlt')
  const nowMs = pruefeNow(now, 'speichereEinstellung')

  return withLocks([`termine-cfg:${feature.$id}`], async () => {
    const col = config.collections.termineConfig
    const vorhanden = await holeOderNull(col, feature.$id)
    const aktuell = vorhanden && Number.isInteger(vorhanden.version) ? vorhanden.version : 0
    if (version !== null && version !== aktuell) throw veraltet()

    const einstellung = alsFunktion ? await einstellungOderFn(vorhanden ? liesDokument(vorhanden).einstellung : null) : einstellungOderFn
    if (!istObjekt(einstellung)) throw new TypeError('einstellung fehlt')
    const json = JSON.stringify(einstellung)

    const felder = {
      customerId: feature.customerId,
      projectId: feature.projectId,
      einstellung: json,
      version: aktuell + 1,
      updatedAt: new Date(nowMs).toISOString(),
      updatedBy: String(by ?? '').slice(0, 100),
    }
    try {
      if (vorhanden) await updateDocument(col, feature.$id, felder)
      else await createDocument(col, felder, feature.$id)
    } finally {
      // auch bei einem Fehler: unklar, was in der Datenbank steht
      generation += 1
      cache.clear()
    }
    return { einstellung: JSON.parse(json), version: aktuell + 1 }
  })
}

/**
 * Adresse der Website des Betriebs (Link auf Gaesteseiten und im Mailfuss), immer die echte Seite statt der Vorschau:
 * betrieb.websiteUrl; sonst https:// + Live-Domain des Projekts (wenn project.liveDomain einen gueltigen Host ergibt);
 * sonst https:// + <subdomain>.project.webklar.com; sonst die Portal-Adresse (config.publicBaseUrl).
 */
export function websiteUrl(ctx) {
  const eigene = ctx?.einstellung?.betrieb?.websiteUrl
  if (typeof eigene === 'string' && eigene !== '') return eigene
  const project = ctx?.project
  if (project) {
    // analyseHosts: [<subdomain>.project.webklar.com, Live-Domain], ungueltige und doppelte Hosts fehlen
    const hosts = analyseHosts(project)
    const vorschau = project.subdomain ? `${String(project.subdomain).trim().toLowerCase()}.project.webklar.com` : null
    const live = project.liveDomain ? hosts.find((host) => host !== vorschau) : undefined
    const host = live ?? hosts.find((h) => h === vorschau)
    if (host) return `https://${host}`
  }
  return config.publicBaseUrl
}

/** Leert den Speicher von kontextPerSiteKey (Tests). */
export function resetKontextForTests() {
  generation += 1
  cache.clear()
}