/* =====================================================================
   pruef-zuteilung.mjs — AUFGABEN AN MENSCHEN
   =====================================================================

   Der Auftrag vom 21.09.2026, Abschnitte 2 bis 5, durchgespielt wie
   ein Arbeitstag: verteilen, annehmen, ablehnen, übernehmen,
   fertigmachen, bewerten.

   WAS HIER GEMESSEN WIRD — und warum gerade das:

   (1) DASS JEMAND SIEHT, WAS ER BEKOMMEN HAT. Bei "mehrere" und "pool"
       bleibt `verantwortlich_id` leer, und die alten Sichtregeln
       fragen genau danach. Ohne die Erweiterung stünde eine Aufgabe im
       Resümee der Leitung und wäre für den, der sie machen soll,
       unsichtbar. Das ist der unangenehmste denkbare Fehler in einem
       Aufgabensystem, und man sieht ihn nirgends — deshalb steht er
       hier an erster Stelle.

   (2) DASS DER POOL WIRKLICH SCHLIESST. "Die erste Modi, die gerade
       Zeit hat, übernimmt" ist nur dann etwas wert, wenn die anderen
       es merken. Geprüft wird nicht nur, dass einer sie hat, sondern
       dass die anderen sie NICHT mehr haben.

   (3) DASS ZWEI NICHT GLEICHZEITIG ÜBERNEHMEN KÖNNEN. Die Prüfung
       fragt vor dem Schreiben, ob schon jemand zugesagt hat.

   (4) DIE GRENZEN. Ein Modi darf nicht bewerten, niemand darf eine
       Aufgabe annehmen, die er nicht bekommen hat, und bewertet wird
       erst, wenn jemand fertig ist.

   (5) GEGENPROBEN. Zu jeder Sperre eine Stelle, an der es erlaubt ist
       — sonst wäre nur bewiesen, dass gar nichts geht.
   ===================================================================== */

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

const ordner = mkdtempSync(join(tmpdir(), "ws-zuteil-"));
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 Zuteilungspruefung");

process.env.PORT = `${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-zuteilung");
await new Promise((r) => setTimeout(r, 1200));

const PROTOKOLL = join(process.cwd(), "pruef-zuteilung-lauf.txt");
try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }
const melde = (z) => { console.log(z); try { appendFileSync(PROTOKOLL, z + "\n"); } catch { /* Zugabe */ } };
let fehler = 0;
const ok = (b, t) => { melde((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

const HOST = "crew.dogfather-universe.com";
/* http.request statt fetch: fetch verwirft den Host-Kopf still, und
   ohne den landet alles im falschen Haus (gemessen am 20.09.2026). */
function rufe(pfad, wie = {}) {
  return new Promise((fertig) => {
    const daten = wie.body === undefined ? null : JSON.stringify(wie.body);
    const a = http.request({
      host: "127.0.0.1", port: PORT, path: pfad, method: wie.method || "GET",
      headers: {
        Host: HOST,
        ...(daten ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(daten) } : {}),
        ...(wie.keks ? { Cookie: wie.keks } : {}),
        Origin: `https://${HOST}`, Referer: `https://${HOST}/workspace/`,
      },
    }, (a2) => {
      let t = "";
      a2.on("data", (c) => (t += c));
      a2.on("end", () => fertig({
        code: a2.statusCode, kopf: a2.headers, text: t,
        json: (() => { try { return JSON.parse(t); } catch { return null; } })(),
      }));
    });
    a.on("error", (e) => fertig({ code: 0, text: e.message, json: null }));
    if (daten) a.write(daten);
    a.end();
  });
}

