/* Prueft "die Sicht eines anderen" — DogFathers Umschalter.

   Wunsch vom 01.09.2026: "ich will alles von den Scouts und Managern
   einsehen koennen, auswaehlen, was und von wem ich sehen will. Und das
   soll ich als DogFather-Rolle ueberall haben, auf jeder Seite.
   NUR WIR BEIDE SOLLEN DIESE OPTION HABEN."

   DAS HIER IST EINE RECHTEPRUEFUNG, keine Bedienpruefung. Wenn etwas
   davon nicht stimmt, kann ein Manager oder Scout durch Anhaengen von
   ?sicht=<Nummer> in fremde Bereiche sehen. Deshalb steht der Missbrauch
   VOR der Funktion:

     1. Ein Scout haengt ?sicht=<DogFather> an  -> muss ignoriert werden
     2. Ein Manager haengt ?sicht=<Creator> an  -> muss ignoriert werden
     3. Ein Creator haengt ?sicht=<Scout> an    -> muss ignoriert werden
     4. DogFather haengt eine erfundene Nummer an -> eigene Sicht
     5. DogFather waehlt einen Scout            -> sieht dessen Liste

   Und, genauso wichtig: SCHREIBEN passiert immer im eigenen Namen. Ein
   Eintrag, der unter fremdem Namen im Protokoll landet, waere schlimmer
   als gar keine Funktion. */

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

const ordner = mkdtempSync(join(tmpdir(), "ws-sicht-"));
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-sicht");
process.env.PORT = `${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";
import { eigenerPort } from "./helfer-port.mjs";
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-sicht");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();

/* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
   Benutzers; toISOString() liefert dagegen UTC und damit zwischen
   Mitternacht und 2 Uhr den VORTAG. In diesem Fenster schlug diese
   Pruefung fehl, ohne dass etwas kaputt war. */
const tagText = (d = new Date()) =>
  `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
  + `-${String(d.getDate()).padStart(2, "0")}`;

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

await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
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();
const heute = tagText();
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;
}
const idDogi  = anlegen("Filipe", "admin", "CODE-DOGI-0001");
/* SPICY MEDIA GEHOERT DAZU (09.09.2026).

   Filipe: "ich will da auch noch die spicy rolle sehen und die leute in
   der rolle wie die anderen."

   Der Umschalter fuehrte eine EIGENE Rollenliste -- vier Eintraege, und
   Spicy Media fehlte. Ohne eine Spicy-Person in diesen Testdaten waere
   das nie aufgefallen: Eine Rolle ohne Leute wird ohnehin weggelassen,
   und die Pruefung darunter haette weiter brav "Manager, Scouts,
   Creator" bestaetigt. */
const idSpicy = anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
const idMgr   = anlegen("Mara", "manager", "CODE-MANA-0001");
const idPat   = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idBen   = anlegen("Ben", "scout", "CODE-SCOB-0001");
const idTili  = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idLuna  = anlegen("Luna", "creator", "CODE-LUNA-0001");
/* Patrick betreut Tili, Ben betreut Luna -- so haben die beiden Scouts
   wirklich VERSCHIEDENE Arbeitsplaetze. Ohne das koennte die Pruefung
   nicht unterscheiden, ob umgeschaltet wurde oder ob beide dasselbe
   sehen. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);

/* Je zwei Aufgaben mit eindeutigen Titeln -- daran laesst sich ablesen,
   WESSEN Liste gerade kommt. */
