/**
 * Abläufe der Auftragsbestätigung (AB): Eingabeprüfung, Entwurf, Vorschau, Senden, Erinnern, neue Fassung, Stornieren
 * und nachträgliches Zuordnen eines Projekts (Spec Abschnitt 2, Übersicht V4 „L3 – AB-Kern“).
 * Speicher nur über auftragStore.js und projektRechnungenStore.js, PDFs nur über ablage.js; PDF, Token und Mail kommen
 * über `deps` (L4/L5, Standard: dynamischer Import beim Aufruf). Jede Änderung an einer bestehenden AB läuft unter
 * sperreAuftrag(id) (konstanten.js), das Senden zusätzlich unter SPERRE_NUMMER; Mails gehen immer erst nach der Sperre.
 */
import { config } from '../../config.js'
import { getDocument, listDocuments, Query, updateDocument } from '../appwriteAdmin.js'
import { withLocks } from '../keyedLock.js'
import { createAuftrag, deleteAuftrag, getAuftrag, updateAuftrag } from './auftragStore.js'
import { AuftragError } from './fehler.js'
import {
  AUFTRAG_ARTEN, AUFTRAG_WEGE, KUNDENARTEN, LIMITS, sperreAuftrag, STUNDENSATZ_STANDARD_CENTS, VIERTELSTUNDE, ZAHLUNGSPLAN_ARTEN,
} from './konstanten.js'

// ---------------------------------------------------------------------------------------------------------------------
// Eingabeprüfung (rein, synchron)
// ---------------------------------------------------------------------------------------------------------------------

/** Appwrite-Dokument-ID (wie in auftragStore.js). */
export function istDokumentId(wert) {
  return typeof wert === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]{0,35}$/.test(wert)
}

const fehler400 = (meldung) => new AuftragError(400, meldung)
const MELDUNG_POSITIONEN = 'Eine Auftragsbestätigung braucht 1 bis 20 Positionen.'
const MELDUNG_ART = 'Art: Bitte Festpreis oder Nach Aufwand wählen.'
const MELDUNG_PLAN = 'Zahlungsplan: Bitte eine Zahlungsart wählen.'
const MELDUNG_VOM = 'Auftrag vom: Bitte ein gültiges Datum angeben (JJJJ-MM-TT).'
const MELDUNG_WEG = 'Weg: Bitte den Weg der Absprache wählen.'
const MELDUNG_SUMME = 'Die Auftragssumme ist zu hoch (höchstens 999.999,99 €).'
const PREIS_GRENZE = 'zwischen 0,01 € und 100.000,00 € liegen.'

const istEinfachesObjekt = (wert) => Object.prototype.toString.call(wert) === '[object Object]'

function istKalendertag(wert) {
  if (typeof wert !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(wert)) return false
  const datum = new Date(`${wert}T00:00:00Z`)
  return !Number.isNaN(datum.getTime()) && datum.toISOString().slice(0, 10) === wert
}

function pruefePosition(roh, n) {
  const p = istEinfachesObjekt(roh) ? roh : {}
  const beschreibung = typeof p.beschreibung === 'string' ? p.beschreibung.trim() : ''
  if (beschreibung.length < 1 || beschreibung.length > LIMITS.maxBeschreibung) {
    throw fehler400(`Position ${n}: Die Beschreibung braucht 1 bis ${LIMITS.maxBeschreibung} Zeichen.`)
  }
  if (!Number.isInteger(p.menge) || p.menge < 1 || p.menge > LIMITS.maxMenge) {
    throw fehler400(`Position ${n}: Die Menge muss eine ganze Zahl von 1 bis ${LIMITS.maxMenge} sein.`)
  }
  if (!Number.isInteger(p.einzelpreisCents) || p.einzelpreisCents < 1 || p.einzelpreisCents > LIMITS.maxEinzelpreisCents) {
    throw fehler400(`Position ${n}: Der Einzelpreis muss ${PREIS_GRENZE}`)
  }
  return { beschreibung, menge: p.menge, einzelpreisCents: p.einzelpreisCents }
}

