import { HttpException } from '@nestjs/common';
import { cuotaBase, montarBaseOp, OpcionesBaseOp } from './op-base-memoria.testutil';

// Usuario sin restricción de sucursal: el alcance se prueba en op-escrituras.spec.ts.
jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn().mockResolvedValue(null),
}));

/**
 * Task 18 (plan 2026-10-28-orden-pago-cxp): la matriz «Probar según configuración» del spec
 * (docs/superpowers/specs/2026-10-28-orden-pago-cxp-design.md, filas 1–9) contra el servicio real sobre la base en
 * memoria de `op-base-memoria.testutil.ts` (locks que esperan y commit/rollback reales): por cada config, el alta
 * (estado, permiso `_PAGAR`, saldo), ejecutar, enviar / aprobar / rechazar, y con la OP apagada el rechazo de todo.
 * Además: Contabilidad encendida y apagada, la regla `PAGO_PROVEEDOR` presente y ausente, el medio sin caja, y una
 * orden en USD desde una cuenta PYG (y el 400 de PYG desde una cuenta USD).
 *
 * Las configs son las de `CONFIG_OP` del front (e2e/flujos/fixtures-compras-op.js), con los mismos nombres. La fila 1
 * es la de las 9 empresas de `config_compras` de la base local (psql en solo lectura, 2026-10-28): 8 iguales a
 * `realLocal` y Novasis Py S.A. con `permitir_pago_parcial` (`pagoParcial`); todas SEMANAL. No hay otra fila que sumar.
 *
 * Lo que la matriz espera de cada fila está escrito a mano (no sale de `requiereAprobacionOrdenPago`): si la fórmula
 * cambia, la matriz lo dice.
 */

const REAL_LOCAL = {
  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,
};

/** `CONFIG_OP` del front. */
const CONFIG_OP = {
  realLocal: { ...REAL_LOCAL },
  pagoParcial: { ...REAL_LOCAL, permitir_pago_parcial: true },
  borradorSinAplicar: { ...REAL_LOCAL, aplicar_pago_al_guardar: false },
  conAprobacion: { ...REAL_LOCAL, requiere_aprobacion: true, permite_pago_sin_aprobacion: false },
  aprobacionConPagoSin: { ...REAL_LOCAL, requiere_aprobacion: true, permite_pago_sin_aprobacion: true },
  workflowObligatorio: { ...REAL_LOCAL, workflow_obligatorio: true },
  contadoEnOp: { ...REAL_LOCAL, incluir_contado_en_orden_pago: true },
  sinCxpAutomatica: { ...REAL_LOCAL, generar_cxp_automatico: false },
  opApagada: { ...REAL_LOCAL, habilitar_orden_pago: false },
};

type Fila = {
  nombre: string;
  config: Record<string, unknown>;
  /** Estado con el que queda el alta (sin `enviar_a_aprobacion`). */
  alta: 'PAGADO' | 'BORRADOR';
  /** La config pide aprobación. */
  aprobacion: boolean;
  parcial: boolean;
};

const FILAS: Fila[] = [
  {
    nombre: '1 · realLocal (las 9 empresas locales)',
    config: CONFIG_OP.realLocal,
    alta: 'PAGADO',
    aprobacion: false,
    parcial: false,
  },
  {
    nombre: '2 · pagoParcial (Novasis Py S.A.)',
    config: CONFIG_OP.pagoParcial,
    alta: 'PAGADO',
    aprobacion: false,
    parcial: true,
  },
  {
    nombre: '3 · borradorSinAplicar',
    config: CONFIG_OP.borradorSinAplicar,
    alta: 'BORRADOR',
    aprobacion: false,
    parcial: false,
  },
  // Aplicar al guardar está encendido y no se tiene en cuenta: la orden pide aprobación.
  { nombre: '4 · conAprobacion', config: CONFIG_OP.conAprobacion, alta: 'BORRADOR', aprobacion: true, parcial: false },
  {
    nombre: '5 · aprobacionConPagoSin (como 1)',
    config: CONFIG_OP.aprobacionConPagoSin,
    alta: 'PAGADO',
    aprobacion: false,
    parcial: false,
  },
  // Con permite_pago_sin_aprobacion encendido igual pide aprobación.
  {
    nombre: '6 · workflowObligatorio (como 4)',
    config: CONFIG_OP.workflowObligatorio,
    alta: 'BORRADOR',
    aprobacion: true,
    parcial: false,
  },
  { nombre: '7 · contadoEnOp', config: CONFIG_OP.contadoEnOp, alta: 'PAGADO', aprobacion: false, parcial: false },
  {
    nombre: '8 · sinCxpAutomatica',
    config: CONFIG_OP.sinCxpAutomatica,
    alta: 'PAGADO',
    aprobacion: false,
    parcial: false,
  },
];

