/* =====================================================================
   DIE MITGLIEDER-KACHEL UND DIE STUFEN (Blueprint Kapitel 4/4.1)

   Vier Fragen, und die dritte ist die, an der es schiefgeht:

     1. Stehen die Angaben aus Kapitel 4 in der Antwort -- Status,
        "dabei seit", Stufe?
     2. Erscheinen auch PAUSIERTE? Vorher stand in der Abfrage
        `AND aktiv = 1`: Wer jemanden pausierte, bei dem verschwand er
        samt seiner offenen Rueckmeldungen aus dem Eingang. Die
        warteten weiter auf eine Antwort, nur sah sie niemand mehr.
     3. WER DARF DIE STUFE SETZEN? Der Blueprint trennt das
        ausdruecklich: gleicher Ueberblick fuer die rechte Hand,
        "Verwaltungsrechte optional durch Owner freischaltbar" -- also
        standardmaessig aus. Eine Rechtegrenze, die man nicht misst,
        ist eine Absichtserklaerung.
     4. Ueberlebt die Stufe den naechsten Aufruf? Ein Wert, der nur im
        Browser steht, sieht bis zum Neuladen richtig aus.

   MIT GEGENPROBE: Am Ende wird dieselbe Person auf eine andere Stufe
   gesetzt und wieder zurueck. Ohne diesen Teil waere nicht bewiesen,
   dass die Pruefung ueberhaupt einen Unterschied bemerkt.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-stufen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
   Ohne diese Zeile startet der eigene Server bei belegtem Port
   STILL nicht -- und alles Folgende misst gegen einen fremden
   Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
   als kaputt. */
const PORT = await eigenerPort(import.meta, "pruef-team-stufen");
process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
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";
import { eigenerPort } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-team-stufen");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;

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

