/* =====================================================================
   pruef-hochladen.mjs — Hochladen, das man sehen und abbrechen kann.

   Filipe, 19.09.2026: „Ladezustände … Bestätigungen … Es darf keine
   Funktionen geben, bei denen man sich fragt: Was soll ich hier jetzt
   machen?"

   ---------------------------------------------------------------------
   WARUM ES DIESE PRÜFUNG GEBEN MUSS

   Am 19.09.2026 wurden alle fünf Hochladewege von `fetch` auf
   `XMLHttpRequest` umgebaut -- `fetch` kann beim SENDEN nicht sagen,
   wie weit es ist. Danach fiel beim Nachsehen auf:

     **Keine einzige Prüfung im Haus lädt eine Datei über die
     Oberfläche hoch.**

   Gesucht wurde nach `feld-datei`, `n-datei`, `sb-datei`,
   `anhang-feld` -- ein Treffer, und der prüft nur, dass das Feld
   existiert. Der komplette Umbau wäre also grün gewesen, ohne dass
   ein einziges Byte je den Weg gegangen wäre, den die Nutzer gehen.

   Das ist die dritte Sorte Fehler aus den Hausregeln: nicht ein
   übersprungener Test, nicht ein grüner, der das Falsche prüft --
   sondern ein Weg, für den es überhaupt keinen Test gab.

   ---------------------------------------------------------------------
   WAS GEPRÜFT WIRD, UND ZWAR AM ECHTEN BILDSCHIRM

     1. Die Datei kommt WIRKLICH an -- in der Liste und auf der Platte.
     2. Der Balken erscheint, und sein Text ÄNDERT sich unterwegs.
        (Nur „er ist da" wäre zu wenig: Genau das konnte die alte
        Fassung auch. Der Unterschied ist die Bewegung.)
     3. Abbrechen bricht wirklich ab -- die Datei kommt NICHT an.
     4. Und der Abbruch erzeugt KEINE rote Fehlermeldung. Wer selbst
        abbricht, hat nichts falsch gemacht; eine rote Meldung dafür
        lehrt nur, rote Meldungen zu übersehen.

   ---------------------------------------------------------------------
   DIE LEITUNG WIRD GEDROSSELT, SONST MISST DIESE PRÜFUNG NICHTS

   Erster Anlauf war eine 12-MB-Datei ohne Drosselung. Ergebnis: EIN
   einziger Fortschritt-Stand, kein Prozentsatz. Das sah nach einem
   Befund aus und war keiner -- auf `localhost` gibt der Browser die
   Daten in einem Atemzug ans Betriebssystem, und das meldet sofort
   "gesendet". Es gab schlicht nichts zu sehen.

   Jetzt wird über CDP auf 2 MBit/s gedrosselt. Das erzeugt genau den
   Verlauf, den Filipes Modis im Mobilfunknetz haben -- also den Fall,
   für den der Balken überhaupt gebaut wurde. 1,5 MB brauchen dabei
   rund sechs Sekunden: lang genug für 57 gemessene Zwischenstände,
   kurz genug für einen Prüflauf, den man abwartet.

   ZWEITER IRRTUM, gleich daneben: Gewartet wurde zuerst auf
   `document.body.textContent.includes(name)` -- und der Dateiname
   stand auch im Fortschrittsbalken. Die Bedingung war erfüllt, bevor
   ein einziges Byte angekommen war. Gewartet wird jetzt auf die
   LISTE.

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

import { mkdtempSync, rmSync, readdirSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-hochlade-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

import { notbremse } from "./helfer-notbremse.mjs";
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Hochladepruefung");

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(300_000, "pruef-hochladen");
await new Promise((r) => setTimeout(r, 1000));
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++; };

/* ---- Bestand ------------------------------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
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 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, jetzt);
d.close();

const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await pw.chromium.launch();
const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } });
const seite = await ctx.newPage();

/* DIE LEITUNG DROSSELN -- sonst misst diese Prüfung nichts.
   ------------------------------------------------------------------
   Auf `localhost` sind 12 MB in einem Atemzug weg: Der Browser gibt
   sie dem Betriebssystem, das meldet sofort "gesendet", und es gibt
   GENAU EIN Fortschritt-Ereignis bei 100 %. Die Prüfung wäre rot --
   nicht weil der Code kaputt ist, sondern weil es nichts zu sehen gab.

   Gedrosselt entsteht derselbe Verlauf wie bei Filipes Modis im
   Mobilfunknetz -- also genau der Fall, für den der Balken gebaut
   wurde. 2 MBit/s ist ein schlechtes, aber realistisches Netz. */