const MSG_APAGADA = 'La empresa tiene deshabilitada la orden de pago en Configuración de Compras';

/**
 * La cuota de cada fila: la de una factura a crédito; en la 7, la de una factura de contado que quedó pendiente para la
 * OP; en la 8, la de una compra que trajo Marangatu (las facturas no crean cuotas, Marangatu sí).
 */
const cuotaDeFila = (f: Fila) =>
  cuotaBase('cxp-1', '001-001-0000123', 500, {
    ...(f.config.incluir_contado_en_orden_pago ? { observaciones: 'Contado pendiente de pago por orden' } : {}),
    ...(f.config.generar_cxp_automatico === false ? { observaciones: 'Marangatu' } : {}),
  });

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

const ordenEn = (estado: string, over: Record<string, unknown> = {}) => ({
  id: 'op-1',
  empresa_id: 'emp-1',
  sucursal_id: 'suc-1',
  proveedor_id: 'prov-1',
  usuario_id: 'u-creador',
  moneda_id: 'mon-pyg',
  cotizacion: 1,
  numero_orden_pago: '001-001-0000004',
  fecha_pago: '2026-10-05T00:00:00.000Z',
  monto_total: 500,
  referencia: null,
  observaciones: null,
  sesion_caja_id: null,
  origen: 'manual',
  estado,
  activo: true,
  anulado: false,
  orden_pago_proveedor_det: [
    { cuenta_pagar_id: 'cxp-1', medio_pago_id: 'mp-efectivo', monto: 500, monto_moneda: 500, cotizacion: 1 },
  ],
  ...over,
});

const errorDe = (p: Promise<unknown>) =>
  p.then(
    () => {
      throw new Error('se esperaba un error');
    },
    (e: HttpException) => e,
  );
const cuerpo = (e: HttpException) =>
  typeof e?.getResponse === 'function' ? (e.getResponse() as Record<string, any>) : {};
const acciones = (audit: { log: jest.Mock }) => audit.log.mock.calls.map((c: any[]) => c[0].action);

const montar = (f: Fila | { config: Record<string, unknown> }, o: Partial<OpcionesBaseOp> = {}) =>
  montarBaseOp({ cuotas: [cuotaDeFila(f as Fila)], ...o, config: f.config });

/** Nada quedó escrito: ni órdenes nuevas, ni pagos, ni la cuota ni la numeración cambiaron. */
const sinEscrituras = (b: ReturnType<typeof montarBaseOp>, ordenesAntes = 0) => {
  expect(b.db.ordenes.size).toBe(ordenesAntes);
  expect(b.db.pagos).toHaveLength(0);
  expect(b.db.cuotas.get('cxp-1')).toMatchObject({ saldo_pendiente: 500, monto_pagado: 0, estado: 'pendiente' });
  expect(b.db.numeracion?.numero_actual).toBe(5);
};

const alta = (b: ReturnType<typeof montarBaseOp>) =>
  [...b.db.ordenes.values()].find((x) => x.id.startsWith('op-alta-'));

