ita-ito-horaires/app/admin/vacances/actions.ts

'use server';

import { revalidatePath } from 'next/cache';

import { diffOf, recordAudit } from '@/lib/audit';
import { requireAdmin } from '@/lib/auth/actions';
import { prisma } from '@/lib/db';
import type { CivilDate } from '@/lib/schedule/civil';
import { countDays, findOverlap, validatePeriod } from '@/lib/schedule/vacations';
import { translateToEnglish } from '@/lib/translation/service';

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

export async function createVacation(input: {
  startDate: CivilDate;
  endDate: CivilDate;
  labelFr: string;
  // Returns the new id so the caller can translate it without having to ask
  // which row was "the last one", which would be a race.
}): Promise<{ ok: true; id: string } | { ok: false; error: string }> {
  const gate = await requireAdmin();
  if (!gate.ok) {
    return { ok: false, error: gate.error };
  }

  const labelFr = input.labelFr.trim();
  const problems = validatePeriod({ ...input, labelFr });
  if (problems.length > 0) {
    return { ok: false, error: problems.join(' ') };
  }

  // Two periods covering the same day would both be in effect with no way to
  // say which; refuse rather than merge silently.
  const existing = await prisma.vacationPeriod.findMany();
  const clash = findOverlap(
    { startDate: input.startDate, endDate: input.endDate },
    existing.map((period) => ({
      id: period.id,
      labelFr: period.labelFr,
      startDate: asCivil(period.startDate),
      endDate: asCivil(period.endDate),
    })),
  );
  if (clash) {
    return {
      ok: false,
      error: `Cette période chevauche « ${clash.labelFr} » (${clash.startDate} au ${clash.endDate}).`,
    };
  }

  // A phrase saved as a template is already translated; reusing it is instant
  // where the service takes seconds. The label reaches the panel during the
  // closure, so it needs its English.
  const fromTemplate = await prisma.messageTemplate.findUnique({ where: { textFr: labelFr } });

  const created = await prisma.vacationPeriod.create({
    data: {
      startDate: asDate(input.startDate),
      endDate: asDate(input.endDate),
      labelFr,
      labelEn: fromTemplate?.textEn ?? null,
      createdBy: gate.value.email,
    },
  });

  await recordAudit({
    userEmail: gate.value.email,
    action: 'vacation.create',
    entity: 'VacationPeriod',
    entityId: created.id,
    diff: diffOf(null, {
      libellé: labelFr,
      du: input.startDate,
      au: input.endDate,
      jours: countDays(input),
    }),
  });

  revalidateAll();
  return { ok: true, id: created.id };
}

export async function deleteVacation(id: string): Promise<ActionResult> {
  const gate = await requireAdmin();
  if (!gate.ok) {
    return { ok: false, error: gate.error };
  }

  const existing = await prisma.vacationPeriod.findUnique({ where: { id } });
  if (!existing) {
    return { ok: false, error: 'Cette période a déjà été supprimée.' };
  }

  await prisma.vacationPeriod.delete({ where: { id } });

  await recordAudit({
    userEmail: gate.value.email,
    action: 'vacation.delete',
    entity: 'VacationPeriod',
    entityId: id,
    diff: diffOf(
      {
        libellé: existing.labelFr,
        du: asCivil(existing.startDate),
        au: asCivil(existing.endDate),
      },
      null,
    ),
  });

  revalidateAll();
  return { ok: true };
}

function asCivil(value: Date): CivilDate {
  return value.toISOString().slice(0, 10);
}

function asDate(value: CivilDate): Date {
  return new Date(`${value}T00:00:00.000Z`);
}

function revalidateAll(): void {
  revalidatePath('/admin');
  revalidatePath('/admin/vacances');
  revalidatePath('/admin/exceptions');
}

/**
 * Translates a period's label, if it still needs one.
 *
 * Separate from the creation, so a slow translation service never costs the
 * shop its holiday dates. A failure leaves the French alone on screen.
 */
export async function translateVacationLabel(id: string): Promise<ActionResult> {
  const gate = await requireAdmin();
  if (!gate.ok) {
    return { ok: false, error: gate.error };
  }

  const existing = await prisma.vacationPeriod.findUnique({ where: { id } });
  if (!existing || existing.labelEn) {
    return { ok: true };
  }

  const outcome = await translateToEnglish(existing.labelFr);
  if (!outcome.ok) {
    return { ok: false, error: outcome.error };
  }

  await prisma.vacationPeriod.update({ where: { id }, data: { labelEn: outcome.text } });
  revalidateAll();
  return { ok: true };
}