import { BadRequestException } from '@nestjs/common';
import { ComprasService } from './compras.service';
import { opcionesMatchingOc } from 'src/ordenes-compra/estado-oc';
import * as ejecucion from 'src/requisiciones/ejecucion-requisicion';

/**
 * Facturas contra una OC según la config (spec 2026-10-23-ordenes-compra, punto 6):
 * - Recepciones apagada (`habilitar_recepcion_compra === false`): se factura contra lo pedido.
 * - Recepciones encendida: contra lo recibido, como hoy.
 */

const crearServicio = (prisma: any = {}) =>
  new ComprasService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any) as any;

/** OC aprobada de una línea: 10 pedidas a 100, nada recibido. */
const ordenSinRecibir = (extra: Record<string, any> = {}) => ({
  id: 'oc-1',
  numero_orden: 'OC-00000001',
  empresa_id: 'emp-1',
  proveedor_id: 'prov-1',
  estado: 'pendiente',
  orden_compra_det: [
    {
      id: 'det-1',
      producto_id: 'prod-1',
      descripcion: 'Producto 1',
      cantidad: 10,
      cantidad_recibida: 0,
      precio_unitario: 100,
    },
  ],
  ...extra,
});

const item = (extra: Record<string, any> = {}) => ({
  orden_compra_det_id: 'det-1',
  producto_id: 'prod-1',
  descripcion: 'Producto 1',
  cantidad: 10,
  precio_unitario: 100,
  ...extra,
});

/** Transacción falsa: la OC, lo ya facturado por línea y la config de compras. */
const txFalsa = (
  opts: { facturado?: Array<{ orden_compra_det_id: string; cantidad: number }>; config?: any } = {},
) => ({
  orden_compra_cab: {
    findFirst: jest.fn().mockResolvedValue(ordenSinRecibir()),
    findUnique: jest.fn().mockResolvedValue(ordenSinRecibir()),
    update: jest.fn().mockResolvedValue(undefined),
  },
  compra_det: {
    findMany: jest.fn().mockResolvedValue(opts.facturado ?? []),
  },
  config_compras: {
    findUnique: jest.fn().mockResolvedValue(opts.config ?? { empresa_id: 'emp-1', habilitar_recepcion_compra: false }),
    create: jest.fn(),
  },
});

const validar = (service: any, tx: any, items: any[], options: Record<string, any>) =>
  service.validateMatchingOrdenCompra(tx, 'emp-1', null, 'prov-1', 'oc-1', items, {
    ordenCompraHabilitada: true,
    ...options,
  });

