import { prisma } from "@/lib/db";
import {
  offeneEntfernungen,
  widerrufGesperrt,
  zielkontoKandidaten,
  type OffeneEntfernung,
  type ZielkontoKandidat,
} from "@/server/services/widerruf";

/**
 * Was ein Widerruf bewirkt (#024) – fuer den Bestaetigungsdialog, die Massenwiderruf-Seite und
 * die Fortsetzen-Ansicht. Nur Namen, Ziele und Pfade; nie Schluesselinhalte.
 */
export type WiderrufSchluessel = {
  readonly id: string;
  readonly name: string;
  readonly kategorie: "PERSON" | "DIENST" | "DEPLOYMENT";
  readonly status: "AKTIV" | "ROTIERT" | "WIDERRUFEN" | "ABGELAUFEN";
  readonly eingeleitet: boolean;
  readonly person: string | null;
  readonly gesperrt: string | null;
};

export type WiderrufZiel = {
  readonly id: string;
  readonly schluesselId: string;
  readonly ziel: string;
  readonly archiviert: boolean;
};

export type WiderrufPrivatZiel = WiderrufZiel & {
  readonly pfad: string;
  readonly alias: string | null;
  readonly beimWiderruf: "LOESCHEN" | "UMBENENNEN";
};

export type WiderrufUebersicht = {
  readonly schluessel: WiderrufSchluessel[];
  readonly public: WiderrufZiel[];
  readonly privat: WiderrufPrivatZiel[];
  readonly zielkonten: ZielkontoKandidat[];
  readonly offen: OffeneEntfernung[];
};

export async function widerrufUebersicht(schluesselIds: readonly string[]): Promise<WiderrufUebersicht> {
  const ids = [...new Set(schluesselIds)];
  const schluessel = await prisma.schluessel.findMany({
    where: { id: { in: ids } },
    select: {
      id: true,
      name: true,
      kategorie: true,
      status: true,
      widerrufEingeleitetAm: true,
      person: { select: { name: true } },
    },
    orderBy: { name: "asc" },
  });
  const [oeffentlich, privat, zielkonten, offen] = await Promise.all([
    prisma.publicVerwendung.findMany({
      where: { schluesselId: { in: ids }, zustand: { not: "ENTFERNT" } },
      select: {
        id: true,
        schluesselId: true,
        zielbenutzer: true,
        host: { select: { name: true, archiviertAm: true } },
        hostgruppe: { select: { name: true } },
      },
      orderBy: { angelegtAm: "asc" },
    }),
    prisma.privateVerwendung.findMany({
      where: { schluesselId: { in: ids }, zustand: { not: "ENTFERNT" } },
      select: {
        id: true,
        schluesselId: true,
        zielbenutzer: true,
        pfad: true,
        sshConfig: true,
        beimWiderruf: true,
        host: { select: { name: true, archiviertAm: true } },
      },
      orderBy: { angelegtAm: "asc" },
    }),
    zielkontoKandidaten(ids),
    offeneEntfernungen(ids),
  ]);
  return {
    schluessel: schluessel.map((s) => ({
      id: s.id,
      name: s.name,
      kategorie: s.kategorie,
      status: s.status,
      eingeleitet: Boolean(s.widerrufEingeleitetAm),
      person: s.person?.name ?? null,
      gesperrt: widerrufGesperrt(s),
    })),
    public: oeffentlich.map((v) => ({
      id: v.id,
      schluesselId: v.schluesselId,
      ziel: v.host
        ? `${v.zielbenutzer}@${v.host.name}`
        : `${v.zielbenutzer}@${v.hostgruppe?.name ?? "?"} (Gruppe)`,
      archiviert: Boolean(v.host?.archiviertAm),
    })),
    privat: privat.map((v) => {
      const config =
        v.sshConfig && typeof v.sshConfig === "object" ? (v.sshConfig as { alias?: unknown }) : null;
      return {
        id: v.id,
        schluesselId: v.schluesselId,
        ziel: `${v.zielbenutzer}@${v.host.name}`,
        pfad: v.pfad,
        alias: typeof config?.alias === "string" ? config.alias : null,
        beimWiderruf: v.beimWiderruf,
        archiviert: Boolean(v.host.archiviertAm),
      };
    }),
    zielkonten,
    offen,
  };
}