Webklar-Kundenbereich/server/services/zeiten/zeitlogik.js

import { zuUtc, wochentag, plusTage } from '../termine/zeit.js'
import { BUNDESLAENDER, feiertageImZeitraum } from '../termine/feiertage.js'

/**
 * Oeffnungszeiten live: Zeitlogik (rein, Europe/Berlin).
 * Kein Appwrite, keine Config, kein eigener Zeitgeber: Aufrufer geben Daten und 'now' hinein.
 * Alles rechnet in Berliner Wanduhrzeit ueber termine/zeit.js; Kalendertage nur mit plusTage, nie als Vielfache von Tages-Millisekunden.
 *
 * Datenform (Spec 2.1): daten = { land, plaene: [{ id, kurz, name, haupt, tage: { 1..7: { modus, fenster } } }],
 *   feiertage: { 'YYYY-MM-DD': { modus, fenster } }, ausnahmen: [{ id, art: 'urlaub'|'sondertag', von, bis, text,
 *   modus, fenster, plan: null|planId }], ... }. modus: 'zu' | 'zeiten' | 'rund' | 'vereinbarung';
 *   fenster: [['09:00','12:30'], ...] (nur bei 'zeiten'; 'bis' vor 'von' = bis zum Folgetag).
 *
 * Alle Funktionen sind tolerant gegenueber kaputten gespeicherten Daten (unbekannter Modus, fehlende Tage,
 * unlesbare Fenster => zu), werfen aber bei einem ungueltigen Tag-Argument (Programmierfehler).
 */

const TAG_RE = /^\d{4}-\d{2}-\d{2}$/
const ZEIT_RE = /^\d{2}:\d{2}$/
const MODI = Object.freeze(['zu', 'zeiten', 'rund', 'vereinbarung'])
const STANDARD_LAND = 'RP'

const pad = (n) => String(n).padStart(2, '0')

/** Ist t ein echter Kalendertag 'YYYY-MM-DD' (kein 30.02.)? */
function gueltigerTag(t) {
  return typeof t === 'string' && TAG_RE.test(t) && plusTage(t, 0) === t
}

function pruefeTag(t, name) {
  if (!gueltigerTag(t)) throw new RangeError(`${name}: ungueltiger Tag ${String(t)}`)
}

/** 'HH:MM' (auch '24:00') -> Minuten seit 00:00, sonst null. */
function minuten(hhmm) {
  if (typeof hhmm !== 'string' || !ZEIT_RE.test(hhmm)) return null
  const h = Number(hhmm.slice(0, 2))
  const m = Number(hhmm.slice(3, 5))
  if (m > 59 || h > 24 || (h === 24 && m !== 0)) return null
  return h * 60 + m
}

const textOderNull = (t) => (typeof t === 'string' && t.trim() !== '' ? t : null)

// ------------------------------------------------------------------ Plaene

/** Der Hauptplan (haupt: true) oder null. */
export function hauptplan(daten) {
  const plaene = daten?.plaene
  if (!Array.isArray(plaene)) return null
  return plaene.find((p) => p && p.haupt === true) ?? null
}

/** Der Plan mit diesem Kurznamen ([a-z0-9-], exakter Vergleich) oder null. */
export function planNachKurz(daten, kurz) {
  const plaene = daten?.plaene
  if (!Array.isArray(plaene) || typeof kurz !== 'string' || kurz === '') return null
  return plaene.find((p) => p && p.kurz === kurz) ?? null
}

/** Bundesland der Daten; fehlend oder unbekannt = Vorgabe RP (Spec 2.1). */
export function landVon(daten) {
  return BUNDESLAENDER.includes(daten?.land) ? daten.land : STANDARD_LAND
}

// ------------------------------------------------------------------ Wanduhr -> UTC

/**
 * Berliner Wanduhr -> UTC-Zeitpunkt wie zuUtc, aber ohne null: Faellt die Zeit in die Luecke der
 * Maerz-Umstellung (02:00-02:59), gilt die erste existierende Minute danach (03:00). Doppelte Zeiten
 * (Oktober) ergeben das erste Vorkommen, '24:00' den Folgetag 00:00. Ungueltige Eingabe wirft RangeError.
 */
