import { ConflictException, ForbiddenException, HttpException } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { CreateOrdenPagoProveedorDto, OrdenPagoProveedorDetalleDto } from './dto/create-orden-pago-proveedor.dto';
import { cuotaBase, montarBaseOp } from './op-base-memoria.testutil';
import { PagosProveedorService } from './pagos-proveedor.service';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));
const alcanceMock = alcanceSucursalUsuario as jest.MockedFunction<typeof alcanceSucursalUsuario>;

/**
 * Task 6 (plan 2026-10-28-orden-pago-cxp): alta, envío a aprobación, aprobación, rechazo y ejecución de la OP.
 * Locks `op:` → `cxp:` → numeración (bloqueos-op.ts) con relectura, «aplica al guardar» exige `_PAGAR`, datos del
 * medio validados en el backend, contabilidad esperada con aviso, auditoría y `usuario_id` sin pisar.
 */

/** Fila 1 de la matriz (real de las 9 empresas locales): sin aprobación, guardar paga. */
const REAL = {
  habilitar_requisicion_compra: false,
  modo_flujo_compra: 'directo',
  afectar_stock_en_compra_directa: true,
  habilitar_orden_compra: true,
  habilitar_recepcion_compra: true,
  habilitar_matching_3_vias: true,
  habilitar_orden_pago: true,
  requiere_aprobacion: false,
  permite_pago_sin_aprobacion: true,
  generar_cxp_automatico: true,
  permitir_pago_parcial: false,
  usar_workflow: false,
  workflow_obligatorio: false,
  aplicar_pago_al_guardar: true,
  incluir_contado_en_orden_pago: false,
  permitir_editar_gasto_pagado: false,
  plan_pagos_periodicidad: 'SEMANAL',
  plan_pagos_dia_semana: 5,
  plan_pagos_dia_mes: 31,
};
const BORRADOR_SIN_APROBACION = { ...REAL, aplicar_pago_al_guardar: false };
const CON_APROBACION = {
  ...REAL,
  requiere_aprobacion: true,
  permite_pago_sin_aprobacion: false,
  aplicar_pago_al_guardar: false,
};

const MEDIOS = [
  { id: 'mp-efectivo', codigo: 1, descripcion: 'Efectivo' },
  { id: 'mp-cheque', codigo: 2, descripcion: 'Cheque' },
  { id: 'mp-tarjeta', codigo: 3, descripcion: 'Tarjeta de crédito' },
  { id: 'mp-transf', codigo: 5, descripcion: 'Transferencia' },
  { id: 'mp-anticipo', codigo: 11, descripcion: 'Pago por anticipo' },
  { id: 'mp-otro', codigo: 99, descripcion: 'Otro' },
];

const cuota = (id: string, factura: string, saldo: number, over: Record<string, unknown> = {}) => ({
  id,
  compra_id: `c-${id}`,
  origen_tipo: 'compra',
  origen_id: null,
  moneda_id: 'mon-pyg',
  saldo_pendiente: saldo,
  monto_pagado: 0,
  numero_cuota: 1,
  total_cuotas: 1,
  fecha_vencimiento: null,
  compra_cab: { numero_factura: factura },
  ...over,
});
const CUOTAS = [cuota('cxp-b', '001-001-0000123', 500), cuota('cxp-a', '001-001-0000124', 300)];
const NUMERACION = {
  id: 'num-1',
  numero_actual: 5,
  numero_final: null,
  punto_expedicion: '001',
  punto_establecimiento: '001',
};

const dtoBase = (over: Record<string, unknown> = {}): any => ({
  sucursal_id: 'suc-1',
  proveedor_id: 'prov-1',
  fecha_pago: '2026-10-05',
  detalles: [
    { cuenta_pagar_id: 'cxp-b', medio_pago_id: 'mp-efectivo', monto: 500 },
    { cuenta_pagar_id: 'cxp-a', medio_pago_id: 'mp-efectivo', monto: 300 },
  ],
  ...over,
});
const unaLinea = (det: Record<string, unknown>, over: Record<string, unknown> = {}) =>
  dtoBase({ detalles: [{ cuenta_pagar_id: 'cxp-b', monto: 500, ...det }], ...over });

type Opciones = {
  config?: Record<string, unknown>;
  cuotas?: any[];
  abiertas?: any[];
  numeracion?: any[];
  sinCaja?: string[];
  chequeEmitido?: any;
  pagar?: boolean;
  sucursal?: any;
  vigente?: { tasa: number; fuente: string };
  orden?: any;
};

const armar = (o: Opciones = {}) => {
  const tx: any = {
    $executeRaw: jest.fn().mockResolvedValue(1),
    $queryRaw: jest.fn().mockResolvedValue(o.numeracion ?? [NUMERACION]),
    config_compras: { findUnique: jest.fn().mockResolvedValue(o.config ?? REAL), create: jest.fn() },
    proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'prov-1' }) },
    empresas_sucursales: { findFirst: jest.fn().mockResolvedValue(o.sucursal ?? { id: 'suc-1', config: {} }) },
    sesiones_caja: { findFirst: jest.fn().mockResolvedValue(null) },
    medio_pago: { findMany: jest.fn(async ({ where }: any) => MEDIOS.filter((m) => where.id.in.includes(m.id))) },
    empresa_medio_pago: {
      findMany: jest.fn().mockResolvedValue((o.sinCaja ?? []).map((medio_pago_id) => ({ medio_pago_id }))),
      findFirst: jest.fn().mockResolvedValue(null),
    },
    tes_cheques: { findFirst: jest.fn().mockResolvedValue(o.chequeEmitido ?? null) },
    cuentas_pagar: {
      findMany: jest.fn(async ({ where }: any) => (o.cuotas ?? CUOTAS).filter((c) => where.id.in.includes(c.id))),
      update: jest.fn(),
    },
    orden_pago_proveedor_det: { findMany: jest.fn().mockResolvedValue(o.abiertas ?? []), create: jest.fn() },
    orden_pago_proveedor_cab: {
      create: jest.fn().mockResolvedValue({ id: 'op-new', numero_orden_pago: '001-001-0000005' }),
      findFirst: jest.fn().mockResolvedValue(o.orden ?? null),
      update: jest.fn(),
    },
    pagos_proveedor: { create: jest.fn() },
    numeraciones_documento: { update: jest.fn() },
    moneda: {
      findUnique: jest.fn(async ({ where }: any) => ({ codigo: where.id === 'mon-usd' ? 'USD' : 'PYG' })),
      findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'mon-pyg' }) },
    tes_cuentas: { findMany: jest.fn().mockResolvedValue([]) },
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
    perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(o.pagar === false ? null : { id: 'pp-pagar' }) },
    gasto_cab: { findMany: jest.fn().mockResolvedValue([]) },
  };
  tx.$transaction = jest.fn(async (cb: (t: any) => unknown) => cb(tx));

  const contab = { integrarOrdenPago: jest.fn().mockResolvedValue(undefined) };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const monedas = {
    getCotizacionVigente: jest.fn().mockResolvedValue(o.vigente ?? { tasa: 7300, fuente: 'contabilidad' }),
  };
  const service = new PagosProveedorService(tx, contab as any, audit as any, monedas as any);
  jest.spyOn(service, 'findOne').mockImplementation(async (id: string) => ({ id, leida: true }) as any);
  const sync = jest.spyOn(service, 'syncTesoreriaOrdenPago').mockResolvedValue({});
  for (const m of ['recalculateCompraEstado', 'recalculateAutoOrderEstado', 'recalculateGastoEstado']) {
    jest.spyOn(service as any, m).mockResolvedValue(undefined);
  }
  return { service, tx, contab, audit, monedas, sync };
};

/** El error que tira la promesa (falla si no tira). */
const errorDe = (p: Promise<unknown>) =>
  p.then(
    () => {
      throw new Error('se esperaba un error');
    },
    (e: HttpException) => e,
  );
const cuerpo = (e: HttpException) => e.getResponse() as Record<string, any>;
/** Claves de los locks en el orden en que se tomaron (`pg_advisory_xact_lock(hashtext($1))`). */
const locks = (tx: any): string[] => tx.$executeRaw.mock.calls.map((c: any[]) => String(c[1]));
const ordenDeLlamada = (tx: any, clave: string) => tx.$executeRaw.mock.invocationCallOrder[locks(tx).indexOf(clave)];

beforeEach(() => {
  alcanceMock.mockReset();
  alcanceMock.mockResolvedValue(null);
});

