import { StockService } from './stock.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

jest.mock('src/utils/alcance-sucursal', () => ({ alcanceSucursalUsuario: jest.fn(), filtroSucursalDeposito: jest.fn() }));

/**
 * Un producto eliminado no tiene stock. Eliminar (`productos.remove`, FOR UPDATE del producto) y cualquier escritura de stock se
 * serializan por el producto: la escritura lo toma FOR KEY SHARE dentro de su transacción, antes de lotes y stock, y si ya está
 * eliminado responde 409 PRODUCTO_ELIMINADO sin escribir nada. (Prueba real de Catálogo: 18 de 20 carreras dejaban stock.)
 */
describe('stock de un producto eliminado', () => {
  const crear = (producto: { deleted: boolean | null } | null) => {
    const tx: any = {
      $queryRaw: jest.fn(async (partes: TemplateStringsArray) =>
        partes.join('?').includes('FROM productos') ? (producto ? [producto] : []) : [{ deposito_id: 'dep-a', cantidad_disponible: 0, cantidad_reservada: 0 }],
      ),
      tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 'tipo' }), upsert: jest.fn() },
      stock_deposito: { upsert: jest.fn().mockResolvedValue({ producto: {}, deposito: {} }), update: jest.fn().mockResolvedValue({}) },
      movimientos_inventario: { create: jest.fn() },
      productos: { findUnique: jest.fn().mockResolvedValue({ precio_costo: 1 }) },
    };
    const prisma: any = {
      $transaction: jest.fn(async (cb: any) => cb(tx)),
      depositos: { count: jest.fn(async (a: any) => new Set(a.where.id.in).size) },
      // Fuera de la transacción el producto todavía se ve vigente: la carrera es que lo eliminen en el medio.
      productos: { findFirst: jest.fn().mockResolvedValue({ maneja_inventario: true, deleted: false }), findUnique: jest.fn().mockResolvedValue(null) },
      stock_deposito: { findUnique: jest.fn().mockResolvedValue({ cantidad_disponible: 10, cantidad_reservada: 0 }), createMany: jest.fn() },
      stock_lote: { findFirst: jest.fn(), createMany: jest.fn() },
    };
    const lotes: any = { usaLotesEnDeposito: jest.fn().mockResolvedValue(false), bloquearFilasLote: jest.fn() };
    const fifo: any = { cantidadSinLote: jest.fn().mockResolvedValue(0) };
    const service = new StockService(prisma, { log: jest.fn() } as any, lotes, fifo);
    return { service, tx, prisma };
  };
  beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null));

  const operaciones: Array<[string, (s: StockService) => Promise<unknown>]> = [
    ['ajustar', (s) => s.ajustarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad: 5 } as any, 'usr', 'AJUSTE_POSITIVO', 'emp')],
    ['cargar desde la ficha', (s) => s.upsertStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad_disponible: 5 } as any, 'usr', 'emp')],
    ['transferir', (s) => s.transferirStock({ deposito_origen_id: 'dep-a', deposito_destino_id: 'dep-b', producto_id: 'p', cantidad: 1 } as any, 'usr', 'emp')],
    ['reservar', (s) => s.reservarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad: 1 } as any, 'usr', 'emp')],
  ];

  it.each(operaciones)('%s: eliminado en el medio → 409 PRODUCTO_ELIMINADO y no escribe stock', async (_n, operar) => {
    const { service, tx } = crear({ deleted: true });
    await expect(operar(service)).rejects.toMatchObject({ status: 409, response: { codigo: 'PRODUCTO_ELIMINADO' } });
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
    expect(tx.stock_deposito.update).not.toHaveBeenCalled();
    expect(tx.movimientos_inventario.create).not.toHaveBeenCalled();
  });

  it.each(operaciones)('%s: toma el producto FOR KEY SHARE, con la empresa, antes que cualquier fila de stock', async (_n, operar) => {
    const { service, tx } = crear({ deleted: false });
    await operar(service).catch(() => undefined);
    const sqls = tx.$queryRaw.mock.calls.map((c: any[]) => (c[0] as string[]).join('?'));
    expect(sqls[0]).toMatch(/FROM productos[\s\S]*empresa_id[\s\S]*FOR KEY SHARE/);
    expect(tx.$queryRaw.mock.calls[0].slice(1)).toEqual(['p', 'emp']);
  });

  it('eliminado antes de empezar (en serie) → 409 sin abrir la transacción', async () => {
    const { service, prisma } = crear({ deleted: true });
    prisma.productos.findFirst.mockResolvedValue({ maneja_inventario: true, deleted: true });
    await expect(operaciones[0][1](service)).rejects.toMatchObject({ status: 409, response: { codigo: 'PRODUCTO_ELIMINADO' } });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
});

