/* =====================================================================
   pruef-material.mjs — BILDER UND VIDEOS ZUM POSTEN, JEDES NUR EINMAL
   =====================================================================

   Auftrag vom 22.09.2026:

     "sobald ein bild oder ein video was von uns gepostet wurde,
      runtergeladen wurde, soll direkt blockiert werden so dass man es
      nicht mehr runterladen kann ... damit nie ein bild zwei mal
      gepostet wird ... und die rechte hand und dogfather, nur die
      beiden sollen auch immer sehen koennen wer das bild oder video
      runtergeladen hat."

   ---------------------------------------------------------------------
   WAS HIER GEMESSEN WIRD — und warum gerade das:

   (1) DIE EINMALIGKEIT. Der entscheidende Nachweis ist NICHT der
       gleichzeitige Zugriff: Node arbeitet die beiden Anfragen
       ohnehin nacheinander ab, und `node:sqlite` ist synchron -- der
       parallele Fall kann hier gar nicht schiefgehen. Was schiefgehen
       KANN, ist die Reihenfolge "erst nachsehen, dann schreiben" ohne
       Bedingung im UPDATE. Genau das faengt der ZWEITE Versuch nach
       dem ersten ab: Er muss 409 bekommen, und der Vermerk darf sich
       nicht mehr aendern. Der gleichzeitige Fall steht trotzdem hier --
       er kostet nichts und faellt auf, falls jemand spaeter ein
       `await` zwischen Lesen und Schreiben setzt.

   (2) DASS DIE DATEI DANACH WIRKLICH ZU IST. Ein Vermerk in der
       Datenbank ist keine Sperre, solange die Datei weiter
       ausgeliefert wird. Geprueft wird der Abruf, nicht das Feld.

   (3) DASS DIE VORSCHAU DIESELBE GRENZE HAT. Sonst waere sie der Weg,
       ein vergebenes Bild doch noch zu bekommen (Rechtsklick,
       speichern) -- und die ganze Einmaligkeit eine Behauptung.

   (4) WER WEN SIEHT — fuer alle fuenf Rollen, nicht nur fuer die zwei,
       die duerfen. Und nicht nur die Angabe `sieht_wer`, sondern das
       Feld selbst: Eine Liste, die "nein" sagt und die Namen trotzdem
       mitschickt, waere das Leck.

   (5) DASS DIE COMMUNITY NICHTS EINSTELLT — und das Team schon. Ohne
       die zweite Haelfte waere die erste auch dann gruen, wenn gar
       nichts mehr ginge.

   ---------------------------------------------------------------------
   WARUM node:http UND NICHT fetch: Das Team und die Community melden
   sich an verschiedenen Waenden an, und welche gilt, entscheidet der
   Host-Kopf. `fetch` in Node setzt den selbst und ignoriert einen
   gesetzten -- die Anmeldung ginge an die falsche Wand.
   ===================================================================== */

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

const PORT = await eigenerPort(import.meta, "pruef-material");

/* DATEN_ORDNER wird in workspace.js aus dem Pfad der Datenbank
   abgeleitet (`dirname(DB_PFAD)`) -- das Material landet damit von
   selbst im Wegwerfordner. Eine eigene Umgebungsvariable dafuer waere
   eine zweite Wahrheit, die beim naechsten Umbau auseinanderlaeuft. */
const ordner = mkdtempSync(join(tmpdir(), "ws-material-"));
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(240_000, "pruef-material");
await new Promise((r) => setTimeout(r, 900));

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 CREW = "crew.dogfather-universe.com";

/* ---------------------------------------------------------------------
   PERSONEN
   --------------------------------------------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
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);
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, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, createHmac("sha256", schluessel).update(code).digest("hex"), jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
anlegen("Filipe", "admin", "CODE-DOGI-0001");
anlegen("Rieke", "hand", "CODE-HAND-0001");
anlegen("Lino", "linke", "CODE-LINK-0001");
anlegen("Frida", "modi", "CODE-MODI-0001");
anlegen("Kessi", "gast", "CODE-GAST-0001");
anlegen("Sam", "gast", "CODE-GAST-0002");
d.close();

/* ---------------------------------------------------------------------
   DER DRAHT
   --------------------------------------------------------------------- */
