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 { xlsxLesen, tabelleAbKopf, alsText } from "./workspace-xlsx.js";
import {
  db, protokolliere, echteIp, sitzungLesen, istLeitung,
  sichtbareCreatorIds, ROLLEN_SORTIERUNG, heuteLokal,
} 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);

/* ---------- Die Spicy-Sperre von 07.09.2026 ist aufgehoben ----------
   (11.09.2026) Filipe, mit der Zahlen-Kachel im Bild: "jetzt soll jede
   rolle diese kachel sehen. spicy, dogfather, manager, scout und
   creator ... der manager scout dogfather oder spicy koennen
   eintragen."

   Hier stand bis heute eine Sperre, die Spicy Media mit 404
   abgewiesen hat -- der Rest des Wunsches vom 07.09. ("bei der spicy
   rolle, die zahlen diese kategorie nicht sehen"). Sie sass
   ausdruecklich am Server und nicht in der Oberflaeche, und genau
   deshalb reichte es heute NICHT, Kachel und Tuer zu oeffnen: Die
   Seite lud, das Auswahlfeld blieb leer, und es sah aus wie ein
   Fehler.

   GEFUNDEN HAT DAS EINE MESSUNG, NICHT DAS LESEN. Ich hatte Kachel
   und Tuer geaendert und haette es dabei belassen; erst die Pruefung
   mit Spicy-Zugang zeigte "0 Creator zur Auswahl" und dahinter das
   404. Drei Schichten mussten zustimmen, und die dritte stand
   woanders als die beiden ersten.

   NEBENWIRKUNG, ausdruecklich: Damit stehen auch im Dashboard wieder
   Diamanten, LIVE-Tage und Verweildauer je Creator-Karte. Das war der
   zweite Teil der damaligen Entscheidung und faellt mit ihr weg.

   Was die Zeile NICHT war: eine Rechteregel. Wessen Zahlen Spicy
   Media sieht, entscheidet weiterhin siehtAlles() -- und das sagt
   seit jeher "alle". */

/* ---------- 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.

     TABULATOR SEIT DEM 11.09.2026, und er ist hier der wichtigste Fall.
     Wer eine Tabelle im Browser markiert und kopiert -- genau das ist
     der Weg aus TikTok LIVE Backstage, das keinen Export hat --, hat
     TAB-getrennte Spalten in der Zwischenablage, nicht Komma oder
     Semikolon. Ohne diese Zeile landete die ganze Zeile in der ersten
     Spalte, und die Vorschau haette gemeldet "keine Datumsspalte" --
     eine richtige Meldung auf eine falsche Fährte.

     Gewählt wird das HÄUFIGSTE der drei, nicht das erste gefundene:
     In "Nickname,ID\tDiamanten" kommen zwei davon vor, und nur die
     Anzahl sagt, welches die Spalten trennt. */
  const kopf = roh.split(/\r?\n/)[0] || "";
  const zaehl = (z) => (kopf.split(z).length - 1);
  const trenner = [["\t", zaehl("\t")], [";", zaehl(";")], [",", zaehl(",")]]
    .sort((a, b) => b[1] - a[1])[0][1] > 0
    ? [["\t", zaehl("\t")], [";", zaehl(";")], [",", zaehl(",")]]
      .sort((a, b) => b[1] - a[1])[0][0]
    : ",";

  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 "86Std. 10Min. 52Sek." Minuten.
 *
 *  GEMESSEN AN DER ECHTEN BACKSTAGE-AUSGABE (14.09.2026): Die Spalte
 *  "LIVE-Dauer" enthaelt dort woertlich `86Std. 10Min. 52Sek.` -- ohne
 *  Leerzeichen vor der Einheit. `zahlLesen` machte daraus `null`, weil
 *  "86.10.52." keine Zahl ist. Die Dauer fiel also stillschweigend weg;
 *  der Tag wurde mit Diamanten, aber ohne Minuten geschrieben.
 *
 *  DIE EINHEIT IST DIE FALLE, nicht die Zahl. Haette `zahlLesen` hier
 *  "86" zurueckgegeben -- was bei einem anderen Trennzeichen leicht
 *  passiert waere --, stuenden 86 Minuten statt 5171 in der Datenbank.
 *  Das sieht richtig aus und ist um Faktor 60 daneben.
 *
 *  Verstanden werden:
 *    "86Std. 10Min. 52Sek."   deutsche Backstage-Ausgabe
 *    "86 Std 10 Min"          mit Leerzeichen
 *    "3h 20m", "3 hrs 20 min" englische Fassungen
 *    "86:10:52" / "3:20"      Doppelpunktform
 *    "184"                    blosse Zahl -> Minuten, wie bisher
 *
 *  OHNE EINHEIT BLEIBT ES EINE ZAHL. Eine blosse "184" als Stunden zu
 *  deuten waere geraten; die bestehenden Exporte liefern dort Minuten,
 *  und dabei bleibt es.
 */