describe('Órdenes de pago: matriz de configuración (spec «Probar según configuración», filas 1–8)', () => {
  describe.each(FILAS)('$nombre', (f) => {
    it(`alta con el saldo entero → ${f.alta}${f.alta === 'PAGADO' ? ' (paga en la misma transacción)' : ' (no paga)'}`, async () => {
      const b = montar(f);
      const r: any = await b.service.create(dto(), 'emp-1', 'u-1');

      const op = alta(b);
      expect(op).toMatchObject({
        estado: f.alta,
        numero_orden_pago: '001-001-0000005',
        monto_total: 500,
        origen: 'manual',
      });
      expect(b.db.numeracion?.numero_actual).toBe(6);
      if (f.alta === 'PAGADO') {
        expect(b.db.pagos).toHaveLength(1);
        expect(b.db.cuotas.get('cxp-1')).toMatchObject({ saldo_pendiente: 0, monto_pagado: 500, estado: 'pagada' });
        expect(b.contab.integrarOrdenPago).toHaveBeenCalledWith(op.id);
        expect(acciones(b.audit)).toEqual(['CREATE', 'PAY']);
      } else {
        expect(b.db.pagos).toHaveLength(0);
        expect(b.db.cuotas.get('cxp-1')).toMatchObject({ saldo_pendiente: 500, estado: 'pendiente' });
        expect(b.contab.integrarOrdenPago).not.toHaveBeenCalled();
        expect(acciones(b.audit)).toEqual(['CREATE']);
      }
      expect(r.avisos).toEqual({});
    });

    it(`alta sin _PAGAR → ${f.alta === 'PAGADO' ? '403 SIN_PERMISO_PAGAR y no escribe nada' : 'se guarda igual (no paga)'}`, async () => {
      const b = montar(f, { pagar: false });
      if (f.alta === 'PAGADO') {
        const e = await errorDe(b.service.create(dto(), 'emp-1', 'u-1'));
        expect(e.getStatus()).toBe(403);
        expect(cuerpo(e).codigo).toBe('SIN_PERMISO_PAGAR');
        sinEscrituras(b);
      } else {
        await b.service.create(dto(), 'emp-1', 'u-1');
        expect(alta(b).estado).toBe('BORRADOR');
      }
    });

    it(`alta con enviar_a_aprobacion → ${f.aprobacion ? 'PENDIENTE_APROBACION en la misma transacción' : '400 APROBACION_NO_REQUERIDA'}`, async () => {
      const b = montar(f);
      if (f.aprobacion) {
        await b.service.create(dto({ enviar_a_aprobacion: true }), 'emp-1', 'u-1');
        expect(alta(b).estado).toBe('PENDIENTE_APROBACION');
        expect(b.db.pagos).toHaveLength(0);
        expect(acciones(b.audit)).toEqual(['CREATE', 'SEND']);
      } else {
        const e = await errorDe(b.service.create(dto({ enviar_a_aprobacion: true }), 'emp-1', 'u-1'));
        expect(e.getStatus()).toBe(400);
        expect(cuerpo(e).codigo).toBe('APROBACION_NO_REQUERIDA');
        sinEscrituras(b);
      }
    });

    it(`monto menor al saldo → ${f.parcial ? 'se acepta; la cuota queda parcial y vuelve a ofrecerse' : '400 MONTO_INVALIDO línea 1 y no escribe nada'}`, async () => {
      const b = montar(f);
      if (!f.parcial) {
        const e = await errorDe(b.service.create(dto({}, { monto: 300 }), 'emp-1', 'u-1'));
        expect(e.getStatus()).toBe(400);
        expect(cuerpo(e)).toMatchObject({ codigo: 'MONTO_INVALIDO', campo: 'detalles', linea: 1 });
        expect(b.db.rollbacks).toBe(1);
        sinEscrituras(b);
        return;
      }
      await b.service.create(dto({}, { monto: 300 }), 'emp-1', 'u-1');
      expect(b.db.cuotas.get('cxp-1')).toMatchObject({ saldo_pendiente: 200, monto_pagado: 300, estado: 'parcial' });
      // La orden pagada no la retiene: otra orden paga el resto; por encima del saldo, no.
      const e = await errorDe(b.service.create(dto({}, { monto: 201 }), 'emp-1', 'u-1'));
      expect(cuerpo(e)).toMatchObject({ codigo: 'MONTO_INVALIDO', linea: 1 });
      await b.service.create(dto({}, { monto: 200 }), 'emp-1', 'u-1');
      expect(b.db.cuotas.get('cxp-1')).toMatchObject({ saldo_pendiente: 0, monto_pagado: 500, estado: 'pagada' });
      expect(b.db.pagos.map((p) => p.monto)).toEqual([300, 200]);
    });

    it(`ejecutar un borrador → ${f.aprobacion ? '400: pide aprobación antes' : 'PAGADO con su pago'}`, async () => {
      const b = montar(f, { ordenes: [ordenEn('BORRADOR')] });
      if (f.aprobacion) {
        const e = await errorDe(b.service.ejecutar('op-1', 'emp-1', 'u-2'));
        expect(e.getStatus()).toBe(400);
        expect(e.message).toBe('La orden requiere aprobación previa. Enviá y aprobá la OP antes de ejecutar');
        expect(b.db.ordenes.get('op-1').estado).toBe('BORRADOR');
        sinEscrituras(b, 1);
        return;
      }
      const r: any = await b.service.ejecutar('op-1', 'emp-1', 'u-2');
      expect(b.db.ordenes.get('op-1').estado).toBe('PAGADO');
      expect(b.db.pagos).toHaveLength(1);
      expect(b.db.cuotas.get('cxp-1')).toMatchObject({ saldo_pendiente: 0, estado: 'pagada' });
      expect(acciones(b.audit)).toEqual(['PAY']);
      expect(r.avisos).toEqual({});
    });

    if (f.aprobacion) {
      it('enviar → rechazar con motivo → ejecutar la rechazada da 409 → reenviar → aprobar → ejecutar', async () => {
        const b = montar(f);
        await b.service.create(dto({ enviar_a_aprobacion: true }), 'emp-1', 'u-1');
        const id = alta(b).id;
        await b.service.rechazar(id, 'Falta la factura original', 'emp-1', 'u-apr');
        expect(b.db.ordenes.get(id).estado).toBe('RECHAZADA');
        const e = await errorDe(b.service.ejecutar(id, 'emp-1', 'u-2'));
        expect(cuerpo(e)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'rechazada' });
        await b.service.enviarAprobacion(id, 'emp-1', 'u-1');
        await b.service.aprobar(id, 'emp-1', 'u-apr');
        expect(b.db.ordenes.get(id).estado).toBe('PENDIENTE');
        expect(b.db.pagos).toHaveLength(0);
        await b.service.ejecutar(id, 'emp-1', 'u-2');
        expect(b.db.ordenes.get(id).estado).toBe('PAGADO');
        expect(b.db.cuotas.get('cxp-1')).toMatchObject({ saldo_pendiente: 0, estado: 'pagada' });
        expect(acciones(b.audit)).toEqual(['CREATE', 'SEND', 'REJECT', 'SEND', 'APPROVE', 'PAY']);
      });
    } else {
      it('enviar, aprobar y rechazar una pendiente de aprobación (de antes) → 400 APROBACION_NO_REQUERIDA, sin cambios', async () => {
        const b = montar(f, { ordenes: [ordenEn('PENDIENTE_APROBACION')] });
        for (const accion of [
          () => b.service.enviarAprobacion('op-1', 'emp-1', 'u-1'),
          () => b.service.aprobar('op-1', 'emp-1', 'u-apr'),
          () => b.service.rechazar('op-1', 'No va', 'emp-1', 'u-apr'),
        ]) {
          const e = await errorDe(accion());
          expect(e.getStatus()).toBe(400);
          expect(cuerpo(e).codigo).toBe('APROBACION_NO_REQUERIDA');
        }
        expect(b.db.ordenes.get('op-1').estado).toBe('PENDIENTE_APROBACION');
        expect(b.audit.log).not.toHaveBeenCalled();
      });
    }
  });
});