function roh(pfad, wie = {}) {
  return new Promise((fertig, schief) => {
    const daten = wie.roh !== undefined
      ? wie.roh
      : (wie.body === undefined ? null : Buffer.from(JSON.stringify(wie.body)));
    const a = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: pfad,
      method: wie.methode || (daten ? "POST" : "GET"),
      headers: {
        Host: CREW,
        ...(daten ? {
          "Content-Type": wie.typ || "application/json",
          "Content-Length": daten.length,
        } : {}),
        ...(wie.kopf || {}),
        ...(wie.keks ? { Cookie: wie.keks } : {}),
        Origin: `https://${CREW}`,
        Referer: `https://${CREW}/workspace/`,
      },
    }, (antwort) => {
      const stuecke = [];
      antwort.on("data", (s) => stuecke.push(s));
      antwort.on("end", () => {
        const puffer = Buffer.concat(stuecke);
        const text = puffer.toString("utf8");
        fertig({
          code: antwort.statusCode, kopf: antwort.headers,
          bytes: puffer.length, text,
          json: (() => { try { return JSON.parse(text); } catch { return null; } })(),
        });
      });
    });
    a.on("error", schief);
    if (daten) a.write(daten);
    a.end();
  });
}

async function anmelden(rolle, code) {
  /* Die Community bestaetigt beim ersten Mal ihr Alter (seit 15.09.). */
  const r = await roh("/workspace/api/anmelden", {
    body: rolle === "gast" ? { rolle, code, alter_ok: true } : { rolle, code },
  });
  const kekse = [].concat(r.kopf?.["set-cookie"] || []);
  return { keks: kekse.map((c) => c.split(";")[0]).join("; "), code: r.code };
}

const chef = await anmelden("admin", "CODE-DOGI-0001");
const hand = await anmelden("hand", "CODE-HAND-0001");
const linke = await anmelden("linke", "CODE-LINK-0001");
const modi = await anmelden("modi", "CODE-MODI-0001");
const kessi = await anmelden("gast", "CODE-GAST-0001");
const sam = await anmelden("gast", "CODE-GAST-0002");

melde("");
melde("=== 0. Alle sechs kommen ueberhaupt herein ===");
for (const [wer, s] of [["DogFather", chef], ["rechte Hand", hand],
  ["linke Hand", linke], ["Modi", modi], ["Kessi", kessi], ["Sam", sam]]) {
  ok(s.code === 200 && s.keks.length > 0, `${wer} ist angemeldet (${s.code})`);
}

/* Ein echtes, winziges PNG (1x1). Der Server prueft die Art -- ein
   erfundener Byteblock haette den falschen Typ und die Pruefung waere
   aus dem falschen Grund gruen. */
const PNG = Buffer.from(
  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
  "base64");

function einstellen(keks, name, text = "") {
  return roh("/workspace/api/material", {
    methode: "POST", roh: PNG, typ: "image/png", keks,
    kopf: {
      "X-Datei-Name": encodeURIComponent(name),
      "X-Text": encodeURIComponent(text),
    },
  });
}
const nehmen = (id, keks) =>
  roh(`/workspace/api/material/${id}/nehmen`, { methode: "POST", keks });
const liste = (keks) => roh("/workspace/api/material", { keks });

/* =====================================================================
   1. WER ETWAS BEREITSTELLEN DARF
   ===================================================================== */