function pruefePlan(roh) {
  if (!istEinfachesObjekt(roh) || !ZAHLUNGSPLAN_ARTEN.includes(roh.art)) throw fehler400(MELDUNG_PLAN)
  let prozent = null
  let text = ''
  if (roh.art === 'anzahlung') {
    prozent = roh.prozent === undefined || roh.prozent === null ? LIMITS.standardAnzahlungProzent : roh.prozent
    if (!Number.isInteger(prozent) || prozent < 1 || prozent > 99) throw fehler400('Zahlungsplan: Die Anzahlung muss eine ganze Zahl von 1 bis 99 Prozent sein.')
  }
  if (roh.art === 'frei') {
    text = typeof roh.text === 'string' ? roh.text.trim() : ''
    if (text.length < 1 || text.length > LIMITS.maxZahlungsplanText) throw fehler400(`Zahlungsplan: Der freie Text braucht 1 bis ${LIMITS.maxZahlungsplanText} Zeichen.`)
  }
  return { art: roh.art, prozent, text }
}

function pruefeOptionalesDatum(wert, meldung) {
  if (wert === null || wert === '') return ''
  if (!istKalendertag(wert)) throw fehler400(meldung)
  return wert
}

/** Feldregeln: jedes übergebene Feld (Wert !== undefined) wird geprüft und bereinigt. */
const FELDREGELN = {
  art: (w) => {
    if (!AUFTRAG_ARTEN.includes(w)) throw fehler400(MELDUNG_ART)
    return w
  },
  projektId: (w) => {
    if (w === null || w === '') return ''
    if (!istDokumentId(w)) throw fehler400('Projekt: Ungültige Projekt-Kennung.')
    return w
  },
  titel: (w) => {
    if (w === null) return ''
    if (typeof w !== 'string' || w.trim().length > LIMITS.maxTitel) throw fehler400(`Titel: Höchstens ${LIMITS.maxTitel} Zeichen.`)
    return w.trim()
  },
  kundenart: (w) => {
    if (w === null || w === '') return ''
    if (!KUNDENARTEN.includes(w)) throw fehler400('Kundenart: Bitte Unternehmen oder Privatperson wählen.')
    return w
  },
  positionen: (w) => {
    if (!Array.isArray(w) || w.length > LIMITS.maxPositionen) throw fehler400(MELDUNG_POSITIONEN)
    return w.map((p, i) => pruefePosition(p, i + 1))
  },
  stundensatzCents: (w) => {
    if (w === null) return null
    if (!Number.isInteger(w) || w < 1 || w > LIMITS.maxEinzelpreisCents) throw fehler400(`Stundensatz: Der Stundensatz muss ${PREIS_GRENZE}`)
    return w
  },
  schaetzungMinuten: (w) => {
    if (w === null || w === '' || w === 0) return null
    if (!Number.isInteger(w) || w % VIERTELSTUNDE !== 0 || w < VIERTELSTUNDE || w > LIMITS.maxSchaetzungMinuten) {
      throw fehler400(`Schätzung: Die Schätzung muss ein Vielfaches von ${VIERTELSTUNDE} Minuten sein (15 bis 99.960).`)
    }
    return w
  },
  zahlungsplan: pruefePlan,
  zahlungszielTage: (w) => {
    if (w === null) return null
    if (!Number.isInteger(w) || w < 0 || w > LIMITS.maxZahlungszielTage) {
      throw fehler400(`Zahlungsziel: Das Zahlungsziel muss eine ganze Zahl von 0 bis ${LIMITS.maxZahlungszielTage} Tagen sein.`)
    }
    return w
  },
  auftragVom: (w) => {
    if (!istKalendertag(w)) throw fehler400(MELDUNG_VOM)
    return w
  },
  auftragWeg: (w) => {
    if (typeof w !== 'string' || !Object.hasOwn(AUFTRAG_WEGE, w)) throw fehler400(MELDUNG_WEG)
    return w
  },
  startAm: (w) => pruefeOptionalesDatum(w, 'Start: Bitte ein gültiges Datum angeben (JJJJ-MM-TT) oder leer lassen.'),
  fertigBis: (w) => pruefeOptionalesDatum(w, 'Fertigstellung: Bitte ein gültiges Datum angeben (JJJJ-MM-TT) oder leer lassen.'),
  zeitquelle: (w) => {
    if (w === null) return []
    if (!Array.isArray(w)) throw fehler400('Zeitquelle: Eine Liste von Ticket-Kennungen erwartet.')
    if (!w.every(istDokumentId)) throw fehler400('Zeitquelle: Ungültige Ticket-Kennung.')
    const ohneDoppelte = [...new Set(w)]
    if (ohneDoppelte.length > LIMITS.maxZeitquellen) throw fehler400(`Zeitquelle: Höchstens ${LIMITS.maxZeitquellen} Tickets.`)
    return ohneDoppelte
  },
}
const FELD_REIHENFOLGE = Object.keys(FELDREGELN)