describe('9 · opApagada: el backend rechaza crear, enviar, aprobar, rechazar y ejecutar', () => {
  const f = { config: CONFIG_OP.opApagada };
  it.each([
    ['crear', (b: ReturnType<typeof montarBaseOp>) => b.service.create(dto(), 'emp-1', 'u-1'), 0],
    [
      'crear con enviar_a_aprobacion',
      (b: ReturnType<typeof montarBaseOp>) => b.service.create(dto({ enviar_a_aprobacion: true }), 'emp-1', 'u-1'),
      0,
    ],
    [
      'enviar a aprobación',
      (b: ReturnType<typeof montarBaseOp>) => b.service.enviarAprobacion('op-1', 'emp-1', 'u-1'),
      1,
    ],
    ['aprobar', (b: ReturnType<typeof montarBaseOp>) => b.service.aprobar('op-1', 'emp-1', 'u-1'), 1],
    ['rechazar', (b: ReturnType<typeof montarBaseOp>) => b.service.rechazar('op-1', 'Motivo', 'emp-1', 'u-1'), 1],
    ['ejecutar', (b: ReturnType<typeof montarBaseOp>) => b.service.ejecutar('op-1', 'emp-1', 'u-1'), 1],
  ])('%s → 400 «deshabilitada» y no escribe nada', async (_n, accion, ordenesAntes) => {
    // Una orden de antes de apagar la OP, en el estado que cada acción espera.
    const estado = _n === 'ejecutar' ? 'BORRADOR' : _n === 'enviar a aprobación' ? 'BORRADOR' : 'PENDIENTE_APROBACION';
    const b = montar(f, { ordenes: ordenesAntes ? [ordenEn(estado)] : [] });
    const e = await errorDe(accion(b));
    expect(e.getStatus()).toBe(400);
    expect(e.message).toBe(MSG_APAGADA);
    sinEscrituras(b, ordenesAntes);
    if (ordenesAntes) expect(b.db.ordenes.get('op-1').estado).toBe(estado);
    expect(b.audit.log).not.toHaveBeenCalled();
  });
});