melde("");
melde("=== 1. Wer etwas bereitstellen darf ===");
{
  for (const [wer, s] of [["DogFather", chef], ["die rechte Hand", hand],
    ["die linke Hand", linke], ["ein Modi", modi]]) {
    const a = await einstellen(s.keks, `Von ${wer}.png`, "Fuer TikTok");
    ok(a.code === 201 && Number.isInteger(a.json?.id),
      `${wer} stellt etwas bereit (${a.code}, Nummer ${a.json?.id})`);
  }

  /* DIE GEGENPROBE, und sie ist Filipes ausdruecklicher Satz:
     "die community soll keine posten koennen in die kategorie". */
  const g = await einstellen(kessi.keks, "Von der Community.png");
  ok(g.code === 403, `die Community NICHT (${g.code})`);
  ok(g.json?.fehler === "nur_team_stellt_ein",
    `und bekommt einen Grund, zu dem es einen Satz gibt (${g.json?.fehler})`);

  /* Und es ist auch wirklich nichts angekommen -- eine 403, nach der
     die Datei trotzdem in der Liste steht, waere die schlimmere Sorte. */
  const l = await liste(chef.keks);
  const vonKessi = (l.json?.material || []).filter((m) => m.von === "Kessi").length;
  ok(vonKessi === 0, `und es liegt auch nichts von ihr da (${vonKessi})`);
}

/* =====================================================================
   2. WAS NICHT HINEINGEHOERT
   ===================================================================== */
melde("");
melde("=== 2. Was nicht hineingehoert ===");
{
  const a = await roh("/workspace/api/material", {
    methode: "POST", roh: Buffer.from("MZ-Programm"),
    typ: "application/octet-stream", keks: chef.keks,
    kopf: { "X-Datei-Name": encodeURIComponent("schadprogramm.exe") },
  });
  ok(a.code === 400, `ein Programm wird abgelehnt (${a.code})`);
  ok(a.json?.fehler === "art_nicht_erlaubt", `mit Grund (${a.json?.fehler})`);

  const b = await roh("/workspace/api/material", {
    methode: "POST", roh: Buffer.alloc(0), typ: "image/png", keks: chef.keks,
  });
  ok(b.code === 400 && b.json?.fehler === "datei_fehlt",
    `eine leere Datei ebenso (${b.code}, ${b.json?.fehler})`);
}

/* =====================================================================
   3. DER KERN: JEDES NUR EINMAL
   ===================================================================== */
melde("");
melde("=== 3. Jedes nur einmal ===");
{
  const a = await einstellen(chef.keks, "Umkaempft.png", "Wer zuerst kommt");
  const id = a.json?.id;
  ok(Number.isInteger(id), `ein Stueck zum Wettlauf liegt bereit (${id})`);

  /* Beide Anfragen gehen los, bevor die erste beantwortet ist. */
  const [x, y] = await Promise.all([nehmen(id, kessi.keks), nehmen(id, sam.keks)]);
  const gewonnen = [x, y].filter((r) => r.code === 200).length;
  const verloren = [x, y].filter((r) => r.code === 409).length;
  ok(gewonnen === 1, `genau einer bekommt es (${gewonnen} von 2)`);
  ok(verloren === 1, `und genau einer bekommt "schon vergeben" (${verloren})`);
  ok([x, y].find((r) => r.code === 409)?.json?.fehler === "schon_genommen",
    `mit Grund (${[x, y].find((r) => r.code === 409)?.json?.fehler})`);

  /* DER EIGENTLICHE NACHWEIS: Wer danach kommt, bekommt nichts -- und
     der Vermerk darf sich nicht mehr aendern. Ein Weg ohne Bedingung
     im UPDATE wuerde hier den zweiten Namen eintragen, und die Liste
     saehe danach voellig normal aus. */
  const vorName = (await liste(chef.keks)).json?.material
    ?.find((m) => m.id === id)?.genommen_von;
  const z = await nehmen(id, modi.keks);
  ok(z.code === 409, `ein Dritter danach ebenso wenig (${z.code})`);
  const nachName = (await liste(chef.keks)).json?.material
    ?.find((m) => m.id === id)?.genommen_von;
  ok(!!vorName && vorName === nachName,
    `und der Vermerk bleibt stehen (${vorName} -> ${nachName})`);
}

/* =====================================================================
   4. DIE DATEI IST DANACH WIRKLICH ZU
   ===================================================================== */
