Simone Educação Digital

/** Usuário existe e não está bloqueado/excluído? (choke point de bloqueio) */
async function isUserActive(userId: string): Promise<boolean> {
  const u = await prisma.user.findUnique({
    where: { id: userId },
    select: { blockedAt: true, deletedAt: true },
  });
  return Boolean(u && !u.blockedAt && !u.deletedAt);
}

/** Existe entitlement ativo que cobre este módulo (Course)? */
export async function hasCourseEntitlement(
  userId: string,
  courseId: string,
): Promise<boolean> {
  if (!(await isUserActive(userId))) return false;
  const now = new Date();
  const found = await prisma.entitlement.findFirst({
    where: {
      userId,
      expiresAt: { gt: now },
      purchase: { status: 'PAID', accessSuspended: false },
      OR: [{ scope: "ALL" }, { scope: "COURSE", courseId }],
    },
    select: { id: true },
  });
  return Boolean(found);
}

export async function POST(req: Request): Promise<NextResponse> {
  const secret = process.env.STRIPE_WEBHOOK_SECRET;
  if (!secret) return NextResponse.json({ error: "not_configured" }, { status: 503 });
  const signature = req.headers.get("stripe-signature");
  if (!signature) return NextResponse.json({ error: "no_signature" }, { status: 400 });
  const rawBody = await req.text();
  if (Buffer.byteLength(rawBody) > 1_048_576) return NextResponse.json({ error: "too_large" }, { status: 413 });
  let event: Stripe.Event;
  try { event = getStripe().webhooks.constructEvent(rawBody, signature, secret); }
  catch { return NextResponse.json({ error: "invalid_signature" }, { status: 400 }); }
  // ... despacha pelo tipo do evento
}

// Na confirmação da compra, depois de conferir valor, moeda e preço com o pedido:
await prisma.$transaction(async tx => {
  await tx.$queryRaw`SELECT pg_advisory_xact_lock(hashtextextended(${"payment:" + paymentId}, 0))::text`;
  const current = await tx.purchase.findUniqueOrThrow({ where: { id: purchaseId } });
  if (current.status !== "PENDING") return;
  // ... marca como paga e materializa os direitos de acesso
});

/**
 * Envia um e-mail transacional. À PROVA DE FALHA por design: nunca lança.
 * Se a key não existe ou o Resend falha, loga e retorna { ok: false } — assim
 * um e-mail quebrado JAMAIS derruba o fluxo que o disparou (signup, compra…).
 */
export async function sendEmail(params: {
  to: string;
  subject: string;
  html: string;
  replyTo?: string;
  idempotencyKey?: string;
}): Promise<SendResult> {
  const resend = getResend();
  if (!resend) {
    // ... registra o aviso
    return { ok: false, skipped: true };
  }

  try {
    const { data, error } = await resend.emails.send({
      from: FROM_EMAIL,
      to: params.to,
      subject: params.subject,
      html: params.html,
      replyTo: params.replyTo ?? REPLY_TO,
    }, params.idempotencyKey ? { idempotencyKey: params.idempotencyKey } : undefined);

    if (error) {
      // ... registra a recusa
      return { ok: false, error: error.message ?? String(error) };
    }
    return { ok: true, id: data?.id };
  } catch (err) {
    // ... registra a exceção
    return {
      ok: false,
      error: err instanceof Error ? err.message : "erro desconhecido",
    };
  }
}