import { REQUIRE_PERMISSION_KEY } from '../auth/decorators/require-permission.decorator';
import { StockController } from './stock.controller';
import { StockService } from './stock.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { resolverPermisos } from 'src/productos/permisos-columnas';

jest.mock('src/utils/alcance-sucursal', () => ({ alcanceSucursalUsuario: jest.fn(), filtroSucursalDeposito: jest.fn() }));
jest.mock('src/productos/permisos-columnas', () => ({ resolverPermisos: jest.fn().mockResolvedValue(new Set()) }));
jest.mock('src/utils/alcance-rubro', () => ({ rubrosFiltroUsuario: jest.fn().mockResolvedValue(null) }));
jest.mock('src/utils/rubro-context', () => ({ rubroDelRequest: jest.fn().mockReturnValue(undefined) }));

const alcanceA = { sucursalIds: ['s'], puntosEstablecimiento: [], depositoIds: ['dep-a'] };
const DEPOSITOS = [
  { id: 'dep-a', descripcion: 'A', sucursal_id: 's-b', es_principal: true, sucursal: { id: 's-b', descripcion: 'Beta' } },
  { id: 'dep-b', descripcion: 'B', sucursal_id: 's-a', es_principal: false, sucursal: { id: 's-a', descripcion: 'Alfa' } },
];
const fila = (deposito_id: string, cantidad_disponible: number, cantidad_reservada = 0) => ({ deposito_id, cantidad_disponible, cantidad_reservada });

function crear(opts: { filas?: any[]; usaLotes?: boolean; sinLote?: number; propio?: boolean; productoPropio?: boolean; stock?: any; lotes?: any; repetido?: boolean; moneda?: string | null; loteOrigen?: any } = {}) {
  const tx: any = {
    // El producto vigente (FOR KEY SHARE) va primero en toda escritura de stock; el resto son las filas de stock.
    $queryRaw: jest.fn(async (q: string[]) => (q.join('').includes('FROM productos') ? [{ deleted: false }] : opts.filas ?? [fila('dep-a', 10)])),
    tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 'tipo' }), upsert: jest.fn() },
    stock_deposito: { upsert: jest.fn().mockResolvedValue({ producto: {}, deposito: {} }), update: jest.fn().mockResolvedValue({ id: 'sd' }) },
    movimientos_inventario: { create: jest.fn().mockResolvedValue({ id: 'mov' }) },
    lotes_producto: { findFirst: jest.fn().mockResolvedValue(opts.repetido ? { id: 'l' } : null) },
    productos: { findUnique: jest.fn().mockResolvedValue({ precio_costo: 700 }) },
  };
  const prisma: any = {
    $transaction: jest.fn(async (cb: any) => cb(tx)),
    depositos: { count: jest.fn(async (a: any) => (opts.propio === false ? 0 : new Set(a.where.id.in).size)), findMany: jest.fn().mockResolvedValue(DEPOSITOS) },
    productos: { findFirst: jest.fn().mockResolvedValue(opts.productoPropio === false ? null : { maneja_inventario: true }), findUnique: jest.fn().mockResolvedValue(null) },
    stock_deposito: { findUnique: jest.fn().mockResolvedValue(opts.stock ?? null), update: jest.fn(), createMany: jest.fn().mockResolvedValue({ count: 0 }) },
    stock_lote: { findFirst: jest.fn().mockResolvedValue(opts.loteOrigen ?? null), createMany: jest.fn().mockResolvedValue({ count: 0 }) },
    categorias: { findMany: jest.fn().mockResolvedValue([{ id: 'c', descripcion: 'Cat' }]) },
    marcas: { findMany: jest.fn().mockResolvedValue([{ id: 'm', descripcion: 'Mar' }]) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue(opts.moneda === null ? null : { moneda: { codigo: opts.moneda ?? 'USD' } }) },
  };
  const lotes: any = {
    usaLotesEnDeposito: jest.fn().mockResolvedValue(!!opts.usaLotes),
    loteDelProducto: jest.fn().mockResolvedValue({ id: 'l' }),
    descontarDeLote: jest.fn(),
    ingresarEnLote: jest.fn(),
    transferirLote: jest.fn(),
    bloquearFilasLote: jest.fn().mockResolvedValue(undefined),
    createLoteIngreso: jest.fn().mockResolvedValue({ id: 'nuevo' }),
    disponiblesEnDeposito: jest.fn().mockResolvedValue(opts.lotes ?? { usa_lotes: false, items: [], sin_lote: 0 }),
  };
  const fifo: any = { cantidadSinLote: jest.fn().mockResolvedValue(opts.sinLote ?? 0) };
  const audit: any = { log: jest.fn() };
  return { service: new StockService(prisma, audit, lotes, fifo), prisma, tx, lotes, audit };
}

