import { config } from '../../config.js'
import { deleteDocument, listAllDocuments, listDocuments, Query, updateDocument, getDocument } from '../appwriteAdmin.js'
import { withLocks } from '../keyedLock.js'
import { heute } from '../termine/zeit.js'
import { aktualisiereAnfrage, ladeAnfrage } from './speicher.js'
import { leereCache } from './kontext.js'

/**
 * Buchungskalender: Aufbewahrung und Loeschfristen (AVV Nr. 9, bindend):
 * - ipHash: spaetestens config.unterkunft.ipHashTage (30) Tage nach Anlage der Anfrage weg (bei Freigabe/Ablehnung schon in ablauf.js).
 * - Status `neu` ohne Entscheidung nach neuVerfallTage (60) Tagen: `abgelaufen`, ohne Mail.
 * - Anfragen, die nie eine Buchung wurden (abgelehnt, abgelaufen, storniert ohne Rechnung): unverbindlichMonate (6) nach Anlage
 *   anonymisiert (gast {}, nachrichtVermieter '', rechnungsadresse null, ipHash '', anonymisiertAt).
 * - Gebuchte Aufenthalte (gebucht, bezahlt, storniert mit Rechnung): Gastdaten 3 Jahre nach Ende des Kalenderjahres der Abreise (Berlin)
 *   anonymisiert; rechnungsadresse und ukRechnungen bleiben (der Rechnungs-Schnappschuss ist der Beleg).
 * - ukRechnungen: 8 Jahre nach Ende des Kalenderjahres des Rechnungsdatums geloescht; zugleich wird die rechnungsadresse der Anfrage
 *   anonymisiert (sobald keine Rechnung der Anfrage mehr uebrig ist).
 * - Abgeschaltete Funktion: 90 Tage nach disabledAt werden alle uk*-Daten der Funktion geloescht (Marker in portalFeatures.adminNote).
 * Je Lauf hoechstens `deckel` (500) Schreib-/Loeschvorgaenge; idempotent; Logs ohne Personendaten (nur Zaehler, IDs, Fehlername).
 * Leichtgewichtig gehalten (retention.js importiert dieses Modul): keine Mail-, Stripe- oder Ablauf-Importe.
 */

const TAG_MS = 24 * 60 * 60 * 1000
const STANDARD_DECKEL = 500
const SEITE = 100
const ANONYM_JAHRE = () => config.unterkunft.anonymisierenJahre ?? 3
const RECHNUNG_JAHRE = () => config.unterkunft.rechnungJahre ?? 8
const MARKER = 'Buchungsdaten gelöscht am '
const MARKER_RE = /Buchungsdaten gelöscht am (\d{4}-\d{2}-\d{2})/
const ANFRAGE_ANONYM = { gast: {}, nachrichtVermieter: '', ipHash: '' }

const zeitMs = (v) => {
  const t = Date.parse(v)
  return Number.isNaN(t) ? NaN : t
}
const jahrVon = (tag) => Number(String(tag).slice(0, 4))
const gueltigerTag = (tag) => typeof tag === 'string' && /^\d{4}-\d{2}-\d{2}/.test(tag)
/** Nur Name, Status und Code: die Meldung kann Personendaten enthalten und kommt nie ins Log. */
const fehlerText = (err) => [err?.name, err?.status, err?.code ?? err?.type].filter((x) => x !== undefined && x !== null && x !== '').join(' ')
const sammlungFehlt = (err) => err?.type === 'collection_not_found' || err?.code === 'collection_not_found'

/** now minus n Kalendermonate (UTC, Tag wird auf den Monatsletzten gekuerzt). */
function minusMonate(ms, n) {
  const d = new Date(ms)
  const ziel = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() - n, 1, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds()))
  const letzter = new Date(Date.UTC(ziel.getUTCFullYear(), ziel.getUTCMonth() + 1, 0)).getUTCDate()
  ziel.setUTCDate(Math.min(d.getUTCDate(), letzter))
  return ziel.getTime()
}

const nowMsVon = (now) => {
  const ms = now instanceof Date ? now.getTime() : Number(now)
  if (!Number.isFinite(ms)) throw new TypeError('aufbewahrung: now fehlt')
  return ms
}