describe('Facturas contra la OC con Recepciones apagada (contra lo pedido)', () => {
  it('Recepciones apagada, matching activo: facturar 10 de 10 sin recibir pasa y la OC queda completada', async () => {
    const service = crearServicio();
    const tx = txFalsa();

    await expect(
      validar(service, tx, [item()], {
        matching3ViasHabilitado: true,
        recepcionRequeridaParaFacturar: false,
        modoFacturacion: 'contra_pedido',
      }),
    ).resolves.toBeUndefined();

    // Ya grabada la factura, el recálculo lee lo facturado (10) y la config (Recepciones apagada).
    tx.compra_det.findMany.mockResolvedValue([{ orden_compra_det_id: 'det-1', cantidad: 10 }]);
    await service.recalculateOrdenCompraEstado(tx, 'oc-1');

    expect(tx.orden_compra_cab.update).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'oc-1' }, data: expect.objectContaining({ estado: 'completada' }) }),
    );
  });

  it('Recepciones apagada: facturar 11 de 10 → rechazo', async () => {
    const service = crearServicio();
    // Aun con matching apagado, en contra_pedido no se factura más de lo pedido.
    const tx = txFalsa();
    const e = await validar(service, tx, [item({ cantidad: 11 })], {
      matching3ViasHabilitado: false,
      recepcionRequeridaParaFacturar: false,
      modoFacturacion: 'contra_pedido',
    }).catch((err: unknown) => err);

    expect(e).toBeInstanceOf(BadRequestException);
    expect((e as BadRequestException).message).toContain('supera lo pedido (10)');

    // Lo ya facturado en otras facturas también cuenta: 4 previas + 7 = 11.
    const tx2 = txFalsa({ facturado: [{ orden_compra_det_id: 'det-1', cantidad: 4 }] });
    await expect(
      validar(service, tx2, [item({ cantidad: 7 })], {
        matching3ViasHabilitado: true,
        modoFacturacion: 'contra_pedido',
      }),
    ).rejects.toThrow('supera lo pedido (10)');
  });

  it('Recepciones apagada, matching activo: precio distinto → rechazo (como hoy)', async () => {
    const service = crearServicio();
    await expect(
      validar(service, txFalsa(), [item({ precio_unitario: 110 })], {
        matching3ViasHabilitado: true,
        modoFacturacion: 'contra_pedido',
      }),
    ).rejects.toThrow('precio unitario debe coincidir con la orden de compra (100)');
  });

  it('Recepciones encendida, matching activo: facturar sin recibir → rechazo (como hoy)', async () => {
    const service = crearServicio();
    await expect(
      validar(service, txFalsa(), [item({ cantidad: 1 })], {
        matching3ViasHabilitado: true,
        modoFacturacion: 'contra_recibido',
      }),
    ).rejects.toThrow('supera recibido (0)');
  });

  it('Recepciones encendida, matching apagado: se factura sin recibir hasta lo pedido; 11 de 10 → rechazo', async () => {
    const service = crearServicio();
    const opciones = { matching3ViasHabilitado: false, recepcionRequeridaParaFacturar: false, modoFacturacion: 'contra_recibido' };
    await expect(validar(service, txFalsa(), [item()], opciones)).resolves.toBeUndefined();
    await expect(validar(service, txFalsa(), [item({ cantidad: 11 })], opciones)).rejects.toThrow('supera lo pedido (10)');

    // Lo ya facturado en otras facturas también cuenta: 4 previas + 7 = 11.
    const tx = txFalsa({ facturado: [{ orden_compra_det_id: 'det-1', cantidad: 4 }] });
    await expect(validar(service, tx, [item({ cantidad: 7 })], opciones)).rejects.toThrow('supera lo pedido (10)');
  });

  it('Recepciones encendida: el recálculo sigue exigiendo lo recibido (facturado 10, recibido 0 → parcial)', async () => {
    const service = crearServicio();
    const tx = txFalsa({
      facturado: [{ orden_compra_det_id: 'det-1', cantidad: 10 }],
      config: { empresa_id: 'emp-1', habilitar_recepcion_compra: true },
    });
    await service.recalculateOrdenCompraEstado(tx, 'oc-1');
    expect(tx.orden_compra_cab.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ estado: 'parcial' }) }),
    );
  });
});