/**
 * I2 (ola 3): un camino legítimo deja stock en un producto ya eliminado (se vende todo, se elimina, se anula la venta: la
 * mercadería vuelve). Antes el ajuste que lo corrige y las lecturas de la pantalla de Ajuste daban 409 y solo quedaba un inventario
 * físico (real: 3/3 en `carrera-cierre-ventas.js eliminado-anular`). Ahora se permite la SALIDA que lo deja en ≥ 0 y las lecturas
 * no rechazan; cargar, entrar, transferir y reservar siguen dando 409.
 */
describe('producto eliminado con stock que volvió', () => {
  const crear = (stock: number) => {
    const tx: any = {
      $queryRaw: jest.fn(async (partes: TemplateStringsArray) =>
        partes.join('?').includes('FROM productos') ? [{ deleted: true }] : [{ cantidad_disponible: stock, cantidad_reservada: 0 }],
      ),
      tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 'tipo' }), upsert: jest.fn() },
      stock_deposito: { upsert: jest.fn().mockResolvedValue({}) },
      movimientos_inventario: { create: jest.fn() },
    };
    const prisma: any = {
      $transaction: jest.fn(async (cb: any) => cb(tx)),
      depositos: { count: jest.fn(async (a: any) => new Set(a.where.id.in).size) },
      productos: { findFirst: jest.fn().mockResolvedValue({ maneja_inventario: true, deleted: true }), findUnique: jest.fn().mockResolvedValue(null) },
      stock_deposito: { findUnique: jest.fn().mockResolvedValue({ cantidad_disponible: stock, cantidad_reservada: 0 }) },
      usuarios: { findUnique: jest.fn().mockResolvedValue(null) },
    };
    const lotes: any = {
      usaLotesEnDeposito: jest.fn().mockResolvedValue(false),
      bloquearFilasLote: jest.fn(),
      disponiblesEnDeposito: jest.fn().mockResolvedValue({ usa_lotes: false, items: [], sin_lote: stock }),
    };
    const fifo: any = { cantidadSinLote: jest.fn().mockResolvedValue(stock) };
    const service = new StockService(prisma, { log: jest.fn() } as any, lotes, fifo);
    jest.spyOn(service as any, 'puedeVerCosto').mockResolvedValue(false);
    return { service, tx };
  };
  beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null));

  it('la pantalla de Ajuste abre el producto: contexto y lotes no rechazan', async () => {
    const { service } = crear(2);
    await expect(service.contextoOperacion('emp', 'p', 'dep-a', 'usr')).resolves.toMatchObject({ stock: { cantidad_disponible: 2 } });
    await expect(service.lotesDisponibles('emp', 'p', 'dep-a', 'usr')).resolves.toBeDefined();
  });

  it('ajuste de salida hasta 0: se graba (stock 0 y movimiento AJUSTE_NEGATIVO)', async () => {
    const { service, tx } = crear(2);
    await service.ajustarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad: -2 } as any, 'usr', 'AJUSTE_NEGATIVO', 'emp');
    expect(tx.stock_deposito.upsert).toHaveBeenCalledWith(expect.objectContaining({ update: expect.objectContaining({ cantidad_disponible: 0 }) }));
    expect(tx.movimientos_inventario.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ cantidad: 2 }) }));
  });

  it('salida de más de lo que hay: STOCK_INSUFICIENTE, como en cualquier producto', async () => {
    const { service, tx } = crear(2);
    await expect(
      service.ajustarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad: -3 } as any, 'usr', 'AJUSTE_NEGATIVO', 'emp'),
    ).rejects.toMatchObject({ response: { codigo: 'STOCK_INSUFICIENTE' } });
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });

  it('entrada: 409 PRODUCTO_ELIMINADO, y el mensaje dice cómo sacar lo que quedó', async () => {
    const { service, tx } = crear(2);
    const error = await service
      .ajustarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad: 1 } as any, 'usr', 'AJUSTE_POSITIVO', 'emp')
      .catch((e) => e);
    expect(error).toMatchObject({ status: 409, response: { codigo: 'PRODUCTO_ELIMINADO' } });
    expect(error.response.message).toMatch(/ajuste de salida/);
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });

  it('eliminado en el medio de una entrada (la transacción lo ve eliminado): 409 sin escribir', async () => {
    const { service, tx } = crear(2);
    (service as any).prisma.productos.findFirst.mockResolvedValue({ maneja_inventario: true, deleted: false });
    await expect(
      service.ajustarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad: 1 } as any, 'usr', 'AJUSTE_POSITIVO', 'emp'),
    ).rejects.toMatchObject({ status: 409, response: { codigo: 'PRODUCTO_ELIMINADO' } });
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });
});

