import { NotaCreditoComprasService } from './nota-credito-compras.service';

/**
 * LT8: la NC de compra que devuelve mercadería al proveedor sale del lote que
 * entró con esa compra; lo que falta, FEFO entre los demás lotes (vencidos
 * incluidos) y el resto sin lote. Un movimiento DEV_COMPRA por lote. Al anular,
 * cada cantidad vuelve a su mismo lote (ANUL_DEV_COMPRA).
 */
describe('NotaCreditoComprasService: devolución por lote', () => {
  const crear = (opciones: { usaLotes?: boolean } = {}) => {
    const usaLotes = opciones.usaLotes ?? true;
    const tx: any = {
      nota_credito_compra_cab: {
        create: jest.fn().mockResolvedValue({ id: 'nc' }),
        update: jest.fn(),
        // Tope del origen: ninguna otra NC vigente. Anular: se marca con updateMany condicionado.
        findMany: jest.fn().mockResolvedValue([]),
        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
      },
      nota_credito_compra_det: { create: jest.fn() },
      compra_det: { findUnique: jest.fn().mockResolvedValue({ cantidad: 10, cantidad_acreditada_nc: 0, descripcion: 'Leche' }) },
      // El UPDATE condicional de lo acreditado en la línea de la compra afecta una fila.
      $executeRaw: jest.fn().mockResolvedValue(1),
      // La compra origen bloqueada (FOR UPDATE) para el tope.
      $queryRaw: jest.fn().mockResolvedValue([{ total: 1000, proveedor_id: 'prov', anulado: false, estado: 'registrada' }]),
      productos: { findFirst: jest.fn().mockResolvedValue({ maneja_inventario: true }) },
      stock_deposito: { findUnique: jest.fn().mockResolvedValue({ cantidad_disponible: 20 }), upsert: jest.fn() },
      stock_lote: {
        findMany: jest.fn().mockResolvedValue([
          // Otro lote de la misma compra (otra línea) y el de esta línea.
          { lote_id: 'L-otra-linea', cantidad_disponible: 5, lotes_producto: { numero_lote: 'B', compra_det_id: 'det-2' } },
          { lote_id: 'L-compra', cantidad_disponible: 3, lotes_producto: { numero_lote: 'A', compra_det_id: 'det-1' } },
        ]),
      },
      movimientos_inventario: { create: jest.fn(), findMany: jest.fn().mockResolvedValue([]) },
      tipo_movimiento_inventario: {
        findUnique: jest.fn().mockImplementation(({ where }) => Promise.resolve({ id: `tipo-${where.codigo}` })),
        upsert: jest.fn(),
      },
    };
    const prisma: any = {
      proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'prov' }) },
      compra_cab: {
        findFirst: jest.fn().mockResolvedValue({
          id: 'compra',
          proveedor_id: 'prov',
          deposito_id: 'dep',
          moneda_id: 'PYG',
          cotizacion: 1,
          anulado: false,
          estado: 'registrada',
          total: 1000,
        }),
      },
      // La línea det-1 es de la compra origen.
      compra_det: { findMany: jest.fn().mockResolvedValue([{ id: 'det-1' }]) },
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'PYG' }) },
      productos: { findMany: jest.fn().mockResolvedValue([{ id: 'p1', maneja_inventario: true }]) },
      depositos: { findFirst: jest.fn().mockResolvedValue({ id: 'dep' }) },
      nota_credito_compra_cab: { findFirst: jest.fn() },
      $transaction: jest.fn().mockImplementation((cb: (t: any) => unknown) => cb(tx)),
    };
    const lotes: any = {
      bloquearStockDe: jest.fn().mockResolvedValue(undefined),
      usaLotesEnDeposito: jest.fn().mockResolvedValue(usaLotes),
      descontarDeLote: jest.fn(),
      ingresarEnLote: jest.fn(),
    };
    const fifo: any = {
      deductFifo: jest.fn().mockResolvedValue({
        lotes_consumidos: [{ lote_id: 'L-fefo', numero_lote: 'C', cantidad: 1 }],
        cantidad_sin_lote: 0.5,
      }),
    };
    const audit: any = { log: jest.fn() };
    const contabilidad: any = {
      integrarNotaCreditoCompra: jest.fn().mockResolvedValue(undefined),
      revertirDocumento: jest.fn().mockResolvedValue(undefined),
    };
    const service = new NotaCreditoComprasService(prisma, audit, contabilidad, lotes, fifo);
    jest.spyOn(service as any, 'reducirCuentasPagar').mockResolvedValue({ aplicado: 0, aplicaciones: [], compraIds: [] });
    jest.spyOn(service as any, 'restaurarCuentasPagar').mockResolvedValue({ restaurado: 0, compraIds: [] });
    jest.spyOn(service as any, 'recalcularEstadoCompra').mockResolvedValue(undefined);
    jest.spyOn(service, 'findOne').mockResolvedValue({} as any);
    return { service, prisma, tx, lotes, fifo };
  };

  const dto: any = {
    proveedor_id: 'prov',
    compra_id: 'compra',
    numero: '1',
    items: [
      { compra_det_id: 'det-1', producto_id: 'p1', descripcion: 'Leche', cantidad: 9.5, precio_unitario: 100, afecta_stock: true },
    ],
  };

  it('sale primero del lote de esa línea, después de la compra, después FEFO y el resto sin lote', async () => {
    const { service, tx, lotes, fifo } = crear();
    await service.create(dto, 'emp', 'usr');

    expect(lotes.descontarDeLote.mock.calls.map((c: any[]) => c[1])).toEqual([
      { loteId: 'L-compra', depositoId: 'dep', cantidad: 3 },
      { loteId: 'L-otra-linea', depositoId: 'dep', cantidad: 5 },
    ]);
    expect(tx.stock_lote.findMany.mock.calls[0][0].where.lotes_producto).toMatchObject({
      empresa_id: 'emp',
      producto_id: 'p1',
      OR: [{ compra_det_id: 'det-1' }, { compra_id: 'compra' }],
    });
    expect(fifo.deductFifo).toHaveBeenCalledWith(tx, 'emp', 'p1', 'dep', 1.5, { vencidos: 'incluir' });

    const movimientos = tx.movimientos_inventario.create.mock.calls.map((c: any[]) => c[0].data);
    expect(movimientos.map((m: any) => [m.lote_id, m.cantidad])).toEqual([
      ['L-compra', 3],
      ['L-otra-linea', 5],
      ['L-fefo', 1],
      [null, 0.5],
    ]);
    expect(movimientos.every((m: any) => m.tipo_movimiento_id === 'tipo-DEV_COMPRA' && m.documento_id === 'nc')).toBe(true);
    // El total del depósito baja por la cantidad entera.
    expect(tx.stock_deposito.upsert.mock.calls[0][0].update.cantidad_disponible).toBe(10.5);
  });

  it('sin lotes en el depósito: un solo movimiento sin lote', async () => {
    const { service, tx, lotes, fifo } = crear({ usaLotes: false });
    await service.create(dto, 'emp', 'usr');
    expect(lotes.descontarDeLote).not.toHaveBeenCalled();
    expect(fifo.deductFifo).not.toHaveBeenCalled();
    const movimientos = tx.movimientos_inventario.create.mock.calls.map((c: any[]) => c[0].data);
    expect(movimientos).toEqual([expect.objectContaining({ lote_id: null, cantidad: 9.5, tipo_movimiento_id: 'tipo-DEV_COMPRA' })]);
  });

  it('anular devuelve cada cantidad a su mismo lote y el resto sin lote', async () => {
    const { service, prisma, tx, lotes } = crear();
    prisma.nota_credito_compra_cab.findFirst.mockResolvedValue({
      id: 'nc',
      estado: 'registrada',
      anulado: false,
      afecta_stock: true,
      deposito_id: 'dep',
      proveedor_id: 'prov',
      compra_id: 'compra',
      gasto_id: null,
      total: 950,
      numero: '1',
      detalles: [{ producto_id: 'p1', cantidad: 9.5, afecta_stock: true, compra_det_id: 'det-1' }],
    });
    tx.movimientos_inventario.findMany.mockResolvedValue([
      { producto_id: 'p1', lote_id: 'L-compra', cantidad: 3, lote: { numero_lote: 'A' } },
      { producto_id: 'p1', lote_id: 'L-fefo', cantidad: 6, lote: { numero_lote: 'C' } },
    ]);

    await service.anular('nc', 'emp', 'Error de carga', 'usr');

    expect(tx.movimientos_inventario.findMany.mock.calls[0][0].where).toMatchObject({
      documento_origen: 'nota_credito_compra',
      documento_id: 'nc',
    });
    expect(lotes.ingresarEnLote.mock.calls.map((c: any[]) => c[1])).toEqual([
      { loteId: 'L-compra', depositoId: 'dep', cantidad: 3 },
      { loteId: 'L-fefo', depositoId: 'dep', cantidad: 6 },
    ]);
    const movimientos = tx.movimientos_inventario.create.mock.calls.map((c: any[]) => c[0].data);
    expect(movimientos.map((m: any) => [m.lote_id, m.cantidad, m.tipo_movimiento_id])).toEqual([
      ['L-compra', 3, 'tipo-ANUL_DEV_COMPRA'],
      ['L-fefo', 6, 'tipo-ANUL_DEV_COMPRA'],
      [null, 0.5, 'tipo-ANUL_DEV_COMPRA'],
    ]);
    expect(tx.stock_deposito.upsert.mock.calls[0][0].update.cantidad_disponible).toBe(29.5);
  });

  describe('I1: orden de bloqueos stock_lote antes que stock_deposito', () => {
    const ultima = (fn: jest.Mock) => Math.max(...fn.mock.invocationCallOrder);

    it('alta: bloquea lotes y stock de todos los ítems una vez, antes de leer el primer lote', async () => {
      const { service, prisma, tx, lotes } = crear();
      prisma.productos.findMany.mockResolvedValue([{ id: 'p1', maneja_inventario: true }, { id: 'p2', maneja_inventario: true }]);
      await service.create(
        {
          ...dto,
          items: [
            { compra_det_id: 'det-1', producto_id: 'p2', descripcion: 'Queso', cantidad: 1, precio_unitario: 100, afecta_stock: true },
            { compra_det_id: 'det-1', producto_id: 'p1', descripcion: 'Leche', cantidad: 2, precio_unitario: 100, afecta_stock: true },
          ],
        },
        'emp',
        'usr',
      );
      expect(lotes.bloquearStockDe).toHaveBeenCalledTimes(1);
      expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', [
        { productoId: 'p2', depositoId: 'dep' },
        { productoId: 'p1', depositoId: 'dep' },
      ]);
      const bloqueo = lotes.bloquearStockDe.mock.invocationCallOrder[0];
      expect(bloqueo).toBeLessThan(tx.stock_lote.findMany.mock.invocationCallOrder[0]);
      expect(bloqueo).toBeLessThan(lotes.descontarDeLote.mock.invocationCallOrder[0]);
      expect(bloqueo).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
    });

    it('anular: bloquea lotes y stock de los ítems que movieron stock antes de reponer el primer lote', async () => {
      const { service, prisma, tx, lotes } = crear();
      prisma.nota_credito_compra_cab.findFirst.mockResolvedValue({
        id: 'nc', estado: 'registrada', anulado: false, afecta_stock: true, deposito_id: 'dep', proveedor_id: 'prov',
        compra_id: 'compra', gasto_id: null, total: 950, numero: '1',
        detalles: [
          { producto_id: 'p2', cantidad: 1, afecta_stock: true, compra_det_id: 'det-1' },
          { producto_id: 'p3', cantidad: 1, afecta_stock: false, compra_det_id: 'det-1' },
          { producto_id: 'p1', cantidad: 2, afecta_stock: true, compra_det_id: 'det-1' },
        ],
      });
      tx.movimientos_inventario.findMany.mockResolvedValue([{ producto_id: 'p1', lote_id: 'L-compra', cantidad: 2, lote: { numero_lote: 'A' } }]);
      await service.anular('nc', 'emp', 'Error de carga', 'usr');
      expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', [
        { productoId: 'p2', depositoId: 'dep' },
        { productoId: 'p1', depositoId: 'dep' },
      ]);
      const bloqueo = lotes.bloquearStockDe.mock.invocationCallOrder[0];
      expect(bloqueo).toBeLessThan(lotes.ingresarEnLote.mock.invocationCallOrder[0]);
      expect(bloqueo).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
    });

    it('alta con el mismo producto en dos ítems: los lotes de todos antes del primer stock_deposito', async () => {
      const { service, tx, lotes, fifo } = crear();
      tx.stock_lote.findMany.mockResolvedValue([{ lote_id: 'L-compra', cantidad_disponible: 3, lotes_producto: { numero_lote: 'A', compra_det_id: 'det-1' } }]);
      // Una lectura por ítem, en la misma transacción: la segunda ve lo que escribió la primera.
      tx.stock_deposito.findUnique.mockResolvedValueOnce({ cantidad_disponible: 20 }).mockResolvedValueOnce({ cantidad_disponible: 19 });
      await service.create(
        {
          ...dto,
          items: [
            { compra_det_id: 'det-1', producto_id: 'p1', descripcion: 'Leche', cantidad: 1, precio_unitario: 100, afecta_stock: true },
            { compra_det_id: 'det-1', producto_id: 'p1', descripcion: 'Leche', cantidad: 2, precio_unitario: 100, afecta_stock: true },
          ],
        },
        'emp',
        'usr',
      );

      expect(lotes.descontarDeLote).toHaveBeenCalledTimes(2);
      expect(ultima(lotes.descontarDeLote)).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
      expect(fifo.deductFifo).not.toHaveBeenCalled();
      expect(tx.stock_deposito.upsert.mock.calls.map(([a]: any[]) => a.update.cantidad_disponible)).toEqual([19, 17]);
      expect(tx.movimientos_inventario.create.mock.calls.map(([a]: any[]) => [a.data.lote_id, a.data.cantidad])).toEqual([
        ['L-compra', 1],
        ['L-compra', 2],
      ]);
    });

    it('la salida por FEFO también va antes que stock_deposito', async () => {
      const { service, tx, fifo } = crear();
      await service.create(dto, 'emp', 'usr');
      expect(ultima(fifo.deductFifo)).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
    });

    it('anular con dos ítems: los lotes de todos antes del primer stock_deposito, repartidos igual', async () => {
      const { service, prisma, tx, lotes } = crear();
      prisma.nota_credito_compra_cab.findFirst.mockResolvedValue({
        id: 'nc',
        estado: 'registrada',
        anulado: false,
        afecta_stock: true,
        deposito_id: 'dep',
        proveedor_id: 'prov',
        compra_id: 'compra',
        gasto_id: null,
        total: 950,
        numero: '1',
        detalles: [
          { producto_id: 'p1', cantidad: 2, afecta_stock: true, compra_det_id: 'det-1' },
          { producto_id: 'p1', cantidad: 3, afecta_stock: true, compra_det_id: 'det-1' },
        ],
      });
      tx.movimientos_inventario.findMany.mockResolvedValue([
        { producto_id: 'p1', lote_id: 'L-1', cantidad: 3, lote: { numero_lote: 'A' } },
        { producto_id: 'p1', lote_id: 'L-2', cantidad: 1, lote: { numero_lote: 'B' } },
      ]);
      tx.stock_deposito.findUnique.mockResolvedValueOnce({ cantidad_disponible: 20 }).mockResolvedValueOnce({ cantidad_disponible: 22 });

      await service.anular('nc', 'emp', 'Error de carga', 'usr');

      expect(ultima(lotes.ingresarEnLote)).toBeLessThan(tx.stock_deposito.upsert.mock.invocationCallOrder[0]);
      expect(lotes.ingresarEnLote.mock.calls.map((c: any[]) => [c[1].loteId, c[1].cantidad])).toEqual([
        ['L-1', 2],
        ['L-1', 1],
        ['L-2', 1],
      ]);
      expect(tx.stock_deposito.upsert.mock.calls.map(([a]: any[]) => a.update.cantidad_disponible)).toEqual([22, 25]);
      expect(tx.movimientos_inventario.create.mock.calls.map(([a]: any[]) => [a.data.lote_id, a.data.cantidad])).toEqual([
        ['L-1', 2],
        ['L-1', 1],
        ['L-2', 1],
        [null, 1],
      ]);
    });
  });
});
