dogfather-universe/server/workspace-leistung.js

/* =====================================================================
   workspace-leistung.js — die Zahlen über das Geschäft.

   Der große Befund aus dem Plan vom 31.08.2026: Der Workspace
   organisiert ARBEIT hervorragend -- Aufgaben, Termine, Protokolle,
   Bereiche, Pipeline. Über das GESCHÄFT wusste er nichts. Keine
   Diamanten, keine LIVE-Tage, keine Verweildauer.

   Damit hing die ganze Betreuung in der Luft:
     * Der Start-Check bewertet, aber misst nicht.
     * Der Report fragt "was hat funktioniert?" -- ohne Beleg.
     * Das 90-Tage-Ziel ist ein Satz, kein Fortschritt.
     * "Creator im Fokus" zeigt überfällige Aufgaben, aber nicht,
       WESSEN ZAHLEN einbrechen.

   ---------------------------------------------------------------------
   DIE DREI REGELN GUTER KENNZAHLEN (Recherche 31.08./06.09.2026)

   Jede Zahl, die dieses Modul ausliefert, bringt mit:

     1. VERGLEICH   gegen die Vorperiode oder gegen das Ziel
     2. VERLAUF     die letzten Wochen als Reihe, damit man Richtung sieht
     3. EINORDNUNG  "+23 % gegenüber der Vorwoche" statt nur "1.240"

   Eine Zahl ohne diese drei ist eine Eitelkeitszahl. Sie sieht nach
   Auskunft aus und ist keine -- man kann nichts entscheiden.

   ---------------------------------------------------------------------
   DIE LEITZAHL IST DIE VERWEILDAUER

   Neu aus der Recherche vom 06.09.2026: 2026 hängt der Algorithmus
   alles an der Completion Rate. Und sie gehört als BETRIEBSkennzahl
   behandelt, nicht als kreative -- sie soll die nächste Runde steuern,
   nicht die letzte erklären. Deshalb steht sie überall vorn.

   ---------------------------------------------------------------------
   WAS DIESES MODUL NICHT TUT

   Es holt nichts von TikTok. Es gibt keine offene Agentur-Schnittstelle;
   Fremd-APIs kosten Geld, verstoßen gegen die Nutzungsbedingungen und
   brechen ohne Vorwarnung. Eingelesen wird der OFFIZIELLE Export --
   und von Hand getippt, was fehlt.
   ===================================================================== */

import express from "express";
import {
  db, protokolliere, echteIp, sitzungLesen, istLeitung, istSpicy,
  sichtbareCreatorIds, ROLLEN_SORTIERUNG,
} from "./workspace.js";

export const leistungRouter = express.Router();

const jetzt = () => new Date().toISOString();
const NOTIZ_MAX = 500;

/* ---------- Schranke ---------------------------------------------------- */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  next();
}

function gleicheHerkunft(req, res, next) {
  const herkunft = req.get("origin");
  if (!herkunft) return next();
  let erlaubt;
  try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
  if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
  next();
}

leistungRouter.use("/workspace/api/leistung", angemeldet);

/* SPICY MEDIA SIEHT DIE ZAHLEN NIRGENDS (07.09.2026).

   Filipe: "bei der spicy rolle, die zahlen diese kategorie nicht
   sehen." Zuerst habe ich woertlich nur die KATEGORIE geschlossen --
   Kachel und Seite. Auf Nachfrage, was noch offen sei, habe ich selbst
   darauf hingewiesen, dass die Creator-Zahlen damit weiterhin im
   Dashboard stehen (Diamanten, LIVE-Tage, Verweildauer je Karte);
   Filipe hat entschieden, dass auch das weg soll.

   DIE SPERRE SITZT AM SERVER UND NICHT IN DER OBERFLAECHE. Eine
   ausgeblendete Zeile ist keine Sperre: Wer die Adresse kennt, ruft
   die Schnittstelle direkt auf. Hier kommt sie gar nicht mehr an
   Daten.

   404 statt 403, wie ueberall in diesem Haus: Wer nicht hierher
   gehoert, muss nicht erfahren, dass es diesen Bereich gibt.

   DAS DASHBOARD BRICHT DADURCH NICHT. Es holt die Zahlen in EINER
   zusaetzlichen Abfrage und faengt ihren Fehlschlag ausdruecklich ab
   ("die Karten stehen auch ohne", uebersicht.js) -- bei ihr fehlen
   also die drei Zeilen, alles andere bleibt. Genau deshalb ist diese
   eine Zeile hier der ganze Eingriff. */
