import { ProductosService } from './productos.service';
import { resolverPermisos } from './permisos-columnas';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

jest.mock('./permisos-columnas', () => ({ resolverPermisos: jest.fn() }));
jest.mock('src/utils/alcance-sucursal', () => ({ alcanceSucursalUsuario: jest.fn().mockResolvedValue(null) }));
jest.mock('src/utils/alcance-rubro', () => ({ rubrosFiltroUsuario: jest.fn(async (_p: unknown, _u: unknown, _e: unknown, rubro?: string) => (rubro ? [rubro] : null)) }));

/** A9: `bulk/ids` y el listado salen del mismo `filtroListado`: «Seleccionar los N» toma exactamente lo que se ve. */
describe('ProductosService.findIdsByFilters', () => {
  const crear = (ids: string[] = ['p-1'], total = ids.length) => {
    const prisma: any = {
      productos: { findMany: jest.fn().mockResolvedValue(ids.map((id) => ({ id }))), count: jest.fn().mockResolvedValue(total) },
      stock_deposito: { groupBy: jest.fn().mockResolvedValue([{ producto_id: 'p-1' }]) },
      depositos: { findMany: jest.fn().mockResolvedValue([{ id: 'dep-1' }, { id: 'dep-2' }]) },
      $transaction: jest.fn(async (ops: any[]) => Promise.all(ops)),
    };
    const service = new ProductosService(prisma, { get: () => undefined } as any, {} as any, {} as any, {} as any, {} as any);
    return { service, prisma };
  };
  const whereIds = (prisma: any) => prisma.productos.findMany.mock.calls[0][0].where;

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

  it("con filtro_stock 'con' solo trae los que suman stock", async () => {
    const { service, prisma } = crear();
    await service.findIdsByFilters('emp', 'usr', { filtro_stock: 'con' });
    expect(whereIds(prisma).AND).toEqual(expect.arrayContaining([{ id: { in: ['p-1'] } }]));
  });

  it("con filtro_stock 'sin' exige maneja_inventario y notIn", async () => {
    const { service, prisma } = crear();
    await service.findIdsByFilters('emp', 'usr', { filtro_stock: 'sin' });
    expect(whereIds(prisma).maneja_inventario).toBe(true);
    expect(whereIds(prisma).AND).toEqual(expect.arrayContaining([{ id: { notIn: ['p-1'] } }]));
  });

  it('con sucursal_id mide en sus depósitos', async () => {
    const { service, prisma } = crear();
    await service.findIdsByFilters('emp', 'usr', { sucursal_id: 's1', filtro_stock: 'con' });
    expect(prisma.stock_deposito.groupBy).toHaveBeenCalledWith(expect.objectContaining({ where: { deposito_id: { in: ['dep-1', 'dep-2'] }, producto: { empresa_id: 'emp' } } }));
  });

  it('con deposito_id fuera del alcance no hay depósitos', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue({ depositoIds: ['dep-9'] });
    const { service, prisma } = crear();
    await service.findIdsByFilters('emp', 'usr', { deposito_id: 'dep-1', filtro_stock: 'con' });
    expect(prisma.stock_deposito.groupBy).toHaveBeenCalledWith(expect.objectContaining({ where: { deposito_id: { in: [] }, producto: { empresa_id: 'emp' } } }));
  });

  it('con rubro_id aplica el filtro de rubro', async () => {
    const { service, prisma } = crear();
    await service.findIdsByFilters('emp', 'usr', { rubro_id: 'r1' });
    expect(JSON.stringify(whereIds(prisma).AND)).toContain('"rubro_id":"r1"');
  });

  it('el where es el mismo que el de findAll con todos los filtros', async () => {
    const filtros = { categoria_id: 'sin', marca_id: 'm1', busqueda: 'tv', mostrar_en_ecommerce: 'true', sucursal_id: 's1', filtro_stock: 'con' as const, rubro_id: 'r1', pendiente: 'marca' as const };
    const { service, prisma } = crear();
    await service.findIdsByFilters('emp', 'usr', filtros);
    const deIds = whereIds(prisma);

    const otro = crear();
    otro.prisma.$transaction = jest.fn(async (ops: any[]) => Promise.all(ops));
    (otro.service as any).listaPrecios = { obtenerPreciosProductosBatch: jest.fn().mockResolvedValue({}) };
    await otro.service.findAll(1, 20, 'emp', 'sin', false, 'tv', 'm1', undefined, 'true', 'marca', 's1', 'con', 'usr', 'r1');
    expect(otro.prisma.productos.findMany.mock.calls[0][0].where).toEqual(deIds);
  });

  it('sin filtros: empresa y deleted false, y con 25.000 avisa truncado con el tope de 20.000', async () => {
    const { service, prisma } = crear(['p-1'], 25000);
    const r = await service.findIdsByFilters('emp', 'usr', {});
    expect(whereIds(prisma)).toMatchObject({ empresa_id: 'emp', deleted: false });
    expect(prisma.productos.findMany.mock.calls[0][0].take).toBe(20000);
    expect(r).toMatchObject({ total: 25000, truncado: true, limite: 20000 });
  });

  it("sin INV_STK_COSTO_VER, pendiente 'costo' no llega al where; con el permiso, sí", async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
    const sin = crear();
    await sin.service.findIdsByFilters('emp', 'usr', { pendiente: 'costo' });
    expect(JSON.stringify(whereIds(sin.prisma))).not.toContain('precio_costo');

    (resolverPermisos as jest.Mock).mockResolvedValue(new Set(['INV_STK_COSTO_VER']));
    const con = crear();
    await con.service.findIdsByFilters('emp', 'usr', { pendiente: 'costo' });
    expect(JSON.stringify(whereIds(con.prisma))).toContain('precio_costo');
  });
});
