'use server'

import { revalidatePath } from 'next/cache'
import { z } from 'zod'
import { requireUser } from '@/lib/auth/current'
import { AccessError } from '@/lib/errors'
import { createLadder, deleteLadder, setLadderRoles, updateLadder } from '@/lib/roles/ladders'
import { de } from '@/lib/i18n/de'

export type ActionResult = { ok: true } | { ok: false; error: string }

function toMessage(error: unknown): string {
  if (error instanceof AccessError) {
    return de.actionErrors[error.code] ?? de.actionErrors.default!
  }
  console.error('[ranggefuege] unerwartet', error)
  return de.actionErrors.default!
}

/**
 * Die Prüfung steht im Dienst, nicht hier und nicht in der Oberfläche: eine
 * Server Action ist ein Endpunkt und direkt aufrufbar, egal was das UI zeigt.
 */
function aktualisieren(): void {
  revalidatePath('/admin/ranggefuege')
  revalidatePath('/admin/rollen')
}

const createSchema = z.object({
  name: z.string().min(1).max(80),
  note: z.string().max(300).optional(),
})

export async function createLadderAction(
  _prev: ActionResult | null,
  formData: FormData,
): Promise<ActionResult> {
  const user = await requireUser()
  const parsed = createSchema.safeParse(Object.fromEntries(formData))
  if (!parsed.success) return { ok: false, error: de.ladderAdmin.nameInvalid }

  try {
    await createLadder(user.permissions, parsed.data)
    aktualisieren()
    return { ok: true }
  } catch (error) {
    return { ok: false, error: toMessage(error) }
  }
}

const updateSchema = z.object({
  id: z.string().min(1),
  name: z.string().min(1).max(80),
  note: z.string().max(300).optional(),
})

export async function updateLadderAction(
  _prev: ActionResult | null,
  formData: FormData,
): Promise<ActionResult> {
  const user = await requireUser()
  const parsed = updateSchema.safeParse(Object.fromEntries(formData))
  if (!parsed.success) return { ok: false, error: de.ladderAdmin.nameInvalid }

  try {
    await updateLadder(user.permissions, parsed.data)
    aktualisieren()
    return { ok: true }
  } catch (error) {
    return { ok: false, error: toMessage(error) }
  }
}

export async function deleteLadderAction(id: string): Promise<ActionResult> {
  const user = await requireUser()
  try {
    await deleteLadder(user.permissions, id)
    aktualisieren()
    return { ok: true }
  } catch (error) {
    return { ok: false, error: toMessage(error) }
  }
}

const orderSchema = z.object({
  id: z.string().min(1),
  roleIds: z.array(z.string().min(1)).max(30),
})

export async function setLadderRolesAction(input: unknown): Promise<ActionResult> {
  const user = await requireUser()
  const parsed = orderSchema.safeParse(input)
  if (!parsed.success) return { ok: false, error: de.actionErrors.default! }

  try {
    await setLadderRoles(user.permissions, parsed.data)
    aktualisieren()
    return { ok: true }
  } catch (error) {
    return { ok: false, error: toMessage(error) }
  }
}