// L10a E2E §43.3 / §38 „Regulärer Auftrag vom Import bis zur Freigabe" — Service-Ebene gegen die DB.
//
// Import (Fake-Provider) → Dublettenkandidat + Objektkandidat → Prüfung/Bestätigung → Zuweisung →
// Vorab-Download (Bundle) → Annehmen/Losfahren/Arbeit → Material/Fotos/Zeiten/Notizen/Checkliste →
// Abschlussbericht → Unterschrift → Teamleiter- und Backoffice-Freigabe → PDF (skip-fähig ohne
// Chromium) → Abrechnung → abgerechnet → Objekt-Historie. Dazu Mandantentrennung (Mandant B) und
// Rollen/Scope (Monteur ohne Zuweisung) an jedem Schritt.
//
// Lauf: npx tsx scripts/test-e2e-regular-order.ts   (auch mit RLS_ENFORCED=true lauffähig)

import "dotenv/config";
import { randomUUID } from "node:crypto";
import { prisma } from "../src/server/db";
import type { WorkOrderExtraction } from "../src/server/ai/providers";
import { FakeExtractionProvider } from "../src/server/ai/extraction/fake";
import { createImport } from "../src/server/services/imports/upload";
import { processImport } from "../src/server/services/imports/process";
import { confirmImport } from "../src/server/services/imports/confirm";
import { getImportDetail } from "../src/server/services/imports/queries";
import { extractionToForm } from "../src/lib/imports/review";
import { assignWorkOrder } from "../src/server/services/work-orders/assign";
import { addChecklistItem, addPhotoRequirement } from "../src/server/services/work-orders/checklist";
import { transitionWorkOrder } from "../src/server/services/work-orders/transition";
import { markBilled, releaseForBilling } from "../src/server/services/work-orders/release-billing";
import { getWorkOrderDetail } from "../src/server/services/work-orders/detail";
import { getFieldBundle, getFieldOrderDetail } from "../src/server/services/field/queries";
import { endSession, pauseSession, resumeSession, startSession } from "../src/server/services/field/sessions";
import { createNote } from "../src/server/services/field/notes";
import { upsertMaterialUsage } from "../src/server/services/field/materials";
import { toggleChecklistItem } from "../src/server/services/field/checklist";
import { storeFieldUpload } from "../src/server/services/field/uploads";
import { attachPhoto } from "../src/server/services/field/photos";
import { storeFile } from "../src/server/services/documents/store";
import { authorizeDocumentAccess } from "../src/server/services/documents/access";
import { createCompletionReport } from "../src/server/services/reports/create";
import { updateReportTexts } from "../src/server/services/reports/edit";
import { captureSignature } from "../src/server/services/reports/signature";
import { submitReport } from "../src/server/services/reports/submit";
import { approveReport } from "../src/server/services/reports/approve";
import { generateReportPdf } from "../src/server/services/reports/pdf";
import { openReportFile } from "../src/server/services/reports/files";
import { contentOf, requireVisibleReport } from "../src/server/services/reports/common";
import { pdfRendererAvailable } from "../src/server/pdf/render";
import { readStoredBytes } from "../src/server/services/documents/read";
import { getSiteHistory } from "../src/server/services/sites/history";
import {
  checklistTogglePayload,
  materialUpsertPayload,
  noteCreatePayload,
  photoAttachPayload,
  sessionControlPayload,
  sessionStartPayload,
} from "../src/lib/sync/ops";
import { buildPdf } from "./make-sample-pdfs";
import { codeOf, createTenant, expectCode, jpegBytes, ok, pngBytes, runSuite, section } from "./lib/e2e-fixture";

const SLUG_A = "zz-q-e2e-reg-a";
const SLUG_B = "zz-q-e2e-reg-b";