/** Liest seitenweise (nach $id, 100 je Seite, nur die genannten Felder) und sammelt Treffer von `passt`, hoechstens max. */
async function sammle(sammlung, filter, felder, passt, max) {
  const treffer = []
  if (max <= 0) return { treffer, gedeckelt: true }
  let cursor = null
  for (;;) {
    const seite = await listDocuments(sammlung, [
      ...filter,
      Query.select(['$id', ...felder]),
      Query.orderAsc('$id'),
      Query.limit(SEITE),
      ...(cursor ? [Query.cursorAfter(cursor)] : []),
    ])
    for (const doc of seite) {
      if (!passt(doc)) continue
      if (treffer.length >= max) return { treffer, gedeckelt: true }
      treffer.push(doc)
    }
    if (seite.length < SEITE) return { treffer, gedeckelt: false }
    cursor = seite[seite.length - 1].$id
  }
}

/** Anfragen mit Rechnung: Menge der anfrageIds aller ukRechnungen (nur ein Feld gelesen). */
async function anfragenMitRechnung() {
  const alle = await listAllDocuments(config.collections.ukRechnungen, [Query.select(['$id', 'anfrageId'])])
  return new Set(alle.map((r) => r.anfrageId).filter(Boolean))
}

/**
 * Tagesarbeit der Aufbewahrung.
 * @param {Date} now
 * @param {{ deckel?: number }} [opt] hoechstens so viele Schreib-/Loeschvorgaenge (Standard 500)
 * @returns {Promise<{ verbraucht: number (genutzter Deckel), anfragen: number, gaeste: number, ipHashes: number, abgelaufen: number, rechnungen: number, adressen: number, fehler: number, gedeckelt: boolean }>}
 *   anfragen = unverbindliche Anfragen anonymisiert, gaeste = Gastdaten gebuchter Aufenthalte anonymisiert
 */
