/* Misst die einzelnen Teile der Kopfleiste auf dem Handy -- damit eine
   Reparatur an der richtigen Stelle ansetzt und nicht geraten wird.

   SIE PRUEFT SEIT DEM 01.09.2026 AUCH, statt nur zu messen.

   Vorher war sie ein reines Messwerkzeug: Sie druckte Zahlen und endete
   IMMER mit Exitcode 0. Damit stand sie als "pruef-..." im Ordner der
   Pruefungen, lief bei jedem Gesamtlauf mit, meldete "in Ordnung" --
   und konnte gar nicht fehlschlagen. Aufgefallen ist das erst, als der
   Gesamtlauf die ANZAHL der Einzelpruefungen mitzaehlte: Diese Datei
   kam auf null.

   Eine Pruefung, die immer bestaetigt, bestaetigt nichts. Die beiden
   Zahlen, um die es geht, wurden laengst gemessen -- sie werden jetzt
   auch beurteilt:
     UEBERSTAND          muss 0 sein (waagerechtes Scrollen ist auf
                         einem Handy der schlimmste Fehler)
     ABMELDEN ERREICHBAR muss wahr sein -- es ist der einzige Weg wieder
                         heraus; liegt er ausserhalb des Bildes, sitzt
                         man fest.
   Die Messwerte werden weiterhin gedruckt: Sie sagen bei einem
   Fehlschlag sofort, WELCHES Teil zu breit ist. */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-messen-"));
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
process.env.PORT = "4179";
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";
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-kopf-messen");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4179";

let fehler = 0;
let geprueft = 0;
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 120_000).unref?.();

await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});

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");
/* Bewusst ein langer Name -- kurze Namen wuerden den Fehler verstecken. */
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
  .run("Filipe Fernandes Ribeiro", "admin", hash, salt, 32768, new Date().toISOString());
d.close();

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

for (const breite of [320, 390, 430]) {
  const kontext = await browser.newContext({ viewport: { width: breite, height: 844 } });
  const seite = await kontext.newPage();
  await seite.goto(BASIS + "/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: 15000 });
  await seite.goto(BASIS + "/workspace/uebersicht.html", { waitUntil: "networkidle" });
  await seite.waitForTimeout(300);
  const r = await seite.evaluate(() => {
    const k = document.querySelector(".kopfleiste");
    const teil = (e) => ({
      was: (e.tagName + "." + String(e.className).split(" ")[0]).slice(0, 34),
      breite: Math.round(e.getBoundingClientRect().width),
      rechts: Math.round(e.getBoundingClientRect().right),
    });
    return {
      fenster: window.innerWidth,
      ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
      kinder: [...k.children].map(teil),
      rechtsKinder: [...(k.querySelector(".kopfleiste__rechts")?.children || [])].map(teil),
      abmeldenSichtbar: (() => {
        const a = document.querySelector(".abmelden")?.getBoundingClientRect();
        return a ? a.right <= window.innerWidth : null;
      })(),
    };
  });
  /* Erst beurteilen, dann drucken -- die Messwerte darunter sind die
     Begründung, falls es schiefgeht. */
  geprueft++;
  const gut = r.ueber <= 0 && r.abmeldenSichtbar === true;
  if (!gut) fehler++;
  console.log(`  ${gut ? "ok  " : "FEHL"} ${breite}px: Überstand ${r.ueber}px, `
    + `Abmelden erreichbar: ${r.abmeldenSichtbar}`);
  for (const t of r.kinder) console.log(`   ${t.was.padEnd(34)} b=${String(t.breite).padStart(4)} rechts=${t.rechts}`);
  console.log("   darin:");
  for (const t of r.rechtsKinder) console.log(`     ${t.was.padEnd(32)} b=${String(t.breite).padStart(4)} rechts=${t.rechts}`);
  await kontext.close();
}
await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch {}
/* Die Anzahl gehoert in die BEDINGUNG, nicht nur in den Meldetext:
   Waere die Schleife nie gelaufen, waere "0 Fehler" sonst ein Erfolg. */
console.log(`
${geprueft} Breiten gemessen, ${fehler} beanstandet.`);
if (!geprueft) { console.log("  FEHL keine einzige Breite gemessen"); fehler++; }
console.log(fehler ? "NICHT in Ordnung." : "Alles in Ordnung.");
process.exit(fehler ? 1 : 0);