"use server";

import { revalidatePath } from "next/cache";
import { currentUserId } from "@/lib/auth/session";
import { withUser } from "@/lib/db";
import type { ActionResult } from "@/lib/db/rpc";

export async function saveHireDraft(payload: {
  id?: string;
  step: number;
  data: Record<string, unknown>;
}): Promise<ActionResult & { id?: string }> {
  const userId = await currentUserId();
  if (!userId) return { success: false, error: "Nicht angemeldet." };

  try {
    const id = await withUser(userId, async (tx) => {
      if (payload.id) {
        // Ob die Zeile der aufrufenden Person gehört, entscheidet die Regel
        // hire_drafts_update — nicht eine Prüfung hier.
        //
        // Die Zahl der geänderten Zeilen wird trotzdem gelesen, und zwar
        // seit fremde Entwürfe sichtbar sind: eine Regel weist ein UPDATE
        // nicht mit einem Fehler ab, sie lässt es ins Leere laufen. Ohne
        // diese Prüfung meldete die Anwendung „gespeichert", und gespeichert
        // wäre nichts.
        const ergebnis = await tx
          .updateTable("hire_drafts")
          .set({ step: payload.step, payload: payload.data, updated_at: new Date().toISOString() })
          .where("id", "=", payload.id)
          .executeTakeFirst();
        if (ergebnis.numUpdatedRows === 0n) {
          throw new Error("Der Entwurf liess sich nicht speichern: er gehört jemand anderem oder wurde inzwischen gelöscht.");
        }
        return payload.id;
      }

      const row = await tx
        .insertInto("hire_drafts")
        .values({ created_by: userId, step: payload.step, payload: payload.data })
        .returning("id")
        .executeTakeFirstOrThrow();
      return row.id;
    });

    revalidatePath("/");
    return { success: true, id };
  } catch (err) {
    return { success: false, error: err instanceof Error ? err.message : "Unbekannter Fehler." };
  }
}

export async function deleteHireDraft(id: string): Promise<ActionResult> {
  try {
    // Auch hier die Zeilenzahl: die Regel hire_drafts_delete lässt ein
    // fremdes Löschen leer laufen statt es abzuweisen. „Entwurf gelöscht"
    // über einem Entwurf, der noch dasteht, wäre die schlechtere Auskunft.
    await withUser(await currentUserId(), async (tx) => {
      const ergebnis = await tx.deleteFrom("hire_drafts").where("id", "=", id).executeTakeFirst();
      if (ergebnis.numDeletedRows === 0n) {
        throw new Error("Der Entwurf liess sich nicht löschen: er gehört jemand anderem oder war schon weg.");
      }
    });
    revalidatePath("/");
    return { success: true };
  } catch (err) {
    return { success: false, error: err instanceof Error ? err.message : "Unbekannter Fehler." };
  }
}