import { bloquearStockVenta, descontarStockDepositoVenta, descontarStockFacturaAuto, paresStockVenta } from './stock-venta';

/** Venta contra el cierre de inventario: qué bloquea y cómo escribe stock_deposito. */
describe('stock de la venta', () => {
  const productos = new Map<string, any>([
    ['p1', { maneja_inventario: true }],
    ['p2', { maneja_inventario: true }],
    ['srv', { maneja_inventario: false }],
  ]);
  const deRemision = (it: any) => (it?.aplicaciones_remision?.length ?? 0) > 0;

  it('paresStockVenta: solo los ítems que mueven stock (con inventario y no de remisión), en el depósito de la venta', () => {
    const items = [
      { producto_id: 'p2', cantidad: 1 },
      { producto_id: 'srv', cantidad: 1 },
      { producto_id: 'p1', cantidad: 2, aplicaciones_remision: [{ nota_remision_det_id: 'r1', cantidad: 2 }] },
      { producto_id: 'p1', cantidad: 3 },
    ];
    expect(paresStockVenta(items, productos, deRemision, 'dep-1')).toEqual([
      { productoId: 'p2', depositoId: 'dep-1' },
      { productoId: 'p1', depositoId: 'dep-1' },
    ]);
    expect(paresStockVenta(items, productos, deRemision, null)).toEqual([]);
  });

  const montar = () => {
    const tx: any = { stock_deposito: { upsert: jest.fn() }, movimientos_inventario: { create: jest.fn() } };
    const descontar = (items: any[]) =>
      descontarStockDepositoVenta(tx, {
        items,
        productosMap: productos,
        esItemDeRemision: deRemision,
        depositoId: 'dep-1',
        tipoMovimientoId: 'tm-venta',
        facturaId: 'f-1',
        numeroFactura: '001-001-0000007',
      });
    return { tx, descontar };
  };

  it('descuenta con un decremento atómico (no escribe un absoluto leído antes: no pisa un cierre que confirmó en el medio)', async () => {
    const { tx, descontar } = montar();
    await descontar([{ producto_id: 'p1', cantidad: 2, precio_unitario: 100 }]);
    expect(tx.stock_deposito.upsert).toHaveBeenCalledWith({
      where: { deposito_id_producto_id: { deposito_id: 'dep-1', producto_id: 'p1' } },
      create: { deposito_id: 'dep-1', producto_id: 'p1', cantidad_disponible: -2 },
      update: { cantidad_disponible: { decrement: 2 }, updated_at: expect.any(Date) },
    });
    expect(tx.movimientos_inventario.create).toHaveBeenCalledWith({
      data: {
        deposito_origen_id: 'dep-1',
        producto_id: 'p1',
        tipo_movimiento_id: 'tm-venta',
        cantidad: 2,
        precio_unitario: 100,
        documento_origen: 'factura_venta',
        documento_id: 'f-1',
        observaciones: 'Venta Fact. 001-001-0000007',
      },
    });
  });

  it('un producto repetido descuenta cada línea; servicios e ítems de remisión no tocan stock', async () => {
    const { tx, descontar } = montar();
    await descontar([
      { producto_id: 'p1', cantidad: 2, precio_unitario: 100 },
      { producto_id: 'srv', cantidad: 1, precio_unitario: 50 },
      { producto_id: 'p2', cantidad: 4, precio_unitario: 10, aplicaciones_remision: [{ nota_remision_det_id: 'r1', cantidad: 4 }] },
      { producto_id: 'p1', cantidad: 3, precio_unitario: 100 },
    ]);
    expect(tx.stock_deposito.upsert.mock.calls.map((c: any[]) => [c[0].where.deposito_id_producto_id.producto_id, c[0].update.cantidad_disponible])).toEqual([
      ['p1', { decrement: 2 }],
      ['p1', { decrement: 3 }],
    ]);
    expect(tx.movimientos_inventario.create).toHaveBeenCalledTimes(2);
  });
});

/**
 * I1 (ola 3): la venta de un pedido suelta su reserva (`cantidad_reservada`) y esa es una escritura de stock_deposito. Antes iba
 * renglón por renglón y ANTES del bloqueo ordenado de la venta: pedido con B e Y reservados y venta de B y A → 40P01 contra el
 * cierre (3/3 en `carrera-cierre-ventas.js venta-pedido`). Ahora se bloquean juntas las filas de la venta y las de la reserva, y
 * recién después se suelta.
 */