melde("");
melde("=== 4. Die Datei ist danach wirklich zu ===");
{
  const a = await einstellen(chef.keks, "Abgeschlossen.png");
  const id = a.json?.id;

  const vorher = await roh(`/workspace/api/material/${id}/datei`, { keks: kessi.keks });
  ok(vorher.code === 403,
    `vor dem Nehmen bekommt sie niemand (${vorher.code})`);

  const genommen = await nehmen(id, kessi.keks);
  ok(genommen.code === 200, `Kessi nimmt es (${genommen.code})`);

  const seine = await roh(`/workspace/api/material/${id}/datei`, { keks: kessi.keks });
  ok(seine.code === 200 && seine.bytes === PNG.length,
    `und bekommt die Datei (${seine.code}, ${seine.bytes} von ${PNG.length} Bytes)`);
  ok(/attachment/.test(String(seine.kopf?.["content-disposition"] || "")),
    "als Download, nicht zum Anschauen im Browser");

  /* DER RIEGEL. Ein Vermerk in der Datenbank ist keine Sperre,
     solange die Datei weiter ausgeliefert wird. */
  for (const [wer, s] of [["ein anderer aus der Community", sam],
    ["ein Modi", modi], ["die linke Hand", linke],
    ["sogar die rechte Hand", hand]]) {
    const r = await roh(`/workspace/api/material/${id}/datei`, { keks: s.keks });
    ok(r.code === 403, `${wer} bekommt sie nicht (${r.code})`);
  }

  /* UND DIE VORSCHAU HAT DIESELBE GRENZE -- sonst waere sie der Weg,
     es doch noch zu bekommen. */
  const schauFremd = await roh(`/workspace/api/material/${id}/vorschau`, { keks: sam.keks });
  ok(schauFremd.code === 403,
    `auch die Vorschau ist fuer andere zu (${schauFremd.code})`);
  const schauSeine = await roh(`/workspace/api/material/${id}/vorschau`, { keks: kessi.keks });
  ok(schauSeine.code === 200 && schauSeine.bytes === PNG.length,
    `wer es genommen hat, sieht es weiter (${schauSeine.code})`);
}

/* =====================================================================
   5. SOLANGE ES FREI IST, DARF JEDER HINSEHEN
   =====================================================================
   Die Gegenprobe zu Abschnitt 4: Waere die Vorschau schlicht immer
   gesperrt, waeren alle Zeilen oben ebenfalls gruen -- und niemand
   koennte je entscheiden, ob ein Bild zu seinem Kanal passt. */
melde("");
melde("=== 5. Solange es frei ist, darf jeder hinsehen ===");
{
  const a = await einstellen(chef.keks, "Noch frei.png");
  const id = a.json?.id;
  for (const [wer, s] of [["die Community", kessi], ["ein Modi", modi],
    ["die linke Hand", linke], ["die rechte Hand", hand]]) {
    const r = await roh(`/workspace/api/material/${id}/vorschau`, { keks: s.keks });
    ok(r.code === 200 && r.bytes === PNG.length,
      `${wer} sieht die Vorschau (${r.code}, ${r.bytes} Bytes)`);
  }
}

/* =====================================================================
   6. WER SIEHT, WER ES GENOMMEN HAT
   =====================================================================
   "die rechte hand und dogfather, NUR die beiden" -- gemessen fuer
   alle fuenf Rollen, und nicht nur an der Angabe `sieht_wer`, sondern
   am Feld selbst. */
melde("");
melde("=== 6. Wer sieht, wer es genommen hat ===");
{
  const soll = { admin: true, hand: true, linke: false, modi: false, gast: false };
  const kekse = { admin: chef, hand, linke, modi, gast: kessi };
  let vergebenGesamt = 0;
  for (const [rolle, darf] of Object.entries(soll)) {
    const a = await liste(kekse[rolle].keks);
    ok(a.code === 200, `${rolle}: die Liste kommt (${a.code})`);
    ok(a.json?.sieht_wer === darf,
      `  und "sieht_wer" ist ${darf} (${a.json?.sieht_wer})`);

    const vergeben = (a.json?.material || []).filter((m) => m.genommen);
    const mitNamen = vergeben.filter((m) => m.genommen_von !== undefined).length;
    vergebenGesamt = Math.max(vergebenGesamt, vergeben.length);
    ok(vergeben.length > 0 && (darf ? mitNamen === vergeben.length : mitNamen === 0),
      `  ${vergeben.length} vergeben, davon ${mitNamen} mit Namen`);
  }
  /* DIE ZAHL GEHOERT IN DIE BEDINGUNG: Ohne vergebene Stuecke waere
     "keine Namen dabei" trivial wahr. */
  ok(vergebenGesamt >= 2,
    `es lagen ueberhaupt vergebene Stuecke vor (${vergebenGesamt})`);
}