export function dauerLesen(roh) {
  const t = String(roh ?? "").trim();
  if (!t) return null;

  /* Doppelpunktform zuerst: "86:10:52" ist eindeutig und wuerde von der
     Einheitensuche unten nicht erkannt. Zwei Teile heissen Stunden und
     Minuten -- so schreibt es jede Uhr. */
  const uhr = /^(\d+):([0-5]?\d)(?::([0-5]?\d))?$/.exec(t);
  if (uhr) {
    const std = Number(uhr[1]);
    const min = Number(uhr[2]);
    const sek = uhr[3] === undefined ? 0 : Number(uhr[3]);
    return Math.round(std * 60 + min + sek / 60);
  }

  /* Einheiten einsammeln. Der Punkt hinter "Std." gehoert nicht dazu,
     die Reihenfolge im Text ist egal, und jede Einheit zaehlt nur
     einmal -- "1 Std 2 Std" ist kein gueltiger Wert und soll nicht
     stillschweigend zu drei Stunden werden. */
  const einheiten = [
    ["std", /(\d+(?:[.,]\d+)?)\s*(?:std|stunden|stunde|hrs|hours|hour|h)(?![a-z])/i],
    ["min", /(\d+(?:[.,]\d+)?)\s*(?:min|minuten|minute|mins|m)(?![a-z])/i],
    ["sek", /(\d+(?:[.,]\d+)?)\s*(?:sek|sekunden|sekunde|secs|sec|s)(?![a-z])/i],
  ];
  let minuten = 0;
  let gefunden = false;
  for (const [art, muster] of einheiten) {
    const m = muster.exec(t);
    if (!m) continue;
    const n = Number(String(m[1]).replace(",", "."));
    if (!Number.isFinite(n)) continue;
    gefunden = true;
    if (art === "std") minuten += n * 60;
    else if (art === "min") minuten += n;
    else minuten += n / 60;
  }
  if (gefunden) return Math.round(minuten);

  /* Keine Einheit erkannt -> wie bisher eine blosse Zahl. */
  return zahlLesen(t);
}

/** Ist das ein ZEITRAUM statt eines Tages?
 *
 *  Backstage schreibt in "Datenzeitraum" woertlich
 *  `2026-09-01 ~ 2026-09-11`. `datumLesen` griff sich davon die erste
 *  Haelfte und gab "2026-09-01" zurueck -- elf Tage Diamanten waeren
 *  damit auf den 1. September geschrieben worden. Gemessen am echten
 *  Export vom 12.09.2026, nicht vermutet.
 *
 *  DAS IST DER TEUERSTE FEHLER, den dieser Weg machen kann: Die Zahl
 *  steht da, sie ist gross, sie sieht richtig aus, und niemand kann
 *  spaeter sagen, dass sie elf Tage enthaelt.
 *
 *  Rueckgabe: {von, bis} bei einem erkannten Zeitraum, sonst null.
 *  Ein Zeitraum von EINEM Tag (von === bis) ist kein Zeitraum -- dann
 *  ist die Datei genau das, was hier gebraucht wird.
 */