describe('Factura que referencia una OC: lock y modo de facturación', () => {
  const PARAR = new Error('PARAR_DESPUES_DEL_MATCHING');

  const dto = () =>
    ({
      cabecera: {
        proveedor_id: 'prov-1',
        deposito_id: 'dep-1',
        sucursal_id: 'suc-1',
        moneda_id: 'm-1',
        condicion_operacion_id: 'cond-1',
        establecimiento: '001',
        punto_expedicion: '001',
        numero_factura: '0000001',
        fecha_emision: '2026-10-05',
        orden_compra_id: 'oc-1',
      },
      items: [],
      pagos: [],
    }) as any;

  /** Servicio con los pasos internos aislados; el matching corta el flujo para mirar lo anterior. */
  const montar = () => {
    const tx: any = {
      $executeRaw: jest.fn().mockResolvedValue(1),
      compra_cab: {
        findFirst: jest.fn().mockResolvedValue({
          id: 'c-1',
          empresa_id: 'emp-1',
          activo: true,
          anulado: false,
          embarque_id: null,
          requisicion_id: null,
          orden_compra_id: 'oc-1',
          compra_det: [],
        }),
      },
    };
    const prisma: any = { $transaction: jest.fn((fn: any) => fn(tx)) };
    const lotes: any = {
      isEnabledForEmpresa: jest.fn().mockResolvedValue(false),
      getEmpresaConfig: jest.fn().mockResolvedValue({ compras_credito_requiere_cuotas: false }),
    };
    const service = new ComprasService(prisma, lotes, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any) as any;
    const stub = (nombre: string, valor?: unknown) => {
      service[nombre] = jest.fn().mockResolvedValue(valor);
      return service[nombre];
    };
    [
      'validateCreateOrUpdatePayload',
      'assertComprobanteNoDuplicado',
      'autoCancelBorradorOrdenesForCompra',
      'anularOrdenAutomaticaDeCompra',
      'assertNoActiveOrdenesForCompra',
      'assertNoCxpPagadaForCompra',
      'cleanupInactiveOrdenesForCompra',
      'validateItems',
    ].forEach((n) => stub(n));
    stub('validateCabeceraRefs', { depositoSucursalId: 'suc-1' });
    stub('getOrCreateConfigCompras', {
      habilitar_orden_compra: true,
      habilitar_recepcion_compra: false,
      habilitar_matching_3_vias: true,
    });
    stub('resolveCondicionOperacion', { codigo: 1 });
    stub('resolveRedondeoConfig', { decimalesMonto: 2, decimalesPorcentaje: 2 });
    stub('resolveFlujoCompra', { afectarStockEnCompra: true });
    const matching = jest.fn().mockRejectedValue(PARAR);
    service.validateMatchingOrdenCompra = matching;
    return { service, tx, matching };
  };

  const lockOc = (tx: any) => tx.$executeRaw.mock.calls.findIndex((c: any[]) => c.slice(1).includes('oc:oc-1'));

  it.each([
    ['create', (s: any) => s.create(dto(), 'emp-1', 'u-1')],
    ['update', (s: any) => s.update('c-1', dto(), 'emp-1', 'u-1')],
  ])('%s toma el lock oc:<id> antes de validar contra la OC y pasa modoFacturacion', async (_n, llamar) => {
    const { service, tx, matching } = montar();

    await expect(llamar(service)).rejects.toBe(PARAR);

    const idx = lockOc(tx);
    expect(idx).toBeGreaterThanOrEqual(0);
    expect(tx.$executeRaw.mock.invocationCallOrder[idx]).toBeLessThan(matching.mock.invocationCallOrder[0]);
    expect(tx.$executeRaw.mock.invocationCallOrder[idx]).toBeLessThan(
      service.resolveFlujoCompra.mock.invocationCallOrder[0],
    );
    expect(matching.mock.calls[0][6]).toMatchObject({ modoFacturacion: 'contra_pedido' });
  });

  it('sin OC no toma el lock', async () => {
    const { service, tx } = montar();
    const sinOc = dto();
    sinOc.cabecera.orden_compra_id = null;

    await expect(service.create(sinOc, 'emp-1', 'u-1')).rejects.toBe(PARAR);
    expect(lockOc(tx)).toBe(-1);
  });
});