// ─────────────────────────── Además (config real) ───────────────────────────

const CAJA = { id: 'tes-caja', nombre: 'Caja chica', moneda: 'PYG', saldo_actual: 10_000_000 };
const BANCO_PYG = { id: 'tes-pyg', nombre: 'Banco Itaú', moneda: 'PYG', saldo_actual: 50_000_000 };
const BANCO_USD = { id: 'tes-usd', nombre: 'Banco Itaú USD', moneda: 'USD', saldo_actual: 20_000 };
const REGLA = { medio_pago_id: null, activo: true, cuenta_id: CAJA.id };
const real = { config: CONFIG_OP.realLocal };
const conTesoreria = (o: Partial<OpcionesBaseOp> = {}) =>
  montar(real, { tesoreriaReal: true, cuentasTes: [CAJA, BANCO_PYG, BANCO_USD], reglas: [REGLA], ...o });

describe('Módulo Contabilidad encendido y apagado', () => {
  it('encendido: la OP pagada sin asiento queda PENDIENTE y se puede reintentar', async () => {
    const b = conTesoreria({ conContabilidad: true });
    await b.service.create(dto(), 'emp-1', 'u-1');
    const id = alta(b).id;
    expect(
      (await b.service.estadosContablesOps(b.prisma, 'emp-1', [{ ...b.db.ordenes.get(id), id }])).get(id)?.estado,
    ).toBe('PENDIENTE');
    // El asiento se confirma al reintentar.
    b.contab.integrarOrdenPago.mockImplementationOnce(() => {
      b.db.documentosContables.push({
        id: 'doc-1',
        empresa_id: 'emp-1',
        origen_tipo: 'orden_pago_proveedor_cab',
        origen_id: id,
        estado: 'CONFIRMADO',
      });
      return Promise.resolve();
    });
    const r: any = await b.service.reintentarContabilidad(id, 'emp-1', 'u-1');
    expect(r.avisos).toEqual({});
    expect(
      (await b.service.estadosContablesOps(b.prisma, 'emp-1', [{ ...b.db.ordenes.get(id), id }])).get(id)?.estado,
    ).toBe('ASENTADO');
  });

  it('apagado: contabilidad_estado null y sin reintento (409 OP_ESTADO_CAMBIADO)', async () => {
    const b = conTesoreria({ conContabilidad: false });
    await b.service.create(dto(), 'emp-1', 'u-1');
    const id = alta(b).id;
    expect(
      (await b.service.estadosContablesOps(b.prisma, 'emp-1', [{ ...b.db.ordenes.get(id), id }])).get(id)?.estado,
    ).toBeNull();
    const llamadas = b.contab.integrarOrdenPago.mock.calls.length;
    const e = await errorDe(b.service.reintentarContabilidad(id, 'emp-1', 'u-1'));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e).codigo).toBe('OP_ESTADO_CAMBIADO');
    expect(b.contab.integrarOrdenPago).toHaveBeenCalledTimes(llamadas);
  });
});

