import { config } from '../../config.js'
import { getDocument, updateDocument } from '../appwriteAdmin.js'
import { pruefeAboFuerEinschalten } from '../featureOrder.js'
import { featureConfig, ticketTexte } from '../featureRegistry.js'
import { withLocks } from '../keyedLock.js'
import { customerOf, ensureFeatureDoc, getFeatureDoc, stateFields, ticketWoid, unlockedByVon } from '../siteFeatures.js'
import { ABRECHNUNGS_ZEILEN, createFeatureTicket } from '../ticketAdmin.js'
import { k27Mail, sendeZeitenMail } from './mails.js'
import { stosseNeubauAn } from './neubau.js'
import { ladeZeiten } from './speicher.js'
import { hauptplan, statusZu } from './zeitlogik.js'

/**
 * Gratisweg "Einschalten" von Oeffnungszeiten live im Wartungs-Abo (Spezifikation 2026-10-04-oeffnungszeiten-live-design.md, 3.2)
 * und die Selbstheilung der Schritte danach. Vorbild ist activateAnalyse (analyse.js).
 *
 *   einschaltenZeiten  Schritte 1-4 unter der Sperre `feature-order:<kunde>:<projekt>` (dieselbe wie im Checkout, damit sich
 *                      Bestellen und Einschalten ausschliessen): Abo frisch pruefen, Zustand pruefen (idempotent), Nachweis speichern,
 *                      Dokument auf setup. Danach, ohne diese Sperre: holeZeitenNach (Neubau, Ticket, K27).
 *   holeZeitenNach     Schritte 5 und 6, jeder fuer sich nur, wenn er noch fehlt: Neubau (einbau), Einbau-Ticket, K27, dann einschaltMailAt.
 *                      Eigene Sperre `zeiten-nachholen:<dokument>`: ein Doppelklick und der 5-Minuten-Job legen nie zwei Tickets an.
 *
 * Sperren (keyedLock) sind nicht wiederbetretbar: stosseNeubauAn nimmt seine eigene Sperre `zeiten-neubau`, darum laufen Neubau, Ticket
 * und Mail nie innerhalb von `feature-order`. Aufrufer, die `feature-order` oder `zeiten-nachholen` halten, duerfen diese Funktionen
 * nicht aufrufen.
 */

const KEY = 'zeiten'

/** Einhaengepunkt fuer Tests: die Uhr der Projektliste (GET /api/funktionen), die den Kurzstatus der Website berechnet. */
export const einschaltenDeps = { jetzt: () => new Date() }

const NOTIZ_MAX = 300
const NICHT_FERTIG = 'Öffnungszeiten live ist eingeschaltet, aber das Einrichten ist noch nicht fertig. Bitte versuch es in einer Minute noch einmal.'

const konflikt = (text) => Object.assign(new Error(text), { status: 409 })

/** Notiz am Dokument: die der Route (staff.adminNote) oder "<Zeit> <Name>: Eingeschaltet ohne Zahlung" vor der bisherigen Notiz. */
function notizDesTeams(staff, bisherige, now) {
  if (typeof staff?.adminNote === 'string' && staff.adminNote) return staff.adminNote.slice(0, NOTIZ_MAX)
  if (!staff?.name) return null
  const eintrag = `${now.toISOString()} ${staff.name}: Eingeschaltet ohne Zahlung`
  return (bisherige ? `${eintrag} | ${bisherige}` : eintrag).slice(0, NOTIZ_MAX)
}

/**
 * Oeffnungszeiten live fuer ein Projekt einschalten (Spec 3.2, Schritte 1 bis 6).
 * @param {{ customerId: string, projectId: string, by?: 'kunde'|'team', staff?: { name?: string, adminNote?: string }|null,
 *   nachweis?: (() => Promise<unknown>)|null, now?: Date }} p
 *   by 'kunde': Abo frisch pruefen (kein_abo/gekuendigt/nicht_aktiv 409, Lesefehler 503), unlockedBy 'abo', K27 geht an den Kunden.
 *   by 'team': keine Abo-Pruefung, unlockedBy 'team' (ein bisher gekauftes Dokument bleibt kauf), keine K27; staff ergibt die Notiz am Dokument.
 *   nachweis: speichert den Zustimmungsnachweis (Schritt 3, nur wenn wirklich eingeschaltet wird); wirft er, bleibt der Zustand unveraendert.
 *   abrechnung ('' | 'abo' | 'projekt', Abo-Modell der Kundenansicht neu, V7): ueberschreibt unlockedBy ('abo' | 'projekt'; ein gekauftes
 *   Dokument bleibt kauf) und setzt einrichtungAbrechnung am Dokument (das Einrichtungs-Ticket traegt es in holeZeitenNach weiter).
 *   Ohne abrechnung bleibt alles wie bisher. Ein anderer Wert ist ein TypeError.
 *   vorpruefung: Funktion, die unter der Sperre statt pruefeAboFuerEinschalten laeuft (nur by 'kunde'); sie wirft, was der Aufrufer
 *   als Fehler will (das Einschalten im Abo-Modell prueft damit Abo und Zustand mit eigenen Codes).
 * @returns {Promise<{ doc: object, changed: boolean }>} doc: das Dokument nach dem Nachholen; changed: false bei idempotentem Aufruf
 * @throws {Error} 409 (Abo, anderer Zustand), 503 (Abo nicht lesbar; oder Zustand gespeichert, aber Neubau/Ticket nicht fertig: erneut aufrufen)
 */