const cdp = await ctx.newCDPSession(seite);
await cdp.send("Network.enable");
await cdp.send("Network.emulateNetworkConditions", {
  offline: false, latency: 40,
  downloadThroughput: 4 * 1024 * 1024 / 8,
  uploadThroughput: 2 * 1024 * 1024 / 8,
});
const konsole = [];
seite.on("pageerror", (f) => konsole.push("Absturz: " + f.message));

await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
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: 25000 });
await seite.goto(BASIS + "/workspace/dateien.html", { waitUntil: "networkidle" });
await seite.waitForTimeout(700);

console.log("\n=== Hochladen: sieht man es, und kann man es abbrechen? ===\n");

ok(await seite.$("#feld-datei") !== null, "die Seite hat ein Dateifeld");
ok(await seite.evaluate(() => typeof window.hochladen === "function"),
  "hochladen() ist geladen");
ok(await seite.evaluate(() => typeof window.hochladeAnzeige === "function"),
  "und die Anzeige dazu auch");

/* ---------------------------------------------------------------------
   1+2. EINE ECHTE DATEI, MIT BEWEGUNG
   ------------------------------------------------------------------ */

/** Legt eine Datei im Browser an und hängt sie ins Feld -- so, wie es
 *  ein Mensch mit dem Dateiauswahlfenster täte. `setInputFiles` mit
 *  einem Puffer geht denselben Weg wie ein echter Griff zur Platte. */
/* Gedrosselt auf 2 MBit/s braucht 1,5 MB rund sechs Sekunden -- lang
   genug für viele Fortschritt-Ereignisse, kurz genug für einen
   Prüflauf, den man abwartet. */
const GROSS = 1536 * 1024;

/* Die Texte MITSCHREIBEN, waehrend es laeuft. Nur nachher zu schauen
   waere sinnlos -- dann ist der Balken schon weg. */
await seite.evaluate(() => {
  window.__gesehen = [];
  const ziel = document.getElementById("fortschritt");
  new MutationObserver(() => {
    const t = ziel.textContent.trim();
    if (t && window.__gesehen[window.__gesehen.length - 1] !== t) window.__gesehen.push(t);
  }).observe(ziel, { childList: true, subtree: true, characterData: true });
});

await seite.setInputFiles("#feld-datei", {
  name: "Kampagne Oktober.pdf",
  mimeType: "application/pdf",
  buffer: Buffer.alloc(GROSS, 7),
});

/* Warten, bis die Datei in der Liste steht -- nicht auf eine feste
   Zeit. Eine feste Zahl waere wieder "eine Rechnung von gestern". */
/* AUF DIE LISTE WARTEN, nicht auf irgendeinen Text im Dokument.
   Erster Anlauf war `document.body.textContent.includes(name)` -- und
   der Name stand auch im Fortschrittsbalken. Die Bedingung war damit
   erfüllt, BEVOR ein einziges Byte angekommen war, und die Prüfung
   maß einen Balken, der noch lief. */
await seite.waitForFunction(
  () => [...document.querySelectorAll(".datei")]
    .some((e) => e.textContent.includes("Kampagne Oktober.pdf")),
  { timeout: 120_000 });

const gesehen = await seite.evaluate(() => window.__gesehen);
ok(gesehen.length > 0, "der Balken war überhaupt zu sehen");
/* DIE ZAHL GEHOERT IN DIE BEDINGUNG: Bei einer leeren Liste waere
   "alle Texte waren verschieden" trivialerweise wahr. */
ok(gesehen.length >= 2,
  `und sein Text hat sich unterwegs geändert (${gesehen.length} verschiedene Stände)`);
const mitProzent = gesehen.filter((t) => /\d+\s*%/.test(t));
ok(mitProzent.length > 0,
  `es stand ein Prozentsatz da (${mitProzent.length}× — z. B. „${mitProzent[0] || "—"}")`);
ok(gesehen.some((t) => /Abbrechen/.test(t)), "und ein Abbrechen-Knopf daneben");

/* Die Datei ist wirklich da -- nicht nur in der Liste, auch auf der Platte. */
const abgelegt = (() => {
  try { return readdirSync(join(ordner, "dateien")); } catch { return []; }
})();
ok(abgelegt.length >= 1, `die Datei liegt wirklich auf der Platte (${abgelegt.length})`);

const listeNachher = await seite.evaluate(() =>
  [...document.querySelectorAll(".datei")].length);