export async function anonymisiere(now, { deckel = config.unterkunft.aufbewahrungDeckel ?? STANDARD_DECKEL } = {}) {
  const nowMs = nowMsVon(now)
  const erg = { anfragen: 0, gaeste: 0, ipHashes: 0, abgelaufen: 0, rechnungen: 0, adressen: 0, fehler: 0, gedeckelt: false, verbraucht: 0 }
  let rest = Number.isInteger(deckel) && deckel > 0 ? deckel : STANDARD_DECKEL
  const start = rest
  const jetztIso = new Date(nowMs).toISOString()
  const AN = config.collections.ukAnfragen
  const c = config.unterkunft

  const bearbeite = async (name, { treffer, gedeckelt }, arbeit) => {
    if (gedeckelt) erg.gedeckelt = true
    for (const doc of treffer) {
      if (rest <= 0) {
        erg.gedeckelt = true
        return
      }
      try {
        if (await arbeit(doc)) rest -= 1
      } catch (err) {
        erg.fehler += 1
        console.warn(`[unterkunft-aufbewahrung] ${name} ${doc.$id} fehlgeschlagen: ${fehlerText(err)}`)
      }
    }
  }
  const schritt = async (name, arbeit) => {
    try {
      await arbeit()
    } catch (err) {
      erg.fehler += 1
      console.warn(`[unterkunft-aufbewahrung] ${name} fehlgeschlagen: ${fehlerText(err)}`)
    }
  }

  // 1. ipHash leeren (30 Tage nach Anlage)
  await schritt('ipHash', async () => {
    const grenze = nowMs - c.ipHashTage * TAG_MS
    const gefunden = await sammle(AN, [Query.lessThan('$createdAt', new Date(grenze).toISOString())], ['ipHash', '$createdAt'], (d) => d.ipHash && zeitMs(d.$createdAt) < grenze, rest)
    await bearbeite('ipHash', gefunden, async (d) => {
      await aktualisiereAnfrage(d.$id, { ipHash: '' })
      erg.ipHashes += 1
      return true
    })
  })

  // 2. neu, nach neuVerfallTage nicht entschieden: abgelaufen (ohne Mail)
  await schritt('neu verfallen', async () => {
    const grenze = nowMs - c.neuVerfallTage * TAG_MS
    const gefunden = await sammle(AN, [Query.equal('status', 'neu'), Query.lessThan('$createdAt', new Date(grenze).toISOString())], ['status', 'unterkunftId', '$createdAt'], (d) => zeitMs(d.$createdAt) < grenze, rest)
    await bearbeite('neu verfallen', gefunden, async (d) => {
      const neu = await withLocks(['unterkunft:' + d.unterkunftId], async () => { // derselbe Schluessel wie ablauf.js (gibFrei/lehneAb/Fristen)
        const a = await ladeAnfrage(d.$id)
        if (!a || a.status !== 'neu') return null
        return aktualisiereAnfrage(a.$id, { status: 'abgelaufen', abgelaufenAt: jetztIso, ipHash: '' })
      })
      if (!neu) return false
      erg.abgelaufen += 1
      return true
    })
  })

  // 3. + 4. Anonymisieren
  await schritt('anonymisieren', async () => {
    const mitRechnung = await anfragenMitRechnung()
    const hatRechnung = (d) => Boolean(d.rechnungId) || mitRechnung.has(d.$id)
    const unverbindlichGrenze = minusMonate(nowMs, c.unverbindlichMonate)
    const gebuchtJahr = jahrVon(heute(new Date(nowMs)))

    const unv = await sammle(
      AN,
      [Query.equal('status', ['abgelehnt', 'abgelaufen', 'storniert']), Query.lessThan('$createdAt', new Date(unverbindlichGrenze).toISOString())],
      ['status', 'rechnungId', 'anonymisiertAt', '$createdAt'],
      (d) => !d.anonymisiertAt && zeitMs(d.$createdAt) < unverbindlichGrenze && !(d.status === 'storniert' && hatRechnung(d)),
      rest,
    )
    await bearbeite('anonymisieren', unv, async (d) => {
      await aktualisiereAnfrage(d.$id, { ...ANFRAGE_ANONYM, rechnungsadresse: null, anonymisiertAt: jetztIso })
      erg.anfragen += 1
      return true
    })

    const gebucht = await sammle(
      AN,
      [Query.equal('status', ['gebucht', 'bezahlt', 'storniert'])],
      ['status', 'rechnungId', 'anonymisiertAt', 'bis'],
      // Abreisejahr Y: faellig, sobald das Berliner Jahr >= Y + 3 + 1 ist (3 Jahre nach Ende des Jahres Y)
      (d) => !d.anonymisiertAt && gueltigerTag(d.bis) && gebuchtJahr >= jahrVon(d.bis) + ANONYM_JAHRE() + 1 && (d.status !== 'storniert' || hatRechnung(d)),
      rest,
    )
    await bearbeite('anonymisieren', gebucht, async (d) => {
      // ohne Rechnung gibt es keinen Beleg, der die Rechnungsadresse schuetzt: sie geht mit den Gastdaten
      await aktualisiereAnfrage(d.$id, { ...ANFRAGE_ANONYM, ...(hatRechnung(d) ? {} : { rechnungsadresse: null }), anonymisiertAt: jetztIso })
      erg.gaeste += 1
      return true
    })
  })

  // 5. Rechnungen nach 8 Jahren loeschen, vorher die Rechnungsadresse der Anfrage anonymisieren
  await schritt('rechnungen', async () => {
    const jahr = jahrVon(heute(new Date(nowMs)))
    const RE = config.collections.ukRechnungen
    const faellig = (r) => gueltigerTag(r.datum) && jahr >= jahrVon(r.datum) + RECHNUNG_JAHRE() + 1
    const gefunden = await sammle(RE, [], ['anfrageId', 'datum'], faellig, rest)
    if (gefunden.gedeckelt) erg.gedeckelt = true
    const erledigt = new Set()
    for (const r of gefunden.treffer) {
      if (rest <= 0) {
        erg.gedeckelt = true
        return
      }
      try {
        // Adresse erst, wenn keine nicht faellige Rechnung der Anfrage uebrig ist (sonst braucht die Anfrage sie noch)
        if (r.anfrageId && !erledigt.has(r.anfrageId)) {
          const alle = await listAllDocuments(RE, [Query.equal('anfrageId', r.anfrageId), Query.select(['$id', 'datum'])])
          if (alle.every(faellig)) {
            const a = await ladeAnfrage(r.anfrageId)
            if (a && (a.rechnungsadresse !== null || !a.anonymisiertAt)) {
              await aktualisiereAnfrage(a.$id, { rechnungsadresse: null, ...(a.anonymisiertAt ? {} : { ...ANFRAGE_ANONYM, anonymisiertAt: jetztIso }) })
              erg.adressen += 1
              rest -= 1
            }
            erledigt.add(r.anfrageId)
          }
        }
        try {
          await deleteDocument(RE, r.$id)
        } catch (err) {
          if (err?.status !== 404) throw err
        }
        erg.rechnungen += 1
        rest -= 1
      } catch (err) {
        erg.fehler += 1
        console.warn(`[unterkunft-aufbewahrung] rechnungen ${r.$id} fehlgeschlagen: ${fehlerText(err)}`)
      }
    }
  })

  erg.verbraucht = start - rest
  return erg
}