describe('Locks oc:<id> al mover o anular una factura con OC', () => {
  const PARAR = new Error('PARAR');

  const dtoCon = (ordenCompraId: string | null) =>
    ({
      cabecera: {
        proveedor_id: 'prov-1',
        deposito_id: 'dep-1',
        sucursal_id: 'suc-1',
        moneda_id: 'm-1',
        condicion_operacion_id: 'cond-1',
        establecimiento: '001',
        punto_expedicion: '001',
        numero_factura: '0000001',
        fecha_emision: '2026-10-05',
        orden_compra_id: ordenCompraId,
      },
      items: [],
      pagos: [],
    }) as any;

  const montar = (ocGuardada: string | null) => {
    const tx: any = {
      $executeRaw: jest.fn().mockResolvedValue(1),
      compra_cab: {
        findFirst: jest.fn().mockResolvedValue({
          id: 'c-1',
          empresa_id: 'emp-1',
          activo: true,
          anulado: false,
          embarque_id: null,
          requisicion_id: null,
          orden_compra_id: ocGuardada,
          deposito_id: 'dep-1',
          sucursal_id: 'suc-1',
          compra_det: [],
        }),
        update: jest.fn().mockResolvedValue(undefined),
      },
      cuentas_pagar: { updateMany: jest.fn().mockResolvedValue({ count: 0 }) },
      // Lotes cuyo costo corrigió esta factura (restaurarCostoLotesDeFactura): ninguno.
      compra_costo_lote: { findMany: jest.fn().mockResolvedValue([]), deleteMany: jest.fn().mockResolvedValue({ count: 0 }) },
    };
    const prisma: any = { $transaction: jest.fn((fn: any) => fn(tx)) };
    const lotes: any = {
      isEnabledForEmpresa: jest.fn().mockResolvedValue(false),
      getEmpresaConfig: jest.fn().mockResolvedValue({ compras_credito_requiere_cuotas: false }),
    };
    const service = new ComprasService(prisma, lotes, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any) as any;
    const stub = (nombre: string, valor?: unknown) => {
      service[nombre] = jest.fn().mockResolvedValue(valor);
      return service[nombre];
    };
    [
      'validateCreateOrUpdatePayload',
      'assertComprobanteNoDuplicado',
      'autoCancelBorradorOrdenesForCompra',
      'anularOrdenAutomaticaDeCompra',
      'assertNoActiveOrdenesForCompra',
      'assertNoCxpPagadaForCompra',
      'cleanupInactiveOrdenesForCompra',
      'validateItems',
      'recalculateProductCosts',
    ].forEach((n) => stub(n));
    stub('validateCabeceraRefs', { depositoSucursalId: 'suc-1' });
    stub('getOrCreateConfigCompras', { habilitar_orden_compra: true, habilitar_recepcion_compra: true });
    stub('resolveCondicionOperacion', { codigo: 1 });
    stub('resolveRedondeoConfig', { decimalesMonto: 2, decimalesPorcentaje: 2 });
    stub('resolveTipoMovimientoSalidaId', 'tm-1');
    stub('hasInventarioAplicadoEnCompra', false);
    service.resolveFlujoCompra = jest.fn().mockRejectedValue(PARAR);
    service.recalculateOrdenCompraEstado = jest.fn().mockRejectedValue(PARAR);
    return { service, tx };
  };

  /** Las claves de lock de OC en el orden en que se tomaron. */
  const locksOc = (tx: any): string[] =>
    tx.$executeRaw.mock.calls.flatMap((c: any[]) =>
      c.slice(1).filter((v: unknown) => typeof v === 'string' && v.startsWith('oc:')),
    );

  it.each([
    ['de oc-2 a oc-1', 'oc-2', 'oc-1'],
    ['de oc-1 a oc-2', 'oc-1', 'oc-2'],
  ])('update que mueve la factura %s toma los dos locks en orden ascendente de id', async (_n, guardada, nueva) => {
    const { service, tx } = montar(guardada);
    await expect(service.update('c-1', dtoCon(nueva), 'emp-1', 'u-1')).rejects.toBe(PARAR);
    expect(locksOc(tx)).toEqual(['oc:oc-1', 'oc:oc-2']);
    // Los dos antes de validar el flujo contra la OC nueva.
    const ultimo = Math.max(...tx.$executeRaw.mock.invocationCallOrder);
    expect(ultimo).toBeLessThan(service.resolveFlujoCompra.mock.invocationCallOrder[0]);
  });

  it('update que sigue en la misma OC toma un solo lock; si deja la OC, toma el de la guardada', async () => {
    const misma = montar('oc-1');
    await expect(misma.service.update('c-1', dtoCon('oc-1'), 'emp-1', 'u-1')).rejects.toBe(PARAR);
    expect(locksOc(misma.tx)).toEqual(['oc:oc-1']);

    const deja = montar('oc-3');
    await expect(deja.service.update('c-1', dtoCon(null), 'emp-1', 'u-1')).rejects.toBe(PARAR);
    expect(locksOc(deja.tx)).toEqual(['oc:oc-3']);
  });

  it('anular toma el lock de la OC de la factura antes de recalcular su estado', async () => {
    const { service, tx } = montar('oc-1');
    await expect(service.anular('c-1', 'emp-1', 'u-1')).rejects.toBe(PARAR);
    expect(locksOc(tx)).toEqual(['oc:oc-1']);
    const idx = tx.$executeRaw.mock.calls.findIndex((c: any[]) => c.slice(1).includes('oc:oc-1'));
    expect(tx.$executeRaw.mock.invocationCallOrder[idx]).toBeLessThan(
      service.recalculateOrdenCompraEstado.mock.invocationCallOrder[0],
    );
    expect(service.recalculateOrdenCompraEstado).toHaveBeenCalledWith(tx, 'oc-1');
  });

  it('anular una factura sin OC no toma lock', async () => {
    const { service, tx } = montar(null);
    await expect(service.anular('c-1', 'emp-1', 'u-1')).rejects.toBe(PARAR);
    expect(locksOc(tx)).toEqual([]);
  });

  it('anular la factura revierte la ejecución (con su moneda y cotización, después del oc:)', async () => {
    const { service, tx } = montar('oc-1');
    const emision = new Date('2026-10-05T00:00:00.000Z');
    tx.compra_cab.findFirst.mockResolvedValue({
      id: 'c-1',
      empresa_id: 'emp-1',
      activo: true,
      anulado: false,
      requisicion_id: 'req-1',
      orden_compra_id: 'oc-1',
      deposito_id: 'dep-1',
      sucursal_id: 'suc-1',
      moneda_id: 'm-usd',
      cotizacion: '7300.000000',
      fecha_emision: emision,
      compra_det: [{ id: 'cd-1', producto_id: null, requisicion_det_id: 'rd-1', cantidad: '2.0000', subtotal: '150.00', afecta_stock: false }],
    });
    tx.moneda = { findUnique: jest.fn().mockResolvedValue({ codigo: 'USD' }) };
    const revertir = jest.spyOn(ejecucion, 'revertirEjecucionRequisicion').mockResolvedValue(undefined);
    try {
      await expect(service.anular('c-1', 'emp-1', 'u-1')).rejects.toBe(PARAR);
      expect(revertir).toHaveBeenCalledWith(tx, {
        empresaId: 'emp-1',
        requisicionId: 'req-1',
        items: [{ requisicion_det_id: 'rd-1', cantidad: 2, subtotal: 150 }],
        monedaCodigo: 'USD',
        cotizacion: 7300,
        fechaOperacion: emision,
      });
      const idxOc = tx.$executeRaw.mock.calls.findIndex((c: any[]) => c.slice(1).includes('oc:oc-1'));
      expect(tx.$executeRaw.mock.invocationCallOrder[idxOc]).toBeLessThan(revertir.mock.invocationCallOrder[0]);
    } finally {
      revertir.mockRestore();
    }
  });

  it('el alta de una factura con requisición toma oc: y enseguida req:, antes de validar el flujo', async () => {
    const { service, tx } = montar(null);
    const dto = dtoCon('oc-1');
    dto.cabecera.requisicion_id = 'req-a';
    await expect(service.create(dto, 'emp-1', 'u-1')).rejects.toBe(PARAR);
    const claves = tx.$executeRaw.mock.calls.flatMap((c: any[]) => c.slice(1).filter((v: unknown) => typeof v === 'string'));
    expect(claves).toEqual(['oc:oc-1', 'req:req-a']);
    // Antes de validar la requisición y de la numeración de la OP automática (que va después del flujo).
    const ultimo = Math.max(...tx.$executeRaw.mock.invocationCallOrder);
    expect(ultimo).toBeLessThan(service.resolveFlujoCompra.mock.invocationCallOrder[0]);
  });

  it('anular una factura con requisición toma oc: y enseguida req:, antes de tocar órdenes de pago', async () => {
    const { service, tx } = montar('oc-1');
    tx.compra_cab.findFirst.mockResolvedValue({
      id: 'c-1', empresa_id: 'emp-1', activo: true, anulado: false, requisicion_id: 'req-1', orden_compra_id: 'oc-1',
      deposito_id: 'dep-1', sucursal_id: 'suc-1', moneda_id: null, cotizacion: '1', compra_det: [],
    });
    await expect(service.anular('c-1', 'emp-1', 'u-1')).rejects.toBe(PARAR);
    const claves = tx.$executeRaw.mock.calls.flatMap((c: any[]) => c.slice(1).filter((v: unknown) => typeof v === 'string'));
    expect(claves).toEqual(['compra:c-1', 'oc:oc-1', 'req:req-1']);
    expect(Math.max(...tx.$executeRaw.mock.invocationCallOrder)).toBeLessThan(
      service.autoCancelBorradorOrdenesForCompra.mock.invocationCallOrder[0],
    );
  });

  it('anular anula la orden automática de la factura (con su número en el motivo) antes de las guardas y de tocar el stock', async () => {
    const { service, tx } = montar('oc-1');
    tx.compra_cab.findFirst.mockResolvedValue({
      id: 'c-1', empresa_id: 'emp-1', activo: true, anulado: false, requisicion_id: null, orden_compra_id: 'oc-1',
      establecimiento: '1', punto_expedicion: '2', numero_factura: '345',
      deposito_id: 'dep-1', sucursal_id: 'suc-1', moneda_id: null, cotizacion: '1', compra_det: [],
    });
    const anuladas = [{ id: 'op-1', numero: 'OP-1', estadoAnterior: 'PAGADO', motivo: 'm', pagada: true }];
    const pagos = { anularAutomaticasDeCompraEnTx: jest.fn().mockResolvedValue(anuladas), registrarHistorialAnulacionAutomaticas: jest.fn() };
    service.pagosProveedor = pagos;
    service.anularOrdenAutomaticaDeCompra = ComprasService.prototype['anularOrdenAutomaticaDeCompra' as keyof ComprasService] as any;
    await expect(service.anular('c-1', 'emp-1', 'u-1')).rejects.toBe(PARAR);
    expect(pagos.anularAutomaticasDeCompraEnTx).toHaveBeenCalledTimes(1);
    // Sin commit no hay historial; y la tx corre con el plazo largo de las anulaciones (reversa de Tesorería/asiento).
    expect(pagos.registrarHistorialAnulacionAutomaticas).not.toHaveBeenCalled();
    expect(service.prisma.$transaction.mock.calls[0][1]).toEqual({ timeout: 60_000 });
    const args = pagos.anularAutomaticasDeCompraEnTx.mock.calls[0];
    expect(args[0]).toBe(tx);
    expect(args.slice(1, 3)).toEqual(['emp-1', 'c-1']);
    expect(args[3]).toContain('1-2-345');
    expect(args[4]).toBe('u-1');
    expect(pagos.anularAutomaticasDeCompraEnTx.mock.invocationCallOrder[0]).toBeLessThan(
      service.assertNoActiveOrdenesForCompra.mock.invocationCallOrder[0],
    );
  });

  it('editar una factura que cambia de requisición toma oc: y después req: de las dos, ordenadas', async () => {
    const { service, tx } = montar('oc-1');
    tx.compra_cab.findFirst.mockResolvedValue({
      id: 'c-1',
      empresa_id: 'emp-1',
      activo: true,
      anulado: false,
      embarque_id: null,
      requisicion_id: 'req-b',
      orden_compra_id: 'oc-1',
      deposito_id: 'dep-1',
      sucursal_id: 'suc-1',
      compra_det: [],
    });
    const dto = dtoCon('oc-1');
    dto.cabecera.requisicion_id = 'req-a';
    await expect(service.update('c-1', dto, 'emp-1', 'u-1')).rejects.toBe(PARAR);
    const claves = tx.$executeRaw.mock.calls.flatMap((c: any[]) => c.slice(1).filter((v: unknown) => typeof v === 'string'));
    expect(claves).toEqual(['compra:c-1', 'oc:oc-1', 'req:req-a', 'req:req-b']);
    // Antes de validar la requisición nueva y de revertir la vieja.
    const ultimo = Math.max(...tx.$executeRaw.mock.invocationCallOrder);
    expect(ultimo).toBeLessThan(service.resolveFlujoCompra.mock.invocationCallOrder[0]);
  });

  it('editar una factura con requisición toma oc: y req: antes de anular los borradores de OP (mismo orden que anular)', async () => {
    const { service, tx } = montar('oc-1');
    tx.compra_cab.findFirst.mockResolvedValue({
      id: 'c-1', empresa_id: 'emp-1', activo: true, anulado: false, embarque_id: null, requisicion_id: 'req-1',
      orden_compra_id: 'oc-1', deposito_id: 'dep-1', sucursal_id: 'suc-1', compra_det: [],
    });
    await expect(service.update('c-1', dtoCon('oc-1'), 'emp-1', 'u-1')).rejects.toBe(PARAR);
    const claves = tx.$executeRaw.mock.calls.flatMap((c: any[]) => c.slice(1).filter((v: unknown) => typeof v === 'string'));
    expect(claves).toEqual(['compra:c-1', 'oc:oc-1', 'req:req-1']);
    // Antes de cualquier fila de órdenes de pago: anular borradores, controlar las activas y limpiar las inactivas.
    const ultimoLock = Math.max(...tx.$executeRaw.mock.invocationCallOrder);
    for (const paso of ['autoCancelBorradorOrdenesForCompra', 'assertNoActiveOrdenesForCompra', 'cleanupInactiveOrdenesForCompra']) {
      expect(ultimoLock).toBeLessThan(service[paso].mock.invocationCallOrder[0]);
    }
  });
});

