/* WIE SIEHT DIE TEILNEHMERWAHL WIRKLICH AUS?

   WARUM ES DIESE PRÜFUNG GIBT. Am 05.09.2026 waren vierzig Prüfungen
   zur Teilnehmerwahl grün -- und auf Filipes Bildschirm stand:

       DogfatherDogFather   VanVanDogFather   CigdemManager

   Alle vierzig prüften Daten: Kommen die richtigen Personen an? Werden
   Fremde weggefiltert? Stimmt die Sichtbarkeit? Alles richtig. Keine
   einzige hat gefragt, ob das Ergebnis auch AUSSIEHT wie gedacht.

   pruef-css-klassen.mjs fängt die Ursache (CSS auf einer Seite, die es
   nicht lädt). Diese hier misst die Wirkung -- im echten Browser, an
   den echten Pixeln:

     * Stehen Name und Rolle getrennt, oder kleben sie?
     * Ist der Knopf hoch genug für einen Daumen?
     * Sieht man einem ausgewählten Knopf an, dass er an ist -- und
       zwar nicht nur an der Farbe?
     * Und die eigentliche Frage: Erscheint die Wahl bei JEDER Rolle?

   Gemessen wird mit getComputedStyle und getBoundingClientRect, nicht
   an der CSS-Datei. Ein Wert, der im Stylesheet steht, kann von einer
   anderen Regel überschrieben sein -- was zählt, ist, was am Ende auf
   dem Schirm ankommt.

   GEGENPROBE am Ende: Die Messung muss "klebt" auch erkennen können. */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-dabei-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

import { notbremse } from "./helfer-notbremse.mjs";
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Optikpruefung der Teilnehmerwahl");

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 }); };
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
notbremse(480_000, "pruef-dabei-optik");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;

/* LAUFEND MITSCHREIBEN. Node puffert stdout, sobald es umgeleitet wird
   -- bei einem Lauf mit sechs Browser-Anmeldungen steht bis zum Schluss
   NICHTS in der Datei. Beim ersten Versuch hing die Prüfung (ein
   geratener Selektor), und die leere Datei sagte nicht, wie weit sie
   gekommen war. Dieselbe Lehre steht schon in pruef-browser.mjs. */
const { appendFileSync } = await import("node:fs");
const PROTOKOLL = join(process.cwd(), "pruef-dabei-lauf.txt");
try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }
const melde = (z) => {
  console.log(z);
  try { appendFileSync(PROTOKOLL, z + "\n"); } catch { /* Protokoll ist Zugabe */ }
};

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

/* ---- Bestand: eine Kette, wie sie im Betrieb aussieht ------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
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, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
/* Namen wie im echten Bestand -- ein zweiteiliger Name ist der Fall,
   an dem das Kleben aufgefallen ist. */
const idDogi = anlegen("Filipe Fernandes Ribeiro", "admin", "CODE-DOGI-0001");
const idCig = anlegen("Cigdem", "manager", "CODE-MANA-0001");
const idPat = anlegen("Patrick von Hohenstein", "scout", "CODE-SCOU-0001");
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
/* DIE RECHTE HAND (11.09.2026). Sie stand in dieser Auswahl bis heute
   GAR NICHT -- kalender.js zeichnete nach einer Liste aus fuenf
   Agentur-Rollen, und wer nicht darin vorkam, fiel lautlos heraus.
   DogFather konnte sein eigenes Team zu keinem Termin einladen, und
   der Bildschirm sah dabei vollkommen normal aus.

   Sie heisst hier "VanVan" und damit alphabetisch HINTER allen anderen
   ausser Patrick -- mit einem Namen wie "Anna" waere die Zeile
   "sie steht vorn" gruen, ohne etwas zu messen. */
anlegen("VanVan", "hand", "CODE-HAND-0001");

/* Die Zahl steht hier und nicht in den Pruefzeilen: Wer unten einen
   Menschen dazusetzt, muss sonst drei Zahlen nachziehen -- und die
   vergessene ist die, die dann still falsch ist. */
const ZUR_WAHL = 4;   // alle aktiven ausser DogFather selbst
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idPat, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idPat, idCig, jetzt);
d.close();

