/* =====================================================================
   DER KREISLAUF (17.09.2026) -- Stufe 8 des Plans im Vault

   Bisher waren die acht Bretter acht Silos. Ein Wunsch wurde
   angenommen, irgendwann passierte etwas im Stream, irgendwann lag ein
   Clip bei den Highlights -- und nichts davon wusste voneinander. Wer
   den Wunsch geschrieben hatte, erfuhr nie, dass er erfuellt wurde.

     Wunsch  ->  Termin bei "Was ansteht"  ->  Clip bei "Highlights"

   DAS IST DER UNTERSCHIED ZWISCHEN EINEM BRIEFKASTEN UND EINER
   COMMUNITY. Jemand schreibt einen Wunsch und sieht ihn vier Wochen
   spaeter als Clip wieder, mit seinem Namen daneben.

   ---------------------------------------------------------------------
   UND DER PLAN LAG ZUM DRITTEN MAL DANEBEN

   Dort stand: "`aus_eintrag_id` gibt es in der Tabelle bereits". Gibt
   es -- an den AUFGABEN. Die Eintraege hatten nichts dergleichen.
   Auch ein Plan von heute Nacht ist eine Bestandsliste und altert;
   dreimal an einem Tag hat er sich geirrt, und jedes Mal hat es das
   Messen gefunden, nicht das Nachdenken.

   ---------------------------------------------------------------------
   VIER FRAGEN

     1. Entsteht die Kette -- und traegt der neue Eintrag den Namen
        dessen, der den Wunsch geschrieben hat?
     2. Sieht man sie von BEIDEN Enden?
     3. Zweimal derselbe Weg darf nichts verdoppeln.
     4. Und sie bleibt in der Community: ein Weg in die Content-Planung
        eines Creators waere ein Leck.

   Aufrufen mit:  node server/pruef-kreislauf.mjs
   Bild:          SCHIRM=1 node server/pruef-kreislauf.mjs
   ===================================================================== */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { eigenerPort } from "./helfer-port.mjs";
import { heuteLokal } from "./helfer-tag.mjs";

const PORT = await eigenerPort(import.meta, "pruef-kreislauf");
const ordner = mkdtempSync(join(tmpdir(), "ws-kreis-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(180_000, "pruef-kreislauf");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;

process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

let fehler = 0, geprueft = 0;
const melde = (t) => console.log(t);
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const schluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", schluessel, jetzt);
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen"
    + " (name, rolle, code_hash, code_salt, code_n, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768,
      createHmac("sha256", schluessel).update(code).digest("hex"), jetzt);
}
anlegen("Filipe", "admin", "CODE-DOGI-0001");
anlegen("Lena", "modi", "CODE-LENA-0001");
const spalten = d.prepare("PRAGMA table_info(eintraege)").all().map((s) => s.name);
d.close();

async function anmelden(kachel, code) {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle: kachel, code }),
  });
  return (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
}
const dogi = await anmelden("admin", "CODE-DOGI-0001");
const lena = await anmelden("modi", "CODE-LENA-0001");
const kopf = (keks) => ({ "Content-Type": "application/json", cookie: keks, origin: BASIS });

async function liste(bereich, keks = dogi) {
  const a = await fetch(`${BASIS}/workspace/api/bereich/${bereich}`, { headers: { cookie: keks } });
  return (await a.json().catch(() => null))?.eintraege || [];
}
async function daraus(vonBereich, id, nach, keks = dogi) {
  const a = await fetch(`${BASIS}/workspace/api/bereich/${vonBereich}/${id}/daraus`, {
    method: "POST", headers: kopf(keks), body: JSON.stringify({ nach }),
  });
  return { status: a.status, daten: await a.json().catch(() => null) };
}

/* ---------- LENA schreibt einen Wunsch ------------------------------- */
const w = await fetch(`${BASIS}/workspace/api/bereich/wunsch`, {
  method: "POST", headers: kopf(lena),
  body: JSON.stringify({ art: "gemeinsam",
    titel: "Ein Abend, an dem wir zusammen zocken", datum: heuteLokal() }),
});
const wunschId = (await w.json().catch(() => null))?.id || 0;

/* =======================================================================
   0. DER PLATZ DAFUER
   ======================================================================= */
melde("");
melde("=== 0. Die Spalte ===");
ok(spalten.includes("aus_eintrag_id"),
  `die Eintraege haben 'aus_eintrag_id' (${spalten.length} Spalten)`);
ok(wunschId > 0, `Lena hat einen Wunsch geschrieben (#${wunschId})`);

/* =======================================================================
   1. AUS DEM WUNSCH WIRD EIN TERMIN
   ======================================================================= */
