/* =====================================================================
   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");
process.env.PORT = "4195";
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 }); };
await import("./index.js");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4195";
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);
/* Die Rückfrage bestätigen, ohne sie anzuklicken. */
rechner.on("dialog", (dlg) => dlg.accept());

const knopf = rechner.locator('.person', { hasText: "Dogfather" })
  .locator('button', { hasText: "Neuer Code" }).first();
await 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);