/* =====================================================================
   Womit anfangen? (15.09.2026)

   Letztes Stück von Stufe 9: „Wichtig-vs-Aufwand im Report".

   ---------------------------------------------------------------------
   DIE FRAGE, DIE EINE AUFGABENLISTE NICHT BEANTWORTET

   Ein Brett mit dreißig offenen Karten sagt, WAS zu tun ist. Es sagt
   nicht, WOMIT man anfängt. Sind acht Karten „wichtig", ist keine davon
   die erste.

   ---------------------------------------------------------------------
   DIE DREI FRAGEN

     1. Landet jede Aufgabe im richtigen Feld — alle vier Ecken?
     2. Verschwindet etwas?   ← die wichtigste
     3. Ist der Aufwand wirklich freiwillig — und lässt er sich
        zurücknehmen?

   Die zweite ist der Grund für die fünfte Gruppe: Eine Übersicht, die
   einen Teil der Arbeit unsichtbar macht, ist schlimmer als keine. Man
   verlässt sich darauf und übersieht genau das, was fehlt. Deshalb wird
   hier gezählt, ob die Summe der Felder die Summe der Aufgaben ist.

   Aufrufen mit:  node server/pruef-womit.mjs
   ===================================================================== */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { request as httpAnfrage } from "node:http";
import { portMussFreiSein } from "./helfer-port.mjs";

const PORT = await portMussFreiSein(4418, "pruef-womit");

const ordner = mkdtempSync(join(tmpdir(), "ws-womit-"));
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 }); };
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(180_000, "pruef-womit");
await new Promise((r) => setTimeout(r, 700));

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 melde = (t) => console.log(t);
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

const HAUS = "workspace.dogfather-universe.com";

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const womit = await import("./workspace-womit.js");

const oeffne = () => new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

let idDogi;
{
  const d = oeffne();
  const schluessel = randomBytes(32).toString("hex");
  d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
    + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
    .run("code_kennung_schluessel", schluessel, jetzt);
  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, code_kennung, aktiv, erstellt)"
    + " VALUES ('Filipe','admin',?,?,?,?,1,?)")
    .run(hash, salt, 32768, createHmac("sha256", schluessel).update("CODE-DOGI-0001").digest("hex"), jetzt);
  idDogi = d.prepare("SELECT last_insert_rowid() AS id").get().id;

  /* ALLE VIER ECKEN, plus eine ohne Schaetzung, plus zwei, die nicht
     mitzaehlen duerfen. */
  const rein = d.prepare(`INSERT INTO aufgaben
      (titel, status, prioritaet, aufwand, erstellt, erstellt_von)
      VALUES (?,?,?,?,?,?)`);
  rein.run("Wichtig und klein", "offen", "hoch", "klein", jetzt, idDogi);
  rein.run("Wichtig und gross", "offen", "hoch", "gross", jetzt, idDogi);
  rein.run("Wichtig und mittel", "offen", "hoch", "mittel", jetzt, idDogi);
  rein.run("Normal und klein", "offen", "mittel", "klein", jetzt, idDogi);
  rein.run("Normal und gross", "arbeit", "niedrig", "gross", jetzt, idDogi);
  rein.run("Ohne Schaetzung", "offen", "hoch", null, jetzt, idDogi);
  rein.run("Schon erledigt", "erledigt", "hoch", "klein", jetzt, idDogi);
  rein.run("Abgebrochen", "abgebrochen", "hoch", "klein", jetzt, idDogi);
  d.close();
}

function ruf(pfad, methode, kopf = {}, koerper = null) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: methode,
      headers: { Host: HAUS, ...(koerper ? { "Content-Type": "application/json" } : {}), ...kopf } },
    (antwort) => {
      let text = "";
      antwort.on("data", (s) => { text += s; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
    });
    a.on("error", schief);
    if (koerper) a.write(JSON.stringify(koerper));
    a.end();
  });
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
const anm = await ruf("/workspace/api/anmelden", "POST", {},
  { rolle: "admin", code: "CODE-DOGI-0001" });