/* =====================================================================
   7. JEDER SIEHT, WAS ER SELBST GENOMMEN HAT
   ===================================================================== */
melde("");
melde("=== 7. Jeder sieht, was er selbst genommen hat ===");
{
  /* SAM MUSS ERST WIRKLICH ETWAS HABEN. Im Wettlauf oben hat Kessi
     gewonnen -- ohne diesen Schritt vergliche die Gegenprobe unten
     zwei Nullen und waere gruen, ohne irgendetwas gesehen zu haben.
     Genau der gruene Haken ueber der Null. */
  const fuerSam = await einstellen(chef.keks, "Fuer Sam.png");
  const holt = await nehmen(fuerSam.json?.id, sam.keks);
  ok(holt.code === 200, `Sam nimmt sich eines (${holt.code})`);

  const meine = ((await liste(kessi.keks)).json?.material || [])
    .filter((m) => m.von_mir_genommen);
  ok(meine.length >= 1, `Kessi sieht ihre eigenen (${meine.length})`);

  const fremde = ((await liste(sam.keks)).json?.material || [])
    .filter((m) => m.von_mir_genommen);
  const ids = new Set(meine.map((m) => m.id));
  const verwechselt = fremde.filter((m) => ids.has(m.id)).length;
  ok(verwechselt === 0,
    `und keines davon steht bei Sam als "von mir" (${verwechselt})`);

  /* Gegenprobe gegen die Liste des DogFathers: Sams eigene Sicht muss
     zu dem passen, was dort mit seinem Namen steht. */
  const samHat = ((await liste(chef.keks)).json?.material || [])
    .filter((m) => m.genommen_von === "Sam").length;
  ok(samHat > 0 && fremde.length === samHat,
    `Sams eigene Sicht deckt sich mit der Liste des DogFathers (${fremde.length} / ${samHat})`);
}

/* =====================================================================
   8. DIE AGENTUR HAT HIER NICHTS
   ===================================================================== */
melde("");
melde("=== 8. Die Grenzen des Bereichs ===");
{
  const { darfSeite } = await import("./rechte.js");
  for (const r of ["admin", "hand", "linke", "modi", "gast"]) {
    ok(darfSeite({ rolle: r, haus: "crew" }, "/workspace/material.html"),
      `${r} darf die Seite oeffnen`);
  }
  for (const r of ["creator", "manager", "scout", "spicy"]) {
    ok(!darfSeite({ rolle: r, haus: "agentur" }, "/workspace/material.html"),
      `${r} aus der Agentur nicht`);
  }

  /* Und die Kachel gibt es -- sonst waere die Seite da und niemand
     faende sie. Abgeleitet aus derselben Quelle wie die Startseite. */
  const w = await import("./workspace.js");
  for (const r of ["gast", "modi", "hand", "linke", "admin"]) {
    const treffer = [...(w.bereicheFuer({ rolle: r, haus: "crew" }) || [])]
      .filter((k) => k.ziel === "material.html");
    ok(treffer.length === 1 && treffer[0].name === "Material",
      `${r} hat genau eine Kachel dorthin (${treffer.length}, "${treffer[0]?.name}")`);
  }
}

/* =====================================================================
   ERGEBNIS
   ===================================================================== */
melde("");
/* Die Zahl gehoert in die Bedingung, nicht nur in den Text: Ein Lauf,
   der nichts geprueft hat, ist kein bestandener Lauf. */
if (geprueft < 40) {
  console.log(`  FEHL nur ${geprueft} Pruefungen gelaufen -- erwartet waren 40+`);
  fehler++;
}
melde(fehler === 0
  ? `Alles in Ordnung. ${geprueft} Pruefungen, 0 Fehler.`
  : `${fehler} FEHLER bei ${geprueft} Pruefungen.`);
melde("");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);