export function zeitraumLesen(roh) {
  const t = String(roh ?? "").trim();
  /* Zwei Datumsangaben, getrennt durch ~, -, bis oder to. Das Muster
     verlangt ZWEI vollstaendige Daten; ein einzelnes "2026-09-06"
     faellt nicht darauf herein. */
  const m = /^(\d{4}-\d{2}-\d{2})[^\d]{1,6}(\d{4}-\d{2}-\d{2})$/.exec(t)
    || /^(\d{1,2}\.\d{1,2}\.\d{4})[^\d]{1,6}(\d{1,2}\.\d{1,2}\.\d{4})$/.exec(t);
  if (!m) return null;
  const von = datumLesen(m[1]);
  const bis = datumLesen(m[2]);
  if (!von || !bis) return null;
  return { von, bis };
}

/** 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" UND "day" NUR ALS GANZES WORT (14.09.2026).

       Gemessen an der echten Backstage-Mitgliederliste: Dort steht
       "Tage seit dem Beitritt", und das alte Muster erklaerte diese
       Spalte zur Datumsspalte -- Wert "65". In der Leistungstabelle
       daneben trifft es "Gueltige LIVE-Gehen-Tage" genauso.

       Aufgefallen ist es nicht beim Lesen, sondern als ich den ganzen
       Weg mit der echten Datei durchlaufen liess.

       "zeitraum" kam dazu, weil Backstages Spalte "Datenzeitraum"
       heisst -- sie wurde bisher nur zufaellig gefunden, weil in
       "Daten" die englische Silbe "date" steckt. Auf Zufall soll das
       nicht beruhen. */
    tag: /datum|date|zeitraum|^\s*tage?\s*$|^\s*day\s*$/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;
}

/* =====================================================================
   DER NETZWERK-IMPORT — eine Tabelle, alle Creator auf einmal
   (11.09.2026)

   Filipe: "wie sehr wir diese seite hier mit dem backstage verbinden
   könnten von tiktok. ohne probleme und ganz schnell."

   Die Recherche vom 10.09. hat ergeben: TikTok LIVE Backstage hat
   KEINE Schnittstelle und KEINEN Export -- weder die offizielle Seite
   noch ein Agenturleitfaden nennen einen, und in den offiziellen
   TikTok-Scopes gibt es nichts zu LIVE, Diamanten oder Netzwerkdaten.
   Was es gibt, ist eine Tabelle im Browser, die man markieren kann.

   ALSO IST DER SCHNELLSTE EHRLICHE WEG: markieren, kopieren, einfügen.
   Kein Zugangsdatum, kein Token, keine Erweiterung, die Backstages
   interne Abfragen mitliest -- letzteres wäre ein Verstoß gegen die
   Nutzungsbedingungen und riskiert ausgerechnet das Netzwerkkonto, an
   dem die Einnahmen hängen.

   WAS ES VOM VORHANDENEN IMPORT UNTERSCHEIDET: Der bestehende Weg
   (/leistung/:creatorId/import) nimmt eine Datei FÜR EINEN Creator.
   Backstage zeigt aber ALLE auf einmal. Der Unterschied ist genau eine
   Frage: Zu wem gehört diese Zeile?

   DIE ANTWORT KOMMT AUS `personen.tiktok` -- dem öffentlichen Namen
   ohne @, den es im Steckbrief längst gibt. Gesucht wird ohne @, ohne
   Groß-/Kleinschreibung und ohne Leerzeichen; fällt das aus, wird der
   ANGEZEIGTE Name verglichen. Beides ergebnislos -> die Zeile wird
   gemeldet, nicht geraten. Eine falsch zugeordnete Zahl ist schlimmer
   als eine fehlende: Die fehlende sieht man.
   ===================================================================== */

/** Wer darf eine GANZE Tabelle einspielen?
 *
 *  Nur die Leitung -- enger als `darfEintragen`, das auch Scouts
 *  einschliesst. Ein Scout traegt Zahlen fuer die Creator ein, die ihm
 *  zugeteilt sind; dieser Weg schreibt dagegen fuer ALLE auf einmal,
 *  und das ist eine Handlung der Leitung.
 *
 *  GEMESSEN, NICHT AUSGEDACHT: Der erste Entwurf nahm `darfEintragen`,
 *  und die Pruefung meldete fuer einen Scout HTTP 400 statt 403 -- er
 *  kam durch die Rechtepruefung und scheiterte erst daran, dass er
 *  keinen der Creator sehen darf. Das ist die richtige Antwort aus dem
 *  falschen Grund, und der Knopf auf der Seite war ohnehin schon der
 *  Leitung vorbehalten. Jetzt sagen beide dasselbe. */
