/* =====================================================================
   pruef-vorschlaege.mjs — Die fertigen Vorschläge lassen sich wechseln

   Filipe, 20.09.2026: „fertige vorschläge, überall auf der ganzen
   kompletten website, will ich dass man auch immer wieder neuladen
   kann, so dass wenn man alle benutzt hat man neue erstellen kann oder
   wenn keiner uns gefällt wir komplett neue erstellen können
   automatisch, mach das richtig geil dass es immer wieder möglich ist
   die liste zu wechseln wenn sie uns nicht gefällt oder leer ist."

   ---------------------------------------------------------------------
   WAS HIER DIE EIGENTLICHE FRAGE IST

   Nicht „gibt es einen Knopf" — sondern „kommt nach dem Druck etwas
   ANDERES". Ein Knopf, der dieselben vier Karten noch einmal malt,
   besteht jede Prüfung, die nur nach dem Knopf sucht, und ist
   trotzdem wertlos. Deshalb werden hier die Titel VORHER und NACHHER
   verglichen.

   UND DER RUNDLAUF: Wer oft genug drückt, muss wieder am Anfang
   landen statt vor einer leeren Liste. Das wird gemessen, indem so oft
   weitergeschaltet wird, dass der Vorrat sicher durch ist.

   AUFRUF:  node server/pruef-vorschlaege.mjs
   ===================================================================== */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { eigenerPort } from "./helfer-port.mjs";
import { notbremse } from "./helfer-notbremse.mjs";