export function zuUtcOderDanach(tag, hhmm) {
  const direkt = zuUtc(tag, hhmm)
  if (direkt) return direkt
  const min = minuten(hhmm)
  if (!gueltigerTag(tag) || min === null) throw new RangeError(`ungueltige Wanduhrzeit ${String(tag)} ${String(hhmm)}`)
  for (let m = min + 1; m <= 1440; m += 1) {
    const kandidat = zuUtc(tag, `${pad(Math.floor(m / 60))}:${pad(m % 60)}`)
    if (kandidat) return kandidat
  }
  throw new RangeError(`keine existierende Wanduhrzeit nach ${tag} ${hhmm}`)
}

// ------------------------------------------------------------------ Tagesbild

/** Gespeicherte Fenster -> nur brauchbare, nach Beginn sortiert, als Kopie ('24:00' nur als Ende, von != bis). */
function sauberFenster(roh) {
  if (!Array.isArray(roh)) return []
  const fenster = []
  for (const e of roh) {
    if (!Array.isArray(e) || e.length !== 2) continue
    const von = minuten(e[0])
    const bis = minuten(e[1])
    if (von === null || bis === null || von >= 1440 || von === bis) continue
    fenster.push([e[0], e[1]])
  }
  return fenster.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
}

/** { modus, fenster } eines gespeicherten Tageseintrags: unbekannter Modus oder 'zeiten' ohne Fenster = zu. */
function modusUndFenster(eintrag) {
  const modus = MODI.includes(eintrag?.modus) ? eintrag.modus : 'zu'
  if (modus !== 'zeiten') return { modus, fenster: [] }
  const fenster = sauberFenster(eintrag.fenster)
  return fenster.length ? { modus, fenster } : { modus: 'zu', fenster: [] }
}

/**
 * Die geltende Ausnahme dieser Art fuer Plan und Tag: planbezogene schlagen globale (plan null),
 * bei Gleichstand gewinnt die spaeter angelegte (hoeherer Index). Ausnahmen mit unlesbarem Zeitraum,
 * von > bis oder fuer einen anderen Plan zaehlen nicht; fehlendes 'bis' = ein Tag.
 */
function ausnahmeFuer(daten, planId, tag, art) {
  const liste = Array.isArray(daten?.ausnahmen) ? daten.ausnahmen : []
  let treffer = null
  let trefferRang = -1
  for (const a of liste) {
    if (!a || a.art !== art) continue
    const von = a.von
    const bis = a.bis ?? a.von
    if (typeof von !== 'string' || typeof bis !== 'string' || !TAG_RE.test(von) || !TAG_RE.test(bis)) continue
    if (tag < von || tag > bis) continue
    const global = a.plan === null || a.plan === undefined
    if (!global && a.plan !== planId) continue
    const rang = global ? 0 : 1
    // Liste in Anlegereihenfolge: bei gleichem Rang ersetzt der spaetere (>=)
    if (rang >= trefferRang) {
      treffer = a
      trefferRang = rang
    }
  }
  return treffer
}

/**
 * Feiertage je (Jahr, Land), einmal berechnet: Map tag -> { name, art: 'feiertag'|'pruefen' }.
 * Begrenzt, damit beliebige Jahre den Speicher nicht fuellen.
 */
const FEIERTAGE_CACHE = new Map()
function feiertageDesJahres(jahr, land) {
  const schluessel = `${jahr}|${land}`
  let karte = FEIERTAGE_CACHE.get(schluessel)
  if (!karte) {
    karte = new Map()
    for (const e of feiertageImZeitraum(`${jahr}-01-01`, `${jahr}-12-31`, land)) {
      karte.set(e.tag, Object.freeze({ name: e.name, art: e.art }))
    }
    if (FEIERTAGE_CACHE.size >= 200) FEIERTAGE_CACHE.clear()
    FEIERTAGE_CACHE.set(schluessel, karte)
  }
  return karte
}

/**
 * Das Tagesbild eines Plans an einem Berliner Kalendertag (Spec 6, spezifisch vor allgemein):
 * Sondertag > Betriebsurlaub > Feiertag (Abweichung oder Vorgabe) > Wochenplan.
 *
 * Rueckgabe { tag, art: 'regulaer'|'feiertag'|'urlaub'|'sondertag', name, modus, fenster }:
 * - name: Feiertagsname, bei Urlaub/Sondertag der Text der Ausnahme, sonst null.
 * - Urlaub ist immer zu. Gesetzlicher Feiertag ohne Abweichung ist zu; ein „bitte pruefen“-Tag
 *   (Heiligabend, Silvester, ...) folgt dem Wochenplan (art 'regulaer'), ausser der Kunde hat unter
 *   daten.feiertage[tag] eine Abweichung gespeichert (dann art 'feiertag' mit dem Namen des Tages).
 * - fenster ist immer ein neues Array (bei 'zu', 'rund', 'vereinbarung' leer); 'bis' kann '24:00' sein.
 */
