/* =====================================================================
   Prüfung: einen neuen Zugangscode erzeugen, ohne sich auszusperren.

   ANLASS (02.09.2026, echter Vorfall): Filipe hat sich einen neuen Code
   erzeugt. Der Server beendete daraufhin ALLE Sitzungen -- auch die, in
   der der Code gerade auf dem Bildschirm stand. Der nächste Aufruf lief
   in ein "nicht angemeldet", die Seite sprang zur Anmeldung, und der
   Code war weg, bevor er abgeschrieben war. Danach kam er nur noch über
   einen Eingriff auf dem Server wieder hinein.

   Diese Datei hält beide Enden fest:

     * Wer seinen EIGENEN Code erneuert, bleibt in dieser Sitzung
       angemeldet -- und nur in dieser.
     * Alle ANDEREN Geräte fliegen weiterhin hinaus. Das ist der Sinn
       eines neuen Codes und darf nicht mit verlorengehen.

   Die zweite Zeile ist die wichtigere. Ohne sie wäre die Reparatur
   ("Sitzung bleibt bestehen") auf dem besten Weg, aus einem neuen Code
   eine Formalie zu machen, die niemanden mehr aussperrt.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-code-"));
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-code");
process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-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";
import { bestaetige } from "./helfer-nachfrage.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-code");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 240_000).unref?.();

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

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
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;
}
const idDogi = anlegen("Dogfather", "admin", "CODE-DOGI-0001");
const idTili = anlegen("Tili", "creator", "CODE-TILI-0001");
const zahl = (sql, ...w) => d.prepare(sql).get(...w)?.n ?? 0;

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

async function anmelden(rolle, code) {
  const kontext = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
  const seite = await kontext.newPage();
  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 seite;
}

const api = (seite, pfad, optionen) => seite.evaluate(async ([p, o]) => {
  const a = await fetch(p, {
    credentials: "same-origin",
    ...(o || {}),
    headers: o?.koerper ? { "Content-Type": "application/json" } : undefined,
    body: o?.koerper ? JSON.stringify(o.koerper) : undefined,
  });
  return { status: a.status, daten: await a.json().catch(() => ({})) };
}, [pfad, optionen]);

/* Zwei Geräte derselben Person: der Rechner, an dem gearbeitet wird,
   und ein zweites (Handy). Genau diese Unterscheidung ist der Kern. */
const rechner = await anmelden("admin", "CODE-DOGI-0001");
const handy = await anmelden("admin", "CODE-DOGI-0001");
ok(zahl("SELECT COUNT(*) AS n FROM sitzungen WHERE person_id = ?", idDogi) === 2,
  "zwei offene Sitzungen derselben Person");

console.log("\n— Den eigenen Code erneuern —");

const abgelehnt = await api(rechner, `/workspace/api/verwaltung/personen/${idDogi}/code`, {
  method: "POST", koerper: {},
});
ok(abgelehnt.status === 400,
  "ohne ausdrückliche Bestätigung wird der eigene Code nicht getauscht");

const neu = await api(rechner, `/workspace/api/verwaltung/personen/${idDogi}/code`, {
  method: "POST", koerper: { auch_mich: true },
});
ok(neu.status === 200 && /^[A-Z0-9]{4}(-[A-Z0-9]{4}){3}$/.test(neu.daten.code || ""),
  `der neue Code kommt zurück (${neu.daten.code})`);

/* DAS IST DER FEHLER VON DAMALS. */
const nachher = await api(rechner, "/workspace/api/ich");
ok(nachher.status === 200,
  "diese Sitzung ist NOCH GÜLTIG – hier ging der Zugang verloren");

/* GEGENPROBE: Ohne sie wäre die Zeile darüber auch dann grün, wenn gar
   keine Sitzung mehr beendet würde -- und ein neuer Code hätte
   aufgehört, alte Zugänge zu schließen. */