describe('Regla PAGO_PROVEEDOR presente y ausente', () => {
  it('presente: «Sale de» la nombra antes de guardar; al pagar, el egreso sale de su cuenta y queda CONFIRMADO', async () => {
    const b = conTesoreria();
    await expect(
      b.service.cuentaPago('emp-1', { medio_pago_id: 'mp-efectivo', moneda_id: 'mon-pyg' }),
    ).resolves.toEqual({
      cuenta: { id: CAJA.id, nombre: CAJA.nombre, moneda: 'PYG' },
      conversion: null,
      avisos: [],
    });
    const r: any = await b.service.create(dto(), 'emp-1', 'u-1');
    const id = alta(b).id;
    expect(r.avisos).toEqual({});
    expect(b.db.movimientos).toEqual([
      expect.objectContaining({ cuenta_id: CAJA.id, tipo: 'EGRESO', estado: 'CONFIRMADO', monto: 500, origen_id: id }),
    ]);
    expect(b.db.cuentasTes.get(CAJA.id).saldo_actual).toBe(CAJA.saldo_actual - 500);
    expect((await b.service.estadosTesoreriaOps(b.prisma, 'emp-1', [id])).get(id)).toBe('CONFIRMADO');
  });

  it('ausente: el aviso antes de guardar; la OP queda pagada con avisos.tesoreria, PENDIENTE y Reintentar lo registra una vez', async () => {
    const b = conTesoreria({ reglas: [] });
    const SIN_REGLA =
      'No existe una regla de Tesorería para "Pago a proveedor". Configurá la cuenta en Configuración > Tesorería > Reglas.';
    await expect(
      b.service.cuentaPago('emp-1', { medio_pago_id: 'mp-efectivo', moneda_id: 'mon-pyg' }),
    ).resolves.toEqual({
      cuenta: null,
      conversion: null,
      avisos: [SIN_REGLA],
    });
    const r: any = await b.service.create(dto(), 'emp-1', 'u-1');
    const id = alta(b).id;
    expect(r.avisos).toEqual({
      tesoreria: `La orden quedó pagada, pero no se pudo registrar en Tesorería. Motivo: ${SIN_REGLA}`,
      codigo_tesoreria: 'SIN_REGLA',
    });
    expect(b.db.ordenes.get(id).estado).toBe('PAGADO');
    expect(b.db.movimientos).toHaveLength(0);
    expect(b.db.cuentasTes.get(CAJA.id).saldo_actual).toBe(CAJA.saldo_actual);
    expect((await b.service.estadosTesoreriaOps(b.prisma, 'emp-1', [id])).get(id)).toBe('PENDIENTE');

    // Sin regla todavía: el reintento no registra nada y lo dice.
    const sigue: any = await b.service.reintentarTesoreria(id, 'emp-1', 'u-1');
    expect(sigue.avisos.tesoreria).toContain(SIN_REGLA);
    expect(sigue.avisos.codigo_tesoreria).toBe('SIN_REGLA');
    expect(b.db.movimientos).toHaveLength(0);

    // Con la regla cargada, Reintentar registra el egreso; un segundo reintento ya no tiene nada pendiente.
    b.db.reglas.push({ empresa_id: 'emp-1', tipo_operacion: 'PAGO_PROVEEDOR', ...REGLA });
    const ok: any = await b.service.reintentarTesoreria(id, 'emp-1', 'u-1');
    expect(ok.avisos).toEqual({});
    expect(b.db.movimientos).toHaveLength(1);
    expect(b.db.cuentasTes.get(CAJA.id).saldo_actual).toBe(CAJA.saldo_actual - 500);
    const e = await errorDe(b.service.reintentarTesoreria(id, 'emp-1', 'u-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO' });
    expect(b.db.movimientos).toHaveLength(1);
  });
});