export function tagesbild(daten, plan, tag) {
  pruefeTag(tag, 'tag')
  const planId = plan?.id

  const sonder = ausnahmeFuer(daten, planId, tag, 'sondertag')
  if (sonder) return { tag, art: 'sondertag', name: textOderNull(sonder.text), ...modusUndFenster(sonder) }

  const urlaub = ausnahmeFuer(daten, planId, tag, 'urlaub')
  if (urlaub) return { tag, art: 'urlaub', name: textOderNull(urlaub.text), modus: 'zu', fenster: [] }

  const feiertag = feiertageDesJahres(tag.slice(0, 4), landVon(daten)).get(tag)
  if (feiertag) {
    const abweichung = daten?.feiertage?.[tag]
    if (abweichung && MODI.includes(abweichung.modus)) {
      return { tag, art: 'feiertag', name: feiertag.name, ...modusUndFenster(abweichung) }
    }
    if (feiertag.art === 'feiertag') return { tag, art: 'feiertag', name: feiertag.name, modus: 'zu', fenster: [] }
  }

  return { tag, art: 'regulaer', name: null, ...modusUndFenster(plan?.tage?.[wochentag(tag)]) }
}

// ------------------------------------------------------------------ Oeffnungsintervalle

/**
 * Zusammengefuegte Oeffnungsintervalle [{ vonMs, bisMs }] (UTC-Millisekunden, sortiert) fuer die
 * Berliner Kalendertage vonTag bis bisTag (inklusive).
 * - Fenster gehoeren zum Starttag; 'bis' vor 'von' laeuft bis zum Folgetag und folgt der Regel des Starttags
 *   (auch wenn der Folgetag Feiertag, Urlaub oder zu ist). Ein am letzten Tag beginnendes Fenster wird
 *   bis zu seinem Ende geliefert.
 * - Enthalten ist auch das vom Vortag in vonTag hineinlaufende Fenster, ungekuerzt (es beginnt vor vonTag 00:00).
 * - 'rund' = 00:00 bis Folgetag 00:00; 'zu' und 'vereinbarung' ergeben nichts.
 * - Ueberlappende und aneinander grenzende Intervalle (auch ueber Tage) sind zusammengefuegt.
 * - Fenster in der Maerz-Luecke beginnen/enden um 03:00, Fenster ohne Dauer fallen weg.
 * vonTag nach bisTag => []. Ungueltige Tage werfen RangeError.
 */
export function oeffnungsIntervalle(daten, plan, vonTag, bisTag) {
  pruefeTag(vonTag, 'vonTag')
  pruefeTag(bisTag, 'bisTag')
  if (vonTag > bisTag) return []

  const bereichStart = zuUtcOderDanach(vonTag, '00:00').getTime()
  const roh = []
  const nimm = (vonMs, bisMs) => {
    if (bisMs > vonMs && bisMs > bereichStart) roh.push({ vonMs, bisMs })
  }

  for (let tag = plusTage(vonTag, -1); tag <= bisTag; tag = plusTage(tag, 1)) {
    const bild = tagesbild(daten, plan, tag)
    if (bild.modus === 'rund') {
      nimm(zuUtcOderDanach(tag, '00:00').getTime(), zuUtcOderDanach(tag, '24:00').getTime())
    } else if (bild.modus === 'zeiten') {
      for (const [von, bis] of bild.fenster) {
        const ueberMitternacht = bis <= von
        nimm(
          zuUtcOderDanach(tag, von).getTime(),
          zuUtcOderDanach(ueberMitternacht ? plusTage(tag, 1) : tag, bis).getTime(),
        )
      }
    }
  }

  roh.sort((a, b) => a.vonMs - b.vonMs || a.bisMs - b.bisMs)
  const zusammen = []
  for (const i of roh) {
    const letztes = zusammen[zusammen.length - 1]
    if (letztes && i.vonMs <= letztes.bisMs) letztes.bisMs = Math.max(letztes.bisMs, i.bisMs)
    else zusammen.push({ vonMs: i.vonMs, bisMs: i.bisMs })
  }
  return zusammen
}