/* ---------- Personen ------------------------------------------------- */
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, aktiv = 1, erstellt = jetzt) {
  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 (?,?,?,?,?,?,?,?)")
    .run(name, rolle, hash, salt, 32768,
      createHmac("sha256", schluessel).update(code).digest("hex"), aktiv, erstellt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

/* Ein Datum weit genug zurueck, damit "seit ... Tagen dabei" etwas
   anderes ergibt als "seit heute" -- und RELATIV gerechnet, nicht fest
   hingeschrieben: Ein festes Datum waere in einem halben Jahr eine
   andere Aussage (Lehre vom 06.09.2026). */
const vor40Tagen = new Date(Date.now() - 40 * 86400000).toISOString();

const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
const idMarina = anlegen("Marina", "modi", "CODE-MODI-0001", 1, vor40Tagen);
const idKim = anlegen("Kim", "modi", "CODE-MODI-0002", 0);   // pausiert
const idCreator = anlegen("Tili", "creator", "CODE-TILI-0001");

async function anmelden(rolle, code) {
  const a = await fetch(`${BASIS}/workspace/api/anmelden`, {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }),
  });
  return (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
}
const holeLage = (keks) => fetch(`${BASIS}/workspace/api/teamlage`, { headers: { Cookie: keks } });
const setzeStufe = (keks, person_id, stufe) =>
  fetch(`${BASIS}/workspace/api/teamlage/stufe`, {
    method: "PUT",
    headers: { Cookie: keks, "Content-Type": "application/json", Origin: BASIS },
    body: JSON.stringify({ person_id, stufe }),
  });

const keksDogi = await anmelden("admin", "CODE-DOGI-0001");
const keksHand = await anmelden("hand", "CODE-HAND-0001");
const keksModi = await anmelden("modi", "CODE-MODI-0001");
if (!keksDogi || !keksHand || !keksModi) {
  console.error("FEHLER: Anmeldung misslang -- ohne sie misst diese Datei nichts.");
  process.exit(1);
}

/* =====================================================================
   1. WAS IN DER ANTWORT STEHT
   ===================================================================== */
console.log("");
console.log("--- Die Mitglieder-Kachel (Kapitel 4) ---");

const a1 = await holeLage(keksDogi);
ok(a1.status === 200, `DogFather bekommt die Lage (${a1.status})`);
const lage = await a1.json();
const leute = lage.leute || [];

/* SEIT DEM 11.09.2026 GEHOERT DIE RECHTE HAND DAZU.

   Filipe: "die rechte hand ist da um mir zu helfen aber auch wie die
   modis um mir zu sagen was passt und nicht." Damit steht sie in
   derselben Liste -- sonst kaemen ihre Rueckmeldungen nirgends an.

   Die Zahl steht hier trotzdem, und zwar mit der Rechnung dahinter:
   zwei Modis (einer pausiert) plus die rechte Hand, minus die Person,
   die gerade liest. Eine Pruefung, die nur `> 0` verlangt, haette den
   Umbau nicht bemerkt. */
ok(leute.length === 3,
  `beide Modis und die rechte Hand stehen da, auch der pausierte (${leute.length})`);
ok(!leute.some((p) => p.id === idDogi),
  "und DogFather selbst nicht -- er liest die Seite, er steht nicht darauf");
ok(leute.some((p) => p.id === idHand),
  "die rechte Hand steht wirklich darin (sonst waere die 3 oben Zufall)");

const marina = leute.find((m) => m.id === idMarina);
const kim = leute.find((m) => m.id === idKim);
ok(!!marina && !!kim, "beide sind namentlich wiederzufinden");

ok(marina?.aktiv === true && kim?.aktiv === false,
  `Status stimmt (Marina aktiv: ${marina?.aktiv}, Kim aktiv: ${kim?.aktiv})`);
/* AKTIVE ZUERST -- wer pausiert ist, steht unten und nicht mittendrin.

   GEPRUEFT WIRD DIE EIGENSCHAFT, NICHT DIE POSITION (berichtigt
   20.09.2026). Hier stand `leute[0]?.id === idMarina` -- und das wurde
   rot, sobald die rechte Hand nach vorn sortiert wurde. Richtig wurde
   es dadurch nicht: Die Aussage "die Aktiven stehen oben" hat mit
   Marinas Platz nichts zu tun. Eine Pruefung, die eine Position
   festnagelt, verbietet jede Umsortierung -- auch die gewollte. */
const letzteAktive = leute.map((m) => m.aktiv).lastIndexOf(true);
const ersteInPause = leute.map((m) => m.aktiv).indexOf(false);
ok(ersteInPause === -1 || letzteAktive < ersteInPause,
  `die Aktiven stehen oben (letzte aktive Stelle ${letzteAktive}, erste Pause ${ersteInPause})`);

/* ==== UND DIE RECHTE HAND VOR DEN MODIS (20.09.2026) ================

   Filipe: "ich will dass hier wie ueberall die reihenfolge immer
   rechte hand und dan erst die modis."

   Vorher sortierte die Abfrage nur nach Namen -- die Rolle wurde nicht
   einmal mitgelesen. Damit stand die Reihenfolge im Alphabet, und das
   ist keine. */
const platzHand = leute.findIndex((m) => m.id === idHand);
const ersterModi = leute.findIndex((m) => m.id !== idHand && m.aktiv);
ok(platzHand >= 0 && (ersterModi === -1 || platzHand < ersterModi),
  `die rechte Hand steht vor den Modis (Platz ${platzHand} vor ${ersterModi})`);
ok(leute.every((m) => typeof m.rolle === "string" && m.rolle),
  "und jede Karte weiss, welche Rolle sie hat — sonst kann die Seite sie nicht unterscheiden");

ok(typeof marina?.seit === "string" && marina.seit.startsWith(vor40Tagen.slice(0, 10)),
  `"dabei seit" kommt mit (${(marina?.seit || "").slice(0, 10)})`);

/* NULL HEISST PROBE, nicht "unbekannt" -- an EINER Stelle im Server
   abgebildet. Beide Modis wurden ohne Stufe angelegt. */
ok(marina?.stufe === "probe" && kim?.stufe === "probe",
  `ohne Eintrag ist die Stufe "Probe" (${marina?.stufe} / ${kim?.stufe})`);

/* Die Liste der Stufen kommt VOM SERVER -- eine zweite im Browser
   waere die Stelle, an der beim naechsten Mal eine fehlt.

   KEINE ABGESCHRIEBENE LISTE MEHR (22.09.2026). Hier stand
   `=== JSON.stringify(["probe","standard","senior"])`. Als die vierte
   und fuenfte Stufe dazukamen, wurde die Pruefung rot, ohne dass
   irgendetwas kaputt war -- sie hat die Zahl von gestern verteidigt.
   Dieselbe Krankheit wie eine abgeschriebene Spaltenliste.

   Geprueft werden jetzt die EIGENSCHAFTEN, die wirklich gelten
   muessen, egal wie viele es sind. */
const stufen = (lage.stufen || []).map((s) => s.wert);
ok(stufen.length >= 3,
  `mindestens drei Stufen kommen mit (${stufen.length}: ${stufen.join(", ")})`);
ok(new Set(stufen).size === stufen.length, "keine Stufe doppelt");
/* "probe" MUSS die erste sein: Der Server bildet NULL auf die erste ab
   (stufeVon), und die Oberflaeche waehlt STUFEN[0] vor. Stuende dort
   etwas anderes, waere jeder neue Mensch still auf dieser anderen
   Stufe -- ohne dass es irgendwo auffaellt. */
ok(stufen[0] === "probe",
  `die erste ist "probe" (${stufen[0]}) -- darauf faellt ein leeres Feld zurueck`);
ok((lage.stufen || []).every((s) => s.name && s.name !== s.wert),
  "und jede hat einen lesbaren Namen");
ok(new Set((lage.stufen || []).map((s) => s.name)).size === stufen.length,
  "kein Name doppelt -- zwei gleich beschriftete Knoepfe waeren ein Ratespiel");

/* =====================================================================
   DIE FARBEN -- NACHGERECHNET, NICHT GEGLAUBT (22.09.2026)

   Filipe: „und ich will das es ein zwei kategorien mehr gibt und das
   soll geiler aussehen und jede seine eigene farbe, stark erkennbar."

   „Stark erkennbar" ist keine Geschmacksfrage, sondern ein Abstand.
   Das Haus hat dafuer laengst Schwellen (tools/kachelton-regeln.mjs);
   die Stufenfarben waren nur nie daran gemessen worden. Nachgerechnet
   lagen "Probe" und "Standard" bei 0,0576 -- weit unter den 0,090, die
   ueberall sonst gelten. Es war also kein Geschmacksurteil, sondern
   ein messbarer Mangel, und er stand seit dem 10.09. da.

   DREI ORTE, EINE FARBE: Die Stufe faerbt das Schild
   (.tmerkmal--<wert>), die ganze Karte ([data-stufe="<wert>"]) und den
   Knopf zum Setzen (--st am [data-stufe="<wert>"]). Stimmen die drei
   nicht ueberein, fuehrt ein oranger Knopf zu einer gruenen Karte.
   ===================================================================== */
console.log("");
console.log("--- Die Farben der Stufen ---");

const { readFileSync: leseDatei } = await import("node:fs");
const { dirname: ordnerVon, join: pfadJoin } = await import("node:path");
const { fileURLToPath: alsPfad } = await import("node:url");
const HIER_ST = ordnerVon(alsPfad(import.meta.url));
const teamCss = leseDatei(
  pfadJoin(HIER_ST, "..", "workspace", "assets", "css", "team.css"), "utf8");

const { oklab } = await import("./helfer-kachel-echtfarbe.mjs");
const regeln = await import("../tools/kachelton-regeln.mjs");

const hexZuRgb = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16));
const linearAnteil = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
const leuchtkraft = ([R, G, B]) => {
  const [r, g, b] = [R / 255, G / 255, B / 255].map(linearAnteil);
  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
};
const kontrastZu = (a, b) => {
  const x = leuchtkraft(a), y = leuchtkraft(b);
  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
};
const okAbstand = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
const buntheit = (o) => Math.hypot(o[1], o[2]);
const GRUND_RGB = hexZuRgb(regeln.GRUND);