describe('Regla PAGO_PROVEEDOR de un solo medio, con la cuenta inactiva', () => {
  it('OP con dos medios: el egreso del primero se deshace con la falla del segundo (Tesorería todo o nada)', async () => {
    const INACTIVA = { id: 'tes-vieja', nombre: 'Caja vieja', moneda: 'PYG', saldo_actual: 0, activo: false };
    const b = conTesoreria({
      cuotas: [cuotaBase('cxp-1', '001-001-0000123', 500), cuotaBase('cxp-2', '001-001-0000124', 300)],
      cuentasTes: [CAJA, INACTIVA],
      reglas: [REGLA, { medio_pago_id: 'mp-otro', activo: true, cuenta_id: INACTIVA.id }],
    });
    const r: any = await b.service.create(
      dto({
        detalles: [
          { cuenta_pagar_id: 'cxp-1', medio_pago_id: 'mp-efectivo', monto: 500 },
          { cuenta_pagar_id: 'cxp-2', medio_pago_id: 'mp-otro', monto: 300 },
        ],
      }),
      'emp-1',
      'u-1',
    );
    const id = alta(b).id;
    expect(b.db.ordenes.get(id).estado).toBe('PAGADO');
    expect(r.avisos.tesoreria).toContain(
      'La cuenta configurada en Tesorería para "Pago a proveedor" está inactiva o no existe',
    );
    // También es de la regla: el front explica la cascada y ofrece «Ir a configurar».
    expect(r.avisos.codigo_tesoreria).toBe('SIN_REGLA');
    // El egreso del efectivo se llegó a escribir y se deshizo con la transacción de Tesorería.
    expect(b.db.movimientos).toHaveLength(0);
    expect(b.db.movimientoDet).toHaveLength(0);
    expect(b.db.cuentasTes.get(CAJA.id).saldo_actual).toBe(CAJA.saldo_actual);
    expect(b.db.rollbacks).toBe(1);
    expect((await b.service.estadosTesoreriaOps(b.prisma, 'emp-1', [id])).get(id)).toBe('PENDIENTE');
  });
});

describe('Medio que no mueve dinero', () => {
  it.each([
    ['Pago por anticipo (código 11)', 'mp-anticipo', []],
    ['un medio que la empresa marcó no_mueve_caja', 'mp-otro', ['mp-otro']],
  ])('%s: sin egreso y sin aviso, aunque no haya regla', async (_n, medio, sinCaja) => {
    const b = conTesoreria({ reglas: [], sinCaja: sinCaja });
    const r: any = await b.service.create(dto({}, { medio_pago_id: medio }), 'emp-1', 'u-1');
    const id = alta(b).id;
    expect(b.db.ordenes.get(id).estado).toBe('PAGADO');
    expect(r.avisos).toEqual({});
    expect(b.db.movimientos).toHaveLength(0);
    expect(b.db.cheques).toHaveLength(0);
    expect((await b.service.estadosTesoreriaOps(b.prisma, 'emp-1', [id])).get(id)).toBeNull();
  });
});