/**
 * Prüft und bereinigt die Eingabe einer AB. Nur Felder der Whitelist (FELDREGELN) werden übernommen; status, nummer,
 * tokenHash & Co. landen nie im Ergebnis. teilweise: nur die übergebenen Felder, ohne Pflicht-, Vorgabe- und Querprüfung.
 */
export function pruefeEingabe(eingabe, { teilweise = false } = {}) {
  if (!istEinfachesObjekt(eingabe)) throw fehler400('Ungültige Eingabe.')
  const felder = {}
  for (const name of FELD_REIHENFOLGE) {
    if (eingabe[name] !== undefined) felder[name] = FELDREGELN[name](eingabe[name])
  }
  if (teilweise) return felder

  // Pflichtfelder: fehlt eines, kommt dieselbe Meldung wie bei einem ungültigen Wert
  if (felder.art === undefined) throw fehler400(MELDUNG_ART)
  if (felder.zahlungsplan === undefined) throw fehler400(MELDUNG_PLAN)
  if (felder.auftragVom === undefined) throw fehler400(MELDUNG_VOM)
  if (felder.auftragWeg === undefined) throw fehler400(MELDUNG_WEG)

  const ergebnis = {
    projektId: felder.projektId ?? '',
    titel: felder.titel ?? '',
    kundenart: felder.kundenart ?? '',
    art: felder.art,
    positionen: [],
    stundensatzCents: null,
    schaetzungMinuten: null,
    summeCents: null,
    zahlungsplan: felder.zahlungsplan,
    zahlungszielTage: felder.zahlungszielTage ?? LIMITS.standardZahlungszielTage,
    auftragVom: felder.auftragVom,
    auftragWeg: felder.auftragWeg,
    startAm: felder.startAm ?? '',
    fertigBis: felder.fertigBis ?? '',
    zeitquelle: felder.zeitquelle ?? [],
  }
  if (felder.art === 'festpreis') {
    if (!felder.positionen || felder.positionen.length === 0) throw fehler400(MELDUNG_POSITIONEN)
    const summe = felder.positionen.reduce((s, p) => s + p.menge * p.einzelpreisCents, 0)
    if (summe > LIMITS.maxSummeCents) throw fehler400(MELDUNG_SUMME)
    if (felder.zahlungsplan.art === 'monatlich') throw fehler400('Zahlungsplan: „Monatlich nach Aufwand“ geht nur bei einem Auftrag nach Aufwand.')
    ergebnis.positionen = felder.positionen
    ergebnis.summeCents = summe
  } else {
    if (felder.zahlungsplan.art === 'anzahlung') throw fehler400('Zahlungsplan: Eine Anzahlung geht nur bei einem Festpreis.')
    ergebnis.stundensatzCents = felder.stundensatzCents ?? STUNDENSATZ_STANDARD_CENTS
    ergebnis.schaetzungMinuten = felder.schaetzungMinuten ?? null
  }
  return ergebnis
}

// ---------------------------------------------------------------------------------------------------------------------
// Entwurf anlegen, ändern, löschen
// ---------------------------------------------------------------------------------------------------------------------

const hatText = (wert) => typeof wert === 'string' && wert.trim() !== ''

export async function ladeAuftrag(id) {
  const auftrag = istDokumentId(id) ? await getAuftrag(id) : null
  if (!auftrag) throw new AuftragError(404, 'Auftragsbestätigung nicht gefunden.')
  return auftrag
}

export async function ladeKunde(kundenId) {
  const nichtGefunden = () => new AuftragError(404, 'Kunde nicht gefunden.')
  if (!istDokumentId(kundenId)) throw nichtGefunden()
  try {
    return await getDocument(config.collections.customers, kundenId)
  } catch (err) {
    if (err?.status === 404) throw nichtGefunden()
    throw err
  }
}

/** Die Felder, die die Eingabeprüfung kennt, aus einem gespeicherten Auftrag (ohne kundenId und kundenart). */
function eingabeAusAuftrag(auftrag) {
  const { projektId, titel, art, positionen, stundensatzCents, schaetzungMinuten, zahlungsplan, zahlungszielTage, auftragVom, auftragWeg, startAm, fertigBis, zeitquelle } = auftrag
  return { projektId, titel, art, positionen, stundensatzCents, schaetzungMinuten, zahlungsplan, zahlungszielTage, auftragVom, auftragWeg, startAm, fertigBis, zeitquelle }
}

/** Das Ticket eines Projekts als Zeitquelle (nie ein Leereintrag). */
function ticketsDesProjekts(projekt) {
  return hatText(projekt?.ticketId) ? [projekt.ticketId.trim()] : []
}