const ajuste = (cantidad: number, extra: object = {}) => ({ deposito_id: 'dep-a', producto_id: 'p', cantidad, ...extra }) as any;
const transferencia = (cantidad: number, extra: object = {}) => ({ deposito_origen_id: 'dep-a', deposito_destino_id: 'dep-b', producto_id: 'p', cantidad, ...extra }) as any;
const entrar = (s: StockService, cantidad: number, extra: object = {}) => s.ajustarStock(ajuste(cantidad, extra), 'usr', 'AJUSTE_POSITIVO', 'emp');
const sacar = (s: StockService, cantidad: number, extra: object = {}) => s.ajustarStock(ajuste(cantidad, extra), 'usr', 'AJUSTE_NEGATIVO', 'emp');
const transferir = (s: StockService, cantidad: number, extra: object = {}) => s.transferirStock(transferencia(cantidad, extra), 'usr', 'emp');

beforeEach(() => {
  (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null);
  (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
});

describe('rutas propias de Ajuste y Transferencias', () => {
  it.each([
    ['opcionesAjuste', 'INV_AJU_AJUSTE_VER', 'INV_AJUSTES'],
    ['contextoAjuste', 'INV_AJU_AJUSTE_VER', 'INV_AJUSTES'],
    ['opcionesTransferencia', 'INV_TRF_TRANSFERENCIA_VER', 'INV_TRANSFERENCIAS'],
    ['contextoTransferencia', 'INV_TRF_TRANSFERENCIA_VER', 'INV_TRANSFERENCIAS'],
  ])('%s exige %s y el submódulo %s', (metodo, privilegio, submodulo) => {
    const handler = (StockController.prototype as any)[metodo];
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, handler)).toEqual({ modulo: 'INVENTARIO', privilegio });
    expect(Reflect.getMetadata('require_submodulo', handler)).toBe(submodulo);
  });
});

describe('opcionesOperacion', () => {
  it('devuelve solo sucursales, depósitos y moneda base, sin leer categorías ni marcas', async () => {
    const { service, prisma } = crear();
    const r = await service.opcionesOperacion('emp', 'usr');
    expect(Object.keys(r)).toEqual(['sucursales', 'depositos', 'moneda_base']);
    expect(r.sucursales.map((s) => s.descripcion)).toEqual(['Alfa', 'Beta']);
    expect(r.depositos[0]).toEqual({ id: 'dep-a', descripcion: 'A', sucursal_id: 's-b', es_principal: true });
    expect(r.moneda_base).toBe('USD');
    expect(prisma.categorias.findMany).not.toHaveBeenCalled();
    expect(prisma.marcas.findMany).not.toHaveBeenCalled();
  });

  it('sin moneda principal cargada, PYG', async () => {
    const { service } = crear({ moneda: null });
    expect((await service.opcionesOperacion('emp', 'usr')).moneda_base).toBe('PYG');
  });

  it('recorta por alcance', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, prisma } = crear();
    await service.opcionesOperacion('emp', 'usr');
    expect(prisma.depositos.findMany.mock.calls[0][0].where.id).toEqual({ in: ['dep-a'] });
  });

  it('`opciones` sigue trayendo categorías y marcas con las mismas listas y sin moneda', async () => {
    const { service } = crear();
    const [nueva, vieja] = [await service.opcionesOperacion('emp', 'usr'), await service.opciones('emp', 'usr')];
    expect(vieja.sucursales).toEqual(nueva.sucursales);
    expect(vieja.depositos).toEqual(nueva.depositos);
    expect(vieja.categorias).toEqual([{ id: 'c', descripcion: 'Cat' }]);
    expect(vieja.marcas).toEqual([{ id: 'm', descripcion: 'Mar' }]);
    expect(vieja).not.toHaveProperty('moneda_base');
  });
});