function netzDarf(person) {
  return istLeitung(person);
}

/** Aus "@Nova_Live " wird "nova_live" -- damit sich zwei Schreibweisen
 *  derselben Person auch dann treffen, wenn eine davon kopiert wurde. */
function handleSchluessel(roh) {
  return String(roh ?? "").trim().toLowerCase()
    .replace(/^@+/, "")
    /* Unsichtbare Zeichen aus der Zwischenablage: geschütztes
       Leerzeichen und die Richtungsmarken, die TikTok um Namen setzt.
       Sie sind nicht zu sehen und verhindern jeden Treffer. */
    .replace(/[‎‏‪-‮ ]/g, "")
    .replace(/\s+/g, "");
}

/** Welche Spalten nennen die Person -- Handle UND Name.
 *
 *  BEIDE, nicht eine (11.09.2026). Der erste Entwurf nahm die erste
 *  passende Spalte: das Handle, wenn es eines gab. Eine Backstage-
 *  Tabelle hat aber beides nebeneinander, und nicht jeder Creator hat
 *  sein Handle im Steckbrief stehen. Ergebnis in der Messung: Die Zeile
 *  mit leerer Handle-Zelle fiel als "keine Person in der Zeile" durch,
 *  obwohl der Name danebenstand.
 *
 *  Jetzt werden beide gemerkt und je Zeile nacheinander versucht:
 *  erst das Handle (eindeutig), dann der Name (mehrdeutig, aber
 *  besser als nichts). */
function personSpaltenRaten(kopf) {
  const handle = kopf.findIndex((n) => /handle|username|user.?name|tiktok.?id|@/i.test(String(n)));
  const name = kopf.findIndex((n, i) => i !== handle
    && /nick|anzeige|display|name|creator/i.test(String(n)));
  return { handle, name };
}

/** Die Creator, auf die diese Person Zahlen schreiben darf --
 *  als zwei Nachschlagewerke: nach Handle und nach Name. */
function creatorNachschlagen(person) {
  const ids = sichtbareCreatorIds(person);
  const wo = ids === null ? "" : ` AND p.id IN (${ids.map(() => "?").join(",")})`;
  if (ids !== null && !ids.length) return { handle: new Map(), name: new Map(), anzahl: 0 };
  const zeilen = db().prepare(
    `SELECT p.id, p.name, p.tiktok FROM personen p
      WHERE p.rolle = 'creator' AND p.aktiv = 1${wo}`).all(...(ids || []));
  const handle = new Map(), name = new Map();
  for (const z of zeilen) {
    if (z.tiktok) handle.set(handleSchluessel(z.tiktok), z);
    name.set(handleSchluessel(z.name), z);
  }
  return { handle, name, anzahl: zeilen.length };
}

/** Die gemeinsame Auswertung -- von Vorschau UND Übernahme benutzt.
 *
 *  EINE Funktion für beide, weil sonst die Vorschau etwas anderes
 *  berechnen könnte als die Übernahme danach schreibt. Genau das ist
 *  die Sorte Unterschied, die niemand bemerkt, bis die Zahlen falsch
 *  sind. */