const neueAufgabe = (titel, creator, verant) =>
  d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet,
    creator_id, verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?)`)
    .run(titel, "", "offen", "mittel", creator, verant, jetzt, idDogi);
neueAufgabe("PATRICK-SACHE-1", idTili, idPat);
neueAufgabe("PATRICK-SACHE-2", idTili, idPat);
neueAufgabe("BEN-SACHE-1", idLuna, idBen);
neueAufgabe("NUR-DOGI", null, idDogi);
d.close();

/* ---------------------------------------------------------------- */

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 }),
  });
  const k = a.headers.getSetCookie?.() || [];
  return k.map((x) => x.split(";")[0]).join("; ");
}
const holen = (pfad, keks) =>
  fetch(BASIS + pfad, { headers: { cookie: keks } });
const titel = async (pfad, keks) => {
  const a = await holen(pfad, keks);
  if (!a.ok) return { status: a.status, liste: [] };
  const j = await a.json();
  return { status: a.status, liste: (j.aufgaben || []).map((x) => x.titel).sort() };
};

const kDogi = await anmelden("admin", "CODE-DOGI-0001");
const kMgr = await anmelden("manager", "CODE-MANA-0001");
const kPat = await anmelden("scout", "CODE-SCOU-0001");
const kTili = await anmelden("creator", "CODE-ANNA-0001");

/* ================================================================
   1. ZUERST DER MISSBRAUCH
   ================================================================ */
console.log("\n=== Niemand ausser DogFather darf umschalten");

{
  const ohne = await titel("/workspace/api/aufgaben", kPat);
  const mit = await titel(`/workspace/api/aufgaben?sicht=${idBen}`, kPat);
  ok(JSON.stringify(ohne.liste) === JSON.stringify(mit.liste),
     `ein Scout aendert mit ?sicht= nichts (${mit.liste.length} Aufgaben, wie ohne)`);
  ok(!mit.liste.includes("BEN-SACHE-1"),
     "  und sieht die Sachen des anderen Scouts NICHT");
}
{
  const ohne = await titel("/workspace/api/aufgaben", kMgr);
  const mit = await titel(`/workspace/api/aufgaben?sicht=${idTili}`, kMgr);
  ok(JSON.stringify(ohne.liste) === JSON.stringify(mit.liste),
     `ein Manager aendert mit ?sicht= nichts (${mit.liste.length} Aufgaben)`);
}
{
  const ohne = await titel("/workspace/api/aufgaben", kTili);
  const mit = await titel(`/workspace/api/aufgaben?sicht=${idPat}`, kTili);
  ok(JSON.stringify(ohne.liste) === JSON.stringify(mit.liste),
     `ein Creator aendert mit ?sicht= nichts (${mit.liste.length} Aufgaben)`);
  ok(!mit.liste.includes("NUR-DOGI"),
     "  und kommt so nicht an fremde Aufgaben");
}

/* ================================================================
   2. DOGFATHER SCHALTET UM
   ================================================================ */
console.log("\n=== DogFather sieht durch fremde Augen");

const alles = await titel("/workspace/api/aufgaben", kDogi);
ok(alles.liste.length === 4, `ohne Auswahl sieht er alles (${alles.liste.length} Aufgaben)`);

const alsPat = await titel(`/workspace/api/aufgaben?sicht=${idPat}`, kDogi);
ok(alsPat.liste.length === 2 &&
   alsPat.liste.every((t) => t.startsWith("PATRICK")),
   `als Patrick genau dessen zwei (${alsPat.liste.join(", ")})`);
ok(!alsPat.liste.includes("BEN-SACHE-1") && !alsPat.liste.includes("NUR-DOGI"),
   "  und wirklich NUR dessen – nicht mehr");

const alsBen = await titel(`/workspace/api/aufgaben?sicht=${idBen}`, kDogi);
ok(alsBen.liste.length === 1 && alsBen.liste[0] === "BEN-SACHE-1",
   `als Ben dessen eine (${alsBen.liste.join(", ")})`);
ok(JSON.stringify(alsPat.liste) !== JSON.stringify(alsBen.liste),
   "  zwei Scouts liefern wirklich Verschiedenes – es wird also umgeschaltet");

const alsTili = await titel(`/workspace/api/aufgaben?sicht=${idTili}`, kDogi);
ok(alsTili.liste.length === 2,
   `als Creator dessen Brett (${alsTili.liste.length})`);

/* ================================================================
   3. WAS BEI UNSINN PASSIERT
   ================================================================ */
console.log("\n=== Unsinnige Auswahl");
for (const [wert, was] of [
  ["999999", "eine Nummer, die es nicht gibt"],
  ["0", "die Null"],
  ["-5", "eine negative Zahl"],
  ["abc", "Buchstaben"],
  ["1%20OR%201=1", "ein Einschleusversuch"],
]) {
  const r = await titel(`/workspace/api/aufgaben?sicht=${wert}`, kDogi);
  ok(r.status === 200 && r.liste.length === 4,
     `${was} faellt auf die eigene Sicht zurueck (${r.status}, ${r.liste.length} Aufgaben)`);
}

/* Eine ABGESCHALTETE Person darf keine Sicht liefern -- sonst waere das
   Abschalten eines Kontos halbherzig. */
{
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  d2.prepare("UPDATE personen SET aktiv = 0 WHERE id = ?").run(idBen);
  d2.close();
  const r = await titel(`/workspace/api/aufgaben?sicht=${idBen}`, kDogi);
  ok(r.liste.length === 4,
     `eine abgeschaltete Person liefert keine Sicht mehr (${r.liste.length} Aufgaben = alles)`);
  const d3 = new DatabaseSync(process.env.WORKSPACE_DB);
  d3.prepare("UPDATE personen SET aktiv = 1 WHERE id = ?").run(idBen);
  d3.close();
}

/* ================================================================
   4. GESCHRIEBEN WIRD IMMER IM EIGENEN NAMEN
   ================================================================ */
console.log("\n=== Schreiben bleibt im eigenen Namen");
{
  const a = await fetch(`${BASIS}/workspace/api/aufgaben?sicht=${idPat}`, {
    method: "POST",
    headers: { cookie: kDogi, "Content-Type": "application/json" },
    body: JSON.stringify({ titel: "WER-HAT-DAS-ANGELEGT", prioritaet: "mittel" }),
  });
  ok(a.ok, `anlegen geht auch bei fremder Sicht (${a.status})`);
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  const z = d2.prepare("SELECT erstellt_von FROM aufgaben WHERE titel = ?")
    .get("WER-HAT-DAS-ANGELEGT");
  d2.close();
  ok(z?.erstellt_von === idDogi,
     `und steht unter DogFather, nicht unter dem angesehenen Scout `
     + `(${z?.erstellt_von} statt ${idPat})`);
}

/* ================================================================
   5. DIE ANDEREN BEREICHE ZIEHEN MIT
   ================================================================ */
console.log("\n=== Es gilt nicht nur fuer Aufgaben");
for (const [pfad, name, feld] of [
  ["/workspace/api/hinweise", "Was ist dran", "hinweise"],
  ["/workspace/api/termine?von=" + heute + "&tage=7", "Kalender", "termine"],
  ["/workspace/api/dateien", "Dateien", "dateien"],
  ["/workspace/api/leads", "Scout-Pipeline", "leads"],
]) {
  const a = await holen(`${pfad}${pfad.includes("?") ? "&" : "?"}sicht=${idPat}`, kDogi);
  const b = await holen(pfad, kDogi);
  ok(a.status === 200 && b.status === 200, `${name}: beide Abfragen gehen durch`);
}

/* DER KALENDER IST PRIVAT -- AUCH FUER DEN UMSCHALTER (11.09.2026).

   Bis heute stand hier das Gegenteil: "Fremde Verabredungen sieht er
   nicht mehr in seinem eigenen Kalender; dafuer gibt es den
   Umschalter." Filipe hat die Regel selbst nachgezogen, als er die
   Sicht vervollstaendigen liess:

     "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. AUSSER die kalender daten oder chat daten wo ich nicht mit
      drin bin.. also private daten."

   Damit ist der Kalender die AUSNAHME von der Sicht, nicht ihr
   Paradebeispiel. Ein Termin traegt Titel, Ort und Gegenueber; wer ihn
   liest, liest mit, wo jemand war und mit wem.

   DIE GEGENPROBE BLEIBT DIESELBE FRAGE, NUR ANDERSHERUM GESTELLT. Ein
   Kalender, der gar nichts mehr liefert, waere die sauberste Pruefung
   von allen und die wertloseste -- deshalb muss jemand die Eintraege
   sehen. Das ist jetzt Patrick selbst, angemeldet als er. */
{
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  const rein = d2.prepare(
    `INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, erstellt, erstellt_von)
     VALUES (?,?,?,?,?,?,?)`);
  rein.run("PATRICK-TERMIN", "call", heute + "T10:00", 30, idTili, jetzt, idPat);
  rein.run("BEN-TERMIN", "call", heute + "T12:00", 30, idLuna, jetzt, idBen);
  /* Am 07.09.2026 nachgezogen: Ein Termin OHNE Teilnehmer ist kein
     Team-Termin mehr, sondern der private Eintrag dessen, der ihn
     angelegt hat -- Filipe hat es an seinem "Manager Meeting" in
     Cigdems Kalender gesehen. Der hier gehoert also Patrick, und genau
     das wird unten geprueft. */
  rein.run("PATRICKS NOTIZ", "termin", heute + "T14:00", 30, null, jetzt, idPat);
  /* UND EINER FUER MARA. Ohne ihn stand die Managerin in der Pruefung
     unten mit einer LEEREN Call-Liste da -- und eine leere Liste ist
     zufaellig genau dasselbe wie DogFathers leere Liste. Die Pruefung
     "bleibt privat" waere damit nicht bestanden, sondern gar nicht
     durchfuehrbar gewesen. Sie hat das gemeldet, statt es zu
     verschweigen; die Antwort darauf sind Daten, keine weichere
     Bedingung. */
  rein.run("MARA-CALL", "call", heute + "T16:00", 30, null, jetzt, idMgr);
  d2.close();

  const j = async (k, s) => {
    const a = await holen(`/workspace/api/termine?von=${heute}&tage=2${s ? "&sicht=" + s : ""}`, k);
    return ((await a.json()).termine || []).map((t) => t.titel).sort();
  };
  const alleT = await j(kDogi);
  const patT = await j(kDogi, idPat);
  ok(!alleT.includes("PATRICK-TERMIN") && !alleT.includes("BEN-TERMIN"),
     `DogFather sieht fremde Verabredungen nicht mehr (${alleT.join(", ") || "nichts"})`);
  ok(!alleT.includes("PATRICKS NOTIZ"),
     "auch einen Termin OHNE Teilnehmer nicht -- der gehoert dem, der ihn anlegt");
  ok(!patT.includes("PATRICK-TERMIN") && !patT.includes("PATRICKS NOTIZ")
     && !patT.includes("BEN-TERMIN"),
     `auch mit dem Umschalter auf Patrick nicht -- der Kalender ist privat (${patT.join(", ") || "nichts"})`);
  /* UND JETZT DER BEWEIS, DASS DIE PRUEFUNG DARUEBER ETWAS MISST.
     Patrick selbst muss beide Eintraege bekommen; sonst hiesse
     "DogFather sieht sie nicht" nur, dass niemand sie sieht. */
  const patSelbst = await j(kPat);
  ok(patSelbst.includes("PATRICK-TERMIN") && patSelbst.includes("PATRICKS NOTIZ")
     && !patSelbst.includes("BEN-TERMIN"),
     `Patrick selbst sieht genau seine beiden (${patSelbst.join(", ")})`);
}

/* ================================================================
   6. IM BROWSER: der Umschalter steht da -- und nur bei DogFather
   ================================================================ */
/* =======================================================================
   DIE SICHT IST VOLLSTAENDIG -- UND SIE HAT GENAU ZWEI AUSNAHMEN
   =======================================================================

   Filipe, 11.09.2026: "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. ausser die kalender daten oder chat daten wo ich nicht
   mit drin bin.. also private daten."

   "GENAU SO WIE SIE ES SEHEN" IST EINE GLEICHUNG, ALSO WIRD SIE ALS
   GLEICHUNG GEPRUEFT. Verglichen wird nicht "mit Umschalter gegen ohne"
   -- das ist bei duenner Datenlage ueberall gleich und beweist nichts,
   genau die Sorte gruener Haken, die nichts gruent. Verglichen wird die
   Antwort, die DogFather mit gesetztem Umschalter bekommt, mit der
   Antwort, die die Person SELBST bekommt, angemeldet als sie.

   So ist dieser Abschnitt entstanden: als Wegwerf-Messung ueber alle
   Wege des Hauses. Sie hat sechs Stellen gefunden, an denen die Sicht
   ins Leere lief -- darunter eine, an der seit dem 01.09. ein
   ausfuehrlicher Kommentar beschrieb, was der Code daneben nie getan
   hat (`req.person.sicht`, ein Feld, das es nicht gibt). Ein Tippfehler
   in einem Variablennamen macht nichts kaputt; er tut nur nichts. Genau
   deshalb steht die Messung jetzt hier fest drin.

   DIE AUSNAHMEN WERDEN GENAUSO SCHARF GEPRUEFT wie die Regel: Kalender,
   Calls, Wiederholungen und Chat MUESSEN abweichen. Waeren sie gleich,
   waere Filipes Grenze gefallen, ohne dass es jemandem auffiele. */
console.log("\n=== Die Sicht zeigt, was die andere Person sieht");
{
  /* Was hier NICHT steht und warum: `/workspace/api/ich` (es meldet
     absichtlich weiter, WER angemeldet ist -- sonst stuende im Kopf der
     falsche Name), `/workspace/api/personen` (das ist die Liste, aus
     der der Umschalter selbst gebaut wird; folgte sie der Sicht, kaeme
     man aus einer fremden Sicht nicht mehr heraus) und die Listen, aus
     denen man beim ANLEGEN waehlt (Kategorien, Empfaenger) -- die
     gehoeren zum Schreiben, und geschrieben wird immer als man selbst. */
  const GLEICH = [
    ["die Zentrale", "/workspace/api/zentrale"],
    ["die Leistungszahlen", "/workspace/api/leistung"],
    ["die Creator-Liste im Profil", "/workspace/api/profil"],
    ["die Schulungen", "/workspace/api/schulung"],
    ["die Fruehwarnung", "/workspace/api/fruehwarnung"],
    ["der Report", "/workspace/api/report"],
    ["die Uebersicht", "/workspace/api/uebersicht"],
  ];
  const PRIVAT = [
    ["der Kalender", "/workspace/api/termine"],
    ["die Calls", "/workspace/api/calls"],
    ["die Gespraeche", "/workspace/api/chat/raeume"],
  ];

  const text = async (pfad, keks) => {
    const a = await holen(pfad, keks);
    return { status: a.status, text: await a.text() };
  };

  for (const [wer, id, keks] of [
    ["Manager", idMgr, kMgr], ["Scout", idPat, kPat], ["Creator", idTili, kTili],
  ]) {
    for (const [name, pfad] of GLEICH) {
      const durch = await text(pfad + "?sicht=" + id, kDogi);
      const selbst = await text(pfad, keks);
      /* DRITTER AUSGANG: Kann die Person den Weg gar nicht aufrufen,
         ist hier nichts zu vergleichen -- und das ist ein Fehler, kein
         Ueberspringen. Sonst waere diese Schleife gruen, sobald eine
         Rolle irgendwann 404 bekommt. */
      ok(durch.status === 200 && selbst.status === 200
        && durch.text === selbst.text,
        `${wer}: ${name} ist in der Sicht dieselbe Antwort`
        + ` (${durch.status}/${selbst.status}, ${durch.text.length}/${selbst.text.length} Zeichen)`);
    }
    for (const [name, pfad] of PRIVAT) {
      const durch = await text(pfad + "?sicht=" + id, kDogi);
      const selbst = await text(pfad, keks);
      const eigen = await text(pfad, kDogi);
      ok(durch.status === 200 && durch.text === eigen.text && durch.text !== selbst.text,
        `${wer}: ${name} bleibt privat -- der Umschalter aendert daran nichts`
        + ` (${durch.text.length} eigene / ${selbst.text.length} ihre)`);
    }
  }

  /* GEGENPROBE ZUR GLEICHUNG SELBST. Wenn zwei Antworten, die
     verschieden sein MUESSEN, hier als gleich durchgingen, waere der
     ganze Abschnitt darueber wertlos. Also einmal absichtlich die
     falsche Person einsetzen: Die Zentrale des Managers und die des
     Scouts duerfen nicht dieselbe Antwort sein. */
  const zMgr = await (await holen("/workspace/api/zentrale?sicht=" + idMgr, kDogi)).text();
  const zPat = await (await holen("/workspace/api/zentrale?sicht=" + idPat, kDogi)).text();
  ok(zMgr !== zPat,
    "Gegenprobe: zwei verschiedene Personen ergeben auch zwei verschiedene Antworten");
}

console.log("\n=== Der Umschalter im Seitenkopf");
const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();

async function browserAls(rolle, code) {
  const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
  const konsole = [];
  const seite = await kontext.newPage();
  seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 15000 });
  return { kontext, seite, konsole };
}

const bDogi = await browserAls("admin", "CODE-DOGI-0001");
/* AUF JEDER SEITE -- das war der ausdrueckliche Wunsch. Geprueft wird
   deshalb nicht eine Seite, sondern alle. */
const SEITEN = ["start.html", "aufgaben.html", "kalender.html", "dateien.html",
                "bereich.html?b=live", "content.html", "calls.html", "scouting.html",
                "report.html", "personen.html", "wissen.html", "uebersicht.html",
                "profil.html", "startcheck.html", "steckbrief.html", "automation.html"];
let fehlend = [];
for (const s of SEITEN) {
  await bDogi.seite.goto(BASIS + "/workspace/" + s, { waitUntil: "networkidle" });
  await bDogi.seite.waitForTimeout(900);
  const da = await bDogi.seite.evaluate(() => {
    const f = document.getElementById("kopf-sicht-wahl");
    if (!f) return false;
    const r = f.getBoundingClientRect();
    return r.width > 0 && r.height > 0;
  });
  if (!da) fehlend.push(s);
}
ok(fehlend.length === 0,
   `der Umschalter steht auf allen ${SEITEN.length} Seiten`
   + (fehlend.length ? ` – FEHLT auf: ${fehlend.join(", ")}` : ""));

const wahl = await bDogi.seite.evaluate(() => {
  const s = document.getElementById("kopf-sicht-feld");
  return {
    gruppen: [...s.querySelectorAll("optgroup")].map((g) => g.label),
    anzahl: s.querySelectorAll("option").length,
    erste: s.querySelector("option")?.textContent,
    ichDrin: [...s.querySelectorAll("option")].some((o) => o.textContent === "Filipe"),
    namen: [...s.querySelectorAll("optgroup option")].map((o) => o.textContent),
  };
});
/* Die Reihenfolge ist die des Hauses (window.Bereiche.ROLLENFOLGE):
   Spicy Media, DogFather, Manager, Scout, Creator. DogFather faellt
   weg, weil dort nur Filipe selbst steht. */
ok(wahl.gruppen.join(", ") === "Spicy Media, Manager, Scouts, Creator",
   `nach Rollen gruppiert: ${wahl.gruppen.join(", ")}`);
ok(wahl.gruppen.includes("Spicy Media"),
   "Spicy Media steht mit dabei — nicht mehr nur vier von fuenf Rollen");

/* GEGENPROBE: Die Liste kommt wirklich aus der zentralen Reihenfolge
   und ist nicht wieder abgeschrieben. Waere sie es, koennte sie beim
   naechsten Mal genauso stehenbleiben. */
const ausZentral = await bDogi.seite.evaluate(() => {
  const folge = window.Bereiche?.ROLLENFOLGE || [];
  const namen = window.Bereiche?.ROLLEN_GRUPPE || {};
  const s = document.getElementById("kopf-sicht-feld");
  const da = [...s.querySelectorAll("optgroup")].map((g) => g.label);
  const erwartet = folge.map((r) => namen[r]).filter((n) => da.includes(n));
  return { gleich: erwartet.join(", ") === da.join(", "), erwartet, da };
});
ok(ausZentral.gleich,
   `die Reihenfolge folgt der zentralen Liste (${ausZentral.erwartet.join(", ")})`);

/* Und die PERSON steht drin, nicht nur die Ueberschrift. */
ok([...(wahl.namen || [])].includes("Cigdem"),
   `die Spicy-Media-Person steht in ihrer Gruppe (${(wahl.namen || []).join(", ")})`);
ok(/meine Sicht/i.test(wahl.erste || ""),
   `der Rueckweg steht ganz oben ("${wahl.erste}")`);
ok(!wahl.ichDrin, "DogFather selbst steht nicht in der Liste – das waere derselbe Zustand");

/* Umschalten im Browser und pruefen, dass die Seite danach wirklich
   die andere Liste zeigt. */
await bDogi.seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
await bDogi.seite.waitForTimeout(1100);
const vorher = await bDogi.seite.evaluate(() =>
  document.querySelectorAll(".karte").length);
await bDogi.seite.selectOption("#kopf-sicht-feld", String(idPat));
await bDogi.seite.waitForTimeout(1800);
const nachher = await bDogi.seite.evaluate(() => ({
  karten: document.querySelectorAll(".karte").length,
  titel: [...document.querySelectorAll(".karte__titel")].map((e) => e.textContent).sort(),
  rahmen: getComputedStyle(document.body, "::after").borderTopWidth,
  hinweis: !!document.querySelector('.sicht[data-fremd="ja"]'),
  weg: !!document.querySelector(".sicht__weg"),
}));
ok(nachher.karten < vorher,
   `nach dem Umschalten weniger Aufgaben (${vorher} -> ${nachher.karten})`);
ok(nachher.titel.every((t) => t.startsWith("PATRICK")),
   `und zwar genau Patricks (${nachher.titel.join(", ")})`);
ok(nachher.hinweis, "der Umschalter zeigt deutlich, dass eine fremde Sicht laeuft");
ok(nachher.weg, "  und bietet den Weg zurueck an");
ok(parseFloat(nachher.rahmen) >= 1,
   `ein Rahmen um die Seite erinnert daran (${nachher.rahmen}) – `
   + "der gefaehrlichste Fall ist, dass man es vergisst");

/* ================================================================
   DIE SEITE SELBST MUSS SICH AENDERN, nicht nur die Listen.

   Der Fehler, den diese Pruefung uebersehen hat (gemeldet 02.09.2026):
   "ich hab oben die Ansicht von Tili ausgewaehlt und seh immer noch die
   Seite genau wie meine."

   Sie hat bisher nur geprueft, dass WENIGER AUFGABEN erscheinen -- und
   das stimmte ja. Kacheln, Rollenzeile und Begruessung kamen aber
   weiterhin von DogFather, weil /api/ich immer den Angemeldeten
   lieferte. Der Umschalter war halb gebaut, und die Pruefung hat genau
   die Haelfte geprueft, die fertig war.

   Deshalb jetzt: Sieht man den Arbeitsplatz eines CREATORS, duerfen die
   Kacheln der Leitung nicht mehr dastehen -- und es muss dranstehen,
   WESSEN Arbeitsplatz das ist. */
console.log("\n=== Die Seite zeigt den fremden Arbeitsplatz, nicht den eigenen");
await bDogi.seite.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
await bDogi.seite.waitForTimeout(1400);
/* ZUERST AUF DIE EIGENE SICHT ZURUECK. Der Abschnitt davor hat auf einen
   Scout umgeschaltet, und die Auswahl ueberlebt den Seitenwechsel -- das
   ist ja gerade gewollt. Ohne dieses Zuruecksetzen mass der erste Anlauf
   "seine eigenen Kacheln" waehrend noch die fremde Sicht lief und
   meldete einen Fehler, den es nicht gab.

   Eine Pruefung, die ihren eigenen Ausgangszustand nicht herstellt,
   misst den Nachhall der vorigen. */
await bDogi.seite.selectOption("#kopf-sicht-feld", "");
await bDogi.seite.waitForTimeout(1600);
const eigene = await bDogi.seite.evaluate(() => ({
  kacheln: [...document.querySelectorAll(".kachel__name")].map((e) => e.textContent),
  rolle: document.getElementById("rollentext")?.textContent,
}));
ok(eigene.kacheln.includes("Personen & Zugänge"),
   `als er selbst sieht er die Leitungs-Kacheln (${eigene.kacheln.length} Kacheln)`);

await bDogi.seite.selectOption("#kopf-sicht-feld", String(idTili));
await bDogi.seite.waitForTimeout(1800);
const fremd = await bDogi.seite.evaluate(() => ({
  kacheln: [...document.querySelectorAll(".kachel__name")].map((e) => e.textContent),
  rolle: document.getElementById("rollentext")?.textContent,
  gruppen: [...document.querySelectorAll(".gruppe__name")].map((e) => e.textContent),
}));
ok(!fremd.kacheln.includes("Personen & Zugänge"),
   `in der Sicht eines Creators fehlen die Leitungs-Kacheln `
   + `(${eigene.kacheln.length} -> ${fremd.kacheln.length})`);
ok(!fremd.kacheln.includes("Automationen"), "  auch die Automationen");
ok(fremd.kacheln.length < eigene.kacheln.length,
   "  die Seite zeigt wirklich weniger, nicht dasselbe");
ok(/Tili/.test(fremd.rolle || ""),
   `und es steht dran, wessen Arbeitsplatz das ist ("${fremd.rolle}")`);
ok(/Creator/.test(fremd.rolle || ""),
   "  samt seiner Rolle");
/* Die Gruppe heisst fuer einen Creator "Wissen" statt "Team & System" --
   ein weiterer Beleg, dass die SEITE der Sicht folgt und nicht nur die
   Daten dahinter. */
ok(fremd.gruppen.includes("Wissen"),
   `die Gruppentitel folgen ebenfalls (${fremd.gruppen.join(", ")})`);

await bDogi.seite.click(".sicht__weg");
await bDogi.seite.waitForTimeout(1600);
const zurueckSeite = await bDogi.seite.evaluate(() => ({
  kacheln: [...document.querySelectorAll(".kachel__name")].map((e) => e.textContent),
  rolle: document.getElementById("rollentext")?.textContent,
}));
ok(zurueckSeite.kacheln.includes("Personen & Zugänge")
   && !/Tili/.test(zurueckSeite.rolle || ""),
   `zurueck bei sich sieht er wieder alles ("${zurueckSeite.rolle}")`);

await bDogi.seite.goto(BASIS + "/workspace/kalender.html", { waitUntil: "networkidle" });
await bDogi.seite.waitForTimeout(1200);
await bDogi.seite.selectOption("#kopf-sicht-feld", String(idPat));
await bDogi.seite.waitForTimeout(1800);

/* Und er BLEIBT beim Seitenwechsel -- sonst muesste man ihn auf jeder
   Seite neu setzen, und genau das war der Wunsch ("ueberall"). */
await bDogi.seite.goto(BASIS + "/workspace/kalender.html", { waitUntil: "networkidle" });
await bDogi.seite.waitForTimeout(1200);
const bleibt = await bDogi.seite.evaluate(() => ({
  wert: document.getElementById("kopf-sicht-feld")?.value,
  fremd: !!document.querySelector('.sicht[data-fremd="ja"]'),
}));
ok(bleibt.wert === String(idPat) && bleibt.fremd,
   `die Auswahl ueberlebt den Seitenwechsel (${bleibt.wert})`);

/* Zurueck -- und wirklich zurueck. */
await bDogi.seite.click(".sicht__weg");
await bDogi.seite.waitForTimeout(1600);
const zurueck = await bDogi.seite.evaluate(() => ({
  wert: document.getElementById("kopf-sicht-feld")?.value,
  fremd: !!document.querySelector('.sicht[data-fremd="ja"]'),
}));
ok(zurueck.wert === "" && !zurueck.fremd, '"zurück zu mir" stellt die eigene Sicht wieder her');
ok(bDogi.konsole.length === 0,
   `keine Fehler in der Konsole${bDogi.konsole.length ? " -> " + bDogi.konsole.join(" | ") : ""}`);
await bDogi.kontext.close();

/* GEGENPROBE IM BROWSER: Die anderen drei Rollen bekommen ihn nicht
   einmal zu sehen. */
for (const [rolle, code, name] of [
  ["manager", "CODE-MANA-0001", "Manager"],
  ["scout", "CODE-SCOU-0001", "Scout"],
  ["creator", "CODE-ANNA-0001", "Creator"],
]) {
  const b = await browserAls(rolle, code);
  await b.seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
  await b.seite.waitForTimeout(900);
  const da = await b.seite.evaluate(() => !!document.getElementById("kopf-sicht-wahl"));
  ok(!da, `Gegenprobe: ein ${name} sieht den Umschalter nicht`);
  await b.kontext.close();
}

await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
process.exit(fehler ? 1 : 0);