MOPC-Portal/src/server/services/finalist-confirmation.ts

import type { CompetitionCategory, PrismaClient } from '@prisma/client'
import { signFinalistToken } from '@/lib/finalist-token'
import { sendFinalistConfirmationEmail } from '@/lib/email'

type AnyPrisma = Pick<PrismaClient, 'finalistConfirmation' | 'waitlistEntry' | 'project'>

/**
 * Create a PENDING FinalistConfirmation row with a signed token. Caller is
 * responsible for sending the notification email separately.
 */
export async function createPendingConfirmation(
  prisma: Pick<PrismaClient, 'finalistConfirmation'>,
  args: {
    projectId: string
    category: CompetitionCategory
    windowHours: number
    promotedFromWaitlistEntryId?: string
  },
): Promise<{ id: string; token: string; deadline: Date }> {
  const deadline = new Date(Date.now() + args.windowHours * 3_600_000)
  // Generate the row ID up front so we can sign it into the token before
  // writing the row (token is unique-indexed; embedding the ID gives the
  // public verify path a stable lookup key).
  const id = `cmfc_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`
  const token = signFinalistToken({
    confirmationId: id,
    exp: Math.floor(deadline.getTime() / 1000),
  })
  await prisma.finalistConfirmation.create({
    data: {
      id,
      projectId: args.projectId,
      category: args.category,
      status: 'PENDING',
      deadline,
      token,
      promotedFromWaitlistEntryId: args.promotedFromWaitlistEntryId ?? null,
    },
  })
  return { id, token, deadline }
}

/**
 * Promote the lowest-ranked WAITING waitlist entry in the given category to
 * PROMOTED, create a fresh PENDING confirmation for the project, and send
 * the notification email. No-op if no WAITING entry exists.
 */
export async function promoteNextWaitlistEntry(
  prisma: AnyPrisma,
  args: { programId: string; category: CompetitionCategory; windowHours: number },
): Promise<{ promoted: boolean; entryId?: string; confirmationId?: string }> {
  const entry = await prisma.waitlistEntry.findFirst({
    where: {
      programId: args.programId,
      category: args.category,
      status: 'WAITING',
    },
    orderBy: { rank: 'asc' },
  })
  if (!entry) return { promoted: false }

  await prisma.waitlistEntry.update({
    where: { id: entry.id },
    data: { status: 'PROMOTED' },
  })

  const { id: confirmationId, token, deadline } = await createPendingConfirmation(prisma, {
    projectId: entry.projectId,
    category: args.category,
    windowHours: args.windowHours,
    promotedFromWaitlistEntryId: entry.id,
  })

  // Send email — log and continue on failure.
  const project = await prisma.project.findUnique({
    where: { id: entry.projectId },
    select: {
      title: true,
      teamMembers: {
        where: { role: 'LEAD' },
        take: 1,
        select: { user: { select: { email: true, name: true } } },
      },
    },
  })
  const lead = project?.teamMembers[0]?.user
  if (lead?.email && project) {
    const baseUrl = (process.env.NEXTAUTH_URL ?? 'http://localhost:3000').replace(/\/$/, '')
    const confirmUrl = `${baseUrl}/finalist/confirm/${token}`
    try {
      await sendFinalistConfirmationEmail(
        lead.email,
        lead.name ?? null,
        project.title,
        deadline,
        confirmUrl,
      )
    } catch (err) {
      console.error(
        `[promoteNextWaitlistEntry] failed to send email for project ${entry.projectId}:`,
        err,
      )
    }
  }

  return { promoted: true, entryId: entry.id, confirmationId }
}