/**
 * M2 (re-revisión de la ola 3): el espejo de I2. Un eliminado puede quedar con stock NEGATIVO (una NC devuelve 1, se vende 1, se
 * elimina, se anula la NC → −1): la salida no sirve y la entrada daba 409. Ahora se admite el ajuste que lo acerca a 0 sin cruzarlo.
 */
describe('producto eliminado con stock negativo', () => {
  const crear = (stock: number) => {
    const tx: any = {
      $queryRaw: jest.fn(async (partes: TemplateStringsArray) =>
        partes.join('?').includes('FROM productos') ? [{ deleted: true }] : [{ cantidad_disponible: stock, cantidad_reservada: 0 }],
      ),
      tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 'tipo' }), upsert: jest.fn() },
      stock_deposito: { upsert: jest.fn().mockResolvedValue({}) },
      movimientos_inventario: { create: jest.fn() },
    };
    const prisma: any = {
      $transaction: jest.fn(async (cb: any) => cb(tx)),
      depositos: { count: jest.fn(async (a: any) => new Set(a.where.id.in).size) },
      productos: { findFirst: jest.fn().mockResolvedValue({ maneja_inventario: true, deleted: true }), findUnique: jest.fn().mockResolvedValue(null) },
      stock_deposito: { findUnique: jest.fn().mockResolvedValue({ cantidad_disponible: stock }) },
      usuarios: { findUnique: jest.fn().mockResolvedValue(null) },
    };
    const lotes: any = { usaLotesEnDeposito: jest.fn().mockResolvedValue(false), bloquearFilasLote: jest.fn() };
    const service = new StockService(prisma, { log: jest.fn() } as any, lotes, { cantidadSinLote: jest.fn() } as any);
    return { service, tx };
  };
  beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null));
  const ajustar = (service: StockService, cantidad: number) =>
    service.ajustarStock({ deposito_id: 'dep-a', producto_id: 'p', cantidad } as any, 'usr', cantidad > 0 ? 'AJUSTE_POSITIVO' : 'AJUSTE_NEGATIVO', 'emp');

  it('−1 y entrada de 1: se graba (stock 0 y movimiento AJUSTE_POSITIVO)', async () => {
    const { service, tx } = crear(-1);
    await ajustar(service, 1);
    expect(tx.stock_deposito.upsert).toHaveBeenCalledWith(expect.objectContaining({ update: expect.objectContaining({ cantidad_disponible: 0 }) }));
    expect(tx.movimientos_inventario.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ cantidad: 1 }) }));
  });

  it('−1 y entrada de 2 (cruza el 0): 409 PRODUCTO_ELIMINADO sin escribir', async () => {
    const { service, tx } = crear(-1);
    await expect(ajustar(service, 2)).rejects.toMatchObject({ status: 409, response: { codigo: 'PRODUCTO_ELIMINADO' } });
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });

  it('0 y entrada: sigue en 409', async () => {
    const { service, tx } = crear(0);
    await expect(ajustar(service, 1)).rejects.toMatchObject({ status: 409, response: { codigo: 'PRODUCTO_ELIMINADO' } });
    expect(tx.stock_deposito.upsert).not.toHaveBeenCalled();
  });
});