const PORT = await eigenerPort(import.meta, "pruef-vorschlaege");
const ordner = mkdtempSync(join(tmpdir(), "ws-vorschlag-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(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");
notbremse(200_000, "pruef-vorschlaege");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;

process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

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

console.log("\n=== Fertige Vorschläge wechseln ===\n");

/* ---- Anmelden: ein Gast, denn nur wer NICHT schreiben darf, bekommt
       den Katalog ueberhaupt. Genau das ist der Sinn: Vorschlaege sind
       fuer leere Bretter da. ------------------------------------------ */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const salt = randomBytes(16).toString("hex");
const hash = scryptSync("CODE-DOGI-0001", 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("Filipe", "admin", hash, salt, 32768, new Date().toISOString());
d.close();

const an = await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json", Origin: BASIS },
  body: JSON.stringify({ rolle: "admin", code: "CODE-DOGI-0001" }),
});
const keks = (an.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
ok(an.ok && !!keks, "angemeldet");

const hole = async (weg) => {
  const a = await fetch(BASIS + weg, { headers: { Cookie: keks } });
  return a.ok ? a.json() : null;
};

/* ---- 1. Welches Brett hat den groessten Vorrat? ------------------- */
/* NICHT geraten: gemessen. Ein fest eingetragener Bereichsname waere
   falsch, sobald jemand den Katalog umbaut -- und die Pruefung liefe
   dann auf einem Brett mit drei Vorschlaegen und koennte gar nichts
   ueber das Weiterschalten sagen. */
const { STARTKATALOG } = await import("./workspace-bereiche.js")
  .then((m) => ({ STARTKATALOG: m.STARTKATALOG }))
  .catch(() => ({ STARTKATALOG: null }));

let bereich = null, vorrat = 0;
for (const b of ["regeln", "mitmachen", "content", "community", "live", "technik", "schutz"]) {
  const r = await hole(`/workspace/api/bereich/${b}/start`);
  if (r && r.offen > vorrat) { bereich = b; vorrat = r.offen; }
}
/* DRITTER AUSGANG: Ohne ein Brett mit mehr als vier offenen
   Vorschlaegen ist die Frage "kommt etwas anderes" nicht zu
   beantworten -- und das muss ein FEHLER sein, kein Schweigen. */
ok(!!bereich && vorrat > 4,
  `Brett mit genug Vorrat gefunden: "${bereich}" mit ${vorrat} offenen`);
if (!bereich || vorrat <= 4) {
  console.log("\n  KONNTE NICHT NACHSEHEN: Kein Brett hat mehr als vier offene");
  console.log("  Vorschlaege. Ohne das ist nicht messbar, ob das Weiterschalten");
  console.log("  etwas anderes liefert. Katalog pruefen: server/workspace-*-start.js\n");
  process.exit(1);
}

/* ---- 2. Es kommt ein FENSTER, nicht die ganze Wand ---------------- */
const s0 = await hole(`/workspace/api/bereich/${bereich}/start?ab=0`);
ok(s0.vorschlaege.length < vorrat,
  `es kommen ${s0.vorschlaege.length} von ${vorrat} auf einmal - nicht alle`);
ok(s0.vorschlaege.length === 4, `das Fenster ist vier gross (${s0.vorschlaege.length})`);
ok(s0.mehr_da === true, "und der Server sagt, dass es mehr gibt (mehr_da)");
ok(s0.offen === vorrat, `"offen" zaehlt weiterhin alle (${s0.offen}) - davon haengt "Alle N uebernehmen" ab`);

/* ---- 3. DIE EIGENTLICHE FRAGE: kommt etwas anderes? --------------- */
const s1 = await hole(`/workspace/api/bereich/${bereich}/start?ab=4`);
const t0 = s0.vorschlaege.map((v) => v.titel);
const t1 = s1.vorschlaege.map((v) => v.titel);
const gleich = t1.filter((t) => t0.includes(t)).length;
ok(gleich === 0,
  `nach dem Weiterschalten ist KEINER der vier derselbe (${gleich} Ueberschneidungen)`);
console.log(`         vorher : ${t0.map((t) => t.slice(0, 22)).join(" | ")}`);
console.log(`         nachher: ${t1.map((t) => t.slice(0, 22)).join(" | ")}`);

/* GEGENPROBE: Dieselbe Abfrage OHNE Weiterschalten muss dieselben
   liefern. Sonst misst der Vergleich oben nur Zufall -- eine Liste,
   die sich bei jedem Abruf mischt, haette den Test auch bestanden und
   waere trotzdem kaputt (man findet einen Vorschlag nie wieder). */
const s0b = await hole(`/workspace/api/bereich/${bereich}/start?ab=0`);
ok(JSON.stringify(s0b.vorschlaege.map((v) => v.titel)) === JSON.stringify(t0),
  "Gegenprobe: ohne Weiterschalten kommen dieselben - die Liste wuerfelt nicht");

/* ---- 4. KEIN ENDE: der Vorrat laeuft im Kreis --------------------- */
/* Weit ueber den Vorrat hinaus. Wer so oft drueckt, darf nicht vor
   einer leeren Liste stehen -- das war Filipes Punkt ("oder leer ist"). */
const weit = await hole(`/workspace/api/bereich/${bereich}/start?ab=${vorrat * 3 + 2}`);
ok((weit?.vorschlaege?.length || 0) === 4,
  `weit hinter dem Ende kommen immer noch vier (${weit?.vorschlaege?.length}) - kein leerer Bildschirm`);
const rund = await hole(`/workspace/api/bereich/${bereich}/start?ab=${vorrat}`);
ok(JSON.stringify(rund.vorschlaege.map((v) => v.titel)) === JSON.stringify(t0),
  "genau einmal herum gibt wieder den Anfang - der Rundlauf schliesst");

/* ---- 5. Unsinn in der Adresse darf nichts umwerfen ---------------- */
for (const mies of ["-7", "abc", "9e99", "", "1.5"]) {
  const r = await hole(`/workspace/api/bereich/${bereich}/start?ab=${encodeURIComponent(mies)}`);
  ok((r?.vorschlaege?.length || 0) === 4, `  "ab=${mies}" liefert trotzdem vier`);
}

/* ---- 6. Ein kleines Brett bekommt KEINEN Wechselknopf ------------- */
/* Ein Knopf, der dieselben drei Karten noch einmal malt, ist ein
   Knopf, der nichts tut -- und der Verdacht, die Seite haenge, ist
   schlimmer als ein fehlender Knopf. */
let klein = null;
for (const b of ["highlight", "ansteht", "agentur", "wunsch", "ideen", "angebote"]) {
  const r = await hole(`/workspace/api/bereich/${b}/start`);
  if (r && r.offen > 0 && r.offen <= 4) { klein = { b, r }; break; }
}
ok(!!klein, `Brett mit hoechstens vier Vorschlaegen gefunden ("${klein?.b}", ${klein?.r?.offen})`);
ok(klein?.r?.mehr_da === false,
  "  und dort sagt der Server: nichts zu wechseln (mehr_da ist falsch)");
ok((klein?.r?.vorschlaege?.length || 0) === klein?.r?.offen,
  `  es kommen trotzdem alle ${klein?.r?.offen} auf einmal - nichts versteckt`);

/* ---- 7. Und die Seite baut den Knopf auch ------------------------- */
const { readFileSync } = await import("node:fs");
const { fileURLToPath } = await import("node:url");
const { dirname } = await import("node:path");
const HIER = dirname(fileURLToPath(import.meta.url));
const js = readFileSync(join(HIER, "..", "workspace", "assets", "js", "bereich.js"), "utf8");
ok(/katalogAb \+= Math\.max\(1, daten\.vorschlaege\.length\)/.test(js),
  "die Seite zaehlt um das weiter, was wirklich kam - keine zweite 4 im Code");
ok(/if \(daten\.mehr_da\)/.test(js),
  "und zeigt den Knopf nur, wenn der Server sagt, dass es mehr gibt");
ok(/let katalogAb = 0;[\s\S]{0,200}async function startkatalogZeigen/.test(js),
  "der Merker steht AUSSERHALB der Funktion - sonst spraenge die Liste nach jedem Uebernehmen zurueck");

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