describe('contextoOperacion', () => {
  it('con fila: cantidades como números', async () => {
    const { service, prisma } = crear({ stock: { cantidad_disponible: { toString: () => '12.5' }, cantidad_reservada: { toString: () => '2' } } });
    const r = await service.contextoOperacion('emp', 'p', 'dep-a', 'usr');
    expect(r.stock).toEqual({ cantidad_disponible: 12.5, cantidad_reservada: 2 });
    expect(prisma.stock_deposito.findUnique.mock.calls[0][0].select).toEqual({ cantidad_disponible: true, cantidad_reservada: true });
  });

  it('sin fila: stock null', async () => {
    const { service } = crear();
    expect((await service.contextoOperacion('emp', 'p', 'dep-a', 'usr')).stock).toBeNull();
  });

  it('depósito ajeno: 403 con código y no lee los lotes', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service, lotes } = crear();
    await expect(service.contextoOperacion('emp', 'p', 'dep-b', 'usr')).rejects.toMatchObject({ status: 403, response: { codigo: 'DEPOSITO_FUERA_DE_ALCANCE' } });
    expect(lotes.disponiblesEnDeposito).not.toHaveBeenCalled();
  });

  it('producto de otra empresa: 404, antes del alcance', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    const { service } = crear({ productoPropio: false });
    await expect(service.contextoOperacion('emp', 'p', 'dep-b', 'usr')).rejects.toMatchObject({ status: 404, response: { codigo: 'PRODUCTO_NO_ENCONTRADO' } });
  });

  it('nunca lleva costo, ni con el permiso', async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set(['INV_STK_COSTO_VER']));
    const lotes = { usa_lotes: true, sugerido_lote_id: 'l', sin_lote: 1, items: [{ lote_id: 'l', numero_lote: 'L-1', fecha_fabricacion: null, fecha_vencimiento: null, costo_unitario: 1200, cantidad_disponible: 3, vencido: false }] };
    const { service } = crear({ lotes });
    const r = await service.contextoOperacion('emp', 'p', 'dep-a', 'usr');
    const texto = JSON.stringify(r);
    expect(texto).not.toContain('costo');
    expect(texto).not.toContain('1200');
    expect(r.lotes).toEqual({ usa_lotes: true, sugerido_lote_id: 'l', sin_lote: 1, items: [{ lote_id: 'l', numero_lote: 'L-1', fecha_fabricacion: null, fecha_vencimiento: null, cantidad_disponible: 3, vencido: false }] });
  });

  it('sin lotes pasa igual', async () => {
    const { service } = crear();
    expect((await service.contextoOperacion('emp', 'p', 'dep-a', 'usr')).lotes).toEqual({ usa_lotes: false, items: [], sin_lote: 0 });
  });
});