/* Die Farben werden AUS DER STILVORLAGE GELESEN, nicht hier
   aufgezaehlt. Eine Liste, die niemand pflegt, kann nicht veralten. */
const holeFarbe = (muster) => {
  const t = teamCss.match(muster);
  return t ? t[1].toLowerCase() : null;
};
const farben = new Map();
for (const wert of stufen) {
  const schild = holeFarbe(new RegExp(
    "\\.tmerkmal--" + wert + "\\s*\\{[^}]*color-mix\\(in srgb,\\s*(#[0-9a-fA-F]{6})"));
  const karte = holeFarbe(new RegExp(
    "\\.tperson\\[data-stufe=\"" + wert + "\"\\]\\s*\\{\\s*--r:\\s*(#[0-9a-fA-F]{6})"));
  const knopf = holeFarbe(new RegExp(
    "\\.tstufen__knopf\\[data-stufe=\"" + wert + "\"\\]\\s*\\{\\s*--st:\\s*(#[0-9a-fA-F]{6})"));
  ok(Boolean(schild && karte && knopf),
    `"${wert}" hat eine Farbe am Schild, an der Karte und am Knopf`
    + ` (${schild || "fehlt"} / ${karte || "fehlt"} / ${knopf || "fehlt"})`);
  ok(schild !== null && schild === karte && schild === knopf,
    `und es ist ueberall dieselbe (${schild})`);
  if (schild) farben.set(wert, schild);
}