const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await pw.chromium.launch();

/** Meldet sich an und öffnet den Kalender mit geöffnetem Formular.
 *
 *  ERST DIE ROLLE, DANN DER CODE. Das war der Grund, warum der erste
 *  Versuch dieser Prüfung hängen blieb: Ich hatte den Rollenklick
 *  geraten statt nachgesehen, das Formular nahm den Code nicht an, und
 *  waitForURL wartete auf eine Adresse, die nie kam. */
async function alsRolle(rolle, code, breite = 1280) {
  const ctx = await browser.newContext({ viewport: { width: breite, height: 900 }, hasTouch: breite <= 860 });
  const seite = await ctx.newPage();
  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 25000 });
  await seite.goto(BASIS + "/workspace/kalender.html", { waitUntil: "networkidle" });
  /* Das Formular öffnen -- die Wahl steht darin. */
  await seite.click("#neu-oeffnen");
  await seite.waitForSelector("#neu:not([hidden])", { timeout: 10000 });
  await seite.waitForTimeout(400);
  return { ctx, seite };
}

/* =======================================================================
   1. Als DogFather -- sieht er alle vier Gruppen?
   ======================================================================= */
console.log("\n=== Die Wahl aus Sicht von DogFather ===");
{
  const { ctx, seite } = await alsRolle("admin", "CODE-DOGI-0001");

  const sichtbar = await seite.isVisible("#feld-dabei");
  ok(sichtbar, sichtbar ? "das Feld 'Wer ist noch dabei?' ist da" : "das Feld fehlt");

  const knoepfe = await seite.$$("#dabei-wahl .k-dabei__knopf");
  /* DIE ANZAHL IN DIE BEDINGUNG: Wären es null, würde jede folgende
     Messung über eine leere Menge laufen und grün melden. */
  ok(knoepfe.length === ZUR_WAHL,
    `${knoepfe.length} Personen zur Auswahl (erwartet ${ZUR_WAHL} -- alle außer ihm selbst)`);

  const gruppen = await seite.$$eval(".k-dabei__gruppe", (g) => g.map((x) => x.dataset.rolle));
  ok(gruppen.length === ZUR_WAHL && !gruppen.includes("admin"),
    `Gruppen: ${gruppen.join(", ") || "keine"} — er selbst ist die einzige admin-Person und steht nicht drin`);

  /* ---- DIE REIHENFOLGE (Filipe, 11.09.2026) --------------------------

     "rechte hand soll immer als erstes sein. ueberall."

     Zwei getrennte Fragen, und beide muessen gestellt werden: Ist sie
     ueberhaupt da? Und steht sie vorn? Die erste allein war jahrelang
     mit Nein zu beantworten, ohne dass es jemand sah. */
  ok(gruppen.includes("hand"),
    `die rechte Hand steht ueberhaupt zur Wahl (${gruppen.join(", ")})`);
  ok(gruppen[0] === "hand",
    `und sie steht ganz vorn (erste Gruppe: ${gruppen[0]})`);

  /* GEGENPROBE: Alphabetisch stuende sie NICHT vorn. Ohne diese Zeile
     waere "sie steht vorn" auch dann gruen, wenn gar nicht sortiert
     wird -- die Namen kaemen zufaellig in der richtigen Folge. */
  const namen = await seite.$$eval("#dabei-wahl .k-dabei__name", (n) => n.map((x) => x.textContent.trim()));
  const alphabetisch = [...namen].sort((a, b) => a.localeCompare(b, "de"));
  ok(namen[0] === "VanVan" && alphabetisch[0] !== "VanVan",
    `gezeichnet: ${namen.join(", ")} — alphabetisch waere ${alphabetisch.join(", ")}`);

  /* DER KERN: Kleben Name und Zeichen? Gemessen wird der echte
     Abstand zwischen den zwei Kästchen, nicht der CSS-Wert. */
  const abstand = await seite.evaluate(() => {
    const k = document.querySelector("#dabei-wahl .k-dabei__knopf");
    if (!k) return null;
    const z = k.querySelector(".k-dabei__zeichen")?.getBoundingClientRect();
    const n = k.querySelector(".k-dabei__name")?.getBoundingClientRect();
    if (!z || !n) return null;
    return Math.round(n.left - z.right);
  });
  ok(abstand !== null && abstand >= 6,
    abstand === null ? "Zeichen oder Name nicht gefunden"
      : `${abstand} px zwischen Zeichen und Name (der alte Fehler war 0)`);

  /* Und die Rolle steht NICHT mehr am Namen -- sonst hieße es wieder
     "CigdemManager". */
  const ersterText = await seite.$eval("#dabei-wahl .k-dabei__knopf", (k) => k.textContent.trim());
  ok(!/DogFather|Manager|Scout|Creator/.test(ersterText),
    `der Knopf trägt nur den Namen: "${ersterText}"`);

  /* Die Rolle steht stattdessen über der Gruppe. */
  const titel = await seite.$$eval(".k-dabei__titel", (t) => t.map((x) => x.textContent.trim()));
  ok(titel.length === ZUR_WAHL && titel.some((t) => /Manager/.test(t)),
    `Gruppenüberschriften: ${titel.join(" · ")}`);
  /* Die Ueberschrift der Team-Gruppe kommt vom SERVER -- diese Datei im
     Browser darf den Rollennamen gar nicht kennen. Steht sie da, hat
     der Weg funktioniert. */
  ok(/Team Dogi/.test(titel[0] || ""),
    `und die erste heißt „${titel[0]}" — sie kommt vom Server, nicht aus dem Browser`);

  /* Daumengröße. 40 px ist die Grenze, die dieses Haus überall nutzt. */
  const hoehe = await seite.$eval("#dabei-wahl .k-dabei__knopf",
    (k) => Math.round(k.getBoundingClientRect().height));
  ok(hoehe >= 40, `Knopfhöhe ${hoehe} px (mindestens 40 für den Daumen)`);

  /* Auswählen: Ändert sich etwas Sichtbares -- und zwar mehr als die
     Farbe? Ein Häkchen erkennt auch, wer Farben schlecht sieht. */
  const vorher = await seite.$eval("#dabei-wahl .k-dabei__knopf .k-dabei__haken",
    (h) => getComputedStyle(h).opacity);
  await seite.click("#dabei-wahl .k-dabei__knopf");
  /* AUF DEN ZUSTAND WARTEN, NICHT AUF DIE UHR (01.10.2026).

     Hier stand `waitForTimeout(250)`, mit dieser Begründung: Beim
     ersten Lauf stand „0 → 0" und sah aus wie ein defektes Häkchen
     -- gemessen wurde aber mitten in der 0,16-Sekunden-Blende.
     „250 ms sind reichlich über den 160."

     Auf einem Rechner, auf dem nebenher vier Browser messen, sind
     sie es nicht. Gemessen: Mit vier parallelen Prüfungen meldete
     diese Zeile wieder „0 → 0", allein gestartet „0 → 1". Damit war
     sie eine Zeitbombe -- grün, solange nichts anderes läuft, und
     rot im Gesamtlauf, also genau dann, wenn niemand sie einzeln
     nachstellen kann.

     Eine Wartezeit ist eine Annahme über den Rechner. Gewartet wird
     deshalb auf das, worauf es ankommt. Läuft die Frist ab, fällt
     die Prüfung mit dem ECHTEN Wert um und nicht mit einem
     Messfehler -- deshalb wird der Abbruch hier geschluckt und die
     Behauptung darunter entscheidet. */
  await seite.waitForFunction(
    () => Number(getComputedStyle(
      document.querySelector("#dabei-wahl .k-dabei__knopf .k-dabei__haken")).opacity) > 0.9,
    null, { timeout: 5000 },
  ).catch(() => { /* der Wert darunter sagt dann, was wirklich da war */ });
  const nachher = await seite.$eval("#dabei-wahl .k-dabei__knopf .k-dabei__haken",
    (h) => getComputedStyle(h).opacity);
  ok(Number(vorher) < 0.1 && Number(nachher) > 0.9,
    `Häkchen: ${vorher} → ${nachher} (erscheint beim Anwählen)`);

  const gedrueckt = await seite.$eval("#dabei-wahl .k-dabei__knopf",
    (k) => k.getAttribute("aria-pressed"));
  ok(gedrueckt === "true", `aria-pressed = ${gedrueckt} (ein Vorleseprogramm sagt den Zustand an)`);

  const hinweis = await seite.$eval("#dabei-hinweis", (p) => p.textContent.trim());
  ok(/1 Person sieht/.test(hinweis), `Hinweis: "${hinweis}"`);

  await ctx.close();
}

