/* 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");
process.env.PORT = "4215";
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");
/* 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:4215";
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 der klarste Beleg -- und seit dem 07.09.2026 gilt
   die Regel "nur was mich betrifft" fuer JEDEN, DogFather
   eingeschlossen (siehe termineSichtbar in workspace.js). Fremde
   Verabredungen sieht er nicht mehr in seinem eigenen Kalender; dafuer
   gibt es den Umschalter. Genau dieser Wechsel wird hier gemessen:
   ohne Umschalter keins der beiden, mit Umschalter genau das eine.
   Dass die Regel nicht einfach ALLES ausblendet, zeigt der Umschalter:
   Als Patrick kommen beide seiner Eintraege an. Ohne diesen Nachweis
   waere ein Kalender, der gar nichts mehr liefert, die sauberste
   Pruefung von allen. */
{
  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);
  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"),
     `mit dem Umschalter auf Patrick genau dessen, beide (${patT.join(", ")})`);
}

/* ================================================================
   6. IM BROWSER: der Umschalter steht da -- und nur bei DogFather
   ================================================================ */
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("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("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("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("#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("#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("#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("#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("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("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("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);