import { bloquearStockOrdenado } from 'src/lotes/bloqueo-stock';
import { PedidosService } from './pedidos.service';
import { liberarReservasFacturadas, liberarReservasPedido, paresReservaPedido } from './reservas-pedido';
import { revertirPedidoPorAnulacionFactura } from './reversion-anulacion-factura';

jest.mock('src/lotes/bloqueo-stock', () => ({ bloquearStockOrdenado: jest.fn(async () => undefined) }));
const bloquear = bloquearStockOrdenado as jest.Mock;

/**
 * Reservar y soltar la reserva de un pedido escribe `stock_deposito.cantidad_reservada` de varias filas en el orden de los
 * renglones. Contra el cierre de inventario (que toma todas las filas del depósito por producto) eso se cruza: renglones B, Y, A
 * toman B, esperan Y y después piden A, que el cierre ya tiene (40P01, prueba real `carrera-cierre-ventas.js`). Por eso todas las
 * filas se bloquean juntas y en el orden del cierre ANTES de la primera escritura.
 */
const renglon = (id: string, producto_id: string, deposito_id: string | null, extra: Record<string, unknown> = {}) => ({
  id,
  pedido_id: 'ped-1',
  producto_id,
  deposito_id,
  cantidad: 1,
  cantidad_base: 1,
  cant_pendiente: null,
  pedido: { empresa_id: 'emp-1' },
  producto: { maneja_inventario: true },
  ...extra,
});

function txReservas(renglones: Array<Record<string, any>>) {
  return {
    $queryRaw: jest.fn(async () => []),
    pedido_detalle: { findMany: jest.fn(async () => renglones), update: jest.fn(async () => ({})) },
    stock_deposito: {
      findUnique: jest.fn(async () => ({ cantidad_reservada: 5 })),
      update: jest.fn(async () => ({})),
      upsert: jest.fn(async () => ({})),
    },
  } as any;
}

const primeraEscritura = (tx: any) =>
  Math.min(
    ...[tx.stock_deposito.update, tx.stock_deposito.upsert].flatMap((f: jest.Mock) => f.mock.invocationCallOrder),
  );

beforeEach(() => bloquear.mockClear());

describe('reservas de pedido: bloqueo ordenado antes de escribir', () => {
  const renglones = [renglon('r1', 'p-b', 'd1'), renglon('r2', 'p-y', 'd1'), renglon('r3', 'p-a', 'd1')];

  it('paresReservaPedido: los (producto, depósito) de los renglones que reservan', async () => {
    const tx = txReservas(renglones);
    expect(await paresReservaPedido(tx, 'ped-1')).toEqual([
      { productoId: 'p-b', depositoId: 'd1' },
      { productoId: 'p-y', depositoId: 'd1' },
      { productoId: 'p-a', depositoId: 'd1' },
    ]);
  });

  it('liberarReservasPedido (cancelar, vencer, eliminar): bloquea todas las filas antes del primer update', async () => {
    const tx = txReservas(renglones);
    await liberarReservasPedido(tx, 'ped-1');
    expect(bloquear).toHaveBeenCalledTimes(1);
    expect(bloquear).toHaveBeenCalledWith(tx, 'emp-1', [
      { productoId: 'p-b', depositoId: 'd1' },
      { productoId: 'p-y', depositoId: 'd1' },
      { productoId: 'p-a', depositoId: 'd1' },
    ]);
    expect(bloquear.mock.invocationCallOrder[0]).toBeLessThan(primeraEscritura(tx));
    expect(tx.stock_deposito.update).toHaveBeenCalledTimes(3);
  });

  it('liberarReservasFacturadas (orden facturada en partes): bloquea antes del primer update', async () => {
    const tx = txReservas(renglones);
    await liberarReservasFacturadas(tx, 'ped-1', [
      { producto_id: 'p-b', cantidad: 1 },
      { producto_id: 'p-a', cantidad: 1 },
    ]);
    expect(bloquear).toHaveBeenCalledTimes(1);
    expect(bloquear.mock.invocationCallOrder[0]).toBeLessThan(primeraEscritura(tx));
  });

  it('sin renglones que reserven no bloquea ni escribe', async () => {
    const tx = txReservas([]);
    expect(await liberarReservasPedido(tx, 'ped-1')).toBe(0);
    expect(bloquear).not.toHaveBeenCalled();
  });

  it('PedidosService.reservarStockPedido (confirmar, aprobar la orden): resuelve los depósitos, bloquea y recién después reserva', async () => {
    const tx = txReservas([
      renglon('r1', 'p-b', 'd1'),
      renglon('r2', 'p-y', null),
      renglon('r3', 'serv', 'd1', { producto: { maneja_inventario: false } }),
      renglon('r4', 'p-a', 'd1'),
    ]);
    const service = new PedidosService({} as any, {} as any, {} as any, {} as any, {} as any);
    // Sin depósito en el renglón: el del pedido.
    await (service as any).reservarStockPedido(tx, 'ped-1', 'd-ped', 'suc-1', 'emp-1');
    expect(bloquear).toHaveBeenCalledTimes(1);
    expect(bloquear).toHaveBeenCalledWith(tx, 'emp-1', [
      { productoId: 'p-b', depositoId: 'd1' },
      { productoId: 'p-y', depositoId: 'd-ped' },
      { productoId: 'p-a', depositoId: 'd1' },
    ]);
    expect(bloquear.mock.invocationCallOrder[0]).toBeLessThan(primeraEscritura(tx));
    // Igual que antes: el renglón sin depósito guarda el resuelto y el servicio no reserva.
    expect(tx.pedido_detalle.update).toHaveBeenCalledWith({ where: { id: 'r2' }, data: { deposito_id: 'd-ped' } });
    expect(tx.stock_deposito.upsert).toHaveBeenCalledTimes(3);
  });
});

describe('volver a reservar al anular la factura: bloqueo ordenado antes de escribir', () => {
  function db(pedido: Record<string, any>, renglones: Array<Record<string, any>>, extra: Record<string, any> = {}) {
    const tx: any = {
      ...txReservas(renglones),
      factura_cab: { findFirst: jest.fn(async () => ({ pedido_id: pedido.id, dest: '001', dpunexp: '001', dnumdoc: '1' })) },
      factura_det: { findMany: jest.fn(async () => extra.facturaDets ?? []) },
      pedidos: { findFirst: jest.fn(async () => pedido), findUnique: jest.fn(async () => pedido), update: jest.fn(async () => ({})) },
      pedido_historial: {
        findMany: jest.fn(async () => extra.historial ?? []),
        count: jest.fn(async () => 0),
        create: jest.fn(async () => ({})),
      },
      empresas_sucursales: { findUnique: jest.fn(async () => ({ config: {} })) },
    };
    return { db: { $transaction: jest.fn(async (fn: any) => fn(tx)) } as any, tx };
  }

  it('pedido: bloquea las filas de todos los renglones antes de la primera reserva', async () => {
    const { db: base, tx } = db(
      { id: 'ped-1', tipo_pedido: 'venta_mayorista', estado: 'facturado', factura_id: 'fac-1' },
      [renglon('r1', 'p-b', 'd1'), renglon('r2', 'p-y', 'd1'), renglon('r3', 'p-a', 'd1')],
    );
    await revertirPedidoPorAnulacionFactura(base, 'fac-1', 'emp-1');
    expect(bloquear).toHaveBeenCalledWith(tx, 'emp-1', [
      { productoId: 'p-b', depositoId: 'd1' },
      { productoId: 'p-y', depositoId: 'd1' },
      { productoId: 'p-a', depositoId: 'd1' },
    ]);
    expect(bloquear.mock.invocationCallOrder[0]).toBeLessThan(primeraEscritura(tx));
  });

  it('orden de venta que reservaba: bloquea antes de la primera reserva', async () => {
    const { db: base, tx } = db(
      { id: 'ped-1', tipo_pedido: 'orden_venta', estado_orden: 'facturada', stock_reservado: true },
      [renglon('r1', 'p-b', 'd1', { cant_pendiente: 0 }), renglon('r2', 'p-a', 'd1', { cant_pendiente: 0 })],
      {
        historial: [{ accion: 'facturada', datos: { factura_id: 'fac-1', reservaba: true } }],
        facturaDets: [{ producto_id: 'p-b', dcantproser: 1 }, { producto_id: 'p-a', dcantproser: 1 }],
      },
    );
    await revertirPedidoPorAnulacionFactura(base, 'fac-1', 'emp-1');
    expect(bloquear).toHaveBeenCalledTimes(1);
    expect(bloquear.mock.invocationCallOrder[0]).toBeLessThan(primeraEscritura(tx));
    expect(tx.stock_deposito.upsert).toHaveBeenCalledTimes(2);
  });

  it('orden que no reservaba: no bloquea stock (no lo escribe)', async () => {
    const { db: base, tx } = db(
      { id: 'ped-1', tipo_pedido: 'orden_venta', estado_orden: 'facturada', stock_reservado: false },
      [renglon('r1', 'p-b', 'd1', { cant_pendiente: 0 })],
      { historial: [{ accion: 'facturada', datos: { factura_id: 'fac-1', reservaba: false } }], facturaDets: [{ producto_id: 'p-b', dcantproser: 1 }] },
    );
    await revertirPedidoPorAnulacionFactura(base, 'fac-1', 'emp-1');
    expect(bloquear).not.toHaveBeenCalled();
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });
});