/* =======================================================================
   2. DIE EIGENTLICHE FRAGE: Bekommt jede Rolle die Wahl?
   ======================================================================= */
console.log("\n=== 'für jeden verfügbar' — jede Rolle einzeln ===");
{
  const faelle = [
    ["Manager", "manager", "CODE-MANA-0001", 3],   // DogFather, Patrick, Luna
    ["Scout", "scout", "CODE-SCOU-0001", 3],       // DogFather, Luna, Cigdem (sein Manager)
    ["Creator", "creator", "CODE-CREA-0001", 3],   // DogFather, Patrick, Cigdem
  ];
  for (const [name, rolle, code, erwartet] of faelle) {
    const { ctx, seite } = await alsRolle(rolle, code);
    const sichtbar = await seite.isVisible("#feld-dabei");
    const anzahl = (await seite.$$("#dabei-wahl .k-dabei__knopf")).length;
    ok(sichtbar && anzahl === erwartet,
      `${name}: Feld ${sichtbar ? "sichtbar" : "FEHLT"}, ${anzahl} Personen zur Auswahl (erwartet ${erwartet})`);

    /* Und niemand sieht jemanden, den er nicht sehen darf. Bei einem
       Creator ist das der Punkt: Er darf seinen Scout markieren, aber
       keinen fremden Creator. */
    const namen = await seite.$$eval("#dabei-wahl .k-dabei__name", (n) => n.map((x) => x.textContent));
    ok(!namen.includes("Luna") || name !== "Creator",
      `${name}: sieht ${namen.join(", ") || "niemanden"}`);
    await ctx.close();
  }
}

