import { Prisma } from '@prisma/client';

type Tx = Prisma.TransactionClient;

/**
 * Locks transaccionales (`pg_advisory_xact_lock`) de Órdenes de compra: una sola definición de las claves para
 * `ordenes-compra.service`, `compras.service` (Facturas) y `recepciones-compra.service`.
 *
 * ORDEN DE TOMA (para no crear ciclos de deadlock), siempre de arriba hacia abajo y nunca al revés:
 *   oc: -> rec: -> req: -> imp: -> imp-num: -> req-num: -> oc-num: -> rep-num:
 *   1. `oc:<orden_compra_id>`: si hace falta más de una OC (factura que cambia de OC), sin repetidos y en orden
 *      ascendente de id (`bloquearOrdenesCompra`).
 *   2. `rec:<recepcion_id>`: editar y anular una recepción existente, siempre después del `oc:` de su OC.
 *   3. `req:<requisicion_id>`: alta y edición de una OC con requisición, generar OC desde una requisición, factura y
 *      gasto con requisición, y las acciones de la requisición (editar, enviar, aprobar, rechazar, cancelar).
 *   4. `req-num:<empresa_id>`: el número del alta de requisición.
 *   5. Numeración de OC: el `FOR UPDATE` de la fila 401 de `numeraciones_documento` de la sucursal o, sin esa fila,
 *      `oc-num:<empresa_id>` (el número de respaldo). Solo lo toma el alta de OC (`crearEnTx`), siempre después de `req:`.
 *   6. `rep-num:<empresa_id>`: el número `REP-` del alta de recepción, al final (después del `oc:`).
 *   Importaciones (`src/importaciones/bloqueos-imp.ts`) se intercala así: `imp:<embarque_id>` va después de `oc:`, `rec:` y
 *   `req:` y antes de cualquier numeración; `imp-num:<empresa_id>` (número del alta de embarque) va enseguida de `imp:` y antes
 *   de `req-num:`, `oc-num:` y `rep-num:`. La numeración de OP y las filas `FOR UPDATE` de CxP se toman siempre después de
 *   `imp:`. Facturas y Gastos toman `imp:` al convertir o tocar un componente de importación, antes de leer el componente.
 * Editar / anular una recepción: leerla sin lock, tomar `bloquearOrdenCompra` si tiene OC, luego `bloquearRecepcion`
 * y releerla bajo el lock.
 *
 * Quién toma qué:
 *   - OC editar / aprobar / cancelar: `oc:` → (`req:` al editar con requisición).
 *   - OC alta (`crearEnTx`): `req:` (si tiene requisición) → numeración de OC (no hay `oc:`: la OC todavía no existe).
 *   - Requisición alta: `req-num:`. Editar / enviar / aprobar / rechazar / cancelar: `req:` y relectura.
 *   - Generar OC desde una requisición: `req:` una vez → por cada OC, `crearEnTx` (que vuelve a pedir `req:`, reentrante,
 *     y después la numeración de OC), todo en la misma transacción. Las OC nuevas no las puede tener bloqueadas nadie
 *     (no existen fuera de esta tx). No hay ciclo con la factura (`oc:` → `req:` → numeración de OP): la factura nunca
 *     toma la numeración de OC, y generar nunca toma `oc:`; la fila de numeración de OP es otra que la de OC.
 *   - Factura y Gasto (la ejecución vive en `src/requisiciones/ejecucion-requisicion.ts`, que toma `req:` y relee
 *     las líneas bajo el lock al aplicar y al revertir):
 *       - factura alta / anulación: `oc:` de su OC y enseguida `req:` (`bloquearRequisiciones`), antes de validar
 *         y de cualquier fila de órdenes de pago: el alta toma la numeración de la OP automática (FOR UPDATE de la
 *         fila de numeración) y la edición también, siempre después de `req:`;
 *       - factura edición: `oc:` de las dos OC (`bloquearOrdenesCompra`) → `req:` de la requisición guardada y de la
 *         nueva con `bloquearRequisiciones` (ordenadas, sin repetir), enseguida de leer la factura: antes de anular
 *         sus borradores de OP y de validar, revertir y aplicar;
 *       - gasto alta: `req:` antes de validar y de escribir; anulación: `FOR UPDATE` del gasto → `req:` →
 *         `imp:` (si está imputado a un embarque, porque apaga su componente) → filas de su CxP;
 *       - gasto edición: `FOR UPDATE` del gasto → `bloquearRequisiciones` de la guardada y la nueva → CxP.
 *     Regla: en Facturas y Gastos, `req:` va antes de cualquier fila con `FOR UPDATE` que no sea la del propio
 *     documento (numeración de OP, CxP).
 *     Las dos tomas de `req:` en la misma transacción son reentrantes. Sin `bloquearRequisiciones`, dos ediciones
 *     cruzadas (una de A a B y otra de B a A) tomarían A y B en orden opuesto: deadlock.
 *   - Recepción alta: `oc:` de su OC → `rep-num:`. Edición / anulación: `oc:` de su OC (si tiene) → `rec:`.
 * Nadie toma `oc:` después de `req:`, `req-num:` ni `oc-num:`, así que no hay ciclo.
 */
export async function bloquearOrdenCompra(tx: Tx, ordenCompraId: string | null | undefined): Promise<void> {
  if (!ordenCompraId) return;
  await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${`oc:${ordenCompraId}`}))`;
}

/** Varias OC: sin repetidos y en orden ascendente de id (ver el orden de arriba). */
export async function bloquearOrdenesCompra(tx: Tx, ordenCompraIds: Array<string | null | undefined>): Promise<void> {
  const ids = [...new Set(ordenCompraIds.filter((id): id is string => Boolean(id)))].sort();
  for (const id of ids) await bloquearOrdenCompra(tx, id);
}

/** Serializa las OC de una misma requisición: el disponible para pedir se lee después de este lock. */
export async function bloquearRequisicion(tx: Tx, requisicionId: string): Promise<void> {
  await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${`req:${requisicionId}`}))`;
}

/**
 * Varias requisiciones (editar una factura o un gasto que cambia de requisición): sin vacíos ni repetidos y en orden
 * ascendente de id, igual que `bloquearOrdenesCompra`, así dos ediciones cruzadas no se bloquean entre sí.
 */
export async function bloquearRequisiciones(tx: Tx, requisicionIds: Array<string | null | undefined>): Promise<void> {
  const ids = [...new Set(requisicionIds.filter((id): id is string => Boolean(id)))].sort();
  for (const id of ids) await bloquearRequisicion(tx, id);
}

/** Serializa el número del alta de requisición de una empresa (va después de `req:`, antes de `oc-num:`). */
export async function bloquearNumeroRequisicion(tx: Tx, empresaId: string): Promise<void> {
  await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${`req-num:${empresaId}`}))`;
}

/** Serializa el número de respaldo (`OC-<n>`) de las altas sin numeración 401 de una empresa. */
export async function bloquearNumeroOc(tx: Tx, empresaId: string): Promise<void> {
  await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${`oc-num:${empresaId}`}))`;
}

/** Serializa la edición y la anulación de una misma recepción (va después del `oc:` de su OC, ver el orden de arriba). */
export async function bloquearRecepcion(tx: Tx, recepcionId: string): Promise<void> {
  await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${`rec:${recepcionId}`}))`;
}

/** Serializa el número `REP-` de las altas de recepción de una empresa (va al final, después del `oc:`). */
export async function bloquearNumeroRecepcion(tx: Tx, empresaId: string): Promise<void> {
  await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${`rep-num:${empresaId}`}))`;
}