describe('venta desde un pedido con reserva', () => {
  const productos = new Map<string, any>([
    ['p-a', { maneja_inventario: true }],
    ['p-b', { maneja_inventario: true }],
  ]);
  const montar = (renglones: any[]) => {
    const tx: any = {
      $queryRaw: jest.fn(async () => []),
      pedidos: { findFirst: jest.fn(async () => ({ tipo_pedido: 'venta_mayorista', estado: 'confirmado' })) },
      pedido_detalle: { findMany: jest.fn(async () => renglones) },
      stock_deposito: { findUnique: jest.fn(async () => ({ cantidad_reservada: 1 })), update: jest.fn(async () => ({})) },
    };
    const lotes: any = { bloquearStockDe: jest.fn(async () => undefined) };
    return { tx, lotes };
  };
  const renglon = (producto_id: string) => ({ producto_id, deposito_id: 'dep-1', cantidad: 1, cantidad_base: 1, cant_pendiente: null, pedido: { empresa_id: 'emp' } });

  it('bloquea los pares de la venta y los de la reserva en una sola llamada, antes de soltar la reserva', async () => {
    const { tx, lotes } = montar([renglon('p-b'), renglon('p-y')]);
    await bloquearStockVenta(tx, lotes, {
      empresaId: 'emp',
      items: [{ producto_id: 'p-b', cantidad: 1 }, { producto_id: 'p-a', cantidad: 1 }],
      productosMap: productos,
      esItemDeRemision: () => false,
      depositoId: 'dep-1',
      pedidoId: 'ped-1',
    });
    expect(lotes.bloquearStockDe).toHaveBeenCalledTimes(1);
    expect(lotes.bloquearStockDe.mock.calls[0][2]).toEqual([
      { productoId: 'p-b', depositoId: 'dep-1' },
      { productoId: 'p-a', depositoId: 'dep-1' },
      { productoId: 'p-b', depositoId: 'dep-1' },
      { productoId: 'p-y', depositoId: 'dep-1' },
    ]);
    expect(tx.stock_deposito.update).toHaveBeenCalledTimes(2);
    expect(lotes.bloquearStockDe.mock.invocationCallOrder[0]).toBeLessThan(tx.stock_deposito.update.mock.invocationCallOrder[0]);
    // La reserva se suelta igual que antes: decremento de cantidad_reservada, sin tocar el disponible.
    expect(tx.stock_deposito.update.mock.calls[0][0].data).toMatchObject({ cantidad_reservada: { decrement: 1 } });
    expect(tx.stock_deposito.update.mock.calls[0][0].data.cantidad_disponible).toBeUndefined();
  });

  it('sin pedido: solo los pares de la venta, y no busca reservas', async () => {
    const { tx, lotes } = montar([]);
    await bloquearStockVenta(tx, lotes, {
      empresaId: 'emp',
      items: [{ producto_id: 'p-a', cantidad: 1 }],
      productosMap: productos,
      esItemDeRemision: () => false,
      depositoId: 'dep-1',
      pedidoId: null,
    });
    expect(lotes.bloquearStockDe.mock.calls[0][2]).toEqual([{ productoId: 'p-a', depositoId: 'dep-1' }]);
    expect(tx.pedido_detalle.findMany).not.toHaveBeenCalled();
    expect(tx.stock_deposito.update).not.toHaveBeenCalled();
  });
});

/**
 * (b) La factura automática descontaba lotes pero no `stock_deposito` (ni dejaba movimiento VENTA: anularla tampoco reponía). Ahora
 * descuenta igual que la venta normal: bloqueo en el orden del cierre, FEFO si el producto maneja lote, decremento atómico del
 * depósito y su movimiento, todo en la misma transacción.
 */
describe('factura automática: stock del depósito', () => {
  const montar = () => {
    const orden: string[] = [];
    const tx: any = {
      stock_deposito: { upsert: jest.fn(async () => orden.push('stock')) },
      movimientos_inventario: { create: jest.fn(async () => orden.push('movimiento')) },
    };
    const lotes: any = { bloquearStockDe: jest.fn(async () => orden.push('bloqueo')) };
    const resultado = { lotes_consumidos: [{ lote_id: 'l1', cantidad: 2, costo_unitario: 5, costo_total: 10 }], cantidad_total: 2, costo_total: 10, costo_unitario_promedio: 5, cantidad_sin_lote: 0 };
    const fifo: any = { deductFifo: jest.fn(async () => (orden.push('fefo'), resultado)) };
    const p = { empresaId: 'emp', productoId: 'p-f', depositoId: 'dep-1', cantidad: 2, precioUnitario: 7000, tipoMovimientoId: 'tm-venta', facturaId: 'f-1', numeroFactura: '001-001-0000009' };
    return { tx, lotes, fifo, orden, resultado, p };
  };

  it('con lotes: bloqueo → FEFO → decremento atómico del depósito → movimiento VENTA', async () => {
    const { tx, lotes, fifo, orden, resultado, p } = montar();
    const r = await descontarStockFacturaAuto(tx, lotes, fifo, { ...p, conLotes: true });
    expect(r).toBe(resultado);
    expect(orden).toEqual(['bloqueo', 'fefo', 'stock', 'movimiento']);
    expect(lotes.bloquearStockDe).toHaveBeenCalledWith(tx, 'emp', [{ productoId: 'p-f', depositoId: 'dep-1' }]);
    const upsert = tx.stock_deposito.upsert.mock.calls[0][0];
    expect(upsert.where).toEqual({ deposito_id_producto_id: { deposito_id: 'dep-1', producto_id: 'p-f' } });
    expect(upsert.update.cantidad_disponible).toEqual({ decrement: 2 });
    expect(upsert.create.cantidad_disponible).toBe(-2);
    expect(tx.movimientos_inventario.create.mock.calls[0][0].data).toMatchObject({
      deposito_origen_id: 'dep-1', producto_id: 'p-f', tipo_movimiento_id: 'tm-venta', cantidad: 2, documento_origen: 'factura_venta',
      documento_id: 'f-1', observaciones: 'Venta Fact. 001-001-0000009',
    });
  });

  it('sin lotes: no hay FEFO, pero el depósito se descuenta igual', async () => {
    const { tx, lotes, fifo, orden, p } = montar();
    const r = await descontarStockFacturaAuto(tx, lotes, fifo, { ...p, conLotes: false });
    expect(r).toBeNull();
    expect(fifo.deductFifo).not.toHaveBeenCalled();
    expect(orden).toEqual(['bloqueo', 'stock', 'movimiento']);
  });
});