melde("");
melde("=== 1. Wunsch wird Termin ===");
let terminId = 0;
{
  const a = await daraus("wunsch", wunschId, "ansteht");
  ok(a.status === 201, `daraus wird ein Termin (${a.status} ${a.daten?.fehler || ""})`);
  terminId = a.daten?.id || 0;

  const termine = await liste("ansteht");
  const t = termine.find((x) => x.id === terminId);
  ok(t?.titel === "Ein Abend, an dem wir zusammen zocken",
    `der Titel wandert mit ("${t?.titel}")`);

  /* DER NAME IST DER GANZE PUNKT. Ein Termin, unter dem steht "Aus
     Wunschliste -- von Lena", ist etwas anderes als ein Termin. */
  ok(t?.aus?.bereich === "wunsch", `und er weiss, woher er kam (${t?.aus?.bereich})`);
  ok(t?.aus?.von_name === "Lena",
    `mit dem Namen dessen, der den Wunsch schrieb ("${t?.aus?.von_name}")`);

  /* ---- UND AN WELCHEM TAG? (01.10.2026) --------------------------

     DIE FRAGE HAT HIER GEFEHLT, und der Fehler stand trotzdem vor
     der Tuer: Der Termin bekam sein Datum aus `jetzt().slice(0, 10)`
     -- dem UTC-Tag. Um 01:22 Ortszeit war das der 30.09., nicht der
     01.10.

     WAS DAS ANRICHTET: Auf „Was ansteht" sortiert sich der Termin
     nach Datum in einen Zeitstrahl ein. Ein Tag in der Vergangenheit
     heisst Abschnitt „Vorbei" -- und der ist mit Absicht zugeklappt.
     Beim Wunsch stand „Daraus wurde ein Termin", auf dem Brett war
     er nicht zu sehen. Zwei Stunden jede Nacht, genau die Stunden,
     in denen hier gearbeitet wird.

     GEFUNDEN HAT ES DER BROWSERTEIL weiter unten -- aber nur als
     Folge („`.kette` wird nicht sichtbar"), und das schickt einen zur
     falschen Stelle. Diese eine Zeile nennt den Fehler beim Namen und
     braucht dafuer keinen Browser. */
  ok(t?.datum === heuteLokal(),
    `und er liegt HEUTE, nicht gestern (${t?.datum}, heute ist ${heuteLokal()})`);
}

/* =======================================================================
   2. VON BEIDEN ENDEN SICHTBAR
   ======================================================================= */
melde("");
melde("=== 2. Beide Enden ===");
{
  /* OHNE DIESEN ABSCHNITT waere die Kette eine Einbahnstrasse: Der
     Termin wuesste vom Wunsch, aber wer den Wunsch ansieht, erfuehre
     nie, dass etwas daraus wurde -- und genau das ist der Mangel, um
     den es hier geht. */
  const wuensche = await liste("wunsch");
  const wu = wuensche.find((x) => x.id === wunschId);
  ok((wu?.wurde || []).length === 1, `am Wunsch steht, was daraus wurde (${(wu?.wurde || []).length})`);
  ok(wu?.wurde?.[0]?.bereich === "ansteht",
    `und wohin (${wu?.wurde?.[0]?.bereich}: ${wu?.wurde?.[0]?.titel})`);

  /* AUCH LENA SIEHT ES. Ein Kreislauf, den nur das Team sieht, ist
     keiner -- der Sinn ist, dass die Person es erfaehrt. */
  const beiLena = (await liste("wunsch", lena)).find((x) => x.id === wunschId);
  ok((beiLena?.wurde || []).length === 1,
    `und Lena sieht es auch (${(beiLena?.wurde || []).length})`);
}

/* =======================================================================
   3. DIE KETTE GEHT WEITER -- UND NICHT ZWEIMAL
   ======================================================================= */
melde("");
melde("=== 3. Weiter zum Highlight ===");
{
  const a = await daraus("ansteht", terminId, "highlight");
  ok(a.status === 201, `aus dem Termin wird ein Highlight (${a.status})`);

  const h = (await liste("highlight")).find((x) => x.id === a.daten?.id);
  ok(h?.aus?.bereich === "ansteht", `es kennt seinen Termin (${h?.aus?.bereich})`);

  /* ZWEIMAL DERSELBE WEG DARF NICHTS VERDOPPELN. Zwei Termine aus
     einem Wunsch waeren ein Versehen, kein Wunsch. */
  const z = await daraus("wunsch", wunschId, "ansteht");
  ok(z.status === 200 && z.daten?.schon === true,
    `derselbe Weg noch einmal legt nichts nach (${z.status}, schon=${z.daten?.schon})`);
  ok(z.daten?.id === terminId, "und verweist auf den vorhandenen");

  /* GEGENPROBE: Ein ANDERER Weg vom selben Wunsch geht sehr wohl --
     sonst hiesse "schon" nur, dass ab dem zweiten Mal nichts mehr
     geht. */
  const g = await daraus("wunsch", wunschId, "highlight");
  ok(g.status === 201, `ein anderer Weg vom selben Wunsch geht (${g.status})`);
}

/* =======================================================================
   4. DIE KETTE BLEIBT IN DER COMMUNITY
   ======================================================================= */