describe('errores con código y el `message` de hoy', () => {
  it('ajustar por encima del stock: STOCK_INSUFICIENTE', async () => {
    const { service } = crear({ filas: [fila('dep-a', 10)] });
    await expect(sacar(service, -15)).rejects.toMatchObject({
      status: 400,
      message: 'Stock insuficiente para el ajuste: en el depósito hay 10 y se quieren sacar 15.',
      response: { codigo: 'STOCK_INSUFICIENTE', campo: 'cantidad', actual: 10, pedido: 15 },
    });
  });

  const textoReservado = 'El movimiento dejaría 5 y hay 8 reservado(s) para pedidos. Podés sacar como máximo 2; para sacar más, liberá o facturá primero esos pedidos (Ventas › Pedidos).';

  it('ajustar por debajo de lo reservado: STOCK_RESERVADO', async () => {
    const { service } = crear({ filas: [fila('dep-a', 10, 8)] });
    await expect(sacar(service, -5)).rejects.toMatchObject({
      status: 400,
      message: textoReservado,
      response: { codigo: 'STOCK_RESERVADO', campo: 'cantidad', quedaria: 5, reservado: 8, maximo: 2 },
    });
  });

  it('POST /stock por debajo de lo reservado: el mismo código', async () => {
    const { service } = crear({ filas: [fila('dep-a', 10, 8)] });
    await expect(service.upsertStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad_disponible: 5 } as any, 'usr', 'emp')).rejects.toMatchObject({
      message: textoReservado,
      response: { codigo: 'STOCK_RESERVADO', quedaria: 5, reservado: 8, maximo: 2 },
    });
  });

  it('transferir al mismo depósito: DEPOSITOS_IGUALES', async () => {
    const { service } = crear();
    await expect(transferir(service, 1, { deposito_destino_id: 'dep-a' })).rejects.toMatchObject({
      status: 400,
      message: 'El depósito origen y destino no pueden ser el mismo',
      response: { codigo: 'DEPOSITOS_IGUALES', campo: 'deposito_destino_id' },
    });
  });

  it('transferir sin fila de origen: 404 STOCK_ORIGEN_INEXISTENTE, aunque el destino tenga fila', async () => {
    const { service } = crear({ filas: [fila('dep-b', 100)] });
    await expect(transferir(service, 1)).rejects.toMatchObject({
      status: 404,
      message: 'Stock en depósito origen no encontrado',
      response: { codigo: 'STOCK_ORIGEN_INEXISTENTE', campo: 'producto_id' },
    });
  });

  it('transferir por encima del libre: STOCK_ORIGEN_INSUFICIENTE, con reservado', async () => {
    const { service } = crear({ filas: [fila('dep-a', 10, 3)] });
    await expect(transferir(service, 8)).rejects.toMatchObject({
      status: 400,
      message: 'Stock disponible insuficiente en el depósito de origen: hay 10, de los que 3 están reservados para pedidos. Se puede transferir como máximo 7.',
      response: { codigo: 'STOCK_ORIGEN_INSUFICIENTE', campo: 'cantidad', actual: 10, reservado: 3, maximo: 7 },
    });
  });

  it('transferir por encima, sin reserva: el texto de hoy sin mencionarla', async () => {
    const { service } = crear({ filas: [fila('dep-a', 10)] });
    await expect(transferir(service, 12)).rejects.toMatchObject({
      message: 'Stock disponible insuficiente en el depósito de origen: hay 10. Se puede transferir como máximo 10.',
      response: { actual: 10, reservado: 0, maximo: 10 },
    });
  });

  it('depósito de otra empresa: DEPOSITO_NO_ENCONTRADO', async () => {
    const { service } = crear({ propio: false });
    await expect(sacar(service, -1)).rejects.toMatchObject({ status: 404, message: 'Depósito no encontrado', response: { codigo: 'DEPOSITO_NO_ENCONTRADO' } });
  });

  it('producto de otra empresa: PRODUCTO_NO_ENCONTRADO', async () => {
    const { service } = crear({ productoPropio: false });
    await expect(sacar(service, -1)).rejects.toMatchObject({ status: 404, message: 'Producto no encontrado', response: { codigo: 'PRODUCTO_NO_ENCONTRADO' } });
  });

  it('ajustar con lote un producto sin lotes: PRODUCTO_SIN_LOTES', async () => {
    const { service } = crear();
    await expect(sacar(service, -1, { lote_id: 'l' })).rejects.toMatchObject({
      message: 'Este producto no se controla por lote en este depósito: quitá el lote del ajuste (o activá «Manejo de Lote» en el producto).',
      response: { codigo: 'PRODUCTO_SIN_LOTES', campo: 'lote' },
    });
  });

  it('transferir con lote un producto sin lotes: PRODUCTO_SIN_LOTES', async () => {
    const { service } = crear();
    await expect(transferir(service, 1, { lote_id: 'l' })).rejects.toMatchObject({
      message: 'Este producto no se controla por lote en el depósito de origen: quitá el lote de la transferencia.',
      response: { codigo: 'PRODUCTO_SIN_LOTES', campo: 'lote' },
    });
  });

  it('entrada con lotes sin lote: LOTE_REQUERIDO', async () => {
    const { service } = crear({ usaLotes: true });
    await expect(entrar(service, 4)).rejects.toMatchObject({
      message: 'Este producto se controla por lote: elegí a qué lote entra el stock o cargá un lote nuevo.',
      response: { codigo: 'LOTE_REQUERIDO', campo: 'lote' },
    });
  });

  it('salida sin lote por encima de lo que está sin lote: SIN_LOTE_INSUFICIENTE', async () => {
    const { service } = crear({ usaLotes: true, sinLote: 2 });
    await expect(sacar(service, -3)).rejects.toMatchObject({
      message: 'Este producto se controla por lote: elegí de qué lote sale. Sin lote hay 2 en este depósito.',
      response: { codigo: 'SIN_LOTE_INSUFICIENTE', campo: 'lote', sin_lote: 2 },
    });
  });

  it('sacar 1,0001 sin lote con 1 sin lote se rechaza (la tolerancia es menor a la unidad mínima)', async () => {
    const { service } = crear({ usaLotes: true, sinLote: 1 });
    await expect(sacar(service, -1.0001)).rejects.toMatchObject({ response: { codigo: 'SIN_LOTE_INSUFICIENTE' } });
  });

  it('lote nuevo repetido: LOTE_NUMERO_REPETIDO', async () => {
    const { service } = crear({ usaLotes: true, repetido: true });
    await expect(entrar(service, 1, { nuevo_lote: { numero_lote: ' L-1 ' } })).rejects.toMatchObject({
      message: 'Este producto ya tiene el lote L-1: elegilo de la lista en vez de crearlo de nuevo.',
      response: { codigo: 'LOTE_NUMERO_REPETIDO', campo: 'numero_lote', numero: 'L-1' },
    });
  });

  it('lote nuevo vacío: LOTE_NUMERO_VACIO', async () => {
    const { service } = crear({ usaLotes: true });
    await expect(entrar(service, 1, { nuevo_lote: { numero_lote: '  ' } })).rejects.toMatchObject({
      message: 'Cargá el número del lote nuevo',
      response: { codigo: 'LOTE_NUMERO_VACIO', campo: 'numero_lote' },
    });
  });

  it('vencimiento anterior a la fabricación: LOTE_VENCIMIENTO_ANTERIOR', async () => {
    const { service } = crear({ usaLotes: true });
    await expect(entrar(service, 1, { nuevo_lote: { numero_lote: 'L', fecha_fabricacion: '2027-01-02', fecha_vencimiento: '2027-01-01' } })).rejects.toMatchObject({
      message: 'El vencimiento no puede ser anterior a la fabricación',
      response: { codigo: 'LOTE_VENCIMIENTO_ANTERIOR', campo: 'fecha_vencimiento' },
    });
  });
});