runSuite("E2E regulärer Auftrag", [SLUG_A, SLUG_B], async () => {
  const A = await createTenant(SLUG_A);
  const B = await createTenant(SLUG_B);
  const bo = A.ctx.backoffice;
  const tech = A.ctx.tech;

  // ---------- 1. Import ----------
  section("1. Import einer Auftragsbestätigung (Fake-Provider)");
  const pdf = buildPdf([[{ text: "Auftragsbestätigung AB-2026-4711" }, { text: `Hausverwaltung ${SLUG_A} GmbH, Hafenstraße 12, 20457 Hamburg` }]]);
  const extraction: Partial<WorkOrderExtraction> = {
    orderNumber: { value: "AB-2026-4711", confidence: 0.97 },
    customerNumber: { value: `K-${SLUG_A}`, confidence: 0.95 },
    companyName: { value: `Hausverwaltung ${SLUG_A} GmbH`, confidence: 0.95 },
    customerAddress: { value: { street: "Hafenstrasse", houseNumber: "12", postalCode: "20457", city: "Hamburg", country: "DE" }, confidence: 0.9 },
    siteName: { value: `Wohnanlage ${SLUG_A}`, confidence: 0.75, source: "Bauvorhaben" },
    siteAddress: { value: { street: "Am Kaiserkai", houseNumber: "30", postalCode: "20457", city: "Hamburg" }, confidence: 0.9 },
    title: { value: "Austausch Heizungspumpe", confidence: 0.88 },
    plannedStart: { value: "01.10.2026", confidence: 0.9 },
    plannedEnd: { value: "02.10.2026", confidence: 0.9 },
    positions: {
      value: [
        { name: "Hocheffizienzpumpe 25-60", articleNumber: "HP-2560", quantity: 1, unit: "Stk", isMaterial: true },
        { name: "Montagearbeiten", quantity: 3, unit: "Std", isMaterial: false },
      ],
      confidence: 0.86,
    },
  };
  const dispatched: unknown[] = [];
  const job = await createImport(bo, { bytes: pdf, fileName: "AB-2026-4711.pdf", mimeType: "application/pdf" }, { dispatch: async (p) => void dispatched.push(p) });
  ok(job.status === "uploaded" && dispatched.length === 1, "Upload angenommen, Extraktion eingereiht");
  const processed = await processImport(bo, job.id, { provider: new FakeExtractionProvider({ extraction, text: "AB-2026-4711" }), loadBytes: async () => pdf });
  ok(processed.status === "review_required", "Extraktion → Prüfung erforderlich");
  ok((await prisma.workOrder.count({ where: { tenantId: A.tenantId } })) === 0, "kein Auftrag ohne Bestätigung");
  await expectCode(() => getImportDetail(B.ctx.backoffice, job.id), "not_found", "Mandant B sieht den Import von A nicht");
  await expectCode(() => getImportDetail(tech, job.id), "forbidden", "Monteur hat keinen Zugriff auf die Prüfmaske");

  // ---------- 2. Prüfung / Bestätigung ----------
  section("2. Prüfung: bestehender Kunde + bestehendes Objekt zugeordnet");
  const detail = await getImportDetail(bo, job.id);
  ok(detail.customerCandidates[0]?.customerId === A.customerId, "Dublettenprüfung schlägt den bestehenden Kunden vor");
  const siteCandidates = (detail.extraction as unknown as { siteCandidates?: { siteId: string }[] }).siteCandidates ?? [];
  ok(siteCandidates.some((s) => s.siteId === A.siteId), "bestehendes Objekt an gleicher Adresse als Kandidat");
  const form = extractionToForm(detail.extraction.fields, { customerId: A.customerId, siteId: A.siteId });
  form.order!.title = "Heizungspumpe Wohnanlage tauschen";
  const confirmed = await confirmImport(bo, job.id, form);
  const wo0 = await prisma.workOrder.findUniqueOrThrow({ where: { id: confirmed.workOrderId }, include: { materialPlans: true } });
  ok(wo0.status === "planned" && wo0.customerId === A.customerId && wo0.siteId === A.siteId && wo0.sourceImportId === job.id, "Auftrag geplant, Kunde/Objekt zugeordnet, Import verknüpft");
  ok(wo0.materialPlans.length === 1 && wo0.materialPlans[0].articleNumber === "HP-2560", "Materialvorgabe aus Positionen übernommen");
  const woId = wo0.id;

  // Backoffice ergänzt Pflichtpunkt + Pflichtfoto.
  const item = await addChecklistItem(bo, woId, { label: "Anlage entlüftet", required: true });
  await addPhotoRequirement(bo, woId, { key: "typenschild", label: "Typenschild neue Pumpe" });

  // ---------- 3. Zuweisung ----------
  section("3. Zuweisung an Team Nord");
  await expectCode(() => assignWorkOrder(tech, { workOrderId: woId, teamId: A.teamId, userIds: [A.users.tech.id] }), "forbidden", "Monteur darf nicht zuweisen");
  await expectCode(() => assignWorkOrder(B.ctx.backoffice, { workOrderId: woId, teamId: B.teamId }), "not_found", "Mandant B kann den Auftrag von A nicht zuweisen");
  const assigned = await assignWorkOrder(bo, { workOrderId: woId, teamId: A.teamId, userIds: [A.users.tech.id] });
  ok(assigned.status === "assigned", "Auftrag zugewiesen");
  ok((await prisma.notification.count({ where: { tenantId: A.tenantId, userId: A.users.tech.id, type: "work_order.assigned", entityId: woId } })) === 1, "Monteur erhält Benachrichtigung „Auftrag zugewiesen“");

  // ---------- 4. Vorab-Download ----------
  section("4. Team lädt Auftrag und Dokumente (Bundle)");
  const bundle = await getFieldBundle(tech);
  const bundled = bundle.orders.find((o) => o.id === woId);
  ok(!!bundled && bundled.site?.accessNotes === "Schlüssel beim Hausmeister" && bundled.materialPlans.length === 1 && bundled.photoRequirements.length === 1, "Bundle enthält Auftrag mit Zugangshinweis, Material, Pflichtfoto");
  ok(!(await getFieldBundle(A.ctx.outsider)).orders.some((o) => o.id === woId), "Monteur ohne Zuweisung (anderes Team) erhält den Auftrag nicht");
  ok(!(await getFieldBundle(B.ctx.tech)).orders.some((o) => o.id === woId), "Mandant B erhält den Auftrag nicht");
  ok(!!bundled && !bundled.documents.some((d) => d.category === "order_confirmation"), "interne Auftragsbestätigung (backoffice_only) nicht im Monteur-Bundle");
  await expectCode(() => getFieldOrderDetail(A.ctx.outsider, woId), "not_found", "Auftragsdetail für fremden Monteur → not_found");

  // ---------- 5. Einsatz ----------
  section("5. Einsatz: Annehmen, Losfahren, Arbeiten, Material, Fotos, Zeiten, Notizen");
  const started = new Date(Date.now() - 3 * 3600_000);
  await transitionWorkOrder(tech, { workOrderId: woId, to: "accepted" });
  await startSession(tech, sessionStartPayload.parse({ workOrderId: woId, mode: "travel", at: started.toISOString() }));
  const workStart = await startSession(tech, sessionStartPayload.parse({ workOrderId: woId, mode: "work", at: new Date(started.getTime() + 30 * 60_000).toISOString() }));
  ok(workStart.workOrderStatus === "in_progress", "Arbeit gestartet → in Arbeit");
  await expectCode(() => startSession(A.ctx.outsider, sessionStartPayload.parse({ workOrderId: woId, mode: "work" })), "not_found", "fremder Monteur kann keinen Einsatz starten");
  await expectCode(() => startSession(B.ctx.tech, sessionStartPayload.parse({ workOrderId: woId, mode: "work" })), "not_found", "Mandant B kann keinen Einsatz starten");

  const jpeg = await jpegBytes("Typenschild");
  const before = await storeFieldUpload(tech, { clientId: randomUUID(), workOrderId: woId, kind: "photo" }, { bytes: jpeg, name: "vorher.jpg", type: "image/jpeg" });
  await attachPhoto(tech, photoAttachPayload.parse({ workOrderId: woId, documentId: before.documentId, phase: "before", comment: "Alte Pumpe" }));
  await createNote(tech, noteCreatePayload.parse({ workOrderId: woId, kind: "work_done", text: "Alte Pumpe demontiert, neue Pumpe eingesetzt." }));
  await pauseSession(tech, sessionControlPayload.parse({ workOrderId: woId, at: new Date(started.getTime() + 90 * 60_000).toISOString() }));
  ok((await prisma.workOrder.findUniqueOrThrow({ where: { id: woId } })).status === "paused", "Pause → Auftrag pausiert");
  await resumeSession(tech, sessionControlPayload.parse({ workOrderId: woId, at: new Date(started.getTime() + 105 * 60_000).toISOString() }));
  await upsertMaterialUsage(tech, materialUpsertPayload.parse({ workOrderId: woId, materialPlanId: wo0.materialPlans[0].id, quantity: 1, unit: "Stk", usageStatus: "fully_used" }));
  await upsertMaterialUsage(tech, materialUpsertPayload.parse({ workOrderId: woId, clientId: randomUUID(), name: "Flachdichtung 1 Zoll", quantity: 2, unit: "Stk", usageStatus: "additional", deviationReason: "Alte Dichtungen porös" }));
  await expectCode(
    () => upsertMaterialUsage(tech, materialUpsertPayload.parse({ workOrderId: woId, clientId: randomUUID(), name: "Ohne Grund", quantity: 1, unit: "Stk", usageStatus: "additional" })),
    "invalid",
    "Zusatzmaterial ohne Begründung → invalid",
  );
  const req = await prisma.photoRequirement.findFirstOrThrow({ where: { workOrderId: woId } });
  const plate = await storeFieldUpload(tech, { clientId: randomUUID(), workOrderId: woId, kind: "photo" }, { bytes: jpeg, name: "typenschild.jpg", type: "image/jpeg" });
  await attachPhoto(tech, photoAttachPayload.parse({ workOrderId: woId, documentId: plate.documentId, phase: "after", photoRequirementId: req.id }));
  await toggleChecklistItem(tech, checklistTogglePayload.parse({ workOrderId: woId, itemId: item.id, checked: true }));

  await expectCode(() => createCompletionReport(tech, { workOrderId: woId }), "blocked", "Abschlussbericht bei laufender Arbeitszeit → blocked");
  const ended = await endSession(tech, sessionControlPayload.parse({ workOrderId: woId }));
  ok(ended.workSeconds > 0 && ended.breakSeconds >= 14 * 60 && ended.travelSeconds >= 29 * 60, `Zeiten berechnet (Arbeit ${Math.round(ended.workSeconds / 60)} min, Pause ${Math.round(ended.breakSeconds / 60)} min, Anfahrt ${Math.round(ended.travelSeconds / 60)} min)`);

  // ---------- 6. Abschlussbericht + Unterschrift ----------
  section("6. Abschlussbericht und Kundenunterschrift");
  const { report } = await createCompletionReport(tech, { workOrderId: woId });
  const content = contentOf(report);
  ok(content.photos.length === 2 && content.materials.used.length === 1 && content.materials.additional.length === 1, "Berichts-Snapshot enthält Fotos und Material (Soll/Ist + Zusatz)");
  ok(content.time.totalMinutes > 0 && content.site?.name === `Wohnanlage ${SLUG_A}`, "Berichts-Snapshot enthält Arbeitszeit und Objekt");
  ok(content.texts.workPerformed.includes("Alte Pumpe demontiert"), "„Ausgeführte Leistungen“ aus den Tätigkeitsnotizen vorbelegt");
  await updateReportTexts(tech, { reportId: report.id, texts: { workPerformed: "" } });
  await expectCode(() => submitReport(tech, { reportId: report.id }), "blocked", "Absenden ohne „Ausgeführte Leistungen“ → blocked");
  await updateReportTexts(tech, { reportId: report.id, texts: { workPerformed: "Heizungspumpe getauscht, Anlage entlüftet und geprüft." } });
  const sigImg = await storeFile(tech, { bytes: await pngBytes(), fileName: "unterschrift.png", declaredMime: "image/png", category: "signature", visibility: "customer_report", links: { workOrderId: woId } });
  await captureSignature(tech, { reportId: report.id, outcome: "signed", signerName: "Frau Prüf", signerRole: "Objektbetreuung", imageDocumentId: sigImg.id, confirmationText: "Arbeiten ordnungsgemäß ausgeführt." });
  await expectCode(() => captureSignature(B.ctx.tech, { reportId: report.id, outcome: "later", reason: "x", confirmationText: "x" }), "not_found", "Mandant B kann keine Unterschrift erfassen");
  await submitReport(tech, { reportId: report.id });
  const afterSubmit = await prisma.workOrder.findUniqueOrThrow({ where: { id: woId } });
  ok(afterSubmit.status === "in_review", "Unterschrift erfasst → Auftrag „Zur Prüfung“");
  ok((await prisma.notification.count({ where: { tenantId: A.tenantId, userId: A.users.lead.id, type: "report.submitted", entityId: report.id } })) === 1, "Teamleiter wird zur Prüfung benachrichtigt");

  // ---------- 7. Freigabe ----------
  section("7. Teamleiter- und Backoffice-Freigabe");
  await expectCode(() => approveReport(tech, { reportId: report.id }, { dispatchPdf: async () => undefined }), "forbidden", "Monteur darf nicht freigeben");
  await expectCode(() => approveReport(B.ctx.backoffice, { reportId: report.id }, { dispatchPdf: async () => undefined }), "not_found", "Mandant B kann nicht freigeben");
  await expectCode(() => releaseForBilling(bo, { workOrderId: woId }), "blocked", "Abrechnung vor Berichtsfreigabe → blocked");
  const teamApproved = await approveReport(A.ctx.lead, { reportId: report.id }, { dispatchPdf: async () => undefined });
  ok(teamApproved.status === "team_approved", "Teamleiter prüft → team_approved");
  const pdfJobs: string[] = [];
  const approved = await approveReport(bo, { reportId: report.id }, { dispatchPdf: async (_c, id) => void pdfJobs.push(id) });
  ok(approved.status === "approved" && pdfJobs[0] === report.id, "Backoffice gibt frei → approved, PDF-Job angestoßen");
  await expectCode(() => updateReportTexts(tech, { reportId: report.id, texts: { workPerformed: "nachträglich geändert" } }), ["conflict", "invalid", "blocked"], "freigegebener Bericht ist unveränderlich");

  // ---------- 8. PDF ----------
  section("8. PDF-Arbeitsnachweis");
  const renderer = await pdfRendererAvailable();
  if (!renderer.ok) {
    console.log(`⚠ PDF-Erzeugung übersprungen: kein Chromium startbar (${renderer.reason})`);
  } else {
    const pdfRes = await generateReportPdf(bo, report.id);
    const stored = await prisma.report.findUniqueOrThrow({ where: { id: report.id } });
    const doc = await prisma.document.findUniqueOrThrow({ where: { id: pdfRes.documentId } });
    ok(!pdfRes.skipped && stored.pdfDocumentId === doc.id && stored.pdfChecksum === doc.checksum, "PDF erzeugt, Prüfsumme am Bericht");
    ok(doc.category === "completion_report" && doc.siteId === A.siteId && doc.workOrderId === woId, "PDF als Abschlussbericht an Auftrag und Objekt abgelegt");
    const bytes = await readStoredBytes(doc.storageKey);
    if (bytes) ok(Buffer.from(bytes).subarray(0, 4).toString() === "%PDF", "Datei beginnt mit %PDF");
    await expectCode(() => openReportFile(B.ctx.backoffice, report.id, "pdf"), "not_found", "Mandant B kann das PDF nicht laden");
    await expectCode(() => authorizeDocumentAccess(A.ctx.outsider, doc.id), "not_found", "fremder Monteur kann das PDF nicht laden");
  }

  // ---------- 9. Abrechnung ----------
  section("9. Abrechnungsfreigabe und abgerechnet");
  await expectCode(() => releaseForBilling(tech, { workOrderId: woId }), "forbidden", "Monteur darf nicht zur Abrechnung freigeben");
  await expectCode(() => releaseForBilling(A.ctx.lead, { workOrderId: woId }), "forbidden", "Teamleiter darf nicht zur Abrechnung freigeben");
  const released = await releaseForBilling(bo, { workOrderId: woId });
  ok(released.status === "released_for_billing", "Auftrag zur Abrechnung freigegeben");
  const billed = await markBilled(bo, { workOrderId: woId });
  ok(billed.status === "billed", "Auftrag abgerechnet");
  ok((await codeOf(transitionWorkOrder(bo, { workOrderId: woId, to: "cancelled", reason: "zu spät" }))) === "invalid", "abgerechneter Auftrag kann nicht storniert werden");

  const history = await prisma.workOrderStatusChange.findMany({ where: { workOrderId: woId }, orderBy: { createdAt: "asc" }, select: { toStatus: true } });
  const path = history.map((h) => h.toStatus).join(">");
  ok(path === "planned>assigned>accepted>en_route>in_progress>paused>in_progress>technically_completed>in_review>released_for_billing>billed", `Statushistorie vollständig (${path})`);
  ok((await prisma.auditLog.count({ where: { tenantId: A.tenantId, entity: "work_order", entityId: woId } })) >= 10, "jede Statusänderung auditiert");
  const woDetail = await getWorkOrderDetail(bo, woId);
  ok(woDetail.id === woId, "Backoffice-Detail lesbar");

  // ---------- 10. Objekt-Historie ----------
  section("10. Einsatz erscheint in der Objekt-Historie");
  const hist = await getSiteHistory(bo, A.siteId);
  const entry = hist.items.find((i) => i.workOrderId === woId);
  ok(!!entry && entry.approvedReports.length === 1 && entry.signed && entry.photoCount === 2, "Historie: freigegebener Bericht, Unterschrift, Fotos");
  ok(!!entry && entry.materials.some((m) => m.name === "Hocheffizienzpumpe 25-60") && entry.workDone.length === 1, "Historie: Material und durchgeführte Arbeiten");
  const techHistory = await getSiteHistory(A.ctx.tech2, A.siteId);
  ok(techHistory.onlyApproved && techHistory.items.some((i) => i.workOrderId === woId), "Teamkollege sieht den freigegebenen Einsatz in der Objekt-Historie");
  await expectCode(() => getSiteHistory(A.ctx.outsider, A.siteId), "not_found", "Monteur ohne Auftrag am Objekt → not_found");
  await expectCode(() => getSiteHistory(B.ctx.backoffice, A.siteId), "not_found", "Mandant B → not_found");
  await expectCode(() => requireVisibleReport(B.ctx.backoffice, report.id), "not_found", "Mandant B kann den Bericht nicht lesen");
});