/**
 * Matriz de configuración de Compras × lo que la factura controla contra la OC (pedido del usuario, ronda final).
 * Las opciones salen de `opcionesMatchingOc(config)`, la misma función que usan `create` y `update` de la factura.
 * OC: 10 pedidas a 100, nada recibido. Casos: precio distinto (10 a 120), 10 sin recibir, 11 (más de lo pedido).
 * «baseLocal» es la config real de la base local (8 de 9 empresas): recepción y matching encendidos, factura mueve stock.
 */
describe('Matriz config × factura contra OC', () => {
  type Caso = {
    nombre: string;
    config: Record<string, boolean>;
    precioDistinto: 'rechaza' | 'pasa';
    diezSinRecibir: 'rechaza' | 'pasa';
    onceDeDiez: 'rechaza' | 'pasa';
  };
  const casos: Caso[] = [
    {
      nombre: 'baseLocal: recepción ON, matching ON, afectar stock en compra ON (mixta)',
      config: { habilitar_recepcion_compra: true, habilitar_matching_3_vias: true, afectar_stock_en_compra_directa: true },
      precioDistinto: 'rechaza',
      diezSinRecibir: 'rechaza',
      onceDeDiez: 'rechaza',
    },
    {
      nombre: 'recepción ON, matching ON, afectar stock OFF (la recepción mueve stock)',
      config: { habilitar_recepcion_compra: true, habilitar_matching_3_vias: true, afectar_stock_en_compra_directa: false },
      precioDistinto: 'rechaza',
      diezSinRecibir: 'rechaza',
      onceDeDiez: 'rechaza',
    },
    {
      nombre: 'recepción ON, matching OFF, afectar stock ON: sin control de precio ni de recibido, tope en lo pedido',
      config: { habilitar_recepcion_compra: true, habilitar_matching_3_vias: false, afectar_stock_en_compra_directa: true },
      precioDistinto: 'pasa',
      diezSinRecibir: 'pasa',
      onceDeDiez: 'rechaza',
    },
    {
      nombre: 'recepción ON, matching OFF, afectar stock OFF: igual exige lo recibido',
      config: { habilitar_recepcion_compra: true, habilitar_matching_3_vias: false, afectar_stock_en_compra_directa: false },
      precioDistinto: 'pasa',
      diezSinRecibir: 'rechaza',
      onceDeDiez: 'rechaza',
    },
    {
      nombre: 'recepción OFF (contra_pedido), matching ON',
      config: { habilitar_recepcion_compra: false, habilitar_matching_3_vias: true, afectar_stock_en_compra_directa: true },
      precioDistinto: 'rechaza',
      diezSinRecibir: 'pasa',
      onceDeDiez: 'rechaza',
    },
    {
      nombre: 'recepción OFF (contra_pedido), matching OFF: el tope de lo pedido sigue',
      config: { habilitar_recepcion_compra: false, habilitar_matching_3_vias: false, afectar_stock_en_compra_directa: true },
      precioDistinto: 'pasa',
      diezSinRecibir: 'pasa',
      onceDeDiez: 'rechaza',
    },
  ];

  const correr = (config: Record<string, boolean>, it: any, recibido = 0) => {
    const service = crearServicio();
    const tx = txFalsa({ config });
    const oc = ordenSinRecibir();
    oc.orden_compra_det[0].cantidad_recibida = recibido;
    tx.orden_compra_cab.findFirst.mockResolvedValue(oc);
    return service.validateMatchingOrdenCompra(tx, 'emp-1', null, 'prov-1', 'oc-1', [it], {
      ...opcionesMatchingOc({ habilitar_orden_compra: true, ...config }),
    });
  };
  const esperar = async (p: Promise<unknown>, r: 'rechaza' | 'pasa') =>
    r === 'pasa' ? expect(p).resolves.toBeUndefined() : expect(p).rejects.toThrow(BadRequestException);

  describe.each(casos)('$nombre', (c) => {
    // El precio se aísla: la OC ya tiene todo recibido, así la cantidad nunca es la razón.
    it(`precio distinto → ${c.precioDistinto}`, () => esperar(correr(c.config, item({ precio_unitario: 120 }), 10), c.precioDistinto));
    it(`10 de 10 sin recibir → ${c.diezSinRecibir}`, () => esperar(correr(c.config, item()), c.diezSinRecibir));
    it(`11 de 10 → ${c.onceDeDiez}`, () => esperar(correr(c.config, item({ cantidad: 11 })), c.onceDeDiez));
  });

  it('OC deshabilitada: facturar contra una OC se rechaza', async () => {
    const service = crearServicio();
    await expect(
      service.validateMatchingOrdenCompra(txFalsa(), 'emp-1', null, 'prov-1', 'oc-1', [item()], opcionesMatchingOc({ habilitar_orden_compra: false })),
    ).rejects.toThrow('deshabilitada la Orden de Compra');
  });
});