ok(listeNachher === 1, `und genau einmal in der Liste (${listeNachher})`);

/* ---------------------------------------------------------------------
   3+4. ABBRECHEN
   ------------------------------------------------------------------ */
console.log("\n— Abbrechen —");

/* Warten, bis die Anzeige des ERSTEN Laufs weg ist. Sonst klickt der
   Abbruch auf einen Knopf, der im selben Moment ersetzt wird --
   Playwright meldet dann "element was detached from the DOM". Das sah
   nach einem Befund aus und war eine Wettlaufsituation in der
   Prüfung selbst. */
await seite.waitForSelector(".hochlade__abbruch", { state: "detached", timeout: 15_000 })
  .catch(() => {});
await seite.evaluate(() => { window.__gesehen = []; });
await seite.setInputFiles("#feld-datei", {
  name: "Wird abgebrochen.pdf",
  mimeType: "application/pdf",
  buffer: Buffer.alloc(GROSS, 3),
});

/* Auf den Abbruchknopf warten und ihn druecken, waehrend es laeuft. */
let abbruchDa = true;
try {
  await seite.waitForSelector(".hochlade__abbruch", { timeout: 10_000 });
} catch { abbruchDa = false; }
ok(abbruchDa, "während es läuft, steht ein Abbrechen-Knopf da");

if (abbruchDa) {
  await seite.click(".hochlade__abbruch");
  await seite.waitForTimeout(1500);

  const listeDanach = await seite.evaluate(() =>
    [...document.querySelectorAll(".datei")].map((e) => e.textContent).join(" | "));
  ok(!listeDanach.includes("Wird abgebrochen"),
    "die abgebrochene Datei ist NICHT in der Liste gelandet");

  const aufPlatte = (() => {
    try { return readdirSync(join(ordner, "dateien")).length; } catch { return 0; }
  })();
  ok(aufPlatte === abgelegt.length,
    `und auch nicht auf der Platte (${aufPlatte}, vorher ${abgelegt.length})`);

  /* DER WICHTIGSTE TEIL: kein roter Fehler fuer etwas, das der Nutzer
     selbst getan hat. */
  const rot = await seite.evaluate(() =>
    document.getElementById("fehler")?.textContent?.trim() || "");
  ok(rot === "", `keine rote Fehlermeldung nach dem eigenen Abbruch (stand: „${rot}")`);

  const schluss = await seite.evaluate(() => window.__gesehen.join(" ‖ "));
  ok(/[Aa]bgebrochen/.test(schluss),
    "stattdessen ein ruhiger Satz, dass abgebrochen wurde");
}

/* ---------------------------------------------------------------------
   DIE GEGENPROBEN
   ------------------------------------------------------------------ */
console.log("\n  --- Gegenproben (jede MUSS anschlagen) ---");

/* Ohne `beiFortschritt` darf KEIN Prozentsatz erscheinen -- sonst
   misst die Prüfung oben etwas, das auch ohne den Umbau dastünde. */
const ohneMelder = await seite.evaluate(async () => {
  const p = document.createElement("p");
  document.body.append(p);
  const a = window.hochladeAnzeige(p, "Probe.pdf", null);
  a.fortschritt(undefined);
  const text = p.textContent;
  a.weg();
  p.remove();
  return text;
});
ok(!/\d+\s*%/.test(ohneMelder),
  `ohne bekannte Größe steht KEINE erfundene Prozentzahl da („${ohneMelder.trim()}")`);

const mitMelder = await seite.evaluate(async () => {
  const p = document.createElement("p");
  document.body.append(p);
  const a = window.hochladeAnzeige(p, "Probe.pdf", null);
  a.fortschritt(0.42, 42, 100);
  const text = p.textContent;
  a.weg();
  p.remove();
  return text;
});
ok(/42\s*%/.test(mitMelder), `mit bekannter Größe schon („${mitMelder.trim()}")`);

/* Und die Anzeige verschwindet wirklich. */
const wegDanach = await seite.evaluate(() => {
  const p = document.createElement("p");
  document.body.append(p);
  const a = window.hochladeAnzeige(p, "x", null);
  a.weg();
  const r = { versteckt: p.hidden, leer: p.textContent === "" };
  p.remove();
  return r;
});
ok(wegDanach.versteckt && wegDanach.leer, "und sie räumt sich hinterher auf");

ok(konsole.length === 0, `keine Fehler in der Konsole${konsole.length ? ": " + konsole[0] : ""}`);

/* ---- Ende ---------------------------------------------------------- */
await browser.close();
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);