describe('alta (create)', () => {
  it('alta toma cxp: en orden ascendente antes de leer las cuotas y la numeración después', async () => {
    const { service, tx } = armar();
    await service.create(dtoBase(), 'emp-1', 'u-1');

    // Las cuotas vienen b, a en el DTO: el lock va en orden ascendente y sin op: (la orden no existe). El op: de la
    // orden nueva se toma recién después del commit, para la contabilidad (revisión final, hallazgo 3).
    expect(locks(tx)).toEqual(['cxp:cxp-a', 'cxp:cxp-b', 'op:op-new']);
    const ultimoLock = ordenDeLlamada(tx, 'cxp:cxp-b');
    expect(ordenDeLlamada(tx, 'cxp:cxp-a')).toBeLessThan(ultimoLock);
    expect(tx.cuentas_pagar.findMany.mock.invocationCallOrder[0]).toBeGreaterThan(ultimoLock);
    expect(tx.orden_pago_proveedor_det.findMany.mock.invocationCallOrder[0]).toBeGreaterThan(ultimoLock);
    // La numeración (FOR UPDATE) va al final.
    expect(tx.$queryRaw.mock.invocationCallOrder[0]).toBeGreaterThan(
      tx.cuentas_pagar.findMany.mock.invocationCallOrder[0],
    );
    expect(String(tx.$queryRaw.mock.calls[0][0].sql)).toContain('FOR UPDATE');
  });

  it('alta con una cuota que otra alta metió mientras esperaba el lock → CUOTA_EN_OTRA_ORDEN con linea', async () => {
    const { service, tx } = armar({
      abiertas: [
        {
          cuenta_pagar_id: 'cxp-a',
          orden_pago_proveedor_cab: {
            id: 'op-9',
            numero_orden_pago: '001-001-0000004',
            estado: 'BORRADOR',
            fecha_pago: new Date('2026-10-05'),
          },
        },
      ],
    });
    const e = await errorDe(service.create(dtoBase(), 'emp-1', 'u-1'));

    expect(e).toBeInstanceOf(ConflictException);
    expect(cuerpo(e)).toMatchObject({
      codigo: 'CUOTA_EN_OTRA_ORDEN',
      campo: 'detalles',
      linea: 2,
      orden: { orden_id: 'op-9', numero: '001-001-0000004', estado: 'BORRADOR' },
    });
    expect(e.message).toBe(
      'La cuenta por pagar de la factura 001-001-0000124 ya está en la orden 001-001-0000004 (en borrador). Una cuota no puede estar en dos órdenes de pago a la vez.',
    );
    // La lectura que decide es la de después del lock.
    expect(tx.orden_pago_proveedor_det.findMany.mock.invocationCallOrder[0]).toBeGreaterThan(
      ordenDeLlamada(tx, 'cxp:cxp-b'),
    );
    expect(tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();
  });

  it('alta con aplicar al guardar y sin _PAGAR → 403 SIN_PERMISO_PAGAR y no crea nada', async () => {
    const { service, tx } = armar({ pagar: false });
    const e = await errorDe(service.create(dtoBase(), 'emp-1', 'u-1'));

    expect(e).toBeInstanceOf(ForbiddenException);
    expect(cuerpo(e)).toMatchObject({
      codigo: 'SIN_PERMISO_PAGAR',
      message: 'Con la configuración de tu empresa, guardar la orden la paga, y tu perfil no puede pagar',
    });
    expect(tx.perfiles_privilegios.findFirst.mock.calls[0][0].where.privilegios).toEqual({
      codigo: { in: ['CMP_OP_ORDEN_PAGO_PAGAR'] },
    });
    expect(tx.$executeRaw).not.toHaveBeenCalled();
    expect(tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();
    expect(tx.pagos_proveedor.create).not.toHaveBeenCalled();
  });

  it('alta en borrador (sin aplicar al guardar) no pide _PAGAR', async () => {
    const { service, tx } = armar({ config: BORRADOR_SIN_APROBACION, pagar: false });
    await service.create(dtoBase(), 'emp-1', 'u-1');
    expect(tx.perfiles_privilegios.findFirst).not.toHaveBeenCalled();
    expect(tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.estado).toBe('BORRADOR');
    expect(tx.pagos_proveedor.create).not.toHaveBeenCalled();
  });

  it('alta con enviar_a_aprobacion y config con aprobación → PENDIENTE_APROBACION en la misma tx; sin aprobación → 400 APROBACION_NO_REQUERIDA', async () => {
    const conAprob = armar({ config: CON_APROBACION });
    await conAprob.service.create(dtoBase({ enviar_a_aprobacion: true }), 'emp-1', 'u-1');
    expect(conAprob.tx.$transaction).toHaveBeenCalledTimes(1);
    expect(conAprob.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.estado).toBe('PENDIENTE_APROBACION');
    expect(conAprob.tx.orden_pago_proveedor_cab.update).not.toHaveBeenCalled();
    expect(conAprob.audit.log.mock.calls.map((c: any[]) => c[0].action)).toEqual(['CREATE', 'SEND']);

    // Con aprobación y sin la bandera, queda en borrador.
    const borrador = armar({ config: CON_APROBACION });
    await borrador.service.create(dtoBase(), 'emp-1', 'u-1');
    expect(borrador.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.estado).toBe('BORRADOR');

    const sinAprob = armar({ config: BORRADOR_SIN_APROBACION });
    const e = await errorDe(sinAprob.service.create(dtoBase({ enviar_a_aprobacion: true }), 'emp-1', 'u-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e).codigo).toBe('APROBACION_NO_REQUERIDA');
    expect(sinAprob.tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();
  });

  describe('fecha de pago', () => {
    afterEach(() => jest.useRealTimers());

    it('alta sin fecha_pago graba hoyComoFechaPY', async () => {
      // 22:30 del 05/10 en Paraguay = 01:30 UTC del 06/10.
      jest.useFakeTimers({ now: new Date('2026-10-06T01:30:00.000Z') });
      const { service, tx } = armar();
      await service.create(dtoBase({ fecha_pago: undefined }), 'emp-1', 'u-1');

      const data = tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data;
      expect(data.fecha_pago.toISOString()).toBe('2026-10-05T00:00:00.000Z');
      expect(tx.pagos_proveedor.create.mock.calls[0][0].data.fecha_pago.toISOString()).toBe('2026-10-05T00:00:00.000Z');
    });

    it('fecha_pago YYYY-MM-DD se graba como medianoche UTC de ese día', async () => {
      const { service, tx } = armar();
      await service.create(dtoBase({ fecha_pago: '2026-10-09' }), 'emp-1', 'u-1');
      expect(tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.fecha_pago.toISOString()).toBe(
        '2026-10-09T00:00:00.000Z',
      );
    });
  });

  describe('moneda y cotización', () => {
    it('alta sin moneda_id graba la de las cuotas', async () => {
      const usd = armar({ cuotas: CUOTAS.map((c) => ({ ...c, moneda_id: 'mon-usd' })) });
      await usd.service.create(dtoBase({ cotizacion: 7350 }), 'emp-1', 'u-1');
      expect(usd.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data).toMatchObject({
        moneda_id: 'mon-usd',
        cotizacion: 7350,
      });
      expect(usd.tx.pagos_proveedor.create.mock.calls[0][0].data.moneda_id).toBe('mon-usd');

      const pyg = armar();
      await pyg.service.create(dtoBase(), 'emp-1', 'u-1');
      expect(pyg.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data).toMatchObject({
        moneda_id: 'mon-pyg',
        cotizacion: 1,
      });

      // Cuotas sin moneda (legacy): la moneda base de la empresa, nunca NULL.
      const sinMoneda = armar({ cuotas: CUOTAS.map((c) => ({ ...c, moneda_id: null })) });
      await sinMoneda.service.create(dtoBase(), 'emp-1', 'u-1');
      expect(sinMoneda.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.moneda_id).toBe('mon-pyg');
    });

    it('alta USD con cotización 1 → COTIZACION_INVALIDA campo cotizacion', async () => {
      const { service, tx } = armar({ cuotas: CUOTAS.map((c) => ({ ...c, moneda_id: 'mon-usd' })) });
      const e = await errorDe(service.create(dtoBase({ cotizacion: 1 }), 'emp-1', 'u-1'));
      expect(e.getStatus()).toBe(400);
      expect(cuerpo(e)).toMatchObject({ codigo: 'COTIZACION_INVALIDA', campo: 'cotizacion' });
      expect(tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();
    });

    it('alta USD sin cotización: usa la vigente de la fecha de pago; sin vigente usable → COTIZACION_REQUERIDA', async () => {
      const conVigente = armar({ cuotas: CUOTAS.map((c) => ({ ...c, moneda_id: 'mon-usd' })) });
      await conVigente.service.create(dtoBase(), 'emp-1', 'u-1');
      expect(conVigente.monedas.getCotizacionVigente).toHaveBeenCalledWith(
        'emp-1',
        'USD',
        new Date('2026-10-05T00:00:00.000Z'),
      );
      expect(conVigente.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.cotizacion).toBe(7300);

      const sinVigente = armar({
        cuotas: CUOTAS.map((c) => ({ ...c, moneda_id: 'mon-usd' })),
        vigente: { tasa: 1, fuente: 'fallback' },
      });
      const e = await errorDe(sinVigente.service.create(dtoBase(), 'emp-1', 'u-1'));
      expect(cuerpo(e)).toMatchObject({ codigo: 'COTIZACION_REQUERIDA', campo: 'cotizacion' });
    });

    it('monedas mezcladas → MONEDAS_MEZCLADAS (detalles); moneda distinta de la de las cuotas → MONEDA_DISTINTA (moneda_id)', async () => {
      const mezcla = armar({ cuotas: [CUOTAS[0], { ...CUOTAS[1], moneda_id: 'mon-usd' }] });
      const e1 = await errorDe(mezcla.service.create(dtoBase(), 'emp-1', 'u-1'));
      expect(cuerpo(e1)).toMatchObject({
        codigo: 'MONEDAS_MEZCLADAS',
        campo: 'detalles',
        message: 'Las cuentas por pagar seleccionadas tienen monedas distintas. Emití una orden de pago por moneda.',
      });

      const distinta = armar();
      const e2 = await errorDe(distinta.service.create(dtoBase({ moneda_id: 'mon-usd' }), 'emp-1', 'u-1'));
      expect(cuerpo(e2)).toMatchObject({
        codigo: 'MONEDA_DISTINTA',
        campo: 'moneda_id',
        message: 'La moneda de la orden de pago debe coincidir con la moneda de las cuentas por pagar seleccionadas.',
      });
    });
  });

  describe('Task 7: minors de la Task 6 en el alta', () => {
    it('la moneda y la cotización de cada línea son las de la orden, no las que manda el cliente', async () => {
      const { service, tx } = armar();
      await service.create(
        dtoBase({
          detalles: [
            {
              cuenta_pagar_id: 'cxp-b',
              medio_pago_id: 'mp-efectivo',
              monto: 500,
              moneda_id: 'mon-usd',
              cotizacion: 9999,
            },
            { cuenta_pagar_id: 'cxp-a', medio_pago_id: 'mp-efectivo', monto: 300, cotizacion: 7 },
          ],
        }),
        'emp-1',
        'u-1',
      );
      for (const [{ data }] of tx.orden_pago_proveedor_det.create.mock.calls) expect(data.cotizacion).toBe(1);
      for (const [{ data }] of tx.pagos_proveedor.create.mock.calls) {
        expect(data).toMatchObject({ moneda_id: 'mon-pyg', cotizacion: 1 });
      }
    });

    it('la misma cuota dos veces → 400 CUOTA_REPETIDA con la línea repetida', async () => {
      const { service, tx } = armar();
      const e = await errorDe(
        service.create(
          dtoBase({
            detalles: [
              { cuenta_pagar_id: 'cxp-b', medio_pago_id: 'mp-efectivo', monto: 500 },
              { cuenta_pagar_id: 'cxp-a', medio_pago_id: 'mp-efectivo', monto: 300 },
              { cuenta_pagar_id: 'cxp-b', medio_pago_id: 'mp-efectivo', monto: 500 },
            ],
          }),
          'emp-1',
          'u-1',
        ),
      );
      expect(e.getStatus()).toBe(400);
      expect(cuerpo(e)).toMatchObject({ codigo: 'CUOTA_REPETIDA', campo: 'detalles', linea: 3 });
      expect(tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();
    });

    it('una cuota anulada o desactivada → CUOTA_SIN_SALDO con linea', async () => {
      const anulada = armar({ cuotas: [CUOTAS[0], { ...CUOTAS[1], estado: 'anulada' }] });
      expect(cuerpo(await errorDe(anulada.service.create(dtoBase(), 'emp-1', 'u-1')))).toMatchObject({
        codigo: 'CUOTA_SIN_SALDO',
        campo: 'detalles',
        linea: 2,
      });
      const inactiva = armar({ cuotas: [{ ...CUOTAS[0], activo: false }, CUOTAS[1]] });
      expect(cuerpo(await errorDe(inactiva.service.create(dtoBase(), 'emp-1', 'u-1')))).toMatchObject({
        codigo: 'CUOTA_SIN_SALDO',
        linea: 1,
      });
    });
  });

  describe('saldo y monto (assertMontoPagoValido con MONTO_INVALIDO)', () => {
    it('cuota sin saldo → CUOTA_SIN_SALDO con linea', async () => {
      const { service } = armar({ cuotas: [CUOTAS[0], { ...CUOTAS[1], saldo_pendiente: 0 }] });
      const e = await errorDe(service.create(dtoBase(), 'emp-1', 'u-1'));
      expect(e.getStatus()).toBe(400);
      expect(cuerpo(e)).toMatchObject({ codigo: 'CUOTA_SIN_SALDO', campo: 'detalles', linea: 2 });
    });

    it('monto distinto del saldo sin pago parcial, o por encima con pago parcial → 400 MONTO_INVALIDO con linea', async () => {
      const exacto = armar();
      const e1 = await errorDe(
        exacto.service.create(
          dtoBase({ detalles: [{ cuenta_pagar_id: 'cxp-b', medio_pago_id: 'mp-efectivo', monto: 400 }] }),
          'emp-1',
          'u-1',
        ),
      );
      expect(e1.getStatus()).toBe(400);
      expect(cuerpo(e1)).toMatchObject({ codigo: 'MONTO_INVALIDO', campo: 'detalles', linea: 1 });
      expect(e1.message).toBe(
        'Pago inválido para la cuenta por pagar de la factura 001-001-0000123: debe ser exacto al saldo pendiente (500)',
      );

      const parcial = armar({ config: { ...REAL, permitir_pago_parcial: true } });
      const e2 = await errorDe(
        parcial.service.create(
          dtoBase({ detalles: [{ cuenta_pagar_id: 'cxp-b', medio_pago_id: 'mp-efectivo', monto: 600 }] }),
          'emp-1',
          'u-1',
        ),
      );
      expect(cuerpo(e2)).toMatchObject({ codigo: 'MONTO_INVALIDO', linea: 1 });

      const ok = armar({ config: { ...REAL, permitir_pago_parcial: true } });
      await ok.service.create(
        dtoBase({ detalles: [{ cuenta_pagar_id: 'cxp-b', medio_pago_id: 'mp-efectivo', monto: 200 }] }),
        'emp-1',
        'u-1',
      );
      expect(ok.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.monto_total).toBe(200);
    });
  });

  describe('datos del medio', () => {
    const cheque = {
      medio_pago_id: 'mp-cheque',
      numero_cheque: '000123',
      banco_emisor: 'Itaú',
      titular_cheque: 'Novasis Py S.A.',
      fecha_emision_cheque: '2026-10-05',
      cuenta_bancaria_id: '7d5b1f3e-1111-4c1a-9e2a-000000000001',
    };

    it('cheque sin titular → DATOS_MEDIO_INCOMPLETOS campo titular_cheque linea 1 (la primera); N° con letras no valida', async () => {
      const { service, tx } = armar();
      const e = await errorDe(service.create(unaLinea({ ...cheque, titular_cheque: '  ' }), 'emp-1', 'u-1'));
      expect(e.getStatus()).toBe(400);
      expect(cuerpo(e)).toMatchObject({ codigo: 'DATOS_MEDIO_INCOMPLETOS', campo: 'titular_cheque', linea: 1 });
      expect(tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();

      const det = plainToInstance(OrdenPagoProveedorDetalleDto, {
        ...cheque,
        cuenta_pagar_id: cheque.cuenta_bancaria_id,
        medio_pago_id: cheque.cuenta_bancaria_id,
        monto: 1,
        numero_cheque: '12A4',
      });
      const errores = await validate(det);
      expect(errores.map((x) => x.property)).toEqual(['numero_cheque']);
    });

    it('transferencia sin cuenta → DATOS_MEDIO_INCOMPLETOS cuenta_bancaria_id', async () => {
      const { service } = armar();
      const e = await errorDe(service.create(unaLinea({ medio_pago_id: 'mp-transf' }), 'emp-1', 'u-1'));
      expect(cuerpo(e)).toMatchObject({ codigo: 'DATOS_MEDIO_INCOMPLETOS', campo: 'cuenta_bancaria_id', linea: 1 });
    });

    it('cheque con N° ya emitido en la misma cuenta → CHEQUE_REPETIDO; anulado no cuenta; repetido en la misma orden también', async () => {
      const emitido = armar({ chequeEmitido: { id: 'chq-1' } });
      const e = await errorDe(emitido.service.create(unaLinea(cheque), 'emp-1', 'u-1'));
      expect(e.getStatus()).toBe(400);
      expect(cuerpo(e)).toMatchObject({ codigo: 'CHEQUE_REPETIDO', campo: 'numero_cheque', linea: 1 });
      // Solo los de órdenes de pago, de esa cuenta y número, y no anulados.
      expect(emitido.tx.tes_cheques.findFirst.mock.calls[0][0].where).toEqual({
        empresa_id: 'emp-1',
        origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
        estado: { not: 'ANULADO' },
        cuenta_id: cheque.cuenta_bancaria_id,
        numero_cheque: '000123',
      });

      // Sin uno vigente (el anulado no aparece por el filtro), pasa.
      const libre = armar();
      await libre.service.create(unaLinea(cheque), 'emp-1', 'u-1');
      expect(libre.tx.orden_pago_proveedor_cab.create).toHaveBeenCalled();

      const repetido = armar();
      const e2 = await errorDe(
        repetido.service.create(
          dtoBase({
            detalles: [
              { cuenta_pagar_id: 'cxp-b', monto: 500, ...cheque },
              { cuenta_pagar_id: 'cxp-a', monto: 300, ...cheque },
            ],
          }),
          'emp-1',
          'u-1',
        ),
      );
      expect(cuerpo(e2)).toMatchObject({ codigo: 'CHEQUE_REPETIDO', campo: 'numero_cheque', linea: 2 });
    });

    it('tarjeta: observaciones Tarjeta Visa ****1234', async () => {
      const { service, tx } = armar();
      await service.create(
        unaLinea({ medio_pago_id: 'mp-tarjeta', tarjeta_descripcion: 'Visa', ultimos_4: '1234' }),
        'emp-1',
        'u-1',
      );
      expect(tx.orden_pago_proveedor_det.create.mock.calls[0][0].data.observaciones).toBe('Tarjeta Visa ****1234');

      const sinUltimos = armar();
      const e = await errorDe(
        sinUltimos.service.create(
          unaLinea({ medio_pago_id: 'mp-tarjeta', tarjeta_descripcion: 'Visa' }),
          'emp-1',
          'u-1',
        ),
      );
      expect(cuerpo(e)).toMatchObject({ codigo: 'DATOS_MEDIO_INCOMPLETOS', campo: 'ultimos_4', linea: 1 });
    });

    it('medio sin caja: no pide cuenta (la transferencia que la empresa marcó no_mueve_caja)', async () => {
      const { service, tx } = armar({ sinCaja: ['mp-transf'] });
      await service.create(unaLinea({ medio_pago_id: 'mp-transf' }), 'emp-1', 'u-1');
      expect(tx.orden_pago_proveedor_cab.create).toHaveBeenCalled();
      expect(tx.empresa_medio_pago.findMany.mock.calls[0][0].where).toEqual({
        empresa_id: 'emp-1',
        no_mueve_caja: true,
      });
    });
  });

  describe('sucursal', () => {
    it('sucursal sin numeración → SUCURSAL_SIN_NUMERACION; con requiere_caja → SUCURSAL_EXIGE_CAJA; fuera del alcance → 403', async () => {
      const sinNum = armar({ numeracion: [] });
      const e1 = await errorDe(sinNum.service.create(dtoBase(), 'emp-1', 'u-1'));
      expect(e1.getStatus()).toBe(400);
      expect(cuerpo(e1)).toMatchObject({ codigo: 'SUCURSAL_SIN_NUMERACION', campo: 'sucursal_id' });
      expect(sinNum.tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();

      const caja = armar({ sucursal: { id: 'suc-1', config: { requiere_caja_pagos_proveedor: true } } });
      const e2 = await errorDe(caja.service.create(dtoBase(), 'emp-1', 'u-1'));
      expect(e2.getStatus()).toBe(400);
      expect(cuerpo(e2)).toMatchObject({ codigo: 'SUCURSAL_EXIGE_CAJA', campo: 'sucursal_id' });

      alcanceMock.mockResolvedValue({ sucursalIds: ['suc-2'], puntosEstablecimiento: [], depositoIds: [] });
      const fuera = armar();
      const e3 = await errorDe(fuera.service.create(dtoBase(), 'emp-1', 'u-1'));
      expect(e3).toBeInstanceOf(ForbiddenException);
      expect(cuerpo(e3)).toMatchObject({ codigo: 'SUCURSAL_FUERA_DE_ALCANCE', campo: 'sucursal_id' });
      expect(fuera.tx.orden_pago_proveedor_cab.create).not.toHaveBeenCalled();
      expect(alcanceMock).toHaveBeenCalledWith(expect.anything(), 'u-1', 'emp-1');
    });

    it('la numeración agotada (numero_actual >= numero_final) no cuenta: el alta y la config de flujo usan el mismo filtro', async () => {
      const { service, tx } = armar();
      await service.create(dtoBase(), 'emp-1', 'u-1');
      const sql = String(tx.$queryRaw.mock.calls[0][0].sql);
      expect(sql).toMatch(/nd\.numero_final IS NULL OR nd\.numero_actual < nd\.numero_final/);
      expect(sql).toContain('td.codigo = 400');
    });
  });

  describe('después del commit: Tesorería, contabilidad esperada, auditoría y avisos', () => {
    it('contabilidad: integrarOrdenPago se espera; si falla, avisos.contabilidad y la OP queda pagada', async () => {
      const ok = armar();
      let contabilizada = false;
      ok.contab.integrarOrdenPago.mockImplementation(async () => {
        await new Promise((r) => setImmediate(r));
        contabilizada = true;
      });
      const r1 = await ok.service.create(dtoBase(), 'emp-1', 'u-1');
      expect(contabilizada).toBe(true);
      expect(ok.contab.integrarOrdenPago).toHaveBeenCalledWith('op-new');
      expect(r1).toEqual({ id: 'op-new', leida: true, avisos: {} });

      const falla = armar();
      falla.contab.integrarOrdenPago.mockRejectedValue(new Error('no hay período abierto'));
      falla.sync.mockResolvedValue({
        warning: 'La orden quedó pagada, pero no se pudo registrar en Tesorería. Motivo: x',
      });
      const r2: any = await falla.service.create(dtoBase(), 'emp-1', 'u-1');
      expect(falla.tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.estado).toBe('PAGADO');
      expect(r2.avisos).toEqual({
        tesoreria: 'La orden quedó pagada, pero no se pudo registrar en Tesorería. Motivo: x',
        contabilidad: 'La orden quedó pagada, pero no se pudo contabilizar. Motivo: no hay período abierto',
      });
      expect(r2).not.toHaveProperty('tesoreria_warning');
    });

    it('una orden que no queda pagada no va a Tesorería ni a contabilidad', async () => {
      const { service, contab, sync } = armar({ config: BORRADOR_SIN_APROBACION });
      const r = await service.create(dtoBase(), 'emp-1', 'u-1');
      expect(sync).not.toHaveBeenCalled();
      expect(contab.integrarOrdenPago).not.toHaveBeenCalled();
      expect(r).toEqual({ id: 'op-new', leida: true, avisos: {} });
    });

    it('auditoría orden_pago_proveedor: CREATE y PAY al pagar; usuario_id es quien crea', async () => {
      const { service, tx, audit } = armar();
      await service.create(dtoBase(), 'emp-1', 'u-1');
      expect(tx.orden_pago_proveedor_cab.create.mock.calls[0][0].data.usuario_id).toBe('u-1');
      expect(
        audit.log.mock.calls.map((c: any[]) => [c[0].action, c[0].entity_type, c[0].entity_id, c[0].user_id]),
      ).toEqual([
        ['CREATE', 'orden_pago_proveedor', 'op-new', 'u-1'],
        ['PAY', 'orden_pago_proveedor', 'op-new', 'u-1'],
      ]);
    });
  });

  it('DTO: enviar_a_aprobacion es booleano opcional', async () => {
    const mal = plainToInstance(CreateOrdenPagoProveedorDto, { ...dtoBase(), detalles: [], enviar_a_aprobacion: 'si' });
    const errores = await validate(mal);
    expect(errores.map((x) => x.property)).toContain('enviar_a_aprobacion');
  });

  it('DTO: fecha_pago solo como fecha de calendario YYYY-MM-DD (sin hora)', async () => {
    const errores = async (fecha_pago: unknown) =>
      (await validate(plainToInstance(CreateOrdenPagoProveedorDto, { ...dtoBase({ fecha_pago }), detalles: [] }))).map(
        (x) => x.property,
      );
    expect(await errores('2026-10-05')).not.toContain('fecha_pago');
    expect(await errores(undefined)).not.toContain('fecha_pago');
    for (const mal of [
      '2026-10-05T19:33:56.814Z',
      '2026-10-05T00:00:00.000Z',
      '05/10/2026',
      '2026-13-01',
      '2026-02-30',
      'hoy',
    ]) {
      expect(await errores(mal)).toContain('fecha_pago');
    }
  });
});

// ─────────────────────────── Tesorería de la OP ───────────────────────────

describe('syncTesoreriaOrdenPago', () => {
  const armarSync = (dets: any[], sinCaja: string[] = []) => {
    const tx: any = {
      // Task 7: el registro toma `op:` (un reintento y el registro después del pago no generan dos egresos).
      $executeRaw: jest.fn().mockResolvedValue(1),
      orden_pago_proveedor_cab: {
        findFirst: jest.fn().mockResolvedValue({
          id: 'op-1',
          numero_orden_pago: '001-001-0000005',
          fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
          monto_total: dets.reduce((a, d) => a + d.monto, 0),
          referencia: null,
          estado: 'PAGADO',
          cotizacion: 1,
          moneda: { codigo: 'PYG' },
          orden_pago_proveedor_det: dets,
        }),
      },
      tes_movimientos: {
        findFirst: jest.fn().mockResolvedValue(null),
        create: jest.fn().mockResolvedValue({ id: 'mov-1' }),
      },
      tes_cheques: { findFirst: jest.fn().mockResolvedValue(null), create: jest.fn() },
      tes_categorias: { findFirst: jest.fn().mockResolvedValue({ id: 'cat-1' }), create: jest.fn() },
      tes_reglas: {
        findFirst: jest.fn().mockResolvedValue({ activo: true, cuenta_id: 'tes-1', tipo_tesoreria: null }),
      },
      tes_cuentas: {
        findFirst: jest.fn().mockResolvedValue({ id: 'tes-1', nombre: 'Caja', moneda: 'PYG' }),
        update: jest.fn(),
      },
      tes_movimiento_det: { create: jest.fn() },
      empresa_medio_pago: {
        findMany: jest.fn().mockResolvedValue(sinCaja.map((medio_pago_id) => ({ medio_pago_id }))),
      },
    };
    tx.$transaction = jest.fn(async (cb: (t: any) => unknown) => cb(tx));
    const service = new PagosProveedorService(tx, {} as any, {} as any, {} as any);
    return { service, tx };
  };
  const det = (
    medio_pago_id: string,
    medio: { codigo: number | null; descripcion: string },
    monto: number,
    extra: any = {},
  ) => ({
    medio_pago_id,
    monto,
    medio_pago: medio,
    numero_cheque: null,
    banco_emisor: null,
    fecha_emision_cheque: null,
    fecha_vencimiento_cheque: null,
    titular_cheque: null,
    cuenta_bancaria_id: null,
    numero_operacion: null,
    ...extra,
  });

  it('medio sin caja: syncTesoreria no crea egreso ni warning (anticipo, o el medio que la empresa marcó)', async () => {
    const anticipo = armarSync([det('mp-anticipo', { codigo: 11, descripcion: 'Pago por anticipo' }, 500)]);
    await expect(anticipo.service.syncTesoreriaOrdenPago('op-1', 'emp-1', 'u-1')).resolves.toEqual({});
    expect(anticipo.tx.tes_movimientos.create).not.toHaveBeenCalled();
    expect(anticipo.tx.tes_cheques.create).not.toHaveBeenCalled();
    expect(anticipo.tx.tes_reglas.findFirst).not.toHaveBeenCalled();

    const marcado = armarSync([det('mp-otro', { codigo: 99, descripcion: 'Otro' }, 500)], ['mp-otro']);
    await expect(marcado.service.syncTesoreriaOrdenPago('op-1', 'emp-1', 'u-1')).resolves.toEqual({});
    expect(marcado.tx.tes_movimientos.create).not.toHaveBeenCalled();
  });

  it('OP mixta: solo la línea que mueve dinero genera el egreso, por su monto', async () => {
    const { service, tx } = armarSync([
      det('mp-anticipo', { codigo: 11, descripcion: 'Pago por anticipo' }, 500),
      det('mp-efectivo', { codigo: 1, descripcion: 'Efectivo' }, 300),
    ]);
    await expect(service.syncTesoreriaOrdenPago('op-1', 'emp-1', 'u-1')).resolves.toEqual({});
    expect(tx.tes_movimientos.create).toHaveBeenCalledTimes(1);
    expect(tx.tes_movimientos.create.mock.calls[0][0].data).toMatchObject({
      monto: 300,
      tipo: 'EGRESO',
      origen_id: 'op-1',
    });
  });

  it('Task 7: el registro toma op: antes de leer la orden', async () => {
    const { service, tx } = armarSync([det('mp-efectivo', { codigo: 1, descripcion: 'Efectivo' }, 500)]);
    await service.syncTesoreriaOrdenPago('op-1', 'emp-1', 'u-1');
    expect(locks(tx)).toEqual(['op:op-1']);
    expect(tx.$executeRaw.mock.invocationCallOrder[0]).toBeLessThan(
      tx.orden_pago_proveedor_cab.findFirst.mock.invocationCallOrder[0],
    );
  });

  it('el cheque se detecta con tipoMedioPago (código 2), no por la descripción', async () => {
    const cheque = armarSync([
      det('mp-cheque', { codigo: 2, descripcion: 'Cheque' }, 500, { numero_cheque: '000123' }),
    ]);
    await cheque.service.syncTesoreriaOrdenPago('op-1', 'emp-1', 'u-1');
    expect(cheque.tx.tes_cheques.create).toHaveBeenCalledTimes(1);
    expect(cheque.tx.tes_movimientos.create).not.toHaveBeenCalled();

    // Un medio propio sin código llamado «Cheque…» ya no es cheque (Puntos decididos, costo anotado).
    const porNombre = armarSync([det('mp-propio', { codigo: null, descripcion: 'Cheque diferido' }, 500)]);
    await porNombre.service.syncTesoreriaOrdenPago('op-1', 'emp-1', 'u-1');
    expect(porNombre.tx.tes_cheques.create).not.toHaveBeenCalled();
    expect(porNombre.tx.tes_movimientos.create).toHaveBeenCalledTimes(1);
  });
});

// ─────────────────────────── Enviar, aprobar, rechazar ───────────────────────────

describe('enviar a aprobación, aprobar y rechazar', () => {
  const ordenEn = (estado: string, over: Record<string, unknown> = {}) => ({
    id: 'op-1',
    empresa_id: 'emp-1',
    proveedor_id: 'prov-1',
    usuario_id: 'u-creador',
    numero_orden_pago: '001-001-0000005',
    estado,
    activo: true,
    anulado: false,
    observaciones: 'Observación previa',
    // Una orden con línea (una vacía no se envía a aprobar: OP_SIN_DETALLE).
    orden_pago_proveedor_det: [{ id: 'det-1' }],
    ...over,
  });

  it('aprobar con la orden ya aprobada por otro bajo el lock → 409 OP_ESTADO_CAMBIADO', async () => {
    const { service, tx } = armar({ config: CON_APROBACION, orden: ordenEn('PENDIENTE') });
    const e = await errorDe(service.aprobar('op-1', 'emp-1', 'u-2'));

    expect(e).toBeInstanceOf(ConflictException);
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'aprobada' });
    expect(locks(tx)).toEqual(['op:op-1']);
    expect(ordenDeLlamada(tx, 'op:op-1')).toBeLessThan(
      tx.orden_pago_proveedor_cab.findFirst.mock.invocationCallOrder[0],
    );
    expect(tx.orden_pago_proveedor_cab.update).not.toHaveBeenCalled();
  });

  it('aprobar una pendiente de aprobación la pasa a PENDIENTE y audita APPROVE', async () => {
    const { service, tx, audit } = armar({ config: CON_APROBACION, orden: ordenEn('PENDIENTE_APROBACION') });
    await expect(service.aprobar('op-1', 'emp-1', 'u-2')).resolves.toEqual({ id: 'op-1', leida: true });
    expect(tx.orden_pago_proveedor_cab.update.mock.calls[0][0].data.estado).toBe('PENDIENTE');
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({
        action: 'APPROVE',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-1',
        user_id: 'u-2',
      }),
    );
  });

  it('enviar a aprobación: una enviada por otro → 409; una anulada → 409 con estado_actual anulada', async () => {
    const enviada = armar({ config: CON_APROBACION, orden: ordenEn('PENDIENTE_APROBACION') });
    const e1 = await errorDe(enviada.service.enviarAprobacion('op-1', 'emp-1', 'u-1'));
    expect(cuerpo(e1)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'pendiente_aprobacion' });

    const anulada = armar({ config: CON_APROBACION, orden: ordenEn('BORRADOR', { anulado: true }) });
    const e2 = await errorDe(anulada.service.enviarAprobacion('op-1', 'emp-1', 'u-1'));
    expect(cuerpo(e2)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'anulada' });

    const ok = armar({ config: CON_APROBACION, orden: ordenEn('RECHAZADA') });
    await ok.service.enviarAprobacion('op-1', 'emp-1', 'u-1');
    expect(ok.tx.orden_pago_proveedor_cab.update.mock.calls[0][0].data.estado).toBe('PENDIENTE_APROBACION');
    expect(ok.audit.log.mock.calls[0][0].action).toBe('SEND');
  });

  it('enviar, aprobar o rechazar con una config que no pide aprobación → 400 APROBACION_NO_REQUERIDA', async () => {
    for (const accion of [
      (s: PagosProveedorService) => s.enviarAprobacion('op-1', 'emp-1', 'u-1'),
      (s: PagosProveedorService) => s.aprobar('op-1', 'emp-1', 'u-1'),
      (s: PagosProveedorService) => s.rechazar('op-1', 'Motivo', 'emp-1', 'u-1'),
    ]) {
      const { service, tx } = armar({ config: REAL, orden: ordenEn('PENDIENTE_APROBACION') });
      const e = await errorDe(accion(service));
      expect(e.getStatus()).toBe(400);
      expect(cuerpo(e).codigo).toBe('APROBACION_NO_REQUERIDA');
      expect(tx.orden_pago_proveedor_cab.update).not.toHaveBeenCalled();
    }
  });

  it('rechazar sin motivo → MOTIVO_REQUERIDO; con motivo no cambia observaciones y audita REJECT con el motivo', async () => {
    const sinMotivo = armar({ config: CON_APROBACION, orden: ordenEn('PENDIENTE_APROBACION') });
    const e = await errorDe(sinMotivo.service.rechazar('op-1', '   ', 'emp-1', 'u-2'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'MOTIVO_REQUERIDO', campo: 'motivo' });
    expect(sinMotivo.tx.orden_pago_proveedor_cab.update).not.toHaveBeenCalled();

    const { service, tx, audit } = armar({ config: CON_APROBACION, orden: ordenEn('PENDIENTE_APROBACION') });
    await service.rechazar('op-1', '  Falta respaldo  ', 'emp-1', 'u-2');
    const data = tx.orden_pago_proveedor_cab.update.mock.calls[0][0].data;
    expect(data.estado).toBe('RECHAZADA');
    expect(data).not.toHaveProperty('observaciones');
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({
        action: 'REJECT',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-1',
        user_id: 'u-2',
        descripcion: 'Falta respaldo',
        new_value: expect.objectContaining({ estado: 'RECHAZADA', motivo: 'Falta respaldo' }),
      }),
    );
  });

  it('ninguna acción cambia usuario_id', async () => {
    const llamadas: any[] = [];
    const correr = async (config: any, estado: string, accion: (s: PagosProveedorService) => Promise<unknown>) => {
      const { service, tx } = armar({
        config,
        orden: { ...ordenEn(estado), orden_pago_proveedor_det: [{ cuenta_pagar_id: 'cxp-b', monto: 500 }] },
        cuotas: [CUOTAS[0]],
      });
      await accion(service);
      llamadas.push(...tx.orden_pago_proveedor_cab.update.mock.calls);
    };
    await correr(CON_APROBACION, 'BORRADOR', (s) => s.enviarAprobacion('op-1', 'emp-1', 'u-otro'));
    await correr(CON_APROBACION, 'PENDIENTE_APROBACION', (s) => s.aprobar('op-1', 'emp-1', 'u-otro'));
    await correr(CON_APROBACION, 'PENDIENTE_APROBACION', (s) => s.rechazar('op-1', 'No va', 'emp-1', 'u-otro'));
    await correr(CON_APROBACION, 'PENDIENTE', (s) => s.ejecutar('op-1', 'emp-1', 'u-otro'));

    expect(llamadas).toHaveLength(4);
    for (const [args] of llamadas) expect(args.data).not.toHaveProperty('usuario_id');
  });
});

// ─────────────────────────── Ejecutar ───────────────────────────

describe('ejecutar', () => {
  const ordenParaEjecutar = (
    estado: string,
    dets = [{ cuenta_pagar_id: 'cxp-b', monto: 500, monto_moneda: 500, cotizacion: 1, medio_pago_id: 'mp-efectivo' }],
  ) => ({
    id: 'op-1',
    empresa_id: 'emp-1',
    proveedor_id: 'prov-1',
    usuario_id: 'u-creador',
    moneda_id: 'mon-pyg',
    cotizacion: 1,
    numero_orden_pago: '001-001-0000005',
    fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
    referencia: null,
    observaciones: null,
    sesion_caja_id: null,
    estado,
    activo: true,
    anulado: false,
    orden_pago_proveedor_det: dets,
  });

  it('ejecutar: op: → relectura → cxp: de sus líneas → relectura de saldos; audita PAY y devuelve findOne + avisos', async () => {
    const { service, tx, audit, contab } = armar({
      orden: ordenParaEjecutar('BORRADOR', [
        { cuenta_pagar_id: 'cxp-b', monto: 500, monto_moneda: 500, cotizacion: 1, medio_pago_id: 'mp-efectivo' },
        { cuenta_pagar_id: 'cxp-a', monto: 300, monto_moneda: 300, cotizacion: 1, medio_pago_id: 'mp-efectivo' },
      ]),
    });
    const r = await service.ejecutar('op-1', 'emp-1', 'u-2');

    // El último op: es el de la contabilidad después del commit (revisión final, hallazgo 3).
    expect(locks(tx)).toEqual(['op:op-1', 'cxp:cxp-a', 'cxp:cxp-b', 'op:op-1']);
    const lockOp = ordenDeLlamada(tx, 'op:op-1');
    const lecturaOrden = tx.orden_pago_proveedor_cab.findFirst.mock.invocationCallOrder[0];
    expect(lecturaOrden).toBeGreaterThan(lockOp);
    expect(ordenDeLlamada(tx, 'cxp:cxp-a')).toBeGreaterThan(lecturaOrden);
    expect(tx.cuentas_pagar.findMany.mock.invocationCallOrder[0]).toBeGreaterThan(ordenDeLlamada(tx, 'cxp:cxp-b'));
    expect(tx.pagos_proveedor.create).toHaveBeenCalledTimes(2);
    expect(tx.orden_pago_proveedor_cab.update.mock.calls[0][0].data.estado).toBe('PAGADO');
    expect(contab.integrarOrdenPago).toHaveBeenCalledWith('op-1');
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({
        action: 'PAY',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-1',
        user_id: 'u-2',
      }),
    );
    expect(r).toEqual({ id: 'op-1', leida: true, avisos: {} });
  });

  it('dos ejecutar: el segundo relee PAGADO bajo op: → OP_ESTADO_CAMBIADO y no crea pagos_proveedor', async () => {
    const { service, tx, audit } = armar({ orden: ordenParaEjecutar('PAGADO') });
    const e = await errorDe(service.ejecutar('op-1', 'emp-1', 'u-2'));

    expect(e).toBeInstanceOf(ConflictException);
    expect(cuerpo(e)).toMatchObject({
      codigo: 'OP_ESTADO_CAMBIADO',
      estado_actual: 'pagada',
      message: 'La orden ya fue ejecutada',
    });
    expect(ordenDeLlamada(tx, 'op:op-1')).toBeLessThan(
      tx.orden_pago_proveedor_cab.findFirst.mock.invocationCallOrder[0],
    );
    expect(tx.pagos_proveedor.create).not.toHaveBeenCalled();
    expect(tx.cuentas_pagar.update).not.toHaveBeenCalled();
    expect(audit.log).not.toHaveBeenCalled();
  });

  it('ejecutar con el saldo bajado por una NC → OP_SALDO_CAMBIADO con linea y el mensaje de hoy', async () => {
    const { service, tx } = armar({
      orden: ordenParaEjecutar('BORRADOR'),
      cuotas: [{ ...CUOTAS[0], saldo_pendiente: 350 }],
    });
    const e = await errorDe(service.ejecutar('op-1', 'emp-1', 'u-2'));

    expect(e).toBeInstanceOf(ConflictException);
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_SALDO_CAMBIADO', campo: 'detalles', linea: 1 });
    expect(e.message).toBe(
      'La cuenta por pagar de la factura 001-001-0000123 cambió su saldo. Recargá cuentas y generá una nueva orden.',
    );
    expect(tx.pagos_proveedor.create).not.toHaveBeenCalled();

    // Con pago parcial, una cuota que quedó por debajo del monto de la línea también cambió su saldo.
    const parcial = armar({
      config: { ...REAL, permitir_pago_parcial: true },
      orden: ordenParaEjecutar('BORRADOR'),
      cuotas: [{ ...CUOTAS[0], saldo_pendiente: 350 }],
    });
    const e2 = await errorDe(parcial.service.ejecutar('op-1', 'emp-1', 'u-2'));
    expect(cuerpo(e2)).toMatchObject({ codigo: 'OP_SALDO_CAMBIADO', linea: 1 });

    // Sin saldo: CUOTA_SIN_SALDO.
    const sinSaldo = armar({ orden: ordenParaEjecutar('BORRADOR'), cuotas: [{ ...CUOTAS[0], saldo_pendiente: 0 }] });
    const e3 = await errorDe(sinSaldo.service.ejecutar('op-1', 'emp-1', 'u-2'));
    expect(cuerpo(e3)).toMatchObject({ codigo: 'CUOTA_SIN_SALDO', campo: 'detalles', linea: 1 });
  });

  it('Task 7: una cuota anulada o desactivada después del alta → CUOTA_SIN_SALDO con linea, sin pagar nada', async () => {
    const dets = [
      { cuenta_pagar_id: 'cxp-b', monto: 500, monto_moneda: 500, cotizacion: 1, medio_pago_id: 'mp-efectivo' },
      { cuenta_pagar_id: 'cxp-a', monto: 300, monto_moneda: 300, cotizacion: 1, medio_pago_id: 'mp-efectivo' },
    ];
    for (const cambio of [{ estado: 'anulada' }, { activo: false }]) {
      const { service, tx } = armar({
        orden: ordenParaEjecutar('BORRADOR', dets),
        cuotas: [CUOTAS[0], { ...CUOTAS[1], ...cambio }],
      });
      const e = await errorDe(service.ejecutar('op-1', 'emp-1', 'u-2'));
      expect(e.getStatus()).toBe(400);
      expect(cuerpo(e)).toMatchObject({ codigo: 'CUOTA_SIN_SALDO', campo: 'detalles', linea: 2 });
      expect(tx.pagos_proveedor.create).not.toHaveBeenCalled();
    }
    // Una cuota que ya no es del proveedor (o no existe) tampoco se paga.
    const { service } = armar({ orden: ordenParaEjecutar('BORRADOR', dets), cuotas: [CUOTAS[0]] });
    expect(cuerpo(await errorDe(service.ejecutar('op-1', 'emp-1', 'u-2')))).toMatchObject({
      codigo: 'CUOTA_SIN_SALDO',
      linea: 2,
    });
  });

  it('ejecutar un borrador con aprobación obligatoria → 400 APROBACION_REQUERIDA con el mensaje de hoy', async () => {
    const { service, tx } = armar({ config: CON_APROBACION, orden: ordenParaEjecutar('BORRADOR') });
    const e = await errorDe(service.ejecutar('op-1', 'emp-1', 'u-2'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({
      codigo: 'APROBACION_REQUERIDA',
      message: 'La orden requiere aprobación previa. Enviá y aprobá la OP antes de ejecutar',
    });
    expect(tx.pagos_proveedor.create).not.toHaveBeenCalled();
  });

  it('ejecutar una pendiente de aprobación o rechazada → 409 con el mensaje de hoy', async () => {
    const pend = armar({ config: CON_APROBACION, orden: ordenParaEjecutar('PENDIENTE_APROBACION') });
    const e1 = await errorDe(pend.service.ejecutar('op-1', 'emp-1', 'u-2'));
    expect(cuerpo(e1)).toMatchObject({
      codigo: 'OP_ESTADO_CAMBIADO',
      estado_actual: 'pendiente_aprobacion',
      message: 'La orden aún está pendiente de aprobación',
    });

    const rech = armar({ config: CON_APROBACION, orden: ordenParaEjecutar('RECHAZADA') });
    const e2 = await errorDe(rech.service.ejecutar('op-1', 'emp-1', 'u-2'));
    expect(cuerpo(e2)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'rechazada' });
  });
});

// ─────────────────────────── Concurrencia real (locks que esperan) ───────────────────────────

/**
 * Base en memoria compartida por dos transacciones (`op-base-memoria.testutil.ts`): `pg_advisory_xact_lock` espera de
 * verdad a que la otra transacción termine y cada lectura cede el turno, así las dos se intercalan como en Postgres.
 * Sin el lock, las dos leerían el mismo estado. Las cuotas son de `emp-1` / `prov-1`.
 */
const baseCompartida = (config: Record<string, unknown>, cuotas: any[] = []) => {
  const { service, db } = montarBaseOp({
    config,
    cuotas: cuotas.map((c) => ({ empresa_id: 'emp-1', proveedor_id: 'prov-1', activo: true, ...c })),
  });
  return { service, ordenes: db.ordenes, cuotas: db.cuotas, pagos: db.pagos };
};

const codigoDe = (r: PromiseSettledResult<unknown>) =>
  r.status === 'rejected'
    ? (r.reason as HttpException).getResponse?.() && ((r.reason as HttpException).getResponse() as any).codigo
    : 'OK';

describe('concurrencia real: dos usuarios sobre la misma plata', () => {
  it('dos «ejecutar» simultáneos de la misma OP: uno paga, el otro 409 OP_ESTADO_CAMBIADO; la cuota se descuenta una vez', async () => {
    const db = baseCompartida(REAL, [cuota('cxp-a', '001-001-0000124', 300)]);
    db.ordenes.set('op-1', {
      id: 'op-1',
      empresa_id: 'emp-1',
      proveedor_id: 'prov-1',
      moneda_id: 'mon-pyg',
      cotizacion: 1,
      numero_orden_pago: '001-001-0000005',
      fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
      estado: 'BORRADOR',
      activo: true,
      anulado: false,
      orden_pago_proveedor_det: [
        { cuenta_pagar_id: 'cxp-a', monto: 300, monto_moneda: 300, cotizacion: 1, medio_pago_id: 'mp-efectivo' },
      ],
    });

    const r = await Promise.allSettled([
      db.service.ejecutar('op-1', 'emp-1', 'u-1'),
      db.service.ejecutar('op-1', 'emp-1', 'u-2'),
    ]);

    expect(r.map(codigoDe).sort()).toEqual(['OK', 'OP_ESTADO_CAMBIADO']);
    expect(db.pagos).toHaveLength(1);
    expect(db.cuotas.get('cxp-a')).toMatchObject({ saldo_pendiente: 0, monto_pagado: 300, estado: 'pagada' });
    expect(db.ordenes.get('op-1').estado).toBe('PAGADO');
  });

  it('dos «aprobar» simultáneos: uno aprueba, el otro 409 OP_ESTADO_CAMBIADO', async () => {
    const db = baseCompartida(CON_APROBACION);
    db.ordenes.set('op-1', {
      id: 'op-1',
      empresa_id: 'emp-1',
      numero_orden_pago: '001-001-0000005',
      estado: 'PENDIENTE_APROBACION',
      activo: true,
      anulado: false,
    });

    const r = await Promise.allSettled([
      db.service.aprobar('op-1', 'emp-1', 'u-1'),
      db.service.aprobar('op-1', 'emp-1', 'u-2'),
    ]);

    expect(r.map(codigoDe).sort()).toEqual(['OK', 'OP_ESTADO_CAMBIADO']);
    expect(db.ordenes.get('op-1').estado).toBe('PENDIENTE');
  });

  it('dos altas simultáneas con la misma cuota: una crea, la otra 409 CUOTA_EN_OTRA_ORDEN', async () => {
    const db = baseCompartida(BORRADOR_SIN_APROBACION, [cuota('cxp-a', '001-001-0000124', 300)]);
    const dto = dtoBase({ detalles: [{ cuenta_pagar_id: 'cxp-a', medio_pago_id: 'mp-efectivo', monto: 300 }] });

    const r = await Promise.allSettled([
      db.service.create(dto, 'emp-1', 'u-1'),
      db.service.create(dto, 'emp-1', 'u-2'),
    ]);

    expect(r.map(codigoDe).sort()).toEqual(['CUOTA_EN_OTRA_ORDEN', 'OK']);
    expect(db.ordenes.size).toBe(1);
  });
});

// ─────────────────────────── Revisión final de la rama ───────────────────────────

describe('revisión final: alcance por sucursal en las acciones (404 fuera)', () => {
  const ALCANCE_A = { sucursalIds: ['suc-1'], puntosEstablecimiento: [], depositoIds: [] };
  const ordenEnSucursal = (sucursal: string, estado: string) => ({
    id: 'op-1',
    empresa_id: 'emp-1',
    sucursal_id: sucursal,
    proveedor_id: 'prov-1',
    usuario_id: 'u-creador',
    moneda_id: 'mon-pyg',
    cotizacion: 1,
    numero_orden_pago: '001-001-0000005',
    fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
    origen: 'manual',
    estado,
    activo: true,
    anulado: false,
    orden_pago_proveedor_det: [
      { cuenta_pagar_id: 'cxp-a', monto: 300, monto_moneda: 300, cotizacion: 1, medio_pago_id: 'mp-efectivo' },
    ],
  });
  const ACCIONES: Array<[string, Record<string, unknown>, string, (s: PagosProveedorService) => Promise<unknown>]> = [
    ['enviar a aprobación', CON_APROBACION, 'BORRADOR', (s) => s.enviarAprobacion('op-1', 'emp-1', 'u-1')],
    ['aprobar', CON_APROBACION, 'PENDIENTE_APROBACION', (s) => s.aprobar('op-1', 'emp-1', 'u-1')],
    ['rechazar', CON_APROBACION, 'PENDIENTE_APROBACION', (s) => s.rechazar('op-1', 'No va', 'emp-1', 'u-1')],
    ['ejecutar', REAL, 'BORRADOR', (s) => s.ejecutar('op-1', 'emp-1', 'u-1')],
  ];

  it.each(ACCIONES)('%s sobre una OP de otra sucursal → 404 y no escribe nada', async (_n, config, estado, accion) => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const b = montarBaseOp({ config, cuotas: [cuotaBase('cxp-a', '001-001-0000124', 300)] });
    b.db.ordenes.set('op-1', ordenEnSucursal('suc-2', estado));

    const e = await errorDe(accion(b.service));

    expect(e.getStatus()).toBe(404);
    expect(b.db.ordenes.get('op-1').estado).toBe(estado);
    expect(b.db.pagos).toHaveLength(0);
    expect(b.db.cuotas.get('cxp-a').saldo_pendiente).toBe(300);
    expect(b.audit.log).not.toHaveBeenCalled();
    expect(b.contab.integrarOrdenPago).not.toHaveBeenCalled();
  });

  it.each(ACCIONES)('%s sobre una OP de su sucursal pasa (control)', async (_n, config, estado, accion) => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const b = montarBaseOp({ config, cuotas: [cuotaBase('cxp-a', '001-001-0000124', 300)] });
    b.db.ordenes.set('op-1', ordenEnSucursal('suc-1', estado));

    await accion(b.service);

    expect(b.db.ordenes.get('op-1').estado).not.toBe(estado);
    expect(b.audit.log).toHaveBeenCalled();
  });
});

describe('revisión final: el alta solo acepta cuotas del alcance del usuario', () => {
  const ALCANCE_A = { sucursalIds: ['suc-1'], puntosEstablecimiento: [], depositoIds: [] };
  const dtoUna = (id: string) => dtoBase({ detalles: [{ cuenta_pagar_id: id, medio_pago_id: 'mp-efectivo', monto: 300 }] });

  it('una cuota de una factura de otra sucursal → 400 sin crear la orden', async () => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const b = montarBaseOp({
      config: REAL,
      cuotas: [cuotaBase('cxp-b2', '001-001-0000200', 300, { compra_cab: { numero_factura: '001-001-0000200', sucursal_id: 'suc-2' } })],
    });

    const e = await errorDe(b.service.create(dtoUna('cxp-b2'), 'emp-1', 'u-1'));

    expect(e.getStatus()).toBe(400);
    expect(b.db.ordenes.size).toBe(0);
    expect(b.db.pagos).toHaveLength(0);
    expect(b.db.cuotas.get('cxp-b2').saldo_pendiente).toBe(300);
  });

  it('una cuota de un gasto de otra sucursal → 400; la de un gasto propio pasa', async () => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const gastos = [
      { id: 'g-1', empresa_id: 'emp-1', sucursal_id: 'suc-1' },
      { id: 'g-2', empresa_id: 'emp-1', sucursal_id: 'suc-2' },
    ];
    const deGasto = (id: string, gasto: string) =>
      cuotaBase(id, 'G', 300, { compra_id: null, compra_cab: null, origen_tipo: 'gasto', origen_id: gasto });
    const ajena = montarBaseOp({ config: REAL, gastos, cuotas: [deGasto('cxp-g2', 'g-2')] });
    expect((await errorDe(ajena.service.create(dtoUna('cxp-g2'), 'emp-1', 'u-1'))).getStatus()).toBe(400);
    expect(ajena.db.ordenes.size).toBe(0);

    const propia = montarBaseOp({ config: REAL, gastos, cuotas: [deGasto('cxp-g1', 'g-1')] });
    await propia.service.create(dtoUna('cxp-g1'), 'emp-1', 'u-1');
    expect(propia.db.ordenes.size).toBe(1);
  });

  it('una cuota de un gasto sin sucursal es de la empresa: el alta la acepta', async () => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    // En DOBA todos los gastos están cargados sin sucursal: su deuda no es de ninguna sucursal.
    const b = montarBaseOp({
      config: REAL,
      gastos: [{ id: 'g-9', empresa_id: 'emp-1', sucursal_id: null }],
      cuotas: [cuotaBase('cxp-g9', 'G', 300, { compra_id: null, compra_cab: null, origen_tipo: 'gasto', origen_id: 'g-9' })],
    });

    await b.service.create(dtoUna('cxp-g9'), 'emp-1', 'u-1');

    expect(b.db.ordenes.size).toBe(1);
    expect(b.db.cuotas.get('cxp-g9')).toMatchObject({ saldo_pendiente: 0, estado: 'pagada' });
  });

  it('control: la cuota de una factura de su sucursal pasa y queda pagada', async () => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const b = montarBaseOp({
      config: REAL,
      cuotas: [cuotaBase('cxp-a1', '001-001-0000201', 300, { compra_cab: { numero_factura: '001-001-0000201', sucursal_id: 'suc-1' } })],
    });

    await b.service.create(dtoUna('cxp-a1'), 'emp-1', 'u-1');

    expect(b.db.ordenes.size).toBe(1);
    expect(b.db.cuotas.get('cxp-a1')).toMatchObject({ saldo_pendiente: 0, estado: 'pagada' });
  });
});