const GRUPPEN = ['ukAnfragen', 'ukRechnungen', 'ukSperren', 'ukPreise', 'ukUnterkuenfte']

/**
 * Alle uk*-Daten EINER Funktion (featureId) loeschen: Anfragen, Rechnungen, Sperren, Preise, Unterkuenfte und zuletzt die Einstellungen
 * (ukEinstellungen, Dokument-ID = featureId). Seitenweise (immer die erste Seite neu), am Deckel endet der Lauf (vollstaendig: false).
 * @returns {Promise<{ geloescht: number, vollstaendig: boolean, abgebrochen: boolean }>}
 */
export async function loescheUkDaten({ featureId, deckel = Number.POSITIVE_INFINITY, nochGueltig = async () => true } = {}) {
  if (typeof featureId !== 'string' || featureId === '') throw new TypeError('loescheUkDaten: featureId fehlt')
  const erg = { geloescht: 0, vollstaendig: false, abgebrochen: false }
  for (const name of GRUPPEN) {
    const sammlung = config.collections[name]
    for (;;) {
      if (!(await nochGueltig())) return { ...erg, abgebrochen: true }
      const rest = deckel - erg.geloescht
      if (rest <= 0) return erg
      let seite
      try {
        seite = await listDocuments(sammlung, [Query.equal('featureId', featureId), Query.select(['$id']), Query.limit(Math.min(SEITE, rest))])
      } catch (err) {
        if (sammlungFehlt(err)) break
        throw err
      }
      if (seite.length === 0) break
      for (const doc of seite) {
        try {
          await deleteDocument(sammlung, doc.$id)
        } catch (err) {
          if (err?.status !== 404) throw err
        }
        erg.geloescht += 1
      }
    }
  }
  if (!(await nochGueltig())) return { ...erg, abgebrochen: true }
  try {
    await deleteDocument(config.collections.ukEinstellungen, featureId)
    erg.geloescht += 1
  } catch (err) {
    if (err?.status !== 404 && !sammlungFehlt(err)) throw err
  }
  erg.vollstaendig = true
  return erg
}

/** Hat die Funktion (featureId) noch uk*-Daten? (fuer die Kundenloeschung in retention.js; fehlende Collections zaehlen als leer) */
export async function hatUkDaten(featureId) {
  for (const name of ['ukUnterkuenfte', 'ukAnfragen', 'ukRechnungen', 'ukSperren', 'ukPreise', 'ukEinstellungen']) {
    try {
      const treffer = await listDocuments(config.collections[name], [Query.equal('featureId', featureId), Query.select(['$id']), Query.limit(1)])
      if (treffer.length) return true
    } catch (err) {
      if (!sammlungFehlt(err)) throw err
    }
  }
  return false
}

/** Marker an die bisherige Notiz haengen (eine alte Marke wird ersetzt, der Rest bleibt; hoechstens 300 Zeichen, der Marker bleibt ganz). */
function markiere(notiz, tag) {
  const marker = `${MARKER}${tag}`
  const alt = String(notiz ?? '').replace(/\s*(?:[-–|]\s*)?Buchungsdaten gelöscht am \d{4}-\d{2}-\d{2}/g, '').trim()
  if (!alt) return marker
  return `${alt.slice(0, Math.max(0, 300 - marker.length - 3))} – ${marker}`
}

