import { ComprasService } from './compras.service';

/**
 * Ola 3 de Existencias: la compra (alta, edición y anulación) toma los lotes y el stock que va a escribir en el orden del cierre de
 * inventario (`LotesService.bloquearStockDe`), una vez y antes de la primera escritura de stock. Antes escribía `stock_deposito`
 * renglón por renglón (y en la reversa, lote → stock → lote → stock), y eso cruzaba con el cierre: 40P01.
 */
describe('ComprasService: bloqueo ordenado de stock contra el cierre de inventario', () => {
  const montar = () => {
    const lotesService = {
      bloquearStockDe: jest.fn().mockResolvedValue(undefined),
      createLoteIngreso: jest.fn().mockResolvedValue({ id: 'lote-1' }),
      revertCompraDetalleLote: jest.fn().mockResolvedValue(undefined),
    };
    const service: any = new ComprasService({} as any, lotesService as any, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any);
    jest.spyOn(service, 'tieneAddonReglasPrecio').mockResolvedValue(false);
    const tx: any = {
      stock_deposito: { upsert: jest.fn() },
      movimientos_inventario: { create: jest.fn() },
      productos: { findUnique: jest.fn().mockResolvedValue({ descripcion: 'P', precio_costo: 50 }), update: jest.fn() },
      compra_det: { update: jest.fn() },
    };
    return { service, lotesService, tx };
  };
  const item = (producto_id: string | null, extra: Record<string, unknown> = {}) => ({
    producto_id,
    cantidad: 3,
    afecta_stock: true,
    requiere_lote: false,
    costo_unitario_neto: 60,
    ...extra,
  });

  it('alta: bloquea los renglones que mueven stock en un solo pase, antes de escribir', async () => {
    const { service, lotesService, tx } = montar();
    await service.applyInventarioYCostos(tx, {
      empresaId: 'emp',
      compraId: 'c1',
      depositoId: 'dep-1',
      items: [item('pB'), item('pA'), item(null), item('pS', { afecta_stock: false })],
      detalles: [{ id: 'd1' }, { id: 'd2' }, { id: 'd3' }, { id: 'd4' }],
      lotesEnabled: true,
      tipoMovimientoId: 'tipo',
      documentoOrigen: 'factura_compra',
    });
    expect(lotesService.bloquearStockDe).toHaveBeenCalledTimes(1);
    expect(lotesService.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', [
      { productoId: 'pB', depositoId: 'dep-1' },
      { productoId: 'pA', depositoId: 'dep-1' },
    ]);
    expect(lotesService.bloquearStockDe.mock.invocationCallOrder[0]).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
    // Lo demás no cambia: un incremento por renglón con stock.
    expect(tx.stock_deposito.upsert).toHaveBeenCalledTimes(2);
    expect(tx.stock_deposito.upsert.mock.calls[0][0].update.cantidad_disponible).toEqual({ increment: 3 });
  });

  it('anulación: bloquea antes de revertir el primer lote y del primer stock, con los pares de la edición si llegan', async () => {
    const { service, lotesService, tx } = montar();
    await service.revertInventario(tx, {
      empresaId: 'emp',
      compraId: 'c1',
      depositoId: 'dep-1',
      items: [
        { id: 'd1', producto_id: 'pB', cantidad: 2, precio_unitario: 10, afecta_stock: true },
        { id: 'd2', producto_id: 'pA', cantidad: 1, precio_unitario: 10, afecta_stock: true },
        { id: 'd3', producto_id: 'pS', cantidad: 1, precio_unitario: 10, afecta_stock: false },
      ],
      lotesEnabled: true,
      tipoMovimientoId: 'tipo',
      paresExtra: [{ productoId: 'pN', depositoId: 'dep-2' }],
    });
    expect(lotesService.bloquearStockDe).toHaveBeenCalledTimes(1);
    expect(lotesService.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', [
      { productoId: 'pB', depositoId: 'dep-1' },
      { productoId: 'pA', depositoId: 'dep-1' },
      { productoId: 'pN', depositoId: 'dep-2' },
    ]);
    const bloqueo = lotesService.bloquearStockDe.mock.invocationCallOrder[0];
    expect(bloqueo).toBeLessThan(lotesService.revertCompraDetalleLote.mock.invocationCallOrder[0]);
    expect(bloqueo).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
    expect(tx.stock_deposito.upsert.mock.calls.map((c: any[]) => c[0].update.cantidad_disponible)).toEqual([{ decrement: 2 }, { decrement: 1 }]);
  });
});

/**
 * Anular la misma compra dos veces a la vez: la segunda leía la compra sin anular antes de que la primera confirmara y revertía el
 * stock otra vez. Ahora toma `compra:<id>` antes de leerla y, si ya está anulada, responde 409 COMPRA_YA_ANULADA.
 */
describe('ComprasService.anular: doble anulación', () => {
  it('toma el lock de la compra antes de leerla y rechaza con 409 si ya está anulada', async () => {
    const tx: any = {
      $executeRaw: jest.fn().mockResolvedValue(1),
      // Como la deja la anulación que ganó: anulada e inactiva. La relectura no filtra por activo (si no, sería un 404 engañoso).
      compra_cab: {
        findFirst: jest.fn(async ({ where }: any) => (where.activo === true ? null : { id: 'c1', anulado: true, activo: false, compra_det: [] })),
      },
      stock_deposito: { upsert: jest.fn() },
    };
    const prisma: any = { $transaction: jest.fn(async (cb: (t: unknown) => unknown) => cb(tx)) };
    const service: any = new ComprasService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, {} as any);
    const error = await service.anular('c1', 'emp', 'u1').catch((e: any) => e);
    expect(error.getStatus()).toBe(409);
    expect(error.getResponse()).toMatchObject({ codigo: 'COMPRA_YA_ANULADA' });
    expect(tx.$executeRaw).toHaveBeenCalledTimes(1);
    expect(tx.$executeRaw.mock.invocationCallOrder[0]).toBeLessThan(tx.compra_cab.findFirst.mock.invocationCallOrder[0]);
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });
});