/**
 * Quién mueve el stock de una compra contra OC (pedido del usuario: config mixta de la base local). La regla:
 *  - factura: `resolveFlujoCompra` devuelve `afectarStockEnCompra = afectar_stock_en_compra_directa` (con o sin OC);
 *  - recepción: mueve stock solo con `afectar_stock_en_compra_directa = false` (recepciones-compra.service.spec);
 *  - anular: cada documento revierte solo lo que movió (factura: movimientos `factura_compra` del documento; recepción: si tiene depósito).
 */
describe('Stock: factura contra OC según afectar_stock_en_compra_directa', () => {
  const items = [{ orden_compra_det_id: 'det-1', requisicion_det_id: null, producto_id: 'prod-1', afecta_stock: true }];
  const flujo = (service: any, afectar: boolean, recepcion = true) =>
    service.resolveFlujoCompra({
      tx: { orden_compra_det: { findMany: jest.fn().mockResolvedValue([]) } },
      empresaId: 'emp-1',
      configCompras: {
        modo_flujo_compra: 'directo',
        afectar_stock_en_compra_directa: afectar,
        habilitar_orden_compra: true,
        habilitar_recepcion_compra: recepcion,
      },
      requisicionId: null,
      ordenCompraId: 'oc-1',
      items,
    });

  it('config mixta (baseLocal): la factura contra OC mueve el stock (la recepción no lo movió)', async () => {
    await expect(flujo(crearServicio(), true)).resolves.toEqual({ afectarStockEnCompra: true });
  });

  it('afectar stock en compra OFF: la factura contra OC NO mueve stock (ya lo movió la recepción)', async () => {
    await expect(flujo(crearServicio(), false)).resolves.toEqual({ afectarStockEnCompra: false });
  });

  it('Recepciones OFF (contra lo pedido) con afectar ON: la factura mueve el stock', async () => {
    await expect(flujo(crearServicio(), true, false)).resolves.toEqual({ afectarStockEnCompra: true });
  });

  describe('anular la factura revierte solo si ella movió stock', () => {
    const PARAR = new Error('PARAR');
    const montar = (aplicado: boolean) => {
      const tx: any = {
        $executeRaw: jest.fn().mockResolvedValue(1),
        compra_cab: {
          findFirst: jest.fn().mockResolvedValue({
            id: 'c-1',
            empresa_id: 'emp-1',
            activo: true,
            anulado: false,
            requisicion_id: null,
            orden_compra_id: 'oc-1',
            deposito_id: 'dep-1',
            sucursal_id: 'suc-1',
            compra_det: [{ id: 'cd-1', producto_id: 'prod-1', cantidad: 2, subtotal: 200, afecta_stock: true }],
          }),
          update: jest.fn().mockResolvedValue(undefined),
        },
        cuentas_pagar: { updateMany: jest.fn().mockResolvedValue({ count: 0 }) },
        compra_costo_lote: { findMany: jest.fn().mockResolvedValue([]), deleteMany: jest.fn().mockResolvedValue({ count: 0 }) },
      };
      const prisma: any = { $transaction: jest.fn((fn: any) => fn(tx)) };
      const lotes: any = { isEnabledForEmpresa: jest.fn().mockResolvedValue(false) };
      const service = new ComprasService(prisma, lotes, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any) as any;
      const stub = (nombre: string, valor?: unknown) => (service[nombre] = jest.fn().mockResolvedValue(valor));
      ['autoCancelBorradorOrdenesForCompra', 'anularOrdenAutomaticaDeCompra', 'assertNoActiveOrdenesForCompra', 'assertNoCxpPagadaForCompra', 'recalculateProductCosts', 'revertInventario'].forEach((n) => stub(n));
      stub('resolveTipoMovimientoSalidaId', 'tm-1');
      stub('hasInventarioAplicadoEnCompra', aplicado);
      service.recalculateOrdenCompraEstado = jest.fn().mockRejectedValue(PARAR);
      return service;
    };

    it('factura de la config mixta (con movimientos factura_compra): revierte', async () => {
      const service = montar(true);
      await expect(service.anular('c-1', 'emp-1', 'u-1')).rejects.toBe(PARAR);
      expect(service.revertInventario).toHaveBeenCalledTimes(1);
    });

    it('factura que no movió stock (afectar OFF: lo movió la recepción): no revierte', async () => {
      const service = montar(false);
      await expect(service.anular('c-1', 'emp-1', 'u-1')).rejects.toBe(PARAR);
      expect(service.revertInventario).not.toHaveBeenCalled();
    });
  });
});
