import { redirect } from "next/navigation";
import { isAdminSession, getAllPermissions } from "@/lib/adminAuth";
import { connectDB } from "@/lib/db";
import { DocumentTemplate } from "@/models/DocumentTemplate";
import { GeneratedDocument } from "@/models/GeneratedDocument";
import { Client } from "@/models/Client";
import { Department } from "@/models/Department";
import { Position } from "@/models/Position";
import { AdminNavLinks } from "@/components/admin/AdminNavLinks";
import { AdminPageHeader } from "@/components/admin/AdminPageHeader";
import { AdminEmptyState } from "@/components/admin/AdminEmptyState";
import { NewTemplateForm } from "@/components/admin/NewTemplateForm";
import { TemplateRow } from "@/components/admin/TemplateRow";
import { GenerateDocumentPanel } from "@/components/admin/GenerateDocumentPanel";
import { GeneratedDocumentRow } from "@/components/admin/GeneratedDocumentRow";
import { DOCUMENT_CATEGORIES, DOCUMENT_CATEGORY_LABELS, documentCategoryPermission, type DocumentCategory } from "@/lib/documentConstants";
import { formatDateDE, formatDateTimeDE, formatEUR } from "@/lib/orderConstants";

export const dynamic = "force-dynamic";

function Section({ title, subtitle, children }: { title: string; subtitle?: string; children: React.ReactNode }) {
  return (
    <section className="mb-12">
      <h2 className="text-sm font-medium text-[var(--rk-ink)] mb-1">{title}</h2>
      {subtitle && <p className="text-xs text-[var(--rk-ink-muted)] mb-4">{subtitle}</p>}
      {children}
    </section>
  );
}

export default async function AdminDocumentsPage() {
  if (!(await isAdminSession())) redirect("/de/login?next=%2Fde%2Fadmin%2Forders");
  const permissions = await getAllPermissions();
  const visibleCategories = DOCUMENT_CATEGORIES.filter((cat) => permissions[documentCategoryPermission(cat, "view")]);
  if (visibleCategories.length === 0) redirect("/de/account");

  await connectDB();
  const [templatesAll, generatedAll, staff, departments, positions] = await Promise.all([
    DocumentTemplate.find({}).sort({ sortOrder: 1 }).lean(),
    GeneratedDocument.find({}).sort({ createdAt: -1 }).limit(200).lean(),
    Client.find({ role: "staff" }).sort({ name: 1 }).lean(),
    Department.find({}).lean(),
    Position.find({}).lean(),
  ]);

  // Nicht jede Position soll jedes fertige Dokument sehen — z. B. Arbeitsverträge
  // nur die Personalabteilung. Vorlagen und erstellte Dokumente werden auf die
  // Kategorien gefiltert, für die die aktuelle Person Zugriff hat.
  const visibleSet = new Set<DocumentCategory>(visibleCategories);
  const templates = templatesAll.filter((t) => visibleSet.has(t.category));
  const generated = generatedAll.filter((g) => visibleSet.has(g.category));

  const departmentById = new Map(departments.map((d) => [String(d._id), d]));
  const positionById = new Map(positions.map((p) => [String(p._id), p]));

  const clientOptions = staff.map((c) => ({
    id: String(c._id),
    name: c.name,
    email: c.email,
    departmentName: c.departmentId ? departmentById.get(String(c.departmentId))?.name ?? "" : "",
    positionName: c.positionId ? positionById.get(String(c.positionId))?.name ?? "" : "",
    address: c.address || "",
    employmentStartDate: (() => {
      const dates = (c.employmentRecords || []).map((r) => new Date(r.startDate).getTime());
      return dates.length ? formatDateDE(new Date(Math.min(...dates))) : "";
    })(),
    birthDate: c.birthDate ? formatDateDE(new Date(c.birthDate)) : "",
    // Letzter Eintrag = aktuell gültiger Beschäftigungs-Datensatz (siehe
    // Client.ts) - {{probezeit}} blieb bisher immer als Platzhalter stehen,
    // obwohl probationMonths längst gepflegt wird (Fund vom Nutzer,
    // 24.09.2026).
    probezeit: (() => {
      const records = c.employmentRecords || [];
      const months = records[records.length - 1]?.probationMonths;
      return months ? `${months} ${months === 1 ? "Monat" : "Monate"}` : "";
    })(),
    // Personalsystem Phase 3 (24.09.2026): eigener Wert > Positions-Standard >
    // Abteilungs-Standard, siehe lib/salary.ts getEffectiveHourlyWage (hier
    // ohne extra DB-Aufrufe inline nachgebildet, departmentById/positionById
    // sind oben schon vollständig geladen).
    stundenlohn: (() => {
      const position = c.positionId ? positionById.get(String(c.positionId)) : null;
      const department = c.departmentId ? departmentById.get(String(c.departmentId)) : null;
      const wage = c.hourlyWage ?? position?.defaultHourlyWage ?? department?.defaultHourlyWage ?? null;
      return wage != null ? `${wage.toLocaleString("de-DE")} €` : "";
    })(),
    gehalt: (() => {
      const position = c.positionId ? positionById.get(String(c.positionId)) : null;
      const department = c.departmentId ? departmentById.get(String(c.departmentId)) : null;
      const wage = c.hourlyWage ?? position?.defaultHourlyWage ?? department?.defaultHourlyWage ?? null;
      return wage != null && c.monthlyHours != null ? formatEUR(Math.round(wage * c.monthlyHours * 100) / 100) : "";
    })(),
  }));

  const templateOptions = templates.map((t) => ({
    id: String(t._id),
    name: t.name,
    category: t.category,
    body: t.body,
    defaultIncludeLetterhead: t.defaultIncludeLetterhead,
    defaultIncludeFooter: t.defaultIncludeFooter,
    defaultFooterText: t.defaultFooterText,
    defaultIncludeRecipientAddress: t.defaultIncludeRecipientAddress,
  }));

  const generatedByCategory = new Map<DocumentCategory, typeof generated>();
  for (const cat of visibleCategories) generatedByCategory.set(cat, []);
  for (const g of generated) generatedByCategory.get(g.category)?.push(g);

  return (
    <main className="px-6 pt-4 pb-24 max-w-5xl mx-auto">
      <AdminNavLinks permissions={permissions} />
      <AdminPageHeader
        title="Dokumente"
        subtitle="Gemeinsame Vorlagen-Engine für Arbeitsverträge, Arbeitszeugnisse, Ausbildungsdokumente, QM-Dokumente und mehr. Du siehst nur die Kategorien, für die du berechtigt bist — Arbeitsverträge/Zeugnisse z. B. nur mit Personal-Berechtigung. Der Dokumenttext ist beim Erstellen und danach jederzeit frei bearbeitbar, unabhängig von der Vorlage."
      />

      <div className="mb-12 rounded-2xl border border-white/10 bg-[var(--rk-surface)] p-5 text-sm leading-relaxed text-[var(--rk-ink-muted)]">
        <p className="text-[var(--rk-ink)] font-medium mb-2">So funktionieren Platzhalter</p>
        <p>
          Ein Vorlagentext enthält Platzhalter in doppelten geschweiften Klammern, z. B. <code>{"{{name}}"}</code>. Ein
          Teil davon wird automatisch aus dem Mitarbeiterprofil ausgefüllt, sobald oben ein Mitarbeiter ausgewählt
          ist: <code>{"{{name}}"}</code>, <code>{"{{email}}"}</code>, <code>{"{{department}}"}</code>,{" "}
          <code>{"{{position}}"}</code>, <code>{"{{address}}"}</code>, <code>{"{{startDate}}"}</code> (Beschäftigt
          seit) und <code>{"{{geburtsdatum}}"}</code> (aus der Personalakte, falls dort hinterlegt).{" "}
          <code>{"{{ausstellungsdatum}}"}</code> wird immer automatisch mit dem heutigen Datum ausgefüllt.
        </p>
        <p className="mt-2">
          Alle anderen Platzhalter (z. B. Gehalt, Kündigungsfrist, Urlaubstage — jede Vorlage hat eigene) kennt das
          System nicht automatisch und lässt sie absichtlich stehen, statt sie leer zu lassen — sie fallen so im
          Text auf. Sobald du unten eine Vorlage auswählst, zeigt dir ein Kasten direkt über dem Dokumenttext genau,
          welche Platzhalter in dieser Vorlage automatisch ausgefüllt wurden und welche du noch von Hand ergänzen
          musst, inklusive kurzer Erklärung, wofür jeder steht.
        </p>
        <p className="mt-2">
          Ein Platzhalter, der beim Erstellen nicht ersetzt wurde, erscheint unverändert im fertigen PDF (z. B.{" "}
          <code>{"{{gehalt}}"}</code>) — das ist kein Fehler, sondern der Hinweis, dass dort noch etwas fehlt.
        </p>
      </div>

      <Section title="Dokument erstellen">
        <GenerateDocumentPanel templates={templateOptions} clients={clientOptions} allowedCategories={visibleCategories} />
      </Section>

      <Section title="Vorlagen" subtitle="Startpunkt für neue Dokumente — Änderungen wirken nicht rückwirkend auf bereits erstellte Dokumente.">
        <NewTemplateForm allowedCategories={visibleCategories} />
        <div className="flex flex-col gap-3">
          {templates.map((t) => (
            <TemplateRow
              key={String(t._id)}
              template={{
                id: String(t._id),
                name: t.name,
                category: t.category,
                body: t.body,
                defaultIncludeLetterhead: t.defaultIncludeLetterhead,
                defaultIncludeFooter: t.defaultIncludeFooter,
                defaultFooterText: t.defaultFooterText,
                defaultIncludeRecipientAddress: t.defaultIncludeRecipientAddress,
              }}
              allowedCategories={visibleCategories}
            />
          ))}
          {templates.length === 0 && <AdminEmptyState message="Noch keine Vorlagen in deinen Kategorien angelegt." />}
        </div>
      </Section>

      <Section title="Erstellte Dokumente" subtitle="Nach Kategorie sortiert, neueste zuerst.">
        {generated.length === 0 ? (
          <AdminEmptyState message="Noch keine Dokumente erstellt." />
        ) : (
          <div className="flex flex-col gap-8">
            {visibleCategories.map((cat) => {
              const docs = generatedByCategory.get(cat) ?? [];
              if (docs.length === 0) return null;
              return (
                <div key={cat}>
                  <h3 className="text-xs uppercase tracking-[0.1em] text-[var(--rk-ink-muted)] mb-2">
                    {DOCUMENT_CATEGORY_LABELS[cat]} <span className="opacity-60">({docs.length})</span>
                  </h3>
                  <div className="flex flex-col gap-2">
                    {docs.map((g) => (
                      <GeneratedDocumentRow
                        key={String(g._id)}
                        document={{
                          id: String(g._id),
                          templateName: g.templateName,
                          category: g.category,
                          clientName: g.clientName,
                          renderedBody: g.renderedBody,
                          includeLetterhead: g.includeLetterhead,
                          includeFooter: g.includeFooter,
                          footerText: g.footerText,
                          includeRecipientAddress: g.includeRecipientAddress,
                          recipientAddress: g.recipientAddress,
                          createdAt: formatDateTimeDE(new Date(g.createdAt)),
                          signature: g.signature
                            ? { name: g.signature.name, signedAt: new Date(g.signature.signedAt).toISOString(), ip: g.signature.ip }
                            : null,
                        }}
                        allowedCategories={visibleCategories}
                      />
                    ))}
                  </div>
                </div>
              );
            })}
          </div>
        )}
      </Section>
    </main>
  );
}