ok(farben.size === stufen.length,
  `alle ${stufen.length} Stufen haben eine Farbe (${farben.size})`);

/* Die eigentliche Messung. Die ZAHL der geprueften Paare steht in der
   Bedingung -- eine leere Schleife darf nicht "in Ordnung" heissen. */
const werte = [...farben.entries()];
let paare = 0, engstes = Infinity, engstesPaar = "";
for (let i = 0; i < werte.length; i++) {
  for (let j = i + 1; j < werte.length; j++) {
    paare++;
    const a = okAbstand(oklab(hexZuRgb(werte[i][1])), oklab(hexZuRgb(werte[j][1])));
    if (a < engstes) { engstes = a; engstesPaar = `${werte[i][0]}/${werte[j][0]}`; }
  }
}
ok(paare === (werte.length * (werte.length - 1)) / 2 && paare > 0
  && engstes >= regeln.MINDEST_ABSTAND,
  `${paare} Paare geprueft, engstes ${engstesPaar} = ${engstes.toFixed(4)}`
  + ` (noetig ${regeln.MINDEST_ABSTAND})`);

let blasseste = Infinity, grellste = 0, schwaechster = Infinity;
for (const [, hex] of werte) {
  const rgb = hexZuRgb(hex), o = oklab(rgb);
  blasseste = Math.min(blasseste, buntheit(o));
  grellste = Math.max(grellste, buntheit(o));
  schwaechster = Math.min(schwaechster, kontrastZu(rgb, GRUND_RGB));
}
ok(werte.length > 0 && blasseste >= regeln.MINDEST_BUNTHEIT,
  `die blasseste hat Buntheit ${blasseste.toFixed(3)} (noetig ${regeln.MINDEST_BUNTHEIT})`);
ok(werte.length > 0 && grellste <= regeln.HOECHST_BUNTHEIT,
  `die bunteste hat ${grellste.toFixed(3)} (hoechstens ${regeln.HOECHST_BUNTHEIT})`);
ok(werte.length > 0 && schwaechster >= regeln.MINDEST_KONTRAST,
  `der schwaechste Kontrast gegen den Kartengrund ist ${schwaechster.toFixed(2)}`
  + ` (noetig ${regeln.MINDEST_KONTRAST})`);

/* GEGENPROBE ZUR MESSUNG SELBST. Ohne sie waere nicht bewiesen, dass
   diese Rechnung ueberhaupt "nicht in Ordnung" sagen kann -- und der
   Stand von gestern ist der beste Beleg dafuer, weil er wirklich so
   ausgeliefert war. */
const alteFarben = ["#9fb6c6", "#7fc4e8", "#8fd6a6"];
let altEngstes = Infinity;
for (let i = 0; i < alteFarben.length; i++) {
  for (let j = i + 1; j < alteFarben.length; j++) {
    altEngstes = Math.min(altEngstes,
      okAbstand(oklab(hexZuRgb(alteFarben[i])), oklab(hexZuRgb(alteFarben[j]))));
  }
}
ok(altEngstes < regeln.MINDEST_ABSTAND,
  `Gegenprobe: der Stand von gestern faellt durch dieselbe Messung`
  + ` (${altEngstes.toFixed(4)} < ${regeln.MINDEST_ABSTAND})`);

/* =====================================================================
   2. WER DARF SIE SETZEN
   ===================================================================== */
console.log("");
console.log("--- Wer die Stufe setzen darf ---");

const gesetzt = await setzeStufe(keksDogi, idMarina, "senior");
ok(gesetzt.status === 200, `DogFather darf (${gesetzt.status})`);

/* DIE RECHTE HAND SIEHT ALLES UND SETZT NICHTS. Blueprint 3.1:
   "Verwaltungsrechte optional durch Owner freischaltbar" -- also aus.
   404 und nicht 403: Wer nicht darf, muss nicht erfahren, dass es den
   Weg gibt. */
const handSieht = await holeLage(keksHand);
ok(handSieht.status === 200, `die rechte Hand sieht die Lage (${handSieht.status})`);
const handSetzt = await setzeStufe(keksHand, idMarina, "probe");
ok(handSetzt.status === 404, `aber sie setzt keine Stufe (${handSetzt.status})`);