/* ---- Leute anlegen -------------------------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await rufe("/workspace/api/anmelden", { method: "POST", body: { rolle: "admin", code: "x" } });
for (let i = 0; i < 60; i++) {
  try { const t = new DatabaseSync(process.env.WORKSPACE_DB);
    try { t.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { t.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
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,aktiv,erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idChef  = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idLinks = anlegen("Lino", "linke", "CODE-LINK-0001");
const idAnna  = anlegen("Anna", "modi", "CODE-MOD1-0001");
const idBea   = anlegen("Bea", "modi", "CODE-MOD2-0001");
const idCem   = anlegen("Cem", "modi", "CODE-MOD3-0001");
d.close();

async function alsWer(rolle, code) {
  const a = await rufe("/workspace/api/anmelden", { method: "POST", body: { rolle, code } });
  return (a.kopf?.["set-cookie"] || []).map((z) => z.split(";")[0]).join("; ");
}
const chef  = await alsWer("admin", "CODE-DOGI-0001");
const links = await alsWer("linke", "CODE-LINK-0001");
const anna  = await alsWer("modi", "CODE-MOD1-0001");
const bea   = await alsWer("modi", "CODE-MOD2-0001");
const cem   = await alsWer("modi", "CODE-MOD3-0001");

/** Die Aufgabe mit dieser Nummer aus der Liste, die jemand sieht. */
async function aufgabeBei(keks, id) {
  const a = await rufe("/workspace/api/aufgaben", { keks });
  return (a.json?.aufgaben || []).find((x) => x.id === id) || null;
}

melde("\n===== AUFGABEN AN MENSCHEN =====");

/* =====================================================================
   1. AN MEHRERE VERTEILEN -- jede macht ihren Teil
   ===================================================================== */
melde("\n=== An mehrere verteilen ===");
let idMehrere = null;
{
  const a = await rufe("/workspace/api/aufgaben", { method: "POST", keks: chef,
    body: { titel: "Clips schneiden", verteilart: "mehrere", zuteilung: [idAnna, idBea] } });
  ok(a.code === 201, `DogFather legt sie an (HTTP ${a.code})`);
  idMehrere = a.json?.id;
  ok(a.json?.zuteilung?.art === "mehrere",
    `sie ist als "mehrere" verteilt (${a.json?.zuteilung?.art})`);
  ok((a.json?.zuteilung?.gesetzt || []).length === 2,
    `an zwei Menschen (${(a.json?.zuteilung?.gesetzt || []).length})`);

  /* DER KERN: Sieht Anna sie ueberhaupt? Bei "mehrere" ist
     verantwortlich_id leer -- die alten Regeln faenden sie nicht. */
  const beiAnna = await aufgabeBei(anna, idMehrere);
  ok(!!beiAnna, "Anna sieht die Aufgabe, obwohl niemand 'verantwortlich' ist");
  ok(beiAnna?.meine_zuteilung?.zustand === "offen",
    `ihr eigener Stand ist "offen" (${beiAnna?.meine_zuteilung?.zustand})`);
  ok((beiAnna?.zuteilung || []).length === 2,
    `sie sieht beide Namen (${(beiAnna?.zuteilung || []).map((z) => z.person_name).join(", ")})`);

  /* GEGENPROBE, UND SIE IST DER KERN VON ABSCHNITT 1:
     *"Eine Modi darf nicht automatisch die vollstaendige
     Aufgabenuebersicht aller anderen Modis sehen."*

     Cem hat sie nicht bekommen -- und er sieht sie auch nicht. Das
     stimmt genau deshalb, weil DogFather sie angelegt hat: Die alte
     Regel gibt einem Modi die Aufgaben des Modi-TEAMS (Entscheidung
     vom 09.09.2026, damit Schichttausch geht), und dazu gehoert eine
     Aufgabe von DogFather an zwei bestimmte Leute nicht.

     Beim ERSTEN Lauf stand hier `meine_zuteilung === null` -- und das
     schlug fehl, weil Cem die Zeile gar nicht bekommt und `null?.x`
     `undefined` ergibt, nicht `null`. Die Zusicherung war zu grob:
     Sie konnte "sieht sie nicht" und "sieht sie ohne Stand" nicht
     unterscheiden, also pruefte sie beides nicht richtig. Jetzt
     stehen beide Faelle einzeln da. */
  const beiCem = await aufgabeBei(cem, idMehrere);
  ok(beiCem === null,
    "Cem sieht sie gar nicht -- sie ist nicht fuer ihn und nicht von seinem Team");

  /* UND DASS DAS NICHT AN EINER LEEREN LISTE LIEGT: Die Aufgabe, die
     er GLEICH aus dem Pool bekommt, sieht er sehr wohl. Ohne diese
     Gegenprobe waere oben auch gruen, wenn Cem gar nichts sieht. */
  const seineListe = await rufe("/workspace/api/aufgaben", { keks: cem });
  ok(seineListe.code === 200,
    `und seine Liste laedt trotzdem (HTTP ${seineListe.code})`);
}