/**
 * Abgeschaltete Buchungskalender (portalFeatures.state disabled, disabledAt aelter als loeschTageNachAbschalten = 90 Tage): alle uk*-Daten
 * loeschen, danach Marker in adminNote (wie beim Shop; ein spaeteres Abschalten setzt disabledAt neu und gilt wieder).
 * @returns {Promise<{ funktionen: number, dokumente: number, fehler: number, gedeckelt: boolean }>}
 */
export async function loescheAbgeschaltete(now, { deckel = STANDARD_DECKEL } = {}) {
  const nowMs = nowMsVon(now)
  const tage = config.unterkunft.loeschTageNachAbschalten ?? 90
  const grenze = nowMs - tage * TAG_MS
  const FEATURES = config.collections.portalFeatures
  const erg = { funktionen: 0, dokumente: 0, fehler: 0, gedeckelt: false }
  let rest = deckel
  const funktionen = await listAllDocuments(FEATURES, [Query.equal('featureKey', 'unterkunft'), Query.equal('state', 'disabled')])
  for (const f of funktionen) {
    if (!(zeitMs(f.disabledAt) < grenze)) continue
    const marker = MARKER_RE.exec(String(f.adminNote ?? ''))
    if (marker && marker[1] >= String(f.disabledAt).slice(0, 10)) continue
    if (rest <= 0) {
      erg.gedeckelt = true
      return erg
    }
    try {
      // vor jeder Seite frisch lesen: das Team kann die Funktion zwischenzeitlich wieder einschalten
      const nochAus = async () => {
        const frisch = await getDocument(FEATURES, f.$id)
        return frisch.state === 'disabled' && zeitMs(frisch.disabledAt) < grenze
      }
      const weg = await loescheUkDaten({ featureId: f.$id, deckel: rest, nochGueltig: nochAus })
      rest -= weg.geloescht
      erg.dokumente += weg.geloescht
      if (f.siteKey) leereCache(f.siteKey)
      if (weg.vollstaendig) {
        erg.funktionen += 1
        const frisch = await getDocument(FEATURES, f.$id)
        if (frisch.state === 'disabled' && zeitMs(frisch.disabledAt) < grenze) {
          await updateDocument(FEATURES, f.$id, { adminNote: markiere(frisch.adminNote, heute(new Date(nowMs))) })
        }
      } else if (!weg.abgebrochen) {
        erg.gedeckelt = true
      }
    } catch (err) {
      erg.fehler += 1
      console.warn(`[unterkunft-aufbewahrung] Funktion ${f.$id} nicht vollständig gelöscht: ${fehlerText(err)}`)
    }
  }
  return erg
}

/**
 * Kundenloeschung (customerAdmin.js): schliesst die Buchungskalender des Kunden fuer neue Anfragen (alle Unterkuenfte aktiv=false) und
 * leert den Speicher der oeffentlichen Schnittstelle. Die Funktion selbst schaltet disableCustomerFeatures ab; die Daten loescht
 * loescheAbgeschaltete 90 Tage nach dem Abschalten. Scheitert eines, werden die uebrigen trotzdem geschlossen, der erste Fehler wird weitergereicht.
 * @returns {Promise<number>} Zahl der geschlossenen Unterkuenfte
 */
export async function schliesseUkVonKunde(customerId) {
  const funktionen = await listAllDocuments(config.collections.portalFeatures, [Query.equal('customerId', customerId), Query.equal('featureKey', 'unterkunft')])
  let geschlossen = 0
  let erster = null
  for (const f of funktionen) {
    try {
      const unterkuenfte = await listAllDocuments(config.collections.ukUnterkuenfte, [Query.equal('featureId', f.$id)])
      for (const u of unterkuenfte) {
        if (u.aktiv !== false) await updateDocument(config.collections.ukUnterkuenfte, u.$id, { aktiv: false })
        geschlossen += 1
      }
    } catch (err) {
      if (!sammlungFehlt(err)) erster ||= err
    }
    if (f.siteKey) leereCache(f.siteKey)
  }
  if (erster) throw erster
  return geschlossen
}