const aufDemHandy = await api(handy, "/workspace/api/ich");
ok(aufDemHandy.status === 401,
  "GEGENPROBE: das zweite Gerät ist abgemeldet – der neue Code sperrt weiterhin aus");
ok(zahl("SELECT COUNT(*) AS n FROM sitzungen WHERE person_id = ?", idDogi) === 1,
  "genau EINE Sitzung ist übrig, nicht null und nicht zwei");

console.log("\n— Der neue Code gilt, der alte nicht mehr —");

const mitNeuem = await anmelden("admin", neu.daten.code);
ok(!!mitNeuem, "mit dem neuen Code kommt man herein");

const alt = await rechner.evaluate(async ([basis, code]) => {
  const a = await fetch(basis + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle: "admin", code }),
  });
  return a.status;
}, [BASIS, "CODE-DOGI-0001"]);
ok(alt === 401, "mit dem alten Code nicht mehr");

console.log("\n— Fremden Code erneuern: dort fliegt alles hinaus —");

const tiliSeite = await anmelden("creator", "CODE-TILI-0001");
ok(zahl("SELECT COUNT(*) AS n FROM sitzungen WHERE person_id = ?", idTili) === 1,
  "Tili ist angemeldet");
const fremd = await api(rechner, `/workspace/api/verwaltung/personen/${idTili}/code`, {
  method: "POST", koerper: {},
});
ok(fremd.status === 200, "DogFather erneuert Tilis Code");
ok(zahl("SELECT COUNT(*) AS n FROM sitzungen WHERE person_id = ?", idTili) === 0,
  "Tilis Sitzungen sind ALLE beendet – die Ausnahme gilt nur für einen selbst");
ok((await api(tiliSeite, "/workspace/api/ich")).status === 401,
  "und ihr Gerät merkt es sofort");

console.log("\n— Der Kasten mit dem Code bleibt stehen —");

await rechner.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
await rechner.waitForTimeout(800);
const knopf = rechner.locator('.person', { hasText: "Dogfather" })
  .locator('button', { hasText: "Neuer Code" }).first();
/* Die Rückfrage ist seit 19.09.2026 ein eigener <dialog>, kein
   confirm() -- `on("dialog", …)` sieht ihn nicht. Der Helfer klickt
   den Knopf wirklich an. */
await bestaetige(rechner, () => knopf.click());
await rechner.waitForTimeout(1500);

const kasten = await rechner.evaluate(() => ({
  sichtbar: !document.getElementById("code-kasten").hidden,
  code: document.getElementById("code-wert")?.textContent || "",
  adresse: location.pathname,
}));
ok(kasten.sichtbar, "der Kasten mit dem Code ist zu sehen");
ok(/^[A-Z0-9]{4}(-[A-Z0-9]{4}){3}$/.test(kasten.code.trim()),
  `und der Code steht wirklich darin (${kasten.code.trim()})`);
ok(kasten.adresse.endsWith("/personen.html"),
  "die Seite ist NICHT zur Anmeldung gesprungen – genau das war der Vorfall");

/* Auch nach dem Neuladen der Liste bleibt er stehen. */
await rechner.waitForTimeout(1200);
const nochDa = await rechner.evaluate(() =>
  !document.getElementById("code-kasten").hidden
  && (document.getElementById("code-wert")?.textContent || "").length > 8);
ok(nochDa, "und er steht auch noch da, nachdem die Liste neu geladen wurde");

await rechner.screenshot({ path: "pruef-code.png", fullPage: false });

const ERWARTET = 16;
console.log("");
ok(geprueft >= ERWARTET, `es sind ${geprueft} Prüfungen gelaufen (erwartet mindestens ${ERWARTET})`);

await browser.close();
d.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(`\n${fehler ? "FEHLER: " + fehler : "Alles in Ordnung"} — ${geprueft} Prüfungen`);
process.exit(fehler ? 1 : 0);