/* =======================================================================
   3. Am Handy
   ======================================================================= */
console.log("\n=== Am Handy (390 px) ===");
{
  const { ctx, seite } = await alsRolle("admin", "CODE-DOGI-0001", 390);
  const ueber = await seite.evaluate(() => {
    const w = document.querySelector("#dabei-wahl");
    if (!w) return null;
    return Math.round(w.scrollWidth - w.clientWidth);
  });
  ok(ueber !== null && ueber <= 1, `nichts steht seitlich über (${ueber} px)`);

  const hoehe = await seite.$eval("#dabei-wahl .k-dabei__knopf",
    (k) => Math.round(k.getBoundingClientRect().height));
  ok(hoehe >= 40, `Knopfhöhe am Handy ${hoehe} px`);
  await ctx.close();
}

/* =======================================================================
   GEGENPROBE — kann die Messung "klebt" überhaupt erkennen?
   ======================================================================= */
console.log("\n=== Gegenprobe ===");
{
  const { ctx, seite } = await alsRolle("admin", "CODE-DOGI-0001");

  /* Das CSS wird absichtlich kaputt gemacht -- genau so, wie es vorher
     WAR: kein Flex, kein gap. Schlägt die Messung jetzt nicht an, misst
     sie nichts und alle Haken oben sind wertlos. */
  await seite.addStyleTag({ content:
    ".k-dabei__knopf { display: inline !important; gap: 0 !important; }" });
  await seite.waitForTimeout(120);

  const abstand = await seite.evaluate(() => {
    const k = document.querySelector("#dabei-wahl .k-dabei__knopf");
    const z = k.querySelector(".k-dabei__zeichen")?.getBoundingClientRect();
    const n = k.querySelector(".k-dabei__name")?.getBoundingClientRect();
    return Math.round(n.left - z.right);
  });
  ok(abstand < 6,
    `mit kaputtem CSS misst die Prüfung ${abstand} px — sie erkennt das Kleben also`);

  await ctx.close();
}

await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }

console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
process.exit(fehler ? 1 : 0);