import { config } from '../../config.js'
import { getDocument, updateDocument } from '../appwriteAdmin.js'
import { withLocks } from '../keyedLock.js'

/**
 * Shop-Einstellungen (Plan 2026-10-05-webshop.md, Task C2; shopConfig.einstellungen als JSON-Text).
 * Normalisieren ist rein: Eingabe => { einstellungen } mit frischem, vollstaendigem Objekt oder { fehler: { 'feld.pfad': 'Text' } }
 * (Texte in Du-Form, das Portal spricht den Haendler an). Leere Pflichtangaben sind beim Normalisieren erlaubt, damit der Haendler
 * Schritt fuer Schritt speichern kann; ob alles da ist, sagt istVollstaendig(). Geld ist immer ganze Cent.
 */

const ZAHLUNGSARTEN = ['card', 'klarna', 'sepa_debit']
const LAENDER = ['DE', 'AT']
const MAX_VERSAND_CENT = 100_000
const MAX_CENT = 10_000_000
const PLZ_RE = { DE: /^\d{5}$/, AT: /^\d{4}$/ }
const USTID_RE = /^(DE\d{9}|ATU\d{8})$/
const AKZENT_RE = /^#[0-9a-fA-F]{6}$/

const tief = (wert) => {
  if (Array.isArray(wert)) return Object.freeze(wert.map(tief))
  if (wert && typeof wert === 'object') return Object.freeze(Object.fromEntries(Object.entries(wert).map(([k, v]) => [k, tief(v)])))
  return wert
}

export const STANDARD_EINSTELLUNGEN = tief({
  shopname: '',
  anbieter: { name: '', strasse: '', plz: '', ort: '', land: 'DE', email: '', telefon: '', ustId: '' },
  kleinunternehmer: true,
  versand: { aktiv: true, laender: ['DE'], kostenCent: { DE: 490 }, freiAbCent: null },
  abholung: { aktiv: false, adresse: '', hinweis: '' },
  lieferzeit: '2–4 Werktage',
  zahlungsarten: ['card'],
  akzent: '#111111',
  mindestbestellCent: null,
  ruecksendekosten: 'kaeufer',
})

/** Tiefe, veraenderbare Kopie (JSON-tauglich). */
const kopie = (wert) => JSON.parse(JSON.stringify(wert))

const istObjekt = (wert) => wert !== null && typeof wert === 'object' && !Array.isArray(wert)
/** Nur eigene Schluessel lesen, nie aus der Prototypkette (zB __proto__ aus JSON.parse bleibt ein eigener Schluessel, wird aber nie gelesen). */
const hole = (objekt, schluessel) => (istObjekt(objekt) && Object.hasOwn(objekt, schluessel) ? objekt[schluessel] : undefined)

// Steuerzeichen und unsichtbare Formatzeichen (Zero-Width, Richtungsmarken, BOM, Soft Hyphen) sowie Zeilen-/Absatztrenner
const STEUERZEICHEN = /[\p{Cc}\p{Cf}\u2028\u2029]/gu

/** Bereinigter Text: ohne Steuerzeichen, getrimmt; einzeilig macht aus Umbruechen Leerzeichen, mehrzeilig behaelt einzelne Umbrueche. */
function bereinige(wert, { mehrzeilig = false } = {}) {
  if (typeof wert !== 'string') return ''
  let s = wert.replace(/\r\n?/g, '\n').replace(/\t/g, ' ')
  s = mehrzeilig ? s.replace(STEUERZEICHEN, (z) => (z === '\n' ? z : '')).replace(/[ ]*\n[ ]*/g, '\n').replace(/\n{3,}/g, '\n\n') : s.replace(/\n+/g, ' ').replace(STEUERZEICHEN, '').replace(/ {2,}/g, ' ')
  return s.trim()
}

const laenge = (s) => [...s].length