leistungRouter.use("/workspace/api/leistung", (req, res, next) => {
  if (istSpicy(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
  next();
});

/* ---------- Wer darf was ------------------------------------------------ */

/** Wessen Zahlen darf ich SEHEN? Dieselbe Regel wie überall sonst --
 *  eine eigene Sichtbarkeit für Zahlen wäre eine zweite Wahrheit, und
 *  zwei Wahrheiten laufen auseinander. */
function darfSehen(person, creatorId) {
  const ids = sichtbareCreatorIds(person);
  if (ids === null) return true;                       // DogFather
  return ids.includes(Number(creatorId));
}

/** Wer darf Zahlen EINTRAGEN? Leitung und Scouts -- nicht der Creator
 *  selbst. Nicht aus Misstrauen: Die Zahlen kommen aus dem offiziellen
 *  Export, und wer sie selbst tippt, hat den Export nicht. Eine Zahl,
 *  die man sich selbst gibt, ist keine Messung. */
function darfEintragen(person) {
  return istLeitung(person) || person.rolle === "scout";
}

/* ---------- Rechnen ----------------------------------------------------- */

const TAG_MS = 86400000;

/** Ortszeit-Datum als "JJJJ-MM-TT". Nie toISOString(): Das ist UTC und
 *  liegt zwischen Mitternacht und zwei Uhr einen Tag daneben. */
function tagText(d) {
  const p = (n) => String(n).padStart(2, "0");
  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
}
const tagVor = (n) => tagText(new Date(Date.now() - n * TAG_MS));

/** Summe und Durchschnitt über einen Zeitraum.
 *
 *  DURCHSCHNITTE ZÄHLEN NUR TAGE MIT WERT. Ein Tag ohne LIVE ist kein
 *  Tag mit 0 Zuschauern -- er ist ein Tag ohne Messung. Wer ihn
 *  mitmittelt, redet jede Zahl klein, sobald jemand Urlaub hat. */
function zeitraum(creatorId, von, bis) {
  const z = db().prepare(`
    SELECT
      COUNT(*)                                  AS tage_erfasst,
      COALESCE(SUM(diamanten), 0)               AS diamanten,
      COALESCE(SUM(dauer_min), 0)               AS dauer_min,
      COALESCE(SUM(gueltiger_tag), 0)           AS gueltige_tage,
      COALESCE(SUM(follower_neu), 0)            AS follower_neu,
      COALESCE(SUM(schenker), 0)                AS schenker,
      AVG(CASE WHEN zuschauer_avg  IS NOT NULL THEN zuschauer_avg  END) AS zuschauer_avg,
      MAX(zuschauer_max)                        AS zuschauer_max,
      AVG(CASE WHEN verweildauer_s IS NOT NULL THEN verweildauer_s END) AS verweildauer_s
    FROM leistung WHERE creator_id = ? AND tag >= ? AND tag <= ?`)
    .get(creatorId, von, bis);

  return {
    tage_erfasst: z.tage_erfasst,
    diamanten: z.diamanten,
    dauer_min: z.dauer_min,
    gueltige_tage: z.gueltige_tage,
    follower_neu: z.follower_neu,
    schenker: z.schenker,
    zuschauer_avg: z.zuschauer_avg === null ? null : Math.round(z.zuschauer_avg),
    zuschauer_max: z.zuschauer_max,
    verweildauer_s: z.verweildauer_s === null ? null : Math.round(z.verweildauer_s),
  };
}

/** Die Veränderung gegenüber der Vorperiode, in Prozent.
 *
 *  VON NULL AUS GIBT ES KEINE PROZENT. 0 → 50 sind nicht "unendlich
 *  Prozent besser", sondern schlicht "vorher nichts". Wer hier eine
 *  Zahl erzwingt, bekommt Unsinn wie "+∞ %" auf den Bildschirm. */
function wandel(jetztWert, vorherWert) {
  if (jetztWert === null || vorherWert === null) return null;
  if (!vorherWert) return jetztWert ? { neu: true } : null;
  return { prozent: Math.round(((jetztWert - vorherWert) / vorherWert) * 100) };
}

/** Der Verlauf: eine Zahl je Woche, die letzten N Wochen.
 *  Für die kleine Linie neben der Zahl -- ohne Richtung ist ein Wert
 *  nur ein Punkt. */
function verlauf(creatorId, wochen = 8) {
  const reihen = [];
  for (let i = wochen - 1; i >= 0; i--) {
    const bis = tagVor(i * 7);
    const von = tagVor(i * 7 + 6);
    const z = zeitraum(creatorId, von, bis);
    reihen.push({
      von, bis,
      diamanten: z.diamanten,
      gueltige_tage: z.gueltige_tage,
      verweildauer_s: z.verweildauer_s,
    });
  }
  return reihen;
}

/* =====================================================================
   Die Schnittstellen
   ===================================================================== */

/** Die Zahlen eines Creators: diese Woche, Vorwoche, Ziel, Verlauf. */
leistungRouter.get("/workspace/api/leistung/:creatorId", (req, res) => {
  try {
    const creatorId = Number(req.params.creatorId);
    if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
    /* Was man nicht sehen darf, existiert nicht -- 404, nicht 403. */
    if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });

    const dieseWoche = zeitraum(creatorId, tagVor(6), tagVor(0));
    const vorwoche = zeitraum(creatorId, tagVor(13), tagVor(7));
    const ziele = db().prepare("SELECT * FROM leistung_ziele WHERE creator_id = ?").get(creatorId);

    /* JEDE ZAHL MIT VERGLEICH UND EINORDNUNG -- die drei Regeln aus
       der Recherche. Eine nackte Zahl fliegt raus. */
    const mitVergleich = {};
    for (const feld of ["diamanten", "gueltige_tage", "dauer_min", "zuschauer_avg",
      "verweildauer_s", "schenker", "follower_neu"]) {
      mitVergleich[feld] = {
        wert: dieseWoche[feld],
        vorher: vorwoche[feld],
        wandel: wandel(dieseWoche[feld], vorwoche[feld]),
      };
    }

    /* Das Ziel als Fortschritt, nicht als Satz. */
    const zielstand = ziele ? {
      diamanten: ziele.diamanten_woche
        ? { ziel: ziele.diamanten_woche, ist: dieseWoche.diamanten,
            anteil: Math.round((dieseWoche.diamanten / ziele.diamanten_woche) * 100) } : null,
      tage: ziele.tage_woche
        ? { ziel: ziele.tage_woche, ist: dieseWoche.gueltige_tage,
            anteil: Math.round((dieseWoche.gueltige_tage / ziele.tage_woche) * 100) } : null,
      verweildauer: ziele.verweildauer_s && dieseWoche.verweildauer_s
        ? { ziel: ziele.verweildauer_s, ist: dieseWoche.verweildauer_s,
            anteil: Math.round((dieseWoche.verweildauer_s / ziele.verweildauer_s) * 100) } : null,
    } : null;

    res.json({
      creator_id: creatorId,
      woche: mitVergleich,
      roh: { woche: dieseWoche, vorwoche },
      ziele: zielstand,
      verlauf: verlauf(creatorId),
      /* Wie vollständig ist die Woche überhaupt? Eine Zahl aus zwei von
         sieben Tagen ist etwas anderes als eine aus sieben. Ohne das
         hält man eine halbe Woche für einen Einbruch. */
      erfassung: { tage: dieseWoche.tage_erfasst, von: 7 },
    });
  } catch (fehler) {
    console.error("[leistung] Lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Die Tageszeilen eines Creators -- für die Schnelleingabe. */
leistungRouter.get("/workspace/api/leistung/:creatorId/tage", (req, res) => {
  try {
    const creatorId = Number(req.params.creatorId);
    if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
    if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });

    const tage = Math.min(Math.max(Number(req.query.tage) || 14, 1), 120);
    const reihen = db().prepare(`
      SELECT * FROM leistung WHERE creator_id = ? AND tag >= ?
       ORDER BY tag DESC`).all(creatorId, tagVor(tage - 1));
    res.json({ tage: reihen });
  } catch (fehler) {
    console.error("[leistung] Tage:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ZIELE STEHEN VOR DER TAGES-ROUTE -- und das ist kein Stilfrage.

   Express nimmt die ERSTE Route, die passt. `:tag` passt auf jeden
   Text, also auch auf "ziele": Ein PUT auf .../ziele landete in der
   Tages-Route, scheiterte dort am Datumsmuster und gab 400 zurueck.
   Die Ziele liessen sich nicht setzen, und die Meldung sagte
   "ungueltig" -- was auf die Zahlen im Koerper hindeutet, nicht auf
   den Weg.

   Gefunden von pruef-leistung ("600 von 1200 Diamanten = undefined %").
   Ohne die Pruefung waere es erst aufgefallen, wenn jemand ein Ziel
   setzen wollte. */
/** Ziele setzen. */
leistungRouter.put("/workspace/api/leistung/:creatorId/ziele", gleicheHerkunft,
  express.json({ limit: "4kb" }), (req, res) => {
    try {
      const creatorId = Number(req.params.creatorId);
      if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
      if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
      if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });

      const z = (n) => {
        const w = Number(req.body?.[n]);
        return Number.isFinite(w) && w > 0 ? Math.round(w) : null;
      };
      db().prepare(`
        INSERT INTO leistung_ziele (creator_id, diamanten_woche, tage_woche, verweildauer_s, gesetzt, gesetzt_von)
        VALUES (?,?,?,?,?,?)
        ON CONFLICT(creator_id) DO UPDATE SET
          diamanten_woche = excluded.diamanten_woche,
          tage_woche = excluded.tage_woche,
          verweildauer_s = excluded.verweildauer_s,
          gesetzt = excluded.gesetzt, gesetzt_von = excluded.gesetzt_von`)
        .run(creatorId, z("diamanten_woche"), z("tage_woche"), z("verweildauer_s"),
          jetzt(), req.person.id);
      res.json({ ok: true });
    } catch (fehler) {
      console.error("[leistung] Ziele:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });


/** Einen Tag eintragen oder ändern.
 *
 *  INSERT OR REPLACE auf (creator_id, tag): Derselbe Tag zweimal
 *  eingetragen überschreibt, statt zu verdoppeln. Verdoppelte Zahlen
 *  sind schlimmer als fehlende -- sie sehen richtig aus. */
leistungRouter.put("/workspace/api/leistung/:creatorId/:tag", gleicheHerkunft,
  express.json({ limit: "8kb" }), (req, res) => {
    try {
      const creatorId = Number(req.params.creatorId);
      const tag = String(req.params.tag);
      if (!Number.isInteger(creatorId) || !/^\d{4}-\d{2}-\d{2}$/.test(tag)) {
        return res.status(400).json({ fehler: "ungueltig" });
      }
      if (!darfEintragen(req.person)) {
        return res.status(403).json({ fehler: "Zahlen tragen DogFather, Manager und Scouts ein." });
      }
      if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });

      /* KEINE ZAHLEN AUS DER ZUKUNFT. Ein Tippfehler im Jahr (2027
         statt 2026) legt sonst eine Zeile an, die nie wieder auffällt
         -- sie taucht in keiner Auswertung auf, weil alle nur
         zurückschauen. */
      if (tag > tagVor(0)) {
        return res.status(400).json({ fehler: "Für einen Tag in der Zukunft gibt es noch keine Zahlen." });
      }

      const z = (name) => {
        const w = req.body?.[name];
        if (w === null || w === undefined || w === "") return null;
        const n = Number(w);
        /* Negative Werte gibt es hier nicht -- weder negative Diamanten
           noch negative Minuten. Ein Minus ist immer ein Tippfehler. */
        return Number.isFinite(n) && n >= 0 ? Math.round(n) : null;
      };

      const notiz = String(req.body?.notiz ?? "").trim().slice(0, NOTIZ_MAX) || null;

      db().prepare(`
        INSERT OR REPLACE INTO leistung
          (creator_id, tag, diamanten, dauer_min, gueltiger_tag, zuschauer_avg,
           zuschauer_max, verweildauer_s, schenker, follower_neu, notiz,
           erfasst, erfasst_von, quelle)
        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(
        creatorId, tag, z("diamanten"), z("dauer_min"),
        req.body?.gueltiger_tag ? 1 : 0,
        z("zuschauer_avg"), z("zuschauer_max"), z("verweildauer_s"),
        z("schenker"), z("follower_neu"), notiz,
        jetzt(), req.person.id, "hand");

      protokolliere("leistung_erfasst", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `Creator #${creatorId} ${tag}`,
      });
      res.json({ ok: true });
    } catch (fehler) {
      console.error("[leistung] Eintragen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Einen Tag löschen -- für den Fall, dass eine Zeile falsch angelegt
 *  wurde. Kein "weg_am" wie beim Chat: Eine Messung, die es nicht gab,
 *  soll auch nicht als leere Zeile herumstehen und Durchschnitte
 *  verwässern. */
leistungRouter.delete("/workspace/api/leistung/:creatorId/:tag", gleicheHerkunft, (req, res) => {
  try {
    const creatorId = Number(req.params.creatorId);
    const tag = String(req.params.tag);
    if (!Number.isInteger(creatorId) || !/^\d{4}-\d{2}-\d{2}$/.test(tag)) {
      return res.status(400).json({ fehler: "ungueltig" });
    }
    if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
    if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });

    const e = db().prepare("DELETE FROM leistung WHERE creator_id = ? AND tag = ?")
      .run(creatorId, tag);
    protokolliere("leistung_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `Creator #${creatorId} ${tag}`,
    });
    res.json({ ok: true, entfernt: Number(e.changes) });
  } catch (fehler) {
    console.error("[leistung] Löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Überblick über ALLE sichtbaren Creator -- für das Dashboard.
 *  Eine Abfrage statt einer je Creator. */
leistungRouter.get("/workspace/api/leistung", (req, res) => {
  try {
    /* DURCH DIE AUGEN DER ANGESEHENEN PERSON (11.09.2026).

       Filipe: "oben bei meine sicht soll ich auch die sicht von allen
       jeden moment sehen koennen und das genau genau so wie sie es
       sehen alles."

       Nur LESEN wird umgestellt, nie ein Recht: `req.person` bleibt
       ueberall dort stehen, wo geschrieben oder geprueft wird. Und
       weil DogFather ohnehin alles sehen darf, kann diese Umstellung
       nichts oeffnen -- sie kann nur WENIGER zeigen, naemlich genau
       das, was die andere Person sieht.
       Gemessen: In der Sicht auf einen Modi kamen hier DogFathers
       eigene Creator zurueck -- 131 Zeichen statt 14. */
    const zeigt = req.sicht || req.person;
    const ids = sichtbareCreatorIds(zeigt);
    const wo = ids === null ? "rolle = 'creator' AND aktiv = 1"
      : ids.length ? `id IN (${ids.map(() => "?").join(",")}) AND aktiv = 1`
        : "0=1";
    const creator = db().prepare(
      `SELECT id, name FROM personen WHERE ${wo} ORDER BY name`)
      .all(...(ids === null ? [] : ids));

    res.json({
      creator: creator.map((c) => {
        const w = zeitraum(c.id, tagVor(6), tagVor(0));
        const v = zeitraum(c.id, tagVor(13), tagVor(7));
        return {
          id: c.id, name: c.name,
          diamanten: w.diamanten,
          gueltige_tage: w.gueltige_tage,
          verweildauer_s: w.verweildauer_s,
          wandel_diamanten: wandel(w.diamanten, v.diamanten),
          tage_erfasst: w.tage_erfasst,
        };
      }),
    });
  } catch (fehler) {
    console.error("[leistung] Überblick:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* =====================================================================
   CSV-Import aus dem offiziellen Export
   =====================================================================

   ZWEIMAL EINLESEN DARF KEINEN SCHADEN ANRICHTEN. Das ist der
   häufigste Fehler bei Importen und der Grund für den
   Primärschlüssel (creator_id, tag): Dieselbe Datei ein zweites Mal
   überschreibt, statt zu verdoppeln.

   VORSCHAU VOR DEM ÜBERNEHMEN: Erst zeigen, was passieren wird, dann
   machen. Ein Import, der sofort schreibt, ist bei einer falsch
   zugeordneten Spalte nicht mehr zurückzuholen. */

/** Zerlegt CSV -- auch mit Anführungszeichen und Semikolon.
 *
 *  Kein fremdes Paket: Die Formate, die hier vorkommen, sind
 *  überschaubar, und eine Abhängigkeit für dreißig Zeilen wäre in
 *  einem Haus mit drei Abhängigkeiten die vierte. */
export function csvZerlegen(text) {
  const zeilen = [];
  let feld = "";
  let zeile = [];
  let inAnfuehrung = false;
  const roh = String(text).replace(/^/, "");   // BOM weg

  /* Trennzeichen erkennen: Deutsche Exporte nutzen oft Semikolon,
     englische Komma. Geraten wird an der ERSTEN Zeile -- dort, wo die
     Überschriften stehen. */
  const kopf = roh.split(/\r?\n/)[0] || "";
  const trenner = (kopf.match(/;/g) || []).length > (kopf.match(/,/g) || []).length ? ";" : ",";

  for (let i = 0; i < roh.length; i++) {
    const z = roh[i];
    if (inAnfuehrung) {
      if (z === '"' && roh[i + 1] === '"') { feld += '"'; i++; }
      else if (z === '"') inAnfuehrung = false;
      else feld += z;
    } else if (z === '"') inAnfuehrung = true;
    else if (z === trenner) { zeile.push(feld); feld = ""; }
    else if (z === "\n") { zeile.push(feld); zeilen.push(zeile); zeile = []; feld = ""; }
    else if (z !== "\r") feld += z;
  }
  if (feld !== "" || zeile.length) { zeile.push(feld); zeilen.push(zeile); }
  return zeilen.filter((z) => z.some((f) => String(f).trim() !== ""));
}

/** Macht aus einem Textwert eine Zahl.
 *
 *  Deutsche Exporte schreiben "1.234,5", englische "1,234.5". Beide
 *  müssen gehen -- und "1.234" darf nicht als 1,234 gelesen werden.
 *  Regel: Das LETZTE Trennzeichen entscheidet, ob es ein Komma-
 *  oder Punktformat ist. */
export function zahlLesen(roh) {
  const t = String(roh ?? "").trim();
  if (!t) return null;
  const nurZiffern = t.replace(/[^\d.,-]/g, "");
  if (!nurZiffern) return null;

  const letztesKomma = nurZiffern.lastIndexOf(",");
  const letzterPunkt = nurZiffern.lastIndexOf(".");
  let sauber;

  if (letztesKomma >= 0 && letzterPunkt >= 0) {
    /* BEIDE kommen vor -- dann ist das LETZTE das Dezimalzeichen und
       das andere der Tausendertrenner. "1.234,5" und "1,234.5" sind
       damit eindeutig. */
    sauber = letztesKomma > letzterPunkt
      ? nurZiffern.replace(/\./g, "").replace(",", ".")
      : nurZiffern.replace(/,/g, "");
  } else if (letztesKomma >= 0 || letzterPunkt >= 0) {
    /* NUR EINES kommt vor -- und das ist die Falle.
       "1.250" ist deutsch Tausend-zweihundertfünfzig, englisch aber
       eins-komma-zwofünfnull. "1,234" genauso, nur andersherum. Die
       Regel "das letzte Trennzeichen ist das Dezimalzeichen" liefert
       hier für BEIDE Fälle das Falsche: Sie las "1.250" als 1,25 und
       "1,234" als 1,234 -- Faktor tausend daneben, und die Zahl sieht
       trotzdem plausibel aus.

       Entscheidend ist stattdessen, WIE VIELE Ziffern dahinter
       stehen: Genau drei heißt Tausendertrenner (so gruppiert man
       überall), alles andere heißt Dezimalstelle.

           "1.250"  -> 3 Ziffern -> 1250
           "1,234"  -> 3 Ziffern -> 1234
           "210,5"  -> 1 Ziffer  -> 210.5
           "12.75"  -> 2 Ziffern -> 12.75

       Bleibt EIN unauflösbarer Fall: "1.500" könnte auch eins Komma
       fünf sein. Bei Diamanten, Minuten und Zuschauern ist die
       Tausenderdeutung die richtige -- Nachkommastellen kommen dort
       nicht vor. Deshalb wird hier so entschieden und nicht anders. */
    const trenner = letztesKomma >= 0 ? "," : ".";
    const stelle = letztesKomma >= 0 ? letztesKomma : letzterPunkt;
    const dahinter = nurZiffern.length - stelle - 1;
    sauber = dahinter === 3
      ? nurZiffern.split(trenner).join("")
      : nurZiffern.replace(trenner, ".");
  } else {
    sauber = nurZiffern;
  }

  const n = Number(sauber);
  return Number.isFinite(n) ? n : null;
}

/** Macht aus einem Textwert ein Datum "JJJJ-MM-TT".
 *  Erkennt 2026-09-06, 06.09.2026 und 09/06/2026. */
export function datumLesen(roh) {
  const t = String(roh ?? "").trim();
  let m;
  if ((m = /^(\d{4})-(\d{2})-(\d{2})/.exec(t))) return `${m[1]}-${m[2]}-${m[3]}`;
  if ((m = /^(\d{1,2})\.(\d{1,2})\.(\d{4})/.exec(t))) {
    return `${m[3]}-${String(m[2]).padStart(2, "0")}-${String(m[1]).padStart(2, "0")}`;
  }
  if ((m = /^(\d{1,2})\/(\d{1,2})\/(\d{4})/.exec(t))) {
    /* Amerikanisch: Monat zuerst. */
    return `${m[3]}-${String(m[1]).padStart(2, "0")}-${String(m[2]).padStart(2, "0")}`;
  }
  return null;
}

/** Rät die Spaltenzuordnung aus den Überschriften.
 *  Nur ein Vorschlag -- bestätigt wird er in der Vorschau. */
export function spaltenRaten(kopf) {
  const muster = {
    tag: /datum|date|tag|day/i,
    diamanten: /diamant|diamond/i,
    dauer_min: /dauer|duration|minut|zeit.*live|live.*zeit/i,
    zuschauer_avg: /(durchschnitt|avg|average|⌀|ø).*(zuschauer|viewer)|(zuschauer|viewer).*(durchschnitt|avg)/i,
    zuschauer_max: /(spitze|peak|max).*(zuschauer|viewer)|(zuschauer|viewer).*(spitze|peak|max)/i,
    verweildauer_s: /verweil|watch.*time|retention|zuschauzeit/i,
    schenker: /schenker|gifter|sender/i,
    follower_neu: /follower|abonnent/i,
  };
  const zu = {};
  kopf.forEach((name, i) => {
    for (const [feld, m] of Object.entries(muster)) {
      if (zu[feld] === undefined && m.test(String(name))) zu[feld] = i;
    }
  });
  return zu;
}

/** Vorschau: Was WÜRDE passieren? Schreibt nichts. */
leistungRouter.post("/workspace/api/leistung/:creatorId/import/vorschau", gleicheHerkunft,
  express.json({ limit: "2mb" }), (req, res) => {
    try {
      const creatorId = Number(req.params.creatorId);
      if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
      if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
      if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });

      const zeilen = csvZerlegen(String(req.body?.text || ""));
      if (zeilen.length < 2) {
        return res.status(400).json({ fehler: "Die Datei hat keine Datenzeilen." });
      }
      const kopf = zeilen[0];
      const zu = req.body?.spalten && typeof req.body.spalten === "object"
        ? req.body.spalten : spaltenRaten(kopf);

      if (zu.tag === undefined) {
        return res.status(400).json({
          fehler: "Ich finde keine Datumsspalte. Bitte die Spalte zuordnen.",
          kopf, spalten: zu,
        });
      }

      const neu = [];
      const ersetzt = [];
      const fehlerhaft = [];
      for (let i = 1; i < zeilen.length; i++) {
        const z = zeilen[i];
        const tag = datumLesen(z[zu.tag]);
        if (!tag) { fehlerhaft.push({ zeile: i + 1, grund: `Datum unlesbar: "${z[zu.tag]}"` }); continue; }
        if (tag > tagVor(0)) { fehlerhaft.push({ zeile: i + 1, grund: `${tag} liegt in der Zukunft` }); continue; }

        const werte = { tag };
        for (const [feld, spalte] of Object.entries(zu)) {
          if (feld === "tag" || spalte === undefined) continue;
          werte[feld] = zahlLesen(z[spalte]);
        }
        const vorhanden = db().prepare(
          "SELECT 1 FROM leistung WHERE creator_id = ? AND tag = ?").get(creatorId, tag);
        (vorhanden ? ersetzt : neu).push(werte);
      }

      res.json({
        kopf, spalten: zu,
        /* Die ZAHLEN stehen vorn, die Beispiele dahinter: Wer
           übernimmt, will wissen "wie viele", nicht "welche". */
        neu: neu.length, ersetzt: ersetzt.length, fehlerhaft: fehlerhaft.length,
        beispiele: neu.slice(0, 5),
        ersetzt_beispiele: ersetzt.slice(0, 5),
        probleme: fehlerhaft.slice(0, 10),
      });
    } catch (fehler) {
      console.error("[leistung] Vorschau:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Übernehmen. Erst jetzt wird geschrieben. */
leistungRouter.post("/workspace/api/leistung/:creatorId/import", gleicheHerkunft,
  express.json({ limit: "2mb" }), (req, res) => {
    try {
      const creatorId = Number(req.params.creatorId);
      if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
      if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
      if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });

      const zeilen = csvZerlegen(String(req.body?.text || ""));
      if (zeilen.length < 2) return res.status(400).json({ fehler: "keine_daten" });
      const zu = req.body?.spalten && typeof req.body.spalten === "object"
        ? req.body.spalten : spaltenRaten(zeilen[0]);
      if (zu.tag === undefined) return res.status(400).json({ fehler: "keine_datumsspalte" });

      const d = db();
      const schreiben = d.prepare(`
        INSERT OR REPLACE INTO leistung
          (creator_id, tag, diamanten, dauer_min, gueltiger_tag, zuschauer_avg,
           zuschauer_max, verweildauer_s, schenker, follower_neu, notiz,
           erfasst, erfasst_von, quelle)
        VALUES (?,?,?,?,?,?,?,?,?,?,
          /* Eine vorhandene Notiz NICHT wegwerfen: Sie ist von Hand
             geschrieben und steht in keinem Export. */
          (SELECT notiz FROM leistung WHERE creator_id = ? AND tag = ?),
          ?,?, 'import')`);

      let geschrieben = 0, uebersprungen = 0;
      d.exec("BEGIN");
      try {
        for (let i = 1; i < zeilen.length; i++) {
          const z = zeilen[i];
          const tag = datumLesen(z[zu.tag]);
          if (!tag || tag > tagVor(0)) { uebersprungen++; continue; }
          const w = (feld) => (zu[feld] === undefined ? null : zahlLesen(z[zu[feld]]));
          const dauer = w("dauer_min");
          schreiben.run(
            creatorId, tag, w("diamanten"), dauer,
            /* Ein gültiger Tag ist ein Tag mit LIVE-Zeit. Steht im
               Export nichts, wird aus der Dauer geschlossen -- eine
               eigene Spalte dafür gibt es meist nicht. */
            dauer && dauer > 0 ? 1 : 0,
            w("zuschauer_avg"), w("zuschauer_max"), w("verweildauer_s"),
            w("schenker"), w("follower_neu"),
            creatorId, tag,
            jetzt(), req.person.id);
          geschrieben++;
        }
        d.exec("COMMIT");
      } catch (f) {
        try { d.exec("ROLLBACK"); } catch { /* schon zurück */ }
        throw f;
      }

      protokolliere("leistung_import", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `Creator #${creatorId}: ${geschrieben} Tage`,
      });
      res.json({ ok: true, geschrieben, uebersprungen });
    } catch (fehler) {
      console.error("[leistung] Import:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });