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) : "";
    })(),
    // Personalsystem-Ergänzung (25.09.2026): Urlaubs-Kontingent jetzt als
    // Standardwert vorhanden (Client.vacationDaysPerYear), siehe Urlaubssystem.
    urlaubstage: c.vacationDaysPerYear != null ? `${c.vacationDaysPerYear} Tage` : "",
  }));

  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), <code>{"{{geburtsdatum}}"}</code>, <code>{"{{probezeit}}"}</code>, <code>{"{{stundenlohn}}"}</code>,{" "}
          <code>{"{{gehalt}}"}</code> und <code>{"{{urlaubstage}}"}</code> (jeweils 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. Kündigungsfrist — jede Vorlage hat eigene) kennt das System nicht
          automatisch. Sobald du unten eine Vorlage auswählst, zeigt dir ein Kasten direkt über dem Dokumenttext genau,
          welche Platzhalter automatisch ausgefüllt wurden und für welche noch ein eigenes Eingabefeld erscheint —
          ausfüllen genügt, der Dokumenttext darunter übernimmt die Werte automatisch (bleibt trotzdem frei
          bearbeitbar).
        </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>
  );
}