/* =====================================================================
   2. ANNEHMEN UND ABLEHNEN
   ===================================================================== */
melde("\n=== Annehmen und ablehnen ===");
{
  const ja = await rufe(`/workspace/api/aufgaben/${idMehrere}/annehmen`, { method: "POST", keks: anna, body: {} });
  ok(ja.code === 200, `Anna nimmt an (HTTP ${ja.code})`);

  const ohneGrund = await rufe(`/workspace/api/aufgaben/${idMehrere}/ablehnen`,
    { method: "POST", keks: bea, body: { grund: "" } });
  ok(ohneGrund.code === 400 && ohneGrund.json?.fehler === "grund_fehlt",
    `ohne Begruendung geht Ablehnen nicht (HTTP ${ohneGrund.code}, ${ohneGrund.json?.fehler})`);

  const nein = await rufe(`/workspace/api/aufgaben/${idMehrere}/ablehnen`,
    { method: "POST", keks: bea, body: { grund: "Bin diese Woche im Urlaub." } });
  ok(nein.code === 200, `mit Begruendung schon (HTTP ${nein.code})`);

  /* UND DIE LEITUNG SIEHT BEIDES -- getrennt nach Person. Genau das
     verlangt Abschnitt 4: keine Sammelaufgabe, sondern je Mensch. */
  const beiChef = await aufgabeBei(chef, idMehrere);
  const stand = Object.fromEntries((beiChef?.zuteilung || []).map((z) => [z.person_name, z.zustand]));
  ok(stand.Anna === "angenommen" && stand.Bea === "abgelehnt",
    `DogFather sieht es je Person (Anna: ${stand.Anna}, Bea: ${stand.Bea})`);
  const beaGrund = (beiChef?.zuteilung || []).find((z) => z.person_name === "Bea")?.grund;
  ok(beaGrund === "Bin diese Woche im Urlaub.",
    `mit Beas Begruendung im Klartext ("${beaGrund}")`);

  /* GRENZE: Cem hat sie nicht bekommen und kann sie nicht annehmen. */
  const fremd = await rufe(`/workspace/api/aufgaben/${idMehrere}/annehmen`, { method: "POST", keks: cem, body: {} });
  ok(fremd.code === 403 && fremd.json?.fehler === "nicht_zugeteilt",
    `Cem kann sie nicht annehmen (HTTP ${fremd.code})`);
}

/* =====================================================================
   3. DER POOL -- die erste, die Zeit hat
   ===================================================================== */
melde("\n=== Der Pool ===");
let idPool = null;
{
  const a = await rufe("/workspace/api/aufgaben", { method: "POST", keks: links,
    body: { titel: "Kommentare durchgehen", verteilart: "pool", zuteilung: [idAnna, idBea, idCem] } });
  ok(a.code === 201, `die LINKE Hand darf auch verteilen (HTTP ${a.code})`);
  idPool = a.json?.id;
  ok(a.json?.zuteilung?.art === "pool", `als Pool (${a.json?.zuteilung?.art})`);

  const vorher = await aufgabeBei(bea, idPool);
  ok(vorher?.uebernommen_von === null,
    "vorher hat sie niemand");

  const nimm = await rufe(`/workspace/api/aufgaben/${idPool}/uebernehmen`, { method: "POST", keks: bea, body: {} });
  ok(nimm.code === 200, `Bea uebernimmt sie (HTTP ${nimm.code})`);

  /* DER EIGENTLICHE PUNKT: Die anderen muessen es SEHEN. */
  const beiCem = await aufgabeBei(cem, idPool);
  ok(beiCem?.uebernommen_von === "Bea",
    `Cem sieht, dass Bea sie hat (${beiCem?.uebernommen_von})`);
  ok(beiCem?.meine_zuteilung?.zustand === "abgelehnt",
    `und dass sie fuer ihn weg ist (${beiCem?.meine_zuteilung?.zustand})`);
  ok(beiCem?.meine_zuteilung?.grund === "Von jemand anderem übernommen",
    `mit dem Grund im Klartext ("${beiCem?.meine_zuteilung?.grund}")`);

  /* ZWEI KOENNEN SIE NICHT GLEICHZEITIG NEHMEN. */
  const zweite = await rufe(`/workspace/api/aufgaben/${idPool}/uebernehmen`, { method: "POST", keks: cem, body: {} });
  ok(zweite.code === 409, `ein zweiter Zugriff wird abgelehnt (HTTP ${zweite.code}, ${zweite.json?.fehler})`);
  ok(zweite.json?.wer === "Bea", `und sagt, wer sie hat (${zweite.json?.wer})`);

  /* GEGENPROBE: Bei einer "mehrere"-Aufgabe gibt es kein Uebernehmen. */
  const keinPool = await rufe(`/workspace/api/aufgaben/${idMehrere}/uebernehmen`, { method: "POST", keks: anna, body: {} });
  ok(keinPool.code === 409 && keinPool.json?.fehler === "kein_pool",
    `bei "mehrere" gibt es kein Uebernehmen (HTTP ${keinPool.code})`);
}