function netzwerkLesen(text, person, tagVorgabe) {
  const zeilen = csvZerlegen(String(text || ""));
  if (zeilen.length < 2) return { fehler: "Die Tabelle hat keine Datenzeilen." };

  const kopf = zeilen[0];
  const zu = spaltenRaten(kopf);
  const wer = personSpaltenRaten(kopf);
  if (wer.handle < 0 && wer.name < 0) {
    return { fehler: "Keine Spalte mit Name oder Handle gefunden. "
      + "Die erste Zeile muss die Überschriften enthalten." };
  }
  /* Ohne Datum in der Tabelle muss eines mitgegeben werden -- sonst
     wüsste niemand, auf welchen Tag die Zahlen gehören. Raten wäre
     hier besonders teuer: Ein falscher Tag überschreibt einen echten. */
  const ausTabelle = zu.tag !== undefined;
  if (!ausTabelle && !tagVorgabe) {
    return { fehler: "Die Tabelle hat keine Datumsspalte. Bitte den Tag angeben, "
      + "für den diese Zahlen gelten.", braucht_tag: true };
  }
  const messwerte = Object.keys(zu).filter((f) => f !== "tag");
  if (!messwerte.length) {
    return { fehler: "Keine Zahlenspalte erkannt (Diamanten, Dauer, Zuschauer …)." };
  }

  const nach = creatorNachschlagen(person);
  const treffer = [];
  const unbekannt = [];
  const schlecht = [];

  for (let i = 1; i < zeilen.length; i++) {
    const z = zeilen[i];
    /* Erst das Handle, dann der Name -- je Zeile, nicht je Tabelle.
       Eine leere Handle-Zelle darf die Zeile nicht kosten, solange der
       Name danebensteht. */
    const rohHandle = wer.handle >= 0 ? z[wer.handle] : "";
    const rohName = wer.name >= 0 ? z[wer.name] : "";
    const rohWer = String(rohHandle).trim() || String(rohName).trim();
    if (!rohWer) { schlecht.push({ zeile: i + 1, grund: "Keine Person in der Zeile." }); continue; }

    /* EIN ZEITRAUM IST KEIN TAG (14.09.2026).

       Backstage schreibt in "Datenzeitraum" `2026-09-01 ~ 2026-09-11`.
       `datumLesen` griff sich davon den ersten Tag -- elf Tage
       Diamanten waeren auf den 1. September geschrieben worden. Die
       Zahl steht da, sie ist gross, sie sieht richtig aus, und niemand
       kann spaeter sagen, dass elf Tage darin stecken.

       Gemessen am echten Export vom 12.09.2026, nicht vermutet.

       Ein Zeitraum von EINEM Tag geht durch -- dann ist die Datei
       genau das, was hier gebraucht wird. */
    const zeitraum = ausTabelle ? zeitraumLesen(z[zu.tag]) : null;
    if (zeitraum && zeitraum.von !== zeitraum.bis) {
      schlecht.push({ zeile: i + 1,
        grund: `Zeitraum ${zeitraum.von} bis ${zeitraum.bis} – das sind mehrere Tage `
          + "auf einmal. Stell in Backstage den Zeitraum auf EINEN Tag." });
      continue;
    }
    const tag = ausTabelle
      ? (zeitraum ? zeitraum.von : datumLesen(z[zu.tag]))
      : tagVorgabe;
    if (!tag) { schlecht.push({ zeile: i + 1, grund: `Datum unlesbar: "${z[zu.tag]}"` }); continue; }
    if (tag > heuteLokal()) { schlecht.push({ zeile: i + 1, grund: `${tag} liegt in der Zukunft` }); continue; }

    /* Vier Versuche, in dieser Reihenfolge: Handle gegen Handle, Handle
       gegen Name, Name gegen Handle, Name gegen Name. Das Eindeutige
       zuerst. */
    const sHandle = handleSchluessel(rohHandle);
    const sName = handleSchluessel(rohName);
    const p = (sHandle && nach.handle.get(sHandle))
      || (sHandle && nach.name.get(sHandle))
      || (sName && nach.handle.get(sName))
      || (sName && nach.name.get(sName));
    if (!p) { unbekannt.push(rohWer.slice(0, 60)); continue; }

    const werte = { creator_id: p.id, name: p.name, tag };
    let hatZahl = false;
    for (const feld of messwerte) {
      /* Die Dauer hat eine EINHEIT, die anderen Felder nicht.
         "86Std. 10Min. 52Sek." ergibt sonst nichts (zahlLesen scheitert
         an "86.10.52.") -- und bei einem anderen Trennzeichen waere es
         schlimmer: 86 statt 5171, Faktor 60 daneben und plausibel. */
      const w = feld === "dauer_min" ? dauerLesen(z[zu[feld]]) : zahlLesen(z[zu[feld]]);
      werte[feld] = w;
      if (w !== null && w !== undefined) hatZahl = true;
    }
    /* Eine Zeile ohne eine einzige Zahl ist keine Messung, sondern eine
       Leerzeile mit Namen. Sie zu schreiben würde einen vorhandenen Tag
       mit Nullen überschreiben. */
    if (!hatZahl) { schlecht.push({ zeile: i + 1, grund: `${p.name}: keine einzige Zahl in der Zeile` }); continue; }
    treffer.push(werte);
  }
  return {
    kopf, spalten: zu, person_spalten: wer, aus_tabelle: ausTabelle,
    treffer, unbekannt: [...new Set(unbekannt)], schlecht,
    creator_gesamt: nach.anzahl,
  };
}