describe('Monedas', () => {
  const USD = { moneda_id: 'mon-usd' };
  const transferencia = (cuenta: string) => ({
    medio_pago_id: 'mp-transf',
    cuenta_bancaria_id: cuenta,
    numero_operacion: 'TR-1',
  });

  it('OP en USD desde una cuenta PYG: se paga y el egreso sale en guaraníes con la cotización', async () => {
    const b = conTesoreria({ cuotas: [cuotaBase('cxp-1', '001-001-0000123', 500, USD)] });
    await b.service.create(dto({ cotizacion: 7350 }, transferencia(BANCO_PYG.id)), 'emp-1', 'u-1');
    const op = alta(b);
    expect(op).toMatchObject({ estado: 'PAGADO', moneda_id: 'mon-usd', cotizacion: 7350 });
    expect(b.db.pagos[0]).toMatchObject({ moneda_id: 'mon-usd', monto: 500, cotizacion: 7350 });
    expect(b.db.movimientos).toEqual([
      expect.objectContaining({ cuenta_id: BANCO_PYG.id, monto: 3_675_000, tipo_cambio: 7350, tipo: 'EGRESO' }),
    ]);
    expect(b.db.cuentasTes.get(BANCO_PYG.id).saldo_actual).toBe(BANCO_PYG.saldo_actual - 3_675_000);
  });

  it('OP en USD desde una cuenta USD: el egreso va en dólares, sin conversión', async () => {
    const b = conTesoreria({ cuotas: [cuotaBase('cxp-1', '001-001-0000123', 500, USD)] });
    await b.service.create(dto({ cotizacion: 7350 }, transferencia(BANCO_USD.id)), 'emp-1', 'u-1');
    expect(b.db.movimientos).toEqual([expect.objectContaining({ cuenta_id: BANCO_USD.id, monto: 500 })]);
    expect(b.db.cuentasTes.get(BANCO_USD.id).saldo_actual).toBe(BANCO_USD.saldo_actual - 500);
  });

  it('OP en PYG desde una cuenta USD → 400 y no escribe nada', async () => {
    const b = conTesoreria();
    const e = await errorDe(b.service.create(dto({}, transferencia(BANCO_USD.id)), 'emp-1', 'u-1'));
    expect(e.getStatus()).toBe(400);
    expect(e.message).toBe(
      'El pago está en guaraníes y la cuenta "Banco Itaú USD" está en USD. Elegí una cuenta en guaraníes.',
    );
    sinEscrituras(b);
    expect(b.db.movimientos).toHaveLength(0);
  });
});

describe('revisión final: el aviso de Tesorería dice de qué tipo es (codigo_tesoreria)', () => {
  it('la cuenta de la regla no acepta la moneda de la orden → CUENTA_NO_ACEPTA_MONEDA (no es de la regla)', async () => {
    const b = conTesoreria({ reglas: [{ medio_pago_id: null, activo: true, cuenta_id: BANCO_USD.id }] });
    const r: any = await b.service.create(dto(), 'emp-1', 'u-1');
    expect(b.db.ordenes.get(alta(b).id).estado).toBe('PAGADO');
    expect(r.avisos.tesoreria).toContain('La orden quedó pagada, pero no se pudo registrar en Tesorería. Motivo:');
    expect(r.avisos.codigo_tesoreria).toBe('CUENTA_NO_ACEPTA_MONEDA');
  });

  it('un error de la base al registrar → ERROR', async () => {
    const b = conTesoreria();
    jest.spyOn(b.service as any, 'getCategoriaTesoreriaPagoProveedor').mockRejectedValue(new Error('deadlock detected'));
    const r: any = await b.service.create(dto(), 'emp-1', 'u-1');
    expect(r.avisos).toEqual({
      tesoreria: 'La orden quedó pagada, pero no se pudo registrar en Tesorería. Motivo: deadlock detected',
      codigo_tesoreria: 'ERROR',
    });
  });

  it('sin aviso no hay codigo_tesoreria', async () => {
    const b = conTesoreria();
    const r: any = await b.service.create(dto(), 'emp-1', 'u-1');
    expect(r.avisos).toEqual({});
  });
});
