import { StockService } from './stock.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { resolverPermisos } from 'src/productos/permisos-columnas';
import { rubrosFiltroUsuario } from 'src/utils/alcance-rubro';

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

const DEP = '9e79de7a-4ed4-4d9f-a787-e745aa359a82';

function crear() {
  const consultas: { sql: string; values: unknown[] }[] = [];
  const prisma: any = {
    depositos: {
      findFirst: jest.fn().mockResolvedValue({ id: DEP, descripcion: 'Principal', sucursal: { descripcion: 'Matriz' } }),
      findMany: jest.fn().mockResolvedValue([
        { id: 'd1', descripcion: 'Uno', sucursal_id: 's1', es_principal: true, sucursal: { id: 's1', descripcion: 'Matriz' } },
        { id: 'd2', descripcion: 'Dos', sucursal_id: 's1', es_principal: false, sucursal: { id: 's1', descripcion: 'Matriz' } },
      ]),
    },
    lista_precios: { findFirst: jest.fn().mockResolvedValue({ id: 'l', nombre: 'Mayorista', moneda: 'PYG' }) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: { codigo: 'PYG' } }) },
    categorias: { findMany: jest.fn().mockResolvedValue([{ id: 'c1', descripcion: 'Cat' }]) },
    marcas: { findMany: jest.fn().mockResolvedValue([{ id: 'm1', descripcion: 'Mar' }]) },
    stock_deposito: { count: jest.fn().mockResolvedValue(5255) },
    $queryRaw: jest.fn().mockImplementation(async (q: { sql: string; values: unknown[] }) => {
      consultas.push({ sql: q.sql, values: q.values });
      if (q.sql.includes('COUNT(*)::int AS total')) return [{ total: 5255 }];
      if (q.sql.includes('AS filas')) return [{ filas: 5255, unidades: '67613', negativos: 199, sin_stock: 154, bajos: 0 }];
      if (q.sql.includes('SUM(total_venta)')) return [{ moneda: 'PYG', valor: '721853500' }];
      if (q.sql.includes('AS moneda')) return [{ moneda: 'PYG', valor: '568912294' }];
      return [];
    }),
  };
  return { service: new StockService(prisma, {} as any, {} as any, {} as any), prisma, consultas };
}

describe('StockService: lecturas de Stock', () => {
  beforeEach(() => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null);
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set(['INV_STK_COSTO_VER']));
  });

  it('listarFilas: 25 por defecto, lastPage por el total y OFFSET de la página', async () => {
    const { service, consultas } = crear();
    const r = await service.listarFilas(DEP, 'emp', 'usr', { page: 2 } as any);
    expect(r).toMatchObject({ total: 5255, page: 2, limit: 25, lastPage: 211 });
    const filas = consultas.find((c) => c.sql.includes('LIMIT'))!;
    expect(filas.values).toEqual(expect.arrayContaining([25]));
  });

  it('resumenDeposito: números, no Decimal, con costo y margen', async () => {
    const { service } = crear();
    const r = await service.resumenDeposito(DEP, 'emp', 'usr', {} as any);
    expect(r).toMatchObject({ filas_deposito: 5255, filas: 5255, unidades: 67613, negativos: 199, sin_stock: 154, bajos: 0 });
    expect(typeof r.unidades).toBe('number');
    expect(r.venta).toEqual([{ moneda: 'PYG', valor: 721853500 }]);
    expect(r.costo).toEqual([{ moneda: 'PYG', valor: 568912294 }]);
    expect(r.margen).toMatchObject({ moneda: 'PYG', valor: 721853500 - 568912294 });
  });

  it('F12: las sumas por moneda dejan afuera las filas sin precio', async () => {
    const { service, consultas } = crear();
    await service.resumenDeposito(DEP, 'emp', 'usr', {} as any);
    const sumas = consultas.filter((c) => c.sql.includes('GROUP BY'));
    expect(sumas.length).toBeGreaterThan(0);
    expect(sumas.every((c) => c.sql.includes('IS NOT NULL'))).toBe(true);
  });

  it('sin INV_STK_COSTO_VER el resumen no trae costo ni margen y no se consulta el costo', async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
    const { service, consultas } = crear();
    const r = await service.resumenDeposito(DEP, 'emp', 'usr', {} as any);
    expect(r).not.toHaveProperty('costo');
    expect(r).not.toHaveProperty('margen');
    expect(consultas.some((c) => c.sql.includes('SUM(total_costo)'))).toBe(false);
  });

  it('fuera de alcance: filas vacías y resumen en cero, sin consultar; Excel da 403', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue({ sucursalIds: [], puntosEstablecimiento: [], depositoIds: ['otro'] });
    const { service, prisma } = crear();
    expect(await service.listarFilas(DEP, 'emp', 'usr', {} as any)).toEqual({ items: [], total: 0, page: 1, limit: 25, lastPage: 1 });
    expect(await service.resumenDeposito(DEP, 'emp', 'usr', {} as any)).toMatchObject({ filas: 0, filas_deposito: 0, unidades: 0, venta: [] });
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
    await expect(service.exportarExcel(DEP, 'emp', 'usr', {} as any)).rejects.toMatchObject({ status: 403 });
  });

  it('exportarExcel de un depósito de otra empresa: 404', async () => {
    const { service, prisma } = crear();
    prisma.depositos.findFirst.mockResolvedValue(null);
    await expect(service.exportarExcel(DEP, 'emp', 'usr', {} as any)).rejects.toMatchObject({ status: 404 });
  });

  it('exportarExcel entrega un libro con el nombre del depósito', async () => {
    const { service } = crear();
    const { buffer, nombre } = await service.exportarExcel(DEP, 'emp', 'usr', {} as any);
    expect(buffer.length).toBeGreaterThan(100);
    expect(nombre).toMatch(/^stock-Principal-\d{4}-\d{2}-\d{2}\.xlsx$/);
  });

  describe('opciones', () => {
    it('depósitos del alcance, una sucursal por depósito sin repetir, marcas y categorías no dadas de baja', async () => {
      (alcanceSucursalUsuario as jest.Mock).mockResolvedValue({ sucursalIds: ['s1'], puntosEstablecimiento: [], depositoIds: ['d1', 'd2'] });
      const { service, prisma } = crear();
      const r = await service.opciones('emp', 'usr');
      expect(prisma.depositos.findMany.mock.calls[0][0].where.id).toEqual({ in: ['d1', 'd2'] });
      expect(r.sucursales).toEqual([{ id: 's1', descripcion: 'Matriz' }]);
      expect(prisma.marcas.findMany.mock.calls[0][0].where.active).toEqual({ not: false });
      const wc = prisma.categorias.findMany.mock.calls[0][0].where;
      expect(wc.activo).toEqual({ not: false });
      expect(wc.deleted_at).toEqual({ not: true });
    });

    it('F5: con un rubro elegido, las categorías se recortan por rubro', async () => {
      (rubrosFiltroUsuario as jest.Mock).mockResolvedValue(['rubro-1']);
      const { service, prisma } = crear();
      await service.opciones('emp', 'usr');
      expect(JSON.stringify(prisma.categorias.findMany.mock.calls[0][0].where)).toContain('rubro-1');
      (rubrosFiltroUsuario as jest.Mock).mockResolvedValue(null);
      await service.opciones('emp', 'usr');
      expect(JSON.stringify(prisma.categorias.findMany.mock.calls[1][0].where)).not.toContain('rubro_id');
    });
  });
});