const modiSetzt = await setzeStufe(keksModi, idMarina, "probe");
ok(modiSetzt.status === 404, `ein Modi erst recht nicht (${modiSetzt.status})`);
const modiSieht = await holeLage(keksModi);
ok(modiSieht.status === 404, `und er sieht die Seite gar nicht (${modiSieht.status})`);

/* =====================================================================
   3. WAS ABGEWIESEN WIRD
   ===================================================================== */
console.log("");
console.log("--- Was nicht durchgeht ---");

const erfunden = await setzeStufe(keksDogi, idMarina, "chef");
ok(erfunden.status === 400, `eine erfundene Stufe wird abgewiesen (${erfunden.status})`);

/* An einem Creator hat die Stufe nichts verloren -- sie stuende in der
   Datenbank und wuerde nirgends angezeigt. */
const anCreator = await setzeStufe(keksDogi, idCreator, "senior");
ok(anCreator.status === 404, `an einem Creator geht sie nicht (${anCreator.status})`);
const nachCreator = d.prepare("SELECT stufe FROM personen WHERE id = ?").get(idCreator);
ok(!nachCreator?.stufe, "und es steht auch nichts in der Datenbank");

const anNiemand = await setzeStufe(keksDogi, 99999, "senior");
ok(anNiemand.status === 404, `an einer unbekannten Nummer auch nicht (${anNiemand.status})`);

/* =====================================================================
   4. UEBERLEBT SIE DEN NAECHSTEN AUFRUF?
   ===================================================================== */
console.log("");
console.log("--- Beim naechsten Laden ---");

const a2 = await holeLage(keksDogi);
const marina2 = ((await a2.json()).leute || []).find((m) => m.id === idMarina);
ok(marina2?.stufe === "senior", `die neue Stufe kommt zurueck (${marina2?.stufe})`);
const inDb = d.prepare("SELECT stufe FROM personen WHERE id = ?").get(idMarina);
ok(inDb?.stufe === "senior", `und steht in der Datenbank (${inDb?.stufe})`);

/* Eine Personalentscheidung gehoert ins Protokoll -- gerade wenn
   jemand zurueckgestuft wird, muss spaeter nachvollziehbar sein, wer
   das wann getan hat. */
const spur = d.prepare(
  "SELECT COUNT(*) AS n FROM protokoll WHERE aktion = 'stufe_gesetzt'").get()?.n || 0;
ok(spur >= 1, `die Entscheidung steht im Protokoll (${spur})`);

/* =====================================================================
   DIE GEGENPROBE

   Bis hierhin koennte alles auch dann gruen sein, wenn der Server
   jeden Wert einfach annimmt und die Anzeige ihn nie wieder aendert.
   Also zurueckstufen und noch einmal nachsehen.
   ===================================================================== */
console.log("");
console.log("--- Gegenprobe: wieder zurueck ---");

const zurueck = await setzeStufe(keksDogi, idMarina, "standard");
ok(zurueck.status === 200, `zurueckstufen geht (${zurueck.status})`);
const a3 = await holeLage(keksDogi);
const marina3 = ((await a3.json()).leute || []).find((m) => m.id === idMarina);
ok(marina3?.stufe === "standard",
  `und die Anzeige folgt (${marina3?.stufe}) -- sie bleibt also nicht auf "senior" stehen`);

/* Dieselbe Stufe noch einmal: kein Fehler, aber auch keine zweite
   Protokollzeile -- sonst waere das Protokoll nach einem Tag Klicken
   unlesbar. */
const vorher = d.prepare(
  "SELECT COUNT(*) AS n FROM protokoll WHERE aktion = 'stufe_gesetzt'").get()?.n || 0;
const nochmal = await setzeStufe(keksDogi, idMarina, "standard");
const nachher = d.prepare(
  "SELECT COUNT(*) AS n FROM protokoll WHERE aktion = 'stufe_gesetzt'").get()?.n || 0;
ok(nochmal.status === 200 && nachher === vorher,
  `dieselbe Stufe noch einmal aendert nichts (${vorher} -> ${nachher} Zeilen)`);

/* ---------- Ende ------------------------------------------------------ */
d.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Windows haelt manchmal */ }

console.log("");
console.log(`${fehler === 0 ? "BESTANDEN" : "FEHLGESCHLAGEN"}`
  + ` -- ${geprueft} geprueft, ${fehler} Fehler, ${offen} nicht nachsehbar`);
process.exit(fehler === 0 ? 0 : 1);