async function ladeProjekt(projektId) {
  try {
    return await getDocument(config.collections.websiteProjects, projektId)
  } catch (err) {
    if (err?.status === 404) return null
    throw err
  }
}

/** Projekt und Tickets müssen dem Kunden gehören; liefert die Felder mit aufgelöstem Titel und aufgelöster Zeitquelle. */
async function pruefeBezuege(kundeDoc, felder) {
  let titel = felder.titel
  let zeitquelle = felder.zeitquelle
  let projekt = null
  if (felder.projektId) {
    projekt = await ladeProjekt(felder.projektId)
    if (!projekt || projekt.customerId !== kundeDoc.$id) throw new AuftragError(400, 'Projekt: Das Projekt gehört nicht zu diesem Kunden.')
  }
  if (!titel) titel = String(projekt?.projectName || '').trim().slice(0, LIMITS.maxTitel).trim()
  if (!titel) throw new AuftragError(400, 'Titel: Bitte einen Titel angeben oder ein Projekt wählen.')
  if (zeitquelle.length === 0 && projekt) zeitquelle = ticketsDesProjekts(projekt)
  if (zeitquelle.length > 0) {
    const tickets = await listDocuments(config.collections.workorders, [Query.equal('$id', zeitquelle), Query.limit(LIMITS.maxZeitquellen)])
    const gefunden = new Map(tickets.map((t) => [t.$id, t]))
    if (!zeitquelle.every((id) => gefunden.get(id)?.customerId === kundeDoc.$id)) {
      throw new AuftragError(400, 'Zeitquelle: Mindestens ein Ticket gehört nicht zu diesem Kunden.')
    }
  }
  return { ...felder, titel, zeitquelle }
}

/** Setzt die Kundenart am Kunden, aber nur, wenn dort noch keine steht. */
async function schreibeKundenart(kundeDoc, kundenart) {
  if (!kundenart || hatText(kundeDoc.kundenart)) return
  await updateDocument(config.collections.customers, kundeDoc.$id, { kundenart })
}

/** Die Felder einer AB, wie createAuftrag und updateAuftrag sie bekommen. */
const speicherFelder = (f) => ({
  projektId: f.projektId, titel: f.titel, zeitquelle: f.zeitquelle, art: f.art, positionen: f.positionen,
  stundensatzCents: f.stundensatzCents, schaetzungMinuten: f.schaetzungMinuten, summeCents: f.summeCents,
  zahlungsplan: f.zahlungsplan, zahlungszielTage: f.zahlungszielTage, auftragVom: f.auftragVom, auftragWeg: f.auftragWeg,
  startAm: f.startAm, fertigBis: f.fertigBis,
})

export async function legeEntwurfAn(eingabe, { von } = {}) {
  const felder = pruefeEingabe(eingabe)
  if (!hatText(eingabe.kundenId)) throw new AuftragError(400, 'Kunde: Bitte einen Kunden angeben.')
  const kundeDoc = await ladeKunde(eingabe.kundenId)
  const fertig = await pruefeBezuege(kundeDoc, felder)
  await schreibeKundenart(kundeDoc, felder.kundenart)
  return createAuftrag({ kundenId: eingabe.kundenId, ...speicherFelder(fertig), erstelltVon: String(von || '') })
}

export async function aendereEntwurf(id, eingabe) {
  return withLocks(sperreAuftrag(id), async () => {
    const auftrag = await ladeAuftrag(id)
    if (auftrag.status !== 'entwurf') throw new AuftragError(409, 'Nur ein Entwurf lässt sich ändern.')
    if (eingabe?.kundenId !== undefined && eingabe.kundenId !== auftrag.kundenId) {
      throw new AuftragError(400, 'Kunde: Der Kunde eines Auftrags lässt sich nicht ändern.')
    }
    const teil = pruefeEingabe(eingabe, { teilweise: true })
    const felder = pruefeEingabe({ ...eingabeAusAuftrag(auftrag), ...teil })
    const kundeDoc = await ladeKunde(auftrag.kundenId)
    const fertig = await pruefeBezuege(kundeDoc, felder)
    await schreibeKundenart(kundeDoc, felder.kundenart)
    return updateAuftrag(id, speicherFelder(fertig))
  })
}

export async function loescheEntwurf(id) {
  return withLocks(sperreAuftrag(id), async () => {
    const auftrag = await ladeAuftrag(id)
    if (auftrag.status !== 'entwurf') throw new AuftragError(409, 'Nur ein Entwurf lässt sich löschen.')
    await deleteAuftrag(id)
  })
}