/** Vorschau des Netzwerk-Imports. Schreibt nichts. */
leistungRouter.post("/workspace/api/leistung/netzwerk-import/vorschau", gleicheHerkunft,
  express.json({ limit: "4mb" }), (req, res) => {
    try {
      if (!netzDarf(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
      const tag = req.body?.tag ? datumLesen(req.body.tag) : null;
      const e = netzwerkLesen(req.body?.text, req.person, tag);
      if (e.fehler) return res.status(400).json(e);

      /* Was ist neu, was wird ersetzt? Wer eine Tabelle zweimal
         einfügt, soll sehen, dass es dieselbe ist -- und nicht
         hinterher raten, ob er etwas überschrieben hat. */
      const vorhanden = db().prepare(
        "SELECT 1 FROM leistung WHERE creator_id = ? AND tag = ?");
      let neu = 0, ersetzt = 0;
      for (const t of e.treffer) (vorhanden.get(t.creator_id, t.tag) ? ersetzt++ : neu++);

      res.json({
        spalten: e.spalten, person_spalten: e.person_spalten, aus_tabelle: e.aus_tabelle,
        kopf: e.kopf,
        zugeordnet: e.treffer.length, neu, ersetzt,
        unbekannt: e.unbekannt, probleme: e.schlecht.slice(0, 12),
        probleme_gesamt: e.schlecht.length,
        creator_gesamt: e.creator_gesamt,
        beispiele: e.treffer.slice(0, 6),
      });
    } catch (fehler) {
      console.error("[leistung] Netzwerk-Vorschau:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Übernehmen. Erst jetzt wird geschrieben. */
leistungRouter.post("/workspace/api/leistung/netzwerk-import", gleicheHerkunft,
  express.json({ limit: "4mb" }), (req, res) => {
    try {
      if (!netzDarf(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
      const tag = req.body?.tag ? datumLesen(req.body.tag) : null;
      const e = netzwerkLesen(req.body?.text, req.person, tag);
      if (e.fehler) return res.status(400).json(e);
      if (!e.treffer.length) return res.status(400).json({ fehler: "keine_zuordnung" });

      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 von Hand geschriebene Notiz überlebt den Import --
             sie steht in keiner Backstage-Tabelle. */
          (SELECT notiz FROM leistung WHERE creator_id = ? AND tag = ?),
          ?,?, 'import')`);

      let geschrieben = 0;
      d.exec("BEGIN");
      try {
        for (const t of e.treffer) {
          schreiben.run(t.creator_id, t.tag,
            t.diamanten ?? null, t.dauer_min ?? null,
            /* Ein gültiger Tag im Sinne von TikTok ist einer mit
               LIVE-Zeit. Steht keine Dauer in der Tabelle, bleibt es
               bei 0 -- geraten wird nichts. */
            (t.dauer_min ?? 0) > 0 ? 1 : 0,
            t.zuschauer_avg ?? null, t.zuschauer_max ?? null,
            t.verweildauer_s ?? null, t.schenker ?? null, t.follower_neu ?? null,
            t.creator_id, t.tag,
            new Date().toISOString(), req.person.id);
          geschrieben++;
        }
        d.exec("COMMIT");
      } catch (f) { d.exec("ROLLBACK"); throw f; }

      protokolliere("leistung_netzwerk_import", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `${geschrieben} Zeilen, ${e.unbekannt.length} unbekannt`.slice(0, 120),
      });
      res.json({ geschrieben, unbekannt: e.unbekannt, probleme: e.schlecht.length });
    } catch (fehler) {
      console.error("[leistung] Netzwerk-Import:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* =====================================================================
   EXCEL-DATEIEN (14.09.2026)

   Filipe: "mach doch bitte so dass man alle dateien hoch laden könne
   auch excel dateien. gib gas und krieg das hin."

   Die Datei kommt roh herein und geht als TEXT wieder hinaus -- genau
   in der Form, die auch beim Einfuegen aus dem Browser entsteht
   (TAB-getrennt). Danach laeuft alles durch dieselbe Zerlegung,
   dieselbe Vorschau und dieselbe Bestaetigung wie bisher.

   WARUM NICHT GLEICH IMPORTIEREN: Eine Datei, die direkt schreibt,
   nimmt dem Menschen den Blick auf das, was passieren wird. Die
   Vorschau ist der ganze Schutz dieses Wegs; sie zu umgehen waere
   bequem und falsch.

   WER DARF: wer auch eintragen darf. Gelesen wird nichts Fremdes --
   die Antwort enthaelt nur, was in der hochgeladenen Datei stand.
   ===================================================================== */
leistungRouter.post("/workspace/api/leistung/tabelle-lesen",
  gleicheHerkunft, express.raw({ type: "*/*", limit: "12mb" }), (req, res) => {
    try {
      if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
      if (!Buffer.isBuffer(req.body) || !req.body.length) {
        return res.status(400).json({ fehler: "Keine Datei empfangen." });
      }
      let gelesen;
      try {
        gelesen = xlsxLesen(req.body);
      } catch (fehler) {
        /* DER DRITTE AUSGANG: nicht "ging nicht", sondern WAS nicht
           ging. Sonst sucht der Mensch den Fehler bei sich. */
        if (fehler?.name === "XlsxFehler") {
          return res.status(415).json({ fehler: fehler.message });
        }
        throw fehler;
      }
      const t = tabelleAbKopf(gelesen.zeilen);
      if (!t.zeilen.length) {
        return res.status(422).json({ fehler: "In der Tabelle steht nichts." });
      }
      const text = alsText(t.zeilen);
      res.json({
        text,
        blatt: gelesen.blatt,
        zeilen: t.zeilen.length,
        spalten: t.zeilen[0]?.length || 0,
        /* Wie viele Zeilen oben weggefallen sind. Steht in der Antwort,
           damit die Oberflaeche es SAGEN kann -- eine Tabelle, die
           stillschweigend anders anfaengt als die Datei, ist genau die
           Sorte Hilfsbereitschaft, die spaeter niemand nachvollzieht. */
        uebersprungen: t.uebersprungen,
      });
    } catch (fehler) {
      console.error("[leistung] Tabelle lesen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* =====================================================================
   DER WEG UEBER DIE TIKTOK-DATEI IST ENTFERNT (11.09.2026)

   Gebaut am 11.09. vormittags, am selben Tag wieder ausgebaut. Filipe,
   mit den drei Knoepfen im Bild: *"ich will nur dass wir manager
   scouts, dogfather oder spicy sachen eintragen koennen und nicht die
   creator. ich will keine daten von denen kriegen, nur wir."*

   Der Weg war technisch einwandfrei -- und er war der einzige, bei dem
   ein CREATOR uns etwas gibt: seine eigene Datenkopie aus der
   TikTok-App. Genau das soll nicht sein. Es bleiben die beiden
   Wir-Wege: die eigene Datei und die Backstage-Tabelle der Agentur.

   VOLLSTAENDIG ENTFERNT, nicht nur versteckt: Schnittstellen, Leser
   (workspace-tiktok-datei.js), Knopf, Fenster und der fertige Text an
   den Creator. Ein Weg, der nur unsichtbar ist, ist weiterhin da --
   wer die Adresse kennt, benutzt ihn. Und ein Text, der einen Creator
   um seine Daten bittet, soll in diesem Haus nirgends mehr stehen.

   WAS WIR DAMIT NICHT MEHR WISSEN: nichts, was Backstage nicht auch
   sagt. Die Datei war die zweite Quelle (COALESCE), nie die erste.
   ===================================================================== */


/** 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" });
    }
  });