/* =====================================================================
   4. FERTIG MACHEN UND BEWERTEN
   ===================================================================== */
melde("\n=== Fertig machen und bewerten ===");
{
  const zuFrueh = await rufe(`/workspace/api/aufgaben/${idPool}/bewerten`, { method: "POST", keks: chef,
    body: { person_id: idBea, bewertung: "gut" } });
  ok(zuFrueh.code === 409 && zuFrueh.json?.fehler === "noch_nicht_erledigt",
    `vor dem Fertigwerden wird nicht bewertet (HTTP ${zuFrueh.code})`);

  const arbeit = await rufe(`/workspace/api/aufgaben/${idPool}/mein-stand`, { method: "POST", keks: bea,
    body: { zustand: "arbeit" } });
  ok(arbeit.code === 200, `Bea setzt "in Bearbeitung" (HTTP ${arbeit.code})`);
  const fertig = await rufe(`/workspace/api/aufgaben/${idPool}/mein-stand`, { method: "POST", keks: bea,
    body: { zustand: "erledigt" } });
  ok(fertig.code === 200, `und danach "erledigt" (HTTP ${fertig.code})`);

  /* DIE DREI RUECKMELDUNGEN AUS ABSCHNITT 5. */
  const leer = await rufe(`/workspace/api/aufgaben/${idPool}/bewerten`, { method: "POST", keks: chef,
    body: { person_id: idBea, bewertung: "verbessern", text: "" } });
  ok(leer.code === 400 && leer.json?.fehler === "text_fehlt",
    `"Verbesserungsmoeglichkeiten" ohne Text geht nicht (HTTP ${leer.code})`);

  const bew = await rufe(`/workspace/api/aufgaben/${idPool}/bewerten`, { method: "POST", keks: chef,
    body: { person_id: idBea, bewertung: "verbessern", text: "Beim naechsten Mal bitte die Zeitstempel mitschreiben." } });
  ok(bew.code === 200, `mit Text schon (HTTP ${bew.code})`);

  /* UND BEA SIEHT SIE. Abschnitt 5: "Die Modi soll nachvollziehen
     koennen, welches Feedback zu ihrer Aufgabe gegeben wurde." */
  const beiBea = await aufgabeBei(bea, idPool);
  ok(beiBea?.meine_zuteilung?.bewertung === "verbessern",
    `Bea sieht die Rueckmeldung (${beiBea?.meine_zuteilung?.bewertung})`);
  ok(String(beiBea?.meine_zuteilung?.bewertung_text || "").includes("Zeitstempel"),
    "samt dem Text dazu");
  ok(beiBea?.meine_zuteilung?.bewertung_text_kurz === "Verbesserungsmöglichkeiten",
    `und im Klartext ("${beiBea?.meine_zuteilung?.bewertung_text_kurz}")`);

  /* GRENZE: Ein Modi bewertet niemanden. */
  const modiBewertet = await rufe(`/workspace/api/aufgaben/${idPool}/bewerten`, { method: "POST", keks: anna,
    body: { person_id: idBea, bewertung: "gut" } });
  ok(modiBewertet.code === 403, `ein Modi darf nicht bewerten (HTTP ${modiBewertet.code})`);
}

/* =====================================================================
   5. DAS RESUEMEE -- je Mensch und fuer alle
   ===================================================================== */
