'use server'

import { revalidatePath } from 'next/cache'
import { z } from 'zod'
import { requireUser } from '@/lib/auth/current'
import { AccessError, ConflictError } from '@/lib/errors'
import { saveSection } from '@/lib/cases/sectionService'
import { de } from '@/lib/i18n/de'
import type { SaveSectionResult, SaveSectionsInput } from '@/components/sections/types'

const schema = z.object({
  fieldKey: z.string().min(1),
  value: z.unknown(),
  baseVersion: z.coerce.number().int().min(0),
  minClearance: z.coerce.number().int().min(0).max(5).optional(),
})

/** Die Akte kommt gebunden herein, siehe `saveSectionAction.bind`. */
export async function saveSectionAction(
  caseNumber: string,
  input: unknown,
): Promise<SaveSectionResult> {
  const user = await requireUser()
  const parsed = schema.safeParse(input)
  if (!parsed.success) return { ok: false, conflict: false, error: de.actionErrors.default! }

  try {
    const { version } = await saveSection(user.permissions, { caseNumber, ...parsed.data })
    revalidatePath(`/faelle/${caseNumber}`)
    return { ok: true, version }
  } catch (error) {
    if (error instanceof ConflictError) {
      return {
        ok: false,
        conflict: true,
        current: { value: error.current.value, version: error.current.version },
      }
    }
    if (error instanceof AccessError) {
      return {
        ok: false,
        conflict: false,
        error: de.actionErrors[error.code] ?? de.actionErrors.default!,
      }
    }
    console.error('[abschnitt] unerwartet', error)
    return { ok: false, conflict: false, error: de.actionErrors.default! }
  }
}

/**
 * Mehrere Abschnitte in einem Zug.
 *
 * Jedes Feld wird einzeln geschrieben und einzeln beantwortet — Abschnitte
 * sind einzeln versioniert, und ein zwischenzeitlich geändertes Feld soll die
 * übrigen nicht aufhalten. Wäre das eine Transaktion, blockierte ein einziger
 * fremder Eingriff das ganze Blatt.
 */
export async function saveSectionsAction(
  caseNumber: string,
  input: unknown,
): Promise<Record<string, SaveSectionResult>> {
  const parsed = batchSchema.safeParse(input)
  if (!parsed.success) return {}

  const ergebnisse: Record<string, SaveSectionResult> = {}
  for (const feld of parsed.data as SaveSectionsInput) {
    ergebnisse[feld.fieldKey] = await saveSectionAction(caseNumber, feld)
  }
  return ergebnisse
}

const batchSchema = z.array(schema).max(200)