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()) }));

const alcanceA = { sucursalIds: ['s'], puntosEstablecimiento: [], depositoIds: ['dep-a'] };

function crear(opts: { maneja?: boolean; propia?: boolean; stockProducto?: any[] } = {}) {
  const tx: any = {
    $queryRaw: jest.fn().mockResolvedValue([{ deposito_id: 'dep-a', cantidad_disponible: 10, cantidad_reservada: 0 }]),
    tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 't' }), upsert: jest.fn() },
    stock_deposito: { upsert: jest.fn().mockResolvedValue({}), update: jest.fn() },
    movimientos_inventario: { create: jest.fn().mockResolvedValue({}) },
  };
  const prisma: any = {
    $transaction: jest.fn(async (cb: any) => cb(tx)),
    depositos: { count: jest.fn(async (a: any) => (opts.propia === false ? 0 : new Set(a.where.id.in).size)), findMany: jest.fn().mockResolvedValue([]) },
    productos: { findFirst: jest.fn().mockResolvedValue({ maneja_inventario: opts.maneja ?? true }), findUnique: jest.fn().mockResolvedValue(null) },
    stock_deposito: {
      findFirst: jest.fn().mockResolvedValue({ cantidad_disponible: 5, cantidad_reservada: 0 }),
      findMany: jest.fn().mockResolvedValue(opts.stockProducto ?? []),
      update: jest.fn(),
    },
  };
  const lotes: any = {
    usaLotesEnDeposito: jest.fn().mockResolvedValue(false),
    bloquearFilasLote: jest.fn(),
    disponiblesEnDeposito: jest.fn().mockResolvedValue({ usa_lotes: true, sugerido_lote_id: 'l', sin_lote: 0, items: [{ lote_id: 'l', costo_unitario: 1200, cantidad_disponible: 3 }] }),
  };
  return { service: new StockService(prisma, { log: jest.fn() } as any, lotes, {} as any), prisma, tx, lotes };
}
const ajuste = (deposito_id: string, cantidad = 1) => ({ deposito_id, producto_id: 'p', cantidad });

describe('StockService: alcance por depósito', () => {
  beforeEach(() => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(alcanceA);
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
  });

  it('ajustar a un depósito ajeno: 403 y no abre transacción', async () => {
    const { service, prisma } = crear();
    await expect(service.ajustarStock(ajuste('dep-b') as any, 'usr', 'AJUSTE_POSITIVO', 'emp')).rejects.toMatchObject({ status: 403, response: { codigo: 'DEPOSITO_FUERA_DE_ALCANCE' } });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('de otra empresa es 404, antes que el 403', async () => {
    const { service } = crear({ propia: false });
    await expect(service.ajustarStock(ajuste('dep-b') as any, 'usr', 'AJUSTE_POSITIVO', 'emp')).rejects.toMatchObject({ status: 404 });
  });

  it.each([
    ['dep-a', 'dep-b'],
    ['dep-b', 'dep-a'],
  ])('transferir %s → %s: 403 (se revisan los dos)', async (origen, destino) => {
    const { service, prisma } = crear();
    await expect(service.transferirStock({ deposito_origen_id: origen, deposito_destino_id: destino, producto_id: 'p', cantidad: 1 } as any, 'usr', 'emp')).rejects.toMatchObject({ status: 403 });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('reservar y liberar en depósito ajeno: 403', async () => {
    const { service } = crear();
    await expect(service.reservarStock({ deposito_id: 'dep-b', producto_id: 'p', cantidad: 1 } as any, 'usr', 'emp')).rejects.toMatchObject({ status: 403 });
    await expect(service.liberarReserva({ deposito_id: 'dep-b', producto_id: 'p', cantidad: 1 } as any, 'usr', 'emp')).rejects.toMatchObject({ status: 403 });
  });

  it('upsertStock en depósito ajeno: 403', async () => {
    const { service } = crear();
    await expect(service.upsertStock({ deposito_id: 'dep-b', producto_id: 'p', cantidad_disponible: 1 } as any, 'usr', 'emp')).rejects.toMatchObject({ status: 403 });
  });

  it('lotesDisponibles de un depósito ajeno: 403', async () => {
    const { service } = crear();
    await expect(service.lotesDisponibles('emp', 'p', 'dep-b', 'usr')).rejects.toMatchObject({ status: 403 });
  });

  it('F2: lotesDisponibles sin INV_STK_COSTO_VER no trae el costo; con el permiso sí', async () => {
    const { service } = crear();
    const sin: any = await service.lotesDisponibles('emp', 'p', 'dep-a', 'usr');
    expect(sin.data.items[0].costo_unitario).toBeNull();
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set(['INV_STK_COSTO_VER']));
    const con: any = await service.lotesDisponibles('emp', 'p', 'dep-a', 'usr');
    expect(con.data.items[0].costo_unitario).toBe(1200);
  });

  it('findOne fuera de alcance es null', async () => {
    const { service } = crear();
    expect(await service.findOne('dep-b', 'p', 'emp', 'usr')).toBeNull();
  });

  it('findByProducto filtra por los depósitos del alcance', async () => {
    const { service, prisma } = crear();
    await service.findByProducto('p', 'emp', 'usr');
    expect(prisma.stock_deposito.findMany.mock.calls[0][0].where.deposito_id).toEqual({ in: ['dep-a'] });
  });

  it('con alcance null, ajustar sigue igual', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null);
    const { service, prisma } = crear();
    await service.ajustarStock(ajuste('dep-z') as any, 'usr', 'AJUSTE_POSITIVO', 'emp');
    expect(prisma.$transaction).toHaveBeenCalled();
  });

  describe('producto sin inventario', () => {
    beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null));
    it('la entrada se rechaza', async () => {
      const { service } = crear({ maneja: false });
      await expect(service.ajustarStock(ajuste('dep-a', 5) as any, 'usr', 'AJUSTE_POSITIVO', 'emp')).rejects.toMatchObject({ response: { codigo: 'PRODUCTO_SIN_INVENTARIO', campo: 'producto_id' } });
    });
    it('la salida pasa: es la forma de corregir lo que quedó', async () => {
      const { service, prisma } = crear({ maneja: false });
      await service.ajustarStock(ajuste('dep-a', -5) as any, 'usr', 'AJUSTE_NEGATIVO', 'emp');
      expect(prisma.$transaction).toHaveBeenCalled();
    });
    it('transferir se rechaza', async () => {
      const { service } = crear({ maneja: false });
      await expect(service.transferirStock({ deposito_origen_id: 'dep-a', deposito_destino_id: 'dep-c', producto_id: 'p', cantidad: 1 } as any, 'usr', 'emp')).rejects.toMatchObject({ response: { codigo: 'PRODUCTO_SIN_INVENTARIO' } });
    });
  });
});

describe('sinCosto', () => {
  // eslint-disable-next-line @typescript-eslint/no-require-imports
  const { sinCosto } = require('./sin-costo');
  it('quita producto.precio_costo y deja el costo_unitario del movimiento en null', () => {
    const r = sinCosto({ id: 'm', costo_unitario: 1100, precio_unitario: 1500, producto: { id: 'p', precio_costo: 900, descripcion: 'P' } });
    expect(r).toEqual({ id: 'm', costo_unitario: null, precio_unitario: 1500, producto: { id: 'p', descripcion: 'P' } });
  });
  it('una fila sin costo no cambia', () => {
    expect(sinCosto({ id: 'x' })).toEqual({ id: 'x' });
  });
});