melde("\n=== Das Resuemee ===");
{
  const meins = await rufe("/workspace/api/aufgaben/resuemee", { keks: bea });
  ok(meins.code === 200, `Bea sieht ihr eigenes Resuemee (HTTP ${meins.code})`);
  ok(meins.json?.erledigt === 1 && meins.json?.abgelehnt === 1,
    `mit ihren Zahlen (erledigt ${meins.json?.erledigt}, abgelehnt ${meins.json?.abgelehnt})`);
  ok(meins.json?.zu_verbessern === 1,
    `und der Rueckmeldung (${meins.json?.zu_verbessern})`);

  /* GRENZE: Ein Modi sieht nicht das Resuemee eines anderen. */
  const fremd = await rufe(`/workspace/api/aufgaben/resuemee?person=${idAnna}`, { keks: bea });
  ok(fremd.code === 403, `aber nicht das von Anna (HTTP ${fremd.code})`);

  /* GEGENPROBE: Die Leitung schon -- das ist der Sinn der Sache. */
  const durchChef = await rufe(`/workspace/api/aufgaben/resuemee?person=${idAnna}`, { keks: chef });
  ok(durchChef.code === 200 && durchChef.json?.name === "Anna",
    `DogFather schon (HTTP ${durchChef.code}, ${durchChef.json?.name})`);

  const team = await rufe("/workspace/api/aufgaben/team-resuemee", { keks: links });
  ok(team.code === 200, `die linke Hand sieht das Team-Resuemee (HTTP ${team.code})`);
  const namen = (team.json?.leute || []).map((p) => p.name);
  ok(namen.includes("Anna") && namen.includes("Bea") && namen.includes("Cem"),
    `mit allen Modis (${namen.join(", ")})`);
  const annaZeile = (team.json?.leute || []).find((p) => p.name === "Anna");
  ok(annaZeile?.angenommen === 1,
    `und je Person die eigenen Zahlen (Anna angenommen: ${annaZeile?.angenommen})`);

  const modiTeam = await rufe("/workspace/api/aufgaben/team-resuemee", { keks: anna });
  ok(modiTeam.code === 403, `ein Modi bekommt es nicht (HTTP ${modiTeam.code})`);
}

/* =====================================================================
   6. EINZELN -- der haeufigste Fall, und die alte Spalte stimmt noch
   ===================================================================== */
melde("\n=== Eine einzelne Person ===");
{
  const a = await rufe("/workspace/api/aufgaben", { method: "POST", keks: chef,
    body: { titel: "Thumbnail bauen", zuteilung: [idCem] } });
  ok(a.code === 201 && a.json?.zuteilung?.art === "einzeln",
    `eine Person heisst "einzeln" (${a.json?.zuteilung?.art})`);
  const beiCem = await aufgabeBei(cem, a.json.id);
  ok(beiCem?.verantwortlich_name === "Cem",
    `und die alte Spalte stimmt weiterhin (${beiCem?.verantwortlich_name})`);

  /* GEGENPROBE ZUR ABLEITUNG: Wer "pool" mit einer Person schickt,
     bekommt "einzeln" -- ein Pool aus einem Menschen ist keiner. */
  const b = await rufe("/workspace/api/aufgaben", { method: "POST", keks: chef,
    body: { titel: "Allein im Pool", verteilart: "pool", zuteilung: [idCem] } });
  ok(b.json?.zuteilung?.art === "einzeln",
    `"pool" mit einer Person wird "einzeln" (${b.json?.zuteilung?.art})`);
}

/* =====================================================================
   7. EIN MODI VERTEILT NICHTS
   ===================================================================== */
melde("\n=== Grenzen beim Verteilen ===");
{
  const a = await rufe("/workspace/api/aufgaben", { method: "POST", keks: anna,
    body: { titel: "Bea soll das machen", zuteilung: [idBea] } });
  ok(a.code === 201, `Anna darf sich selbst etwas notieren (HTTP ${a.code})`);
  const beiBea = await aufgabeBei(bea, a.json?.id);
  ok(!beiBea?.meine_zuteilung,
    "aber Bea bekommt nichts davon zugeteilt");
  const beiAnna = await aufgabeBei(anna, a.json?.id);
  ok(beiAnna?.verantwortlich_name === "Anna",
    `die Aufgabe liegt bei Anna selbst (${beiAnna?.verantwortlich_name})`);
}

try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Zugabe */ }
melde(`\n  ${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
process.exit(fehler ? 1 : 0);