melde("");
melde("=== 4. Wohin sie NICHT fuehrt ===");
{
  /* Ein Weg in die Content-Planung eines Creators waere ein Leck:
     Dort steht Arbeit, die die Community nichts angeht. */
  const a = await daraus("wunsch", wunschId, "content");
  ok(a.status === 404, `nicht in die Content-Planung (${a.status})`);
  const b = await daraus("content", 1, "wunsch");
  ok(b.status === 404, `und nicht von dort hierher (${b.status})`);

  /* UND EINE ERFUNDENE NUMMER ist kein Sonderfall. */
  const c = await daraus("wunsch", 999999, "ansteht");
  ok(c.status === 404, `eine erfundene Quelle ebenfalls nicht (${c.status})`);
}

/* =======================================================================
   5. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 5. Was man sieht ===");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  try {
    const kontext = await browser.newContext({ viewport: { width: 1100, height: 950 } });
    await kontext.addCookies(dogi.split("; ").map((k) => {
      const [name, ...rest] = k.split("=");
      return { name, value: rest.join("="), domain: "127.0.0.1", path: "/" };
    }));
    const seite = await kontext.newPage();
    const konsole = [];
    seite.on("console", (e) => { if (e.type() === "error") konsole.push(e.text()); });
    await seite.goto(`${BASIS}/workspace/bereich.html?b=ansteht`, { waitUntil: "networkidle" });

    /* ---- ERST AUFKLAPPEN, DANN HINSEHEN (01.10.2026) -------------

       Hier stand nur `waitForSelector(".kette")`. Das wartet auf
       SICHTBARKEIT -- und am 01.10. um 01:22 lag der Termin wegen
       eines falschen Datums im Abschnitt „Vorbei", der von sich aus
       zugeklappt ist. Die Meldung lautete „Zeitsperre nach 15 s", mit
       dem Zusatz „33 x locator resolved to 2 elements": Das Element
       WAR da. Wer die erste Zeile liest, sucht in der Anzeige; die
       Ursache lag im Datum.

       Diese Pruefung misst die KETTE, nicht die Zeiteinteilung. Also
       macht sie auf, was zu ist -- wie ein Mensch, der einen
       Abschnitt anklickt. Dass der Tag stimmt, fragt jetzt eine
       eigene Zeile weiter oben; so bleibt jede Frage bei einer
       Pruefung, und ein Fehler zeigt sich dort, wo er hingehoert. */
    await seite.waitForSelector(".kette", { state: "attached", timeout: 15_000 });
    const aufgeklappt = await seite.evaluate(() => {
      let n = 0;
      for (const schild of document.querySelectorAll(".zeitstrahl__schild")) {
        const kasten = schild.nextElementSibling;
        if (kasten?.hidden) { schild.click(); n++; }
      }
      return n;
    });
    await seite.waitForTimeout(400);
    if (aufgeklappt) melde(`  --   ${aufgeklappt} zugeklappte(n) Abschnitt(e) aufgemacht`);

    /* DRITTER AUSGANG: „gar nicht da" ist etwas anderes als „da und
       unsichtbar". Ohne diese Unterscheidung heisst beides
       „Zeitsperre", und man sucht zweimal an der falschen Stelle. */
    const lage = await seite.evaluate(() => {
      const alle = [...document.querySelectorAll(".kette")];
      return {
        da: alle.length,
        sichtbar: alle.filter((z) => z.getBoundingClientRect().height > 0).length,
      };
    });
    ok(lage.da >= 2 && lage.sichtbar === lage.da,
      `beide Kettenzeilen stehen sichtbar auf der Seite (${lage.sichtbar} von ${lage.da})`);

    const m = await seite.evaluate(() => ({
      her: [...document.querySelectorAll(".kette--her")].map((z) => z.textContent.trim()),
      hin: [...document.querySelectorAll(".kette--hin")].map((z) => z.textContent.trim()),
      wege: [...document.querySelectorAll(".kette__weg[href]")].length,
    }));
    ok(m.her.length >= 1, `die Herkunft steht auf der Karte ("${m.her[0] || ""}")`);
    ok(/Lena/.test(m.her[0] || ""), "mit dem Namen");
    ok(/Wunschliste/.test(m.her[0] || ""), "und dem Brett, aus dem es kam");
    ok(m.hin.length >= 1, `und was daraus wurde ("${m.hin[0] || ""}")`);
    ok(m.wege >= 2, `beide sind anklickbar (${m.wege} Wege)`);
    ok(konsole.length === 0,
      konsole.length ? `Konsole: ${konsole[0]}` : "keine Fehler in der Konsole");

    if (process.env.SCHIRM) {
      await seite.screenshot({ path: fileURLToPath(new URL("pruef-kreislauf.png",
        import.meta.url)), fullPage: false });
      melde("  --   Bildschirmfoto: server/pruef-kreislauf.png");
    }
    await kontext.close();
  } finally {
    await browser.close();
  }
}

melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);