const kDogi = [].concat(anm.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
ok(!!kDogi, "DogFather ist angemeldet");

/* =======================================================================
   1. ALLE VIER ECKEN
   ======================================================================= */
melde("");
melde("=== 1. Die vier Ecken ===");
{
  const f = (p, a) => womit.feldVon({ status: "offen", prioritaet: p, aufwand: a });
  ok(f("hoch", "klein") === "sofort", `wichtig + klein → ${f("hoch", "klein")}`);
  ok(f("hoch", "gross") === "einplanen", `wichtig + groß → ${f("hoch", "gross")}`);
  ok(f("mittel", "klein") === "nebenbei", `normal + klein → ${f("mittel", "klein")}`);
  ok(f("niedrig", "gross") === "spaeter", `normal + groß → ${f("niedrig", "gross")}`);

  /* "mittel" zaehlt als NICHT klein -- die Trennlinie liegt dort, wo sie
     im Alltag liegt: zwischendurch oder Zeit nehmen. */
  ok(f("hoch", "mittel") === "einplanen",
    `wichtig + mittel gehört zu „einplanen“ (${f("hoch", "mittel")})`);

  ok(f("hoch", null) === "offen", "ohne Schätzung: eigene Gruppe");
  ok(f("hoch", "riesig") === "offen",
    "und ein unbekannter Wert landet dort ebenfalls, statt irgendwo");

  ok(womit.FELDER.length === 5, `${womit.FELDER.length} Felder (vier plus die offene Gruppe)`);
  ok(womit.FELDER.every((x) => x.name && x.satz),
    "jedes Feld sagt, was es heißt und was zu tun ist");
  /* Die Namen sind Handlungsanweisungen, keine Etiketten. */
  ok(womit.FELDER.some((x) => /Sofort/i.test(x.name)) && womit.FELDER.some((x) => /Später/i.test(x.name)),
    "und die Namen sagen, was zu tun ist");
}

/* =======================================================================
   2. ES VERSCHWINDET NICHTS

   Die wichtigste Zeile: Eine Uebersicht, die einen Teil der Arbeit
   unsichtbar macht, ist schlimmer als keine.
   ======================================================================= */
melde("");
melde("=== 2. Nichts verschwindet ===");
{
  const alle = [
    { id: 1, status: "offen", prioritaet: "hoch", aufwand: "klein" },
    { id: 2, status: "offen", prioritaet: "hoch", aufwand: "gross" },
    { id: 3, status: "arbeit", prioritaet: "niedrig", aufwand: null },
    { id: 4, status: "review", prioritaet: "mittel", aufwand: "mittel" },
    { id: 5, status: "erledigt", prioritaet: "hoch", aufwand: "klein" },
    { id: 6, status: "abgebrochen", prioritaet: "hoch", aufwand: "klein" },
  ];
  const felder = womit.verteilen(alle);
  const summe = felder.reduce((n, f) => n + f.anzahl, 0);
  const offen = alle.filter((a) => a.status !== "erledigt" && a.status !== "abgebrochen").length;
  ok(summe === offen,
    `die Felder zusammen ergeben genau die offenen Aufgaben (${summe} von ${offen})`);

  ok(felder.find((f) => f.schluessel === "offen").anzahl === 1,
    "die Aufgabe ohne Schätzung steht in ihrer eigenen Gruppe");

  /* GEGENPROBE -- ohne sie beweist die Summe nichts: Erledigtes zaehlt
     wirklich NICHT mit. */
  ok(summe === 4, `erledigte und abgebrochene sind draußen (${summe} statt 6)`);

  /* Und die Felder kommen IMMER alle fuenf zurueck, auch leere -- sonst
     koennte die Oberflaeche nicht zwischen "keine" und "vergessen"
     unterscheiden. */
  ok(felder.length === womit.FELDER.length,
    `alle ${felder.length} Felder kommen zurück, auch die leeren`);
}

/* =======================================================================
   3. DER AUFWAND IST FREIWILLIG — UND ZURÜCKNEHMBAR
   ======================================================================= */
melde("");
melde("=== 3. Freiwillig ===");
{
  const liste = json(await ruf("/workspace/api/aufgaben", "GET", { cookie: kDogi })).aufgaben || [];
  const ohne = liste.find((a) => a.titel === "Ohne Schaetzung");
  ok(!!ohne && ohne.aufwand === null, "eine Aufgabe darf ohne Aufwand bestehen");

  const setzen = await ruf(`/workspace/api/aufgaben/${ohne.id}`, "PATCH",
    { cookie: kDogi }, { aufwand: "klein" });
  ok(setzen.code === 200, `der Aufwand lässt sich setzen (${setzen.code})`);

  const zurueck = await ruf(`/workspace/api/aufgaben/${ohne.id}`, "PATCH",
    { cookie: kDogi }, { aufwand: "" });
  ok(zurueck.code === 200, `und wieder zurücknehmen (${zurueck.code})`);
  const nach = (json(await ruf("/workspace/api/aufgaben", "GET", { cookie: kDogi })).aufgaben || [])
    .find((a) => a.id === ohne.id);
  ok(nach?.aufwand === null, "danach steht sie wieder ohne Schätzung da");

  const bloedsinn = await ruf(`/workspace/api/aufgaben/${ohne.id}`, "PATCH",
    { cookie: kDogi }, { aufwand: "riesig" });
  ok(bloedsinn.code === 400, `ein erfundener Wert wird abgelehnt (${bloedsinn.code})`);
  ok(/Aufwand/i.test(json(bloedsinn).fehler || ""),
    `und die Absage sagt, woran es liegt (${json(bloedsinn).fehler})`);

  /* Die Stufen kommen mit der Liste -- sonst fuehrt der Browser eine
     zweite, die beim naechsten Wert veraltet. */
  const daten = json(await ruf("/workspace/api/aufgaben", "GET", { cookie: kDogi }));
  ok(Array.isArray(daten.aufwand) && daten.aufwand.length === womit.AUFWAND.length,
    `die ${daten.aufwand?.length} Aufwandsstufen kommen mit der Liste`);
  ok(daten.aufwand.every((s) => s.schluessel && s.name),
    "jede mit Schlüssel und Namen");
}

/* =======================================================================
   4. IM REPORT
   ======================================================================= */
melde("");
melde("=== 4. Im Report ===");
{
  const d = json(await ruf("/workspace/api/report?tage=30", "GET", { cookie: kDogi }));
  ok(Array.isArray(d.womit), "der Report bringt die Verteilung mit");
  const nach = (s) => d.womit.find((f) => f.schluessel === s);
  ok(nach("sofort")?.anzahl === 1, `„Sofort“: ${nach("sofort")?.anzahl}`);
  ok(nach("einplanen")?.anzahl === 2,
    `„Einplanen“: ${nach("einplanen")?.anzahl} (groß und mittel)`);
  ok(nach("nebenbei")?.anzahl === 1, `„Nebenbei“: ${nach("nebenbei")?.anzahl}`);
  ok(nach("spaeter")?.anzahl === 1, `„Später“: ${nach("spaeter")?.anzahl}`);
  ok(nach("offen")?.anzahl === 1, `„Noch nicht eingeschätzt“: ${nach("offen")?.anzahl}`);

  const summe = d.womit.reduce((n, f) => n + f.anzahl, 0);
  ok(summe === 6, `zusammen ${summe} offene Aufgaben — die beiden fertigen fehlen zu Recht`);

  ok((nach("sofort")?.aufgaben || [])[0]?.titel === "Wichtig und klein",
    "und die Titel stehen dabei");
}

/* =======================================================================
   5. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 5. Im Browser ===");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
  const seite = await kontext.newPage();
  const konsole = [];
  seite.on("console", (m) => { if (m.type() === "error" && !/favicon|ERR_/i.test(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));

  await seite.goto(`http://127.0.0.1:${PORT}/workspace/`, { waitUntil: "domcontentloaded" });
  await seite.click('.rolle[data-rolle="admin"]');
  await seite.fill("#code", "CODE-DOGI-0001");
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 20000 });

  /* ---- Der Abschnitt im Report ---- */
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/report.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(1200);
  const r = await seite.evaluate(() => ({
    felder: document.querySelectorAll(".womit__feld").length,
    namen: [...document.querySelectorAll(".womit__name")].map((x) => x.textContent.trim()),
    zahlen: [...document.querySelectorAll(".womit__zahl")].map((x) => x.textContent.trim()),
    eintraege: document.querySelectorAll(".womit__eintrag").length,
  }));
  ok(r.felder === 5, `${r.felder} Felder stehen im Report`);
  ok(r.namen.includes("Sofort") && r.namen.includes("Noch nicht eingeschätzt"),
    `mit sprechenden Namen: ${r.namen.join(", ")}`);
  ok(r.zahlen.length === r.felder, "jedes mit seiner Zahl");
  ok(r.eintraege >= 5, `${r.eintraege} Aufgaben sind namentlich aufgeführt`);

  /* ---- Die Auswahl im Aufgaben-Dialog ---- */
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/aufgaben.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(900);
  await seite.evaluate(() => {
    const k = [...document.querySelectorAll(".karte")]
      .find((x) => x.textContent.includes("Wichtig und klein"));
    k?.querySelector("button")?.click();
  });
  await seite.waitForTimeout(600);
  const a = await seite.evaluate(() => {
    const f = document.getElementById("b-aufwand");
    if (!f) return null;
    return {
      werte: [...f.options].map((o) => o.value),
      texte: [...f.options].map((o) => o.textContent.trim()),
      gewaehlt: f.value,
    };
  });
  ok(a !== null, "die Auswahl steht im Dialog");
  ok(a.werte.length === womit.AUFWAND.length + 1,
    `mit ${a.werte.length} Möglichkeiten (drei Stufen plus „noch nicht eingeschätzt“)`);
  ok(a.werte[0] === "", "und die erste ist „noch nicht eingeschätzt“ — keine erfundene Vorgabe");
  ok(a.gewaehlt === "klein",
    `der gespeicherte Wert steht drin (${a.gewaehlt}) — die Liste vom Server überschreibt ihn nicht`);
  ok(a.texte.some((t) => /Stunde|Tag/.test(t)),
    `und jede Stufe sagt, was sie ungefähr heißt: ${a.texte.join(" | ").slice(0, 80)}`);

  ok(konsole.length === 0,
    konsole.length ? "Fehler im Browser: " + konsole[0].slice(0, 90) : "keine Fehler im Browser");
  await browser.close();
}

/* ------------------------------------------------------------------- */
melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);