describe('revisión final: la contabilidad que sigue al pago corre con el lock op:', () => {
  /** `$transaction` que cuenta cuántas transacciones están abiertas cuando se llama a `integrarOrdenPago`. */
  const conContadorDeTx = (r: ReturnType<typeof armar>) => {
    let abiertas = 0;
    const enIntegrar: number[] = [];
    r.tx.$transaction = jest.fn(async (cb: (t: any) => unknown) => {
      abiertas++;
      try {
        return await cb(r.tx);
      } finally {
        abiertas--;
      }
    });
    r.contab.integrarOrdenPago.mockImplementation(() => {
      enIntegrar.push(abiertas);
      return Promise.resolve();
    });
    return enIntegrar;
  };
  const ordenBorrador = {
    id: 'op-1',
    empresa_id: 'emp-1',
    proveedor_id: 'prov-1',
    moneda_id: 'mon-pyg',
    cotizacion: 1,
    numero_orden_pago: '001-001-0000005',
    fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
    estado: 'BORRADOR',
    activo: true,
    anulado: false,
    orden_pago_proveedor_det: [{ cuenta_pagar_id: 'cxp-b', monto: 500, monto_moneda: 500, cotizacion: 1, medio_pago_id: 'mp-efectivo' }],
  };

  it('ejecutar: integrarOrdenPago corre dentro de una transacción, después de tomar op: (no la del pago)', async () => {
    const r = armar({ orden: ordenBorrador });
    const enIntegrar = conContadorDeTx(r);
    await r.service.ejecutar('op-1', 'emp-1', 'u-2');

    expect(enIntegrar).toEqual([1]);
    // op: se toma dos veces: la del pago y la de la contabilidad, justo antes de integrar.
    const tomasOp = r.tx.$executeRaw.mock.calls
      .map((c: any[], i: number) => [String(c[1]), r.tx.$executeRaw.mock.invocationCallOrder[i]])
      .filter(([k]: any[]) => k === 'op:op-1')
      .map(([, orden]: any[]) => orden);
    expect(tomasOp).toHaveLength(2);
    expect(tomasOp[1]).toBeGreaterThan(r.tx.orden_pago_proveedor_cab.update.mock.invocationCallOrder[0]);
    expect(tomasOp[1]).toBeLessThan(r.contab.integrarOrdenPago.mock.invocationCallOrder[0]);
    expect(r.tx.$transaction).toHaveBeenCalledTimes(2);
    expect(r.tx.$transaction.mock.calls[1][1]).toEqual({ timeout: 60_000 });
  });

  it('alta que paga: integrarOrdenPago corre dentro de una transacción con op: de la orden nueva', async () => {
    const r = armar();
    const enIntegrar = conContadorDeTx(r);
    await r.service.create(dtoBase(), 'emp-1', 'u-1');

    expect(enIntegrar).toEqual([1]);
    const ultimaOp = locks(r.tx).lastIndexOf('op:op-new');
    expect(ultimaOp).toBeGreaterThanOrEqual(0);
    expect(r.tx.$executeRaw.mock.invocationCallOrder[ultimaOp]).toBeLessThan(
      r.contab.integrarOrdenPago.mock.invocationCallOrder[0],
    );
  });

  it('si integrar falla, ejecutar devuelve avisos.contabilidad y la orden queda pagada', async () => {
    const r = armar({ orden: ordenBorrador });
    r.contab.integrarOrdenPago.mockRejectedValue(new Error('no hay período abierto'));
    const res: any = await r.service.ejecutar('op-1', 'emp-1', 'u-2');

    expect(r.tx.orden_pago_proveedor_cab.update.mock.calls[0][0].data.estado).toBe('PAGADO');
    expect(res.avisos).toEqual({
      contabilidad: 'La orden quedó pagada, pero no se pudo contabilizar. Motivo: no hay período abierto',
    });
  });

  it('anular durante la contabilidad: espera el lock y encuentra el asiento (base en memoria)', async () => {
    const b = montarBaseOp({ config: REAL, cuotas: [cuotaBase('cxp-b', '001-001-0000123', 500)] });
    b.db.ordenes.set('op-1', { ...ordenBorrador, origen: 'manual' });
    let soltarIntegracion!: () => void;
    const integrando = new Promise<void>((r) => (soltarIntegracion = r));
    const orden: string[] = [];
    b.contab.integrarOrdenPago.mockImplementation(async () => {
      orden.push('integrar:inicio');
      await integrando;
      orden.push('integrar:fin');
    });
    const pago = b.service.ejecutar('op-1', 'emp-1', 'u-1');
    // Espera a que la integración haya empezado (con el lock tomado).
    while (!orden.length) await new Promise((r) => setImmediate(r));
    const otroLock = b.prisma.$transaction(async (tx: any) => {
      await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${'op:op-1'}))`;
      orden.push('anular:lock');
    });
    for (let i = 0; i < 5; i++) await new Promise((r) => setImmediate(r));
    expect(orden).toEqual(['integrar:inicio']);
    soltarIntegracion();
    await Promise.all([pago, otroLock]);
    expect(orden).toEqual(['integrar:inicio', 'integrar:fin', 'anular:lock']);
  });
});

describe('revisión final: estado legacy «pendiente» en minúscula es borrador (estadoOpClave)', () => {
  const ordenLegacy = {
    id: 'op-1',
    empresa_id: 'emp-1',
    proveedor_id: 'prov-1',
    usuario_id: 'u-creador',
    moneda_id: 'mon-pyg',
    cotizacion: 1,
    numero_orden_pago: '001-001-0000005',
    fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
    estado: 'pendiente',
    activo: true,
    anulado: false,
    orden_pago_proveedor_det: [{ cuenta_pagar_id: 'cxp-b', monto: 500, monto_moneda: 500, cotizacion: 1, medio_pago_id: 'mp-efectivo' }],
  };

  it('con aprobación se envía a aprobación', async () => {
    const { service, tx } = armar({ config: CON_APROBACION, orden: ordenLegacy });
    await service.enviarAprobacion('op-1', 'emp-1', 'u-1');
    expect(tx.orden_pago_proveedor_cab.update.mock.calls[0][0].data.estado).toBe('PENDIENTE_APROBACION');
  });

  it('con aprobación no se aprueba (no está pendiente de aprobación)', async () => {
    const { service, tx } = armar({ config: CON_APROBACION, orden: ordenLegacy });
    const e = await errorDe(service.aprobar('op-1', 'emp-1', 'u-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'borrador' });
    expect(tx.orden_pago_proveedor_cab.update).not.toHaveBeenCalled();
  });

  it('ejecutar con aprobación → 400 APROBACION_REQUERIDA y no paga', async () => {
    const { service, tx } = armar({ config: CON_APROBACION, orden: ordenLegacy });
    const e = await errorDe(service.ejecutar('op-1', 'emp-1', 'u-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'APROBACION_REQUERIDA' });
    expect(tx.pagos_proveedor.create).not.toHaveBeenCalled();
  });

  it('sin aprobación se ejecuta', async () => {
    const { service, tx } = armar({ config: REAL, orden: ordenLegacy });
    await service.ejecutar('op-1', 'emp-1', 'u-1');
    expect(tx.pagos_proveedor.create).toHaveBeenCalledTimes(1);
    expect(tx.orden_pago_proveedor_cab.update.mock.calls[0][0].data.estado).toBe('PAGADO');
  });
});

describe('revisión final: timeout de las transacciones que esperan locks', () => {
  it('alta, workflow y ejecutar pasan { timeout: 30_000 } a $transaction', async () => {
    const alta = armar();
    await alta.service.create(dtoBase(), 'emp-1', 'u-1');
    expect(alta.tx.$transaction.mock.calls[0][1]).toEqual({ timeout: 30_000 });

    const orden = {
      id: 'op-1',
      empresa_id: 'emp-1',
      proveedor_id: 'prov-1',
      numero_orden_pago: '001-001-0000005',
      estado: 'PENDIENTE_APROBACION',
      activo: true,
      anulado: false,
    };
    const wf = armar({ config: CON_APROBACION, orden });
    await wf.service.aprobar('op-1', 'emp-1', 'u-1');
    expect(wf.tx.$transaction.mock.calls[0][1]).toEqual({ timeout: 30_000 });

    const ej = armar({
      orden: {
        ...orden,
        estado: 'BORRADOR',
        moneda_id: 'mon-pyg',
        cotizacion: 1,
        fecha_pago: new Date('2026-10-05T00:00:00.000Z'),
        orden_pago_proveedor_det: [{ cuenta_pagar_id: 'cxp-b', monto: 500, monto_moneda: 500, cotizacion: 1, medio_pago_id: 'mp-efectivo' }],
      },
    });
    await ej.service.ejecutar('op-1', 'emp-1', 'u-1');
    expect(ej.tx.$transaction.mock.calls[0][1]).toEqual({ timeout: 30_000 });
  });
});