/** Ein Postfach: kein Leerraum, genau ein @, keine ,;<>" und mindestens ein Punkt in der Domain, hoechstens 254 Zeichen. */
function emailAdresse(wert) {
  const s = bereinige(wert).toLowerCase()
  if (s.length === 0 || s.length > 254) return null
  return /^[^\s@,;<>"]+@[^\s@,;<>".]+(\.[^\s@,;<>".]+)+$/.test(s) ? s : null
}

/**
 * Pruefen und Normalisieren. Fehlende Felder bekommen die Standardwerte, unbekannte Schluessel werden ignoriert,
 * das Ergebnis teilt keine Referenzen mit der Eingabe.
 * @returns {{einstellungen: object} | {fehler: Object<string, string>}}
 */
export function normalisiereEinstellungen(eingabe) {
  if (!istObjekt(eingabe)) return { fehler: { einstellungen: 'Die Einstellungen fehlen oder sind unlesbar.' } }
  const fehler = {}
  const fehl = (pfad, text) => {
    if (!(pfad in fehler)) fehler[pfad] = text
  }
  const std = STANDARD_EINSTELLUNGEN

  /** Textfeld bis max Zeichen; leer erlaubt, ausser min > 0 (dann leer oder zu kurz = Fehler nur bei nicht leerem Text). */
  const textFeld = (pfad, wert, { max, min = 0, mehrzeilig = false, vorgabe = '', name }) => {
    if (wert === undefined || wert === null) return vorgabe
    if (typeof wert !== 'string') {
      fehl(pfad, `Bitte gib ${name} als Text an.`)
      return vorgabe
    }
    const s = bereinige(wert, { mehrzeilig })
    if (laenge(s) > max) {
      fehl(pfad, `${name[0].toUpperCase()}${name.slice(1)} darf höchstens ${max} Zeichen lang sein.`)
      return vorgabe
    }
    if (s !== '' && laenge(s) < min) {
      fehl(pfad, `${name[0].toUpperCase()}${name.slice(1)} muss mindestens ${min} Zeichen lang sein.`)
      return vorgabe
    }
    return s
  }
  const wahrheit = (pfad, wert, vorgabe, name) => {
    if (wert === undefined || wert === null) return vorgabe
    if (typeof wert !== 'boolean') {
      fehl(pfad, `Bitte wähle bei „${name}“ ja oder nein.`)
      return vorgabe
    }
    return wert
  }
  /** null oder ganze Zahl 1..max (Cent). */
  const centOderNull = (pfad, wert, name) => {
    if (wert === undefined || wert === null) return null
    if (!Number.isSafeInteger(wert) || wert <= 0 || wert > MAX_CENT) {
      fehl(pfad, `${name} muss ein Betrag über 0 € (in ganzen Cent) sein – oder leer, wenn es keinen geben soll.`)
      return null
    }
    return wert
  }

  const shopname = textFeld('shopname', hole(eingabe, 'shopname'), { max: 80, name: 'der Shopname' })

  // Anbieter
  const a = hole(eingabe, 'anbieter')
  const land = (() => {
    const w = hole(a, 'land')
    if (w === undefined || w === null) return std.anbieter.land
    if (!LAENDER.includes(w)) {
      fehl('anbieter.land', 'Bitte wähle Deutschland oder Österreich als Land deines Unternehmens.')
      return std.anbieter.land
    }
    return w
  })()
  const anbieter = {
    name: textFeld('anbieter.name', hole(a, 'name'), { max: 120, name: 'der Name des Anbieters' }),
    strasse: textFeld('anbieter.strasse', hole(a, 'strasse'), { max: 120, name: 'die Straße' }),
    plz: '',
    ort: textFeld('anbieter.ort', hole(a, 'ort'), { max: 80, name: 'der Ort' }),
    land,
    email: '',
    telefon: textFeld('anbieter.telefon', hole(a, 'telefon'), { max: 40, name: 'die Telefonnummer' }),
    ustId: '',
  }
  const plzRoh = hole(a, 'plz')
  if (plzRoh !== undefined && plzRoh !== null) {
    const plz = bereinige(plzRoh)
    if (plz === '') anbieter.plz = ''
    else if (PLZ_RE[land].test(plz)) anbieter.plz = plz
    else fehl('anbieter.plz', land === 'AT' ? 'Bitte gib eine österreichische Postleitzahl mit 4 Ziffern an.' : 'Bitte gib eine deutsche Postleitzahl mit 5 Ziffern an.')
  }
  const emailRoh = hole(a, 'email')
  if (emailRoh !== undefined && emailRoh !== null && bereinige(emailRoh) !== '') {
    const mail = emailAdresse(emailRoh)
    if (mail) anbieter.email = mail
    else fehl('anbieter.email', 'Bitte gib genau eine gültige E-Mail-Adresse an (höchstens 254 Zeichen).')
  }
  const ustRoh = hole(a, 'ustId')
  if (ustRoh !== undefined && ustRoh !== null) {
    const ust = bereinige(ustRoh).replace(/\s+/g, '').toUpperCase()
    if (ust === '') anbieter.ustId = ''
    else if (USTID_RE.test(ust)) anbieter.ustId = ust
    else fehl('anbieter.ustId', 'Die USt-IdNr. sieht so aus: DE123456789 oder ATU12345678. Lass das Feld leer, wenn du keine hast.')
  }

  const kleinunternehmer = wahrheit('kleinunternehmer', hole(eingabe, 'kleinunternehmer'), std.kleinunternehmer, 'Kleinunternehmer')

  // Versand
  const v = hole(eingabe, 'versand')
  const versandAktiv = wahrheit('versand.aktiv', hole(v, 'aktiv'), std.versand.aktiv, 'Versand anbieten')
  let laender = [...std.versand.laender]
  const laenderRoh = hole(v, 'laender')
  if (laenderRoh !== undefined && laenderRoh !== null) {
    const menge = Array.isArray(laenderRoh) ? new Set(laenderRoh) : null
    if (menge && menge.has('DE') && [...menge].every((l) => LAENDER.includes(l))) laender = LAENDER.filter((l) => menge.has(l))
    else fehl('versand.laender', 'Du kannst nach Deutschland oder nach Deutschland und Österreich liefern. Deutschland ist immer dabei.')
  }
  const kostenRoh = hole(v, 'kostenCent')
  const kostenCent = {}
  for (const l of laender) {
    const w = hole(kostenRoh, l)
    if (w === undefined || w === null) {
      if (versandAktiv && l !== 'DE') fehl(`versand.kostenCent.${l}`, `Bitte gib die Versandkosten für ${l === 'AT' ? 'Österreich' : 'Deutschland'} an.`)
      kostenCent[l] = l === 'DE' ? std.versand.kostenCent.DE : 990
    } else if (!Number.isSafeInteger(w) || w < 0 || w > MAX_VERSAND_CENT) {
      fehl(`versand.kostenCent.${l}`, `Die Versandkosten für ${l === 'AT' ? 'Österreich' : 'Deutschland'} müssen zwischen 0 € und 1.000 € liegen (in ganzen Cent).`)
      kostenCent[l] = l === 'DE' ? std.versand.kostenCent.DE : 990
    } else kostenCent[l] = w
  }
  const freiAbCent = centOderNull('versand.freiAbCent', hole(v, 'freiAbCent'), 'Die Grenze für versandkostenfreie Lieferung')

  // Abholung
  const ab = hole(eingabe, 'abholung')
  const abholungAktiv = wahrheit('abholung.aktiv', hole(ab, 'aktiv'), std.abholung.aktiv, 'Abholung anbieten')
  const abholung = {
    aktiv: abholungAktiv,
    adresse: textFeld('abholung.adresse', hole(ab, 'adresse'), { max: 300, mehrzeilig: true, name: 'die Abholadresse' }),
    hinweis: textFeld('abholung.hinweis', hole(ab, 'hinweis'), { max: 300, mehrzeilig: true, name: 'der Abholhinweis' }),
  }
  if (abholungAktiv && abholung.adresse === '' && !('abholung.adresse' in fehler)) fehl('abholung.adresse', 'Bitte gib an, wo die Ware abgeholt werden kann.')
  if (!versandAktiv && !abholungAktiv && !('versand.aktiv' in fehler) && !('abholung.aktiv' in fehler)) {
    fehl('versand.aktiv', 'Bitte biete Versand oder Abholung an – mindestens eins von beiden muss aktiv sein.')
  }

  const lieferzeit = textFeld('lieferzeit', hole(eingabe, 'lieferzeit'), { max: 80, min: 3, vorgabe: std.lieferzeit, name: 'die Lieferzeit' })

  // Zahlungsarten: card immer dabei
  let zahlungsarten = ['card']
  const zahlRoh = hole(eingabe, 'zahlungsarten')
  if (zahlRoh !== undefined && zahlRoh !== null) {
    if (Array.isArray(zahlRoh) && zahlRoh.every((z) => ZAHLUNGSARTEN.includes(z))) {
      const menge = new Set(zahlRoh)
      zahlungsarten = ZAHLUNGSARTEN.filter((z) => z === 'card' || menge.has(z))
    } else fehl('zahlungsarten', 'Bitte wähle nur Karte, Klarna oder SEPA-Lastschrift als Zahlungsarten. Die Kartenzahlung ist immer dabei.')
  }

  let akzent = std.akzent
  const akzentRoh = hole(eingabe, 'akzent')
  if (akzentRoh !== undefined && akzentRoh !== null) {
    if (typeof akzentRoh === 'string' && AKZENT_RE.test(akzentRoh.trim())) akzent = akzentRoh.trim().toLowerCase()
    else fehl('akzent', 'Bitte gib die Akzentfarbe als Hex-Wert an, zum Beispiel #111111.')
  }

  const mindestbestellCent = centOderNull('mindestbestellCent', hole(eingabe, 'mindestbestellCent'), 'Der Mindestbestellwert')

  let ruecksendekosten = std.ruecksendekosten
  const rueckRoh = hole(eingabe, 'ruecksendekosten')
  if (rueckRoh !== undefined && rueckRoh !== null) {
    if (rueckRoh === 'kaeufer' || rueckRoh === 'haendler') ruecksendekosten = rueckRoh
    else fehl('ruecksendekosten', 'Bitte wähle, ob die Käuferin bzw. der Käufer oder du die Kosten der Rücksendung trägst.')
  }

  if (Object.keys(fehler).length) return { fehler }
  return {
    einstellungen: {
      shopname,
      anbieter,
      kleinunternehmer,
      versand: { aktiv: versandAktiv, laender, kostenCent, freiAbCent },
      abholung,
      lieferzeit,
      zahlungsarten,
      akzent,
      mindestbestellCent,
      ruecksendekosten,
    },
  }
}

/** Alles Noetige zum Verkaufen: Normalisierung ohne Fehler und Pflichtangaben vorhanden. */
export function istVollstaendig(einstellungen) {
  const r = normalisiereEinstellungen(einstellungen)
  if (r.fehler) return false
  const e = r.einstellungen
  return [e.shopname, e.anbieter.name, e.anbieter.strasse, e.anbieter.plz, e.anbieter.ort, e.anbieter.email, e.lieferzeit].every((s) => s !== '')
}

/** Standardwerte, darueber die bekannten Felder aus gespeichertem Stand (eine Ebene tief fuer die Unterobjekte). */
function mitStandard(roh) {
  const e = kopie(STANDARD_EINSTELLUNGEN)
  if (!istObjekt(roh)) return e
  for (const key of Object.keys(e)) {
    const w = hole(roh, key)
    if (w === undefined) continue
    if (['anbieter', 'abholung'].includes(key)) {
      if (istObjekt(w)) for (const k of Object.keys(e[key])) if (hole(w, k) !== undefined) e[key][k] = kopie(w[k])
    } else if (key === 'versand') {
      if (istObjekt(w)) {
        for (const k of Object.keys(e.versand)) if (hole(w, k) !== undefined) e.versand[k] = kopie(w[k])
      }
    } else e[key] = kopie(w)
  }
  return e
}

/**
 * Einstellungen aus einem shopConfig-Dokument. Fehlt der JSON-Text oder ist er kaputt, gelten die Standardwerte.
 * Ein lesbarer, aber ungueltiger Stand wird nicht verworfen, sondern mit den Standardwerten aufgefuellt zurueckgegeben
 * (istVollstaendig() / normalisiereEinstellungen() melden dann die Fehler).
 */
export function ladeEinstellungen(shopDoc) {
  let roh = null
  try {
    roh = typeof shopDoc?.einstellungen === 'string' && shopDoc.einstellungen !== '' ? JSON.parse(shopDoc.einstellungen) : null
  } catch {
    roh = null
  }
  const gefuellt = mitStandard(roh)
  const r = normalisiereEinstellungen(gefuellt)
  return r.einstellungen || gefuellt
}

// ---------------------------------------------------------------- Speichern

const hooks = new Set()

/** Meldet eine Funktion an, die nach jedem Speichern mit der Shop-ID gerufen wird (zB Cache leeren). Rueckgabe: Abmelden. */
export function nachSpeichern(fn) {
  if (typeof fn !== 'function') throw new TypeError('nachSpeichern: Funktion erwartet')
  hooks.add(fn)
  return () => hooks.delete(fn)
}

function rufeHooks(shopId) {
  for (const fn of [...hooks]) {
    try {
      Promise.resolve(fn(shopId)).catch(() => {})
    } catch {
      /* Fehler im Hook duerfen das Speichern nicht kippen */
    }
  }
}

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

/**
 * Speichert die Einstellungen eines Shops (Dokument-ID = shopId) und erhoeht `version`.
 * Mit erwarteteVersion (ganze Zahl; 0 = noch nie gespeichert) wird gegen gleichzeitige Aenderungen geprueft: Abweichung => Fehler 409.
 * Ungueltige Einstellungen => Fehler 400 mit `fehler` (Feld => Text), unbekannter Shop => 404 aus Appwrite.
 * @returns {Promise<{einstellungen: object, version: number}>}
 */
export async function speichereEinstellungen(shopId, einstellungen, { erwarteteVersion } = {}) {
  if (typeof shopId !== 'string' || shopId === '') throw new TypeError('shopId fehlt')
  const r = normalisiereEinstellungen(einstellungen)
  if (r.fehler) throw Object.assign(new Error('Die Einstellungen sind nicht gültig.'), { status: 400, fehler: r.fehler })
  const ergebnis = await withLocks([`shop-cfg:${shopId}`], async () => {
    const col = config.collections.shopConfig
    const doc = await getDocument(col, shopId)
    const aktuell = Number.isInteger(doc?.version) && doc.version > 0 ? doc.version : 0
    if (erwarteteVersion !== undefined && erwarteteVersion !== null && erwarteteVersion !== aktuell) throw veraltet()
    await updateDocument(col, shopId, { einstellungen: JSON.stringify(r.einstellungen), version: aktuell + 1 })
    return { einstellungen: r.einstellungen, version: aktuell + 1 }
  })
  rufeHooks(shopId)
  return ergebnis
}