export async function einschaltenZeiten({ customerId, projectId, by = 'kunde', staff = null, nachweis = null, now = new Date(), abrechnung = '', vorpruefung = null } = {}) {
  if (by !== 'kunde' && by !== 'team') throw new TypeError(`einschaltenZeiten: by muss kunde oder team sein, nicht ${String(by)}`)
  if (abrechnung !== '' && abrechnung !== 'abo' && abrechnung !== 'projekt') {
    throw new TypeError(`einschaltenZeiten: abrechnung muss '', 'abo' oder 'projekt' sein, nicht ${String(abrechnung)}`)
  }
  const feature = featureConfig(KEY)

  const { doc, changed } = await withLocks([`feature-order:${customerId}:${projectId}`], async () => {
    // 1 Abo frisch (nie aus einem Zwischenspeicher); fuer das Team entfaellt es
    if (by === 'kunde') await (vorpruefung ? vorpruefung() : pruefeAboFuerEinschalten(customerId))

    // 2 Zustand: schon eingeschaltet (setup/active) ist idempotent; sonst nur aus off (der Kunde) bzw. off/ordered/disabled (das Team)
    const bisher = await getFeatureDoc(customerId, projectId, KEY)
    if (bisher?.state === 'setup' || bisher?.state === 'active') {
      if (by === 'team' || unlockedByVon(bisher) === 'abo') return { doc: bisher, changed: false }
      throw konflikt(feature.orderedConflictMessage)
    }
    if (by === 'kunde' && bisher?.state === 'ordered') throw konflikt(feature.orderedConflictMessage)
    if (by === 'kunde' && bisher?.state === 'disabled') throw konflikt(feature.disabledMessage)

    // 3 Zustimmung speichern (ohne Stripe-Sitzung), vor dem Zustand: scheitert sie, bleibt alles wie es war
    if (nachweis) await nachweis()

    // 4 Dokument auf setup. Reste einer frueheren Abschaltung oder eines Abo-Endes gehoeren zum alten Lauf und enden hier;
    // einbau beginnt leer, der Neubau (holeZeitenNach) setzt es neu.
    const vorhanden = bisher ?? (await ensureFeatureDoc(customerId, projectId, KEY))
    const notiz = by === 'team' ? notizDesTeams(staff, vorhanden.adminNote, now) : null
    // Ein gekauftes Dokument (bisher kauf), das das Team wieder einschaltet, bleibt gekauft: unlockedBy/unlockedByPurchase ordnen den
    // Widerruf zu (paidFeatureOrders). Neubau und Ticket kennt dort markPaid, nicht das Nachholen (holeZeitenNach laesst kauf aus): einbau
    // bleibt darum stehen, statt auf leer gesetzt zu werden, ohne dass es je neu gefuellt wuerde.
    const gekauft = by === 'team' && unlockedByVon(bisher) === 'kauf'
    const gespeichert = await updateDocument(config.collections.portalFeatures, vorhanden.$id, {
      ...stateFields('setup'),
      featureKey: KEY,
      unlockedBy: gekauft ? 'kauf' : abrechnung || (by === 'kunde' ? 'abo' : 'team'),
      unlockedByPurchase: gekauft,
      ...(abrechnung ? { einrichtungAbrechnung: abrechnung } : {}),
      ...(gekauft ? {} : { einbau: '' }),
      aboEndeAt: null,
      behaltenSessionId: '',
      disabledAt: null,
      disabledReason: null,
      aboEndeMailAt: null,
      ...(notiz ? { adminNote: notiz } : {}),
    })
    return { doc: gespeichert, changed: true }
  })

  // 5 und 6 nach der Sperre: Neubau, Ticket, K27
  try {
    return { doc: await holeZeitenNach(doc, { now }), changed }
  } catch (err) {
    // der Zustand ist gespeichert; ein erneuter Aufruf (oder der 5-Minuten-Job) holt nach. Im Log Art und Meldung, nie beim Kunden.
    console.error(`[zeiten] Einschalten für Projekt ${projectId}: Nachholen fehlgeschlagen: ${err?.name ?? 'Fehler'} ${err?.status ?? ''} ${err?.message ?? ''}`.trim())
    throw Object.assign(new Error(NICHT_FERTIG), { status: 503, cause: err })
  }
}

/**
 * Fehlende Schritte des Einschaltens nachholen (Spec 3.2 Schritt 5/6 und Selbstheilung): fuer ein Dokument im Zustand setup, das nicht
 * vom Kauf stammt (unlockedBy kauf bringt markPaid in Ordnung):
 *   1. einbau leer       => Neubau anstossen (stosseNeubauAn), Ergebnis in einbau
 *   2. ticketId leer     => Einbau-Ticket aus dem Register (Text mit dem frischen einbau), ticketId
 *   3. unlockedBy abo und einschaltMailAt leer => K27 an den Kunden, danach einschaltMailAt. Gesendet wird erst nach dem Ticket (die Mail nennt es);
 *      nicht gesendet (Fehler) laesst einschaltMailAt leer, ein Kunde ohne Adresse oder ein geloeschter Kunde bekommt einschaltMailAt (es gibt nichts zu senden).
 * Jeder Schritt erst nach dem Erfolg des vorigen. Liest das Dokument unter der Sperre frisch; andere Zustaende bleiben unberuehrt.
 * Wirft bei Lesefehlern und wenn das Ticket nicht angelegt werden kann (der Aufrufer faengt und versucht es spaeter); eine
 * nicht gesendete K27 wirft nicht.
 * @param {{ $id: string }} doc portalFeatures-Dokument der Zeiten (nur $id zaehlt)
 * @param {{ now?: Date }} [options]
 * @returns {Promise<object>} das aktuelle Dokument
 */
export async function holeZeitenNach(doc, { now = new Date() } = {}) {
  if (!doc?.$id) return doc
  return withLocks([`zeiten-nachholen:${doc.$id}`], async () => {
    let frisch = await getDocument(config.collections.portalFeatures, doc.$id)
    if (frisch.state !== 'setup' || unlockedByVon(frisch) === 'kauf') return frisch
    const mitK27 = unlockedByVon(frisch) === 'abo'
    // nichts fehlt: weder Projekt noch Kunde lesen (der 5-Minuten-Job fragt jedes Dokument in setup)
    if (frisch.einbau && frisch.ticketId && !(mitK27 && !frisch.einschaltMailAt)) return frisch
    const feature = featureConfig(KEY)
    // das Projekt frisch: der Neubau und der Text des Tickets brauchen den Stand nach dem Speichern des Zustands
    const project = await getDocument(config.collections.websiteProjects, frisch.projectId)

    if (!frisch.einbau) {
      const einbau = await stosseNeubauAn(project)
      frisch = await updateDocument(config.collections.portalFeatures, frisch.$id, { einbau })
    }

    const customer = await customerOf(frisch.customerId)
    if (!frisch.ticketId) {
      const texte = await ticketTexte({ feature, doc: frisch, project, customer })
      // Abo-Modell: die Abrechnung am Dokument (abo | projekt) geht ans Ticket; Dokumente ohne Marker (alte Ansicht) bleiben wie sie waren
      const abrechnung = Object.hasOwn(ABRECHNUNGS_ZEILEN, frisch.einrichtungAbrechnung) ? { abrechnung: frisch.einrichtungAbrechnung } : {}
      const { ticketId } = await createFeatureTicket({ customerId: frisch.customerId, project, featureKey: KEY, siteKey: frisch.siteKey, ...texte, ...abrechnung })
      frisch = await updateDocument(config.collections.portalFeatures, frisch.$id, { ticketId })
    }

    if (mitK27 && !frisch.einschaltMailAt) {
      const nachricht = k27Mail({
        kunde: customer,
        projekt: project?.projectName || project?.subdomain || '',
        einbau: frisch.einbau,
        wieder: false,
        ticketNr: await ticketWoid(frisch.ticketId).catch(() => null),
      })
      const { sent, reason } = await sendeZeitenMail(customer, nachricht)
      if (sent || reason === 'keine_adresse') {
        frisch = await updateDocument(config.collections.portalFeatures, frisch.$id, { einschaltMailAt: now.toISOString() })
      }
    }
    return frisch
  })
}

/**
 * Teil der Projektliste (GET /api/funktionen) zu den Zeiten eines Projekts: { zeitenStatus, zeitenLeer }. Eine Abfrage je Projekt mit
 * Funktionsdokument (nicht je Kachel im Browser). zeitenLeer: es sind keine Plaene gespeichert (auch ohne Dokument oder im Zustand off).
 * zeitenStatus { offen, kurz, text } (Hauptplan, wie ihn die Website zeigt): nur in setup und active und nur mit gespeichertem
 * Hauptplan, sonst null. Wirft bei Lesefehlern.
 * @param {object|null|undefined} doc portalFeatures-Dokument der Zeiten
 * @param {Date} now
 */
export async function zeitenProjektAnsicht(doc, now) {
  if (!doc || doc.state === 'off') return { zeitenStatus: null, zeitenLeer: true }
  const daten = (await ladeZeiten(doc.$id))?.daten ?? null
  const leer = !Array.isArray(daten?.plaene) || daten.plaene.length === 0
  const haupt = !leer && (doc.state === 'setup' || doc.state === 'active') ? hauptplan(daten) : null
  if (!haupt) return { zeitenStatus: null, zeitenLeer: leer }
  const { offen, kurz, text } = statusZu(daten, haupt, now)
  return { zeitenStatus: { offen, kurz, text }, zeitenLeer: false }
}