describe('cantidades sin arrastre de coma flotante', () => {
  it('transferir exactamente el máximo con reserva decimal pasa', async () => {
    const { service, tx } = crear({ filas: [fila('dep-a', 0.3, 0.1)] });
    await transferir(service, 0.2);
    expect(tx.stock_deposito.update).toHaveBeenCalled();
  });

  it('transferir de más informa el máximo redondeado', async () => {
    const { service } = crear({ filas: [fila('dep-a', 0.3, 0.1)] });
    await expect(transferir(service, 0.3)).rejects.toMatchObject({
      message: 'Stock disponible insuficiente en el depósito de origen: hay 0.3, de los que 0.1 están reservados para pedidos. Se puede transferir como máximo 0.2.',
      response: { maximo: 0.2 },
    });
  });

  it('sacar exactamente lo libre con reserva decimal pasa y guarda sin ruido', async () => {
    const { service, tx } = crear({ filas: [fila('dep-a', 0.3, 0.1)] });
    await sacar(service, -0.2);
    expect(tx.stock_deposito.upsert.mock.calls[0][0].update.cantidad_disponible).toBe(0.1);
  });

  it('sacar de más informa cifras redondeadas', async () => {
    const { service } = crear({ filas: [fila('dep-a', 0.3, 0.2)] });
    await expect(sacar(service, -0.2)).rejects.toMatchObject({ response: { codigo: 'STOCK_RESERVADO', quedaria: 0.1, reservado: 0.2, maximo: 0.1 } });
  });

  it('reservar exactamente lo libre con reserva decimal pasa', async () => {
    const { service, tx } = crear({ filas: [fila('dep-a', 0.3, 0.1)] });
    await service.reservarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad: 0.2 } as any, 'usr', 'emp');
    expect(tx.stock_deposito.update).toHaveBeenCalled();
  });
});

describe('bloqueos en orden', () => {
  /** Las consultas de stock (sin la del producto vigente), con su orden de invocación. */
  const deStock = (m: jest.Mock) =>
    m.mock.calls.map((c, i) => ({ c, orden: m.mock.invocationCallOrder[i] })).filter(({ c }) => !c[0].join('').includes('FROM productos'));
  const sql = (m: jest.Mock) => deStock(m)[0].c[0].join('');

  it('transferir lee las dos filas de stock en una consulta, en orden', async () => {
    const { service, tx } = crear({ filas: [fila('dep-a', 10), fila('dep-b', 1)] });
    await transferir(service, 1);
    expect(sql(tx.$queryRaw)).toContain('ORDER BY deposito_id');
    expect(sql(tx.$queryRaw)).toContain('FOR UPDATE');
    expect(deStock(tx.$queryRaw)[0].c.slice(1)).toEqual(expect.arrayContaining(['dep-a', 'dep-b']));
  });

  it('toma el origen por `deposito_id`, venga primero o segundo', async () => {
    const filas = [fila('dep-a', 2), fila('dep-b', 100)];
    const desdeB = crear({ filas });
    await transferir(desdeB.service, 50, { deposito_origen_id: 'dep-b', deposito_destino_id: 'dep-a' });
    expect(desdeB.tx.stock_deposito.update).toHaveBeenCalled();
    const desdeA = crear({ filas });
    await expect(transferir(desdeA.service, 50)).rejects.toMatchObject({ response: { codigo: 'STOCK_ORIGEN_INSUFICIENTE', actual: 2 } });
  });

  it('destino sin fila: sigue por el upsert', async () => {
    const { service, tx } = crear({ filas: [fila('dep-a', 10)] });
    await transferir(service, 1);
    expect(tx.stock_deposito.upsert.mock.calls[0][0].create).toMatchObject({ deposito_id: 'dep-b', cantidad_disponible: 1 });
  });

  describe('destino sin fila: se crea antes de la transacción, para bloquear siempre las dos en orden', () => {
    const conStock = { cantidad_disponible: 10, cantidad_reservada: 0 };

    it('crea la fila del destino en 0, ya commiteada, antes de abrir la transacción', async () => {
      const { service, prisma } = crear({ stock: conStock });
      await transferir(service, 1);
      expect(prisma.stock_deposito.createMany).toHaveBeenCalledWith({ data: [{ deposito_id: 'dep-b', producto_id: 'p', cantidad_disponible: 0 }], skipDuplicates: true });
      expect(prisma.stock_deposito.createMany.mock.invocationCallOrder[0]).toBeLessThan(prisma.$transaction.mock.invocationCallOrder[0]);
    });

    it.each([
      ['sin fila de origen', null],
      ['sin disponible', { cantidad_disponible: 3, cantidad_reservada: 3 }],
    ])('%s no deja una fila vacía: el error lo da la transacción', async (_n, stock) => {
      const { service, prisma } = crear({ stock, filas: [] });
      await expect(transferir(service, 1)).rejects.toMatchObject({ response: { codigo: 'STOCK_ORIGEN_INEXISTENTE' } });
      expect(prisma.stock_deposito.createMany).not.toHaveBeenCalled();
    });

    it('con lote: también la fila del lote en el destino, en 0 e inactiva, si el lote es del producto y le alcanza', async () => {
      const { service, prisma } = crear({ usaLotes: true, stock: conStock, loteOrigen: { cantidad_disponible: 5 } });
      await transferir(service, 1, { lote_id: 'l' });
      expect(prisma.stock_lote.findFirst.mock.calls[0][0].where).toEqual({ lote_id: 'l', deposito_id: 'dep-a', lotes_producto: { empresa_id: 'emp', producto_id: 'p' } });
      expect(prisma.stock_lote.createMany).toHaveBeenCalledWith({ data: [{ lote_id: 'l', deposito_id: 'dep-b', cantidad_disponible: 0, active: false }], skipDuplicates: true });
      expect(prisma.stock_lote.createMany.mock.invocationCallOrder[0]).toBeLessThan(prisma.$transaction.mock.invocationCallOrder[0]);
    });

    it('E2 M1: un lote ajeno o sin stock en el origen no crea nada, tampoco la fila de stock del destino', async () => {
      const { service, prisma } = crear({ usaLotes: true, stock: conStock });
      await transferir(service, 1, { lote_id: 'l' }).catch(() => undefined);
      expect(prisma.stock_lote.createMany).not.toHaveBeenCalled();
      expect(prisma.stock_deposito.createMany).not.toHaveBeenCalled();
    });

    it('E2 M1: sin lote elegido en un producto con lotes, si lo sin lote no alcanza no se crea la fila del destino', async () => {
      const { service, prisma } = crear({ usaLotes: true, stock: conStock, sinLote: 0.5 });
      await expect(transferir(service, 1)).rejects.toMatchObject({ response: { codigo: 'SIN_LOTE_INSUFICIENTE' } });
      expect(prisma.stock_deposito.createMany).not.toHaveBeenCalled();
    });

    it('E2 M1: sin lote elegido y con lo sin lote suficiente, sí crea la fila del destino', async () => {
      const { service, prisma } = crear({ usaLotes: true, stock: conStock, sinLote: 2 });
      await transferir(service, 1);
      expect(prisma.stock_deposito.createMany).toHaveBeenCalledTimes(1);
    });
  });

  it('transferir con lote: primero las filas del lote y después stock_deposito, como la venta', async () => {
    const { service, tx, lotes } = crear({ usaLotes: true, filas: [fila('dep-a', 10)] });
    await transferir(service, 1, { lote_id: 'l' });
    expect(lotes.bloquearFilasLote).toHaveBeenCalledWith(tx, { empresaId: 'emp', productoId: 'p', loteId: 'l', depositoIds: ['dep-a', 'dep-b'] });
    expect(lotes.bloquearFilasLote.mock.invocationCallOrder[0]).toBeLessThan(deStock(tx.$queryRaw)[0].orden);
  });

  it('ajustar con lote: el mismo orden', async () => {
    const { service, tx, lotes } = crear({ usaLotes: true });
    await sacar(service, -1, { lote_id: 'l' });
    expect(lotes.bloquearFilasLote).toHaveBeenCalledWith(tx, { empresaId: 'emp', productoId: 'p', loteId: 'l', depositoIds: ['dep-a'] });
    expect(lotes.bloquearFilasLote.mock.invocationCallOrder[0]).toBeLessThan(deStock(tx.$queryRaw)[0].orden);
  });

  it('sin lote elegido no bloquea filas de lote', async () => {
    const { service, lotes } = crear();
    await sacar(service, -1);
    await transferir(service, 1);
    expect(lotes.bloquearFilasLote).not.toHaveBeenCalled();
  });

  it('el bloqueo del lote no cambia qué error sale primero', async () => {
    const { service } = crear({ filas: [fila('dep-a', 10)] });
    await expect(sacar(service, -15, { lote_id: 'l' })).rejects.toMatchObject({ response: { codigo: 'STOCK_INSUFICIENTE' } });
  });

  describe('reservar y liberar', () => {
    const reserva = { deposito_id: 'dep-a', producto_id: 'p', cantidad: 2 } as any;

    it('reservar bloquea la fila atada a la empresa y actualiza dentro de la transacción', async () => {
      const { service, prisma, tx } = crear({ filas: [fila('dep-a', 10)] });
      await service.reservarStock(reserva, 'usr', 'emp');
      expect(prisma.$transaction).toHaveBeenCalled();
      expect(sql(tx.$queryRaw)).toContain('FOR UPDATE OF sd');
      expect(deStock(tx.$queryRaw)[0].c.slice(1)).toEqual(['dep-a', 'p', 'emp']);
      expect(tx.stock_deposito.update.mock.calls[0][0].data.cantidad_reservada).toEqual({ increment: 2 });
      expect(prisma.stock_deposito.update).not.toHaveBeenCalled();
    });

    it('reservar sin disponible: no actualiza, con el texto de hoy', async () => {
      const { service, tx } = crear({ filas: [fila('dep-a', 3, 2)] });
      await expect(service.reservarStock(reserva, 'usr', 'emp')).rejects.toThrow('Stock disponible insuficiente. Disponible: 1');
      expect(tx.stock_deposito.update).not.toHaveBeenCalled();
    });

    it('liberar bloquea y descuenta a lo sumo lo reservado', async () => {
      const { service, prisma, tx } = crear({ filas: [fila('dep-a', 10, 1)] });
      await service.liberarReserva(reserva, 'usr', 'emp');
      expect(sql(tx.$queryRaw)).toContain('FOR UPDATE OF sd');
      expect(tx.stock_deposito.update.mock.calls[0][0].data.cantidad_reservada).toEqual({ decrement: 1 });
      expect(prisma.stock_deposito.update).not.toHaveBeenCalled();
    });

    it.each(['reservarStock', 'liberarReserva'] as const)('%s: sin fila de la empresa es 404, antes del alcance', async (metodo) => {
      (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
      const { service } = crear({ filas: [] });
      await expect(service[metodo]({ ...reserva, deposito_id: 'dep-b' }, 'usr', 'emp')).rejects.toMatchObject({ status: 404, message: 'Stock no encontrado' });
    });

    it.each(['reservarStock', 'liberarReserva'] as const)('E2 M5: %s lee el alcance antes de abrir la transacción', async (metodo) => {
      const { service, prisma } = crear({ filas: [fila('dep-a', 10, 5)] });
      await service[metodo](reserva, 'usr', 'emp');
      expect((alcanceSucursalUsuario as jest.Mock).mock.invocationCallOrder.at(-1)).toBeLessThan(prisma.$transaction.mock.invocationCallOrder[0]);
    });

    it.each(['reservarStock', 'liberarReserva'] as const)('la auditoría de %s lleva la empresa', async (metodo) => {
      const { service, audit } = crear({ filas: [fila('dep-a', 10, 5)] });
      await service[metodo](reserva, 'usr', 'emp');
      expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ empresa_id: 'emp', entity_type: 'stock_reserva' }));
    });
  });
});
