import { reponerStockNotaCredito } from './stock-nota-credito';

/**
 * P1 (ola 3): la NC de venta reponía stock_deposito con un absoluto leído sin bloqueo (`findUnique` + `leído + cantidad`) y
 * renglón por renglón, stock antes que lotes. En real: contra el conteo del cierre lo pisaba (3/3) y contra el cierre daba 40P01
 * (3/3, con y sin lotes). Ahora bloquea todo en el orden del cierre antes de escribir y suma con incremento atómico.
 */
describe('NC de venta: reponer stock', () => {
  const productos = new Map<string, any>([
    ['p-a', { maneja_inventario: true }],
    ['p-b', { maneja_inventario: true }],
    ['srv', { maneja_inventario: false }],
  ]);
  const montar = (restaurados: Array<{ lote_id: string; cantidad: number }> = []) => {
    const tx: any = {
      depositos: { findFirst: jest.fn(async ({ where }: any) => (where.id === 'dep-inactivo' ? null : { id: where.id })) },
      stock_deposito: { findUnique: jest.fn(), upsert: jest.fn(async () => ({})) },
      movimientos_inventario: { create: jest.fn(async () => ({})) },
    };
    const lotes: any = {
      bloquearStockDe: jest.fn(async () => undefined),
      restoreFacturaDetLotes: jest.fn(async () => restaurados),
    };
    return { tx, lotes };
  };
  const base = {
    empresaId: 'emp',
    ncId: 'nc-1',
    numeroNC: '001-001-0000009',
    tipoMovimientoId: 'tm-dev',
    productosMap: productos,
    depositoFallback: { id: 'dep-fb' },
    lotesEnabled: false,
    facturaDetPorProducto: new Map<string, { id: string }>(),
  };

  it('bloquea todos los pares una vez, antes de la primera escritura, y suma con incremento (no lee para escribir un absoluto)', async () => {
    const { tx, lotes } = montar();
    await reponerStockNotaCredito(tx, lotes, {
      ...base,
      items: [{ producto_id: 'p-b', cantidad: 1 }, { producto_id: 'srv', cantidad: 1 }, { producto_id: 'p-a', cantidad: 2 }],
      devuelvePorIndice: [true, true, true],
      depositosPorItem: new Map([['p-b', 'dep-1']]),
    });
    expect(lotes.bloquearStockDe).toHaveBeenCalledTimes(1);
    expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', [
      { productoId: 'p-b', depositoId: 'dep-1' },
      { productoId: 'p-a', depositoId: 'dep-fb' },
    ]);
    expect(lotes.bloquearStockDe.mock.invocationCallOrder[0]).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
    expect(tx.stock_deposito.findUnique).not.toHaveBeenCalled();
    expect(tx.stock_deposito.upsert.mock.calls.map((c: any[]) => c[0])).toEqual([
      expect.objectContaining({
        where: { deposito_id_producto_id: { deposito_id: 'dep-1', producto_id: 'p-b' } },
        create: { deposito_id: 'dep-1', producto_id: 'p-b', cantidad_disponible: 1 },
        update: expect.objectContaining({ cantidad_disponible: { increment: 1 } }),
      }),
      expect.objectContaining({
        where: { deposito_id_producto_id: { deposito_id: 'dep-fb', producto_id: 'p-a' } },
        update: expect.objectContaining({ cantidad_disponible: { increment: 2 } }),
      }),
    ]);
    expect(tx.movimientos_inventario.create).toHaveBeenCalledTimes(2);
    expect(tx.movimientos_inventario.create.mock.calls[0][0].data).toMatchObject({
      deposito_origen_id: 'dep-1', deposito_destino_id: 'dep-1', producto_id: 'p-b', tipo_movimiento_id: 'tm-dev', cantidad: 1,
      documento_origen: 'nota_credito', documento_id: 'nc-1', observaciones: 'Devolución NC 001-001-0000009', lote_id: null,
    });
  });

  it('la línea que no devuelve mercadería no se bloquea ni se repone; depósito inactivo cae al de respaldo', async () => {
    const { tx, lotes } = montar();
    await reponerStockNotaCredito(tx, lotes, {
      ...base,
      items: [{ producto_id: 'p-b', cantidad: 1 }, { producto_id: 'p-a', cantidad: 1 }],
      devuelvePorIndice: [false, true],
      depositosPorItem: new Map([['p-a', 'dep-inactivo']]),
    });
    expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', [{ productoId: 'p-a', depositoId: 'dep-fb' }]);
    expect(tx.stock_deposito.upsert).toHaveBeenCalledTimes(1);
  });

  it('con lotes: devuelve a los lotes de la factura después del bloqueo y deja un movimiento por lote y otro por lo sin lote', async () => {
    const { tx, lotes } = montar([{ lote_id: 'l-1', cantidad: 2 }]);
    await reponerStockNotaCredito(tx, lotes, {
      ...base,
      lotesEnabled: true,
      facturaDetPorProducto: new Map([['p-a', { id: 'fd-1' }]]),
      items: [{ producto_id: 'p-a', cantidad: 3 }],
      devuelvePorIndice: [true],
      depositosPorItem: new Map([['p-a', 'dep-1']]),
    });
    expect(lotes.restoreFacturaDetLotes).toHaveBeenCalledWith(tx, { facturaDetId: 'fd-1', depositoId: 'dep-1', cantidad: 3 });
    expect(lotes.bloquearStockDe.mock.invocationCallOrder[0]).toBeLessThan(lotes.restoreFacturaDetLotes.mock.invocationCallOrder[0]);
    expect(tx.movimientos_inventario.create.mock.calls.map((c: any[]) => [c[0].data.lote_id, c[0].data.cantidad])).toEqual([
      ['l-1', 2],
      [null, 1],
    ]);
  });

  it('sin depósito (ni del ítem ni de respaldo): no repone ni bloquea', async () => {
    const { tx, lotes } = montar();
    await reponerStockNotaCredito(tx, lotes, {
      ...base,
      depositoFallback: null,
      items: [{ producto_id: 'p-a', cantidad: 1 }],
      devuelvePorIndice: [true],
      depositosPorItem: new Map(),
    });
    expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', []);
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });
});
