import { ListaPreciosController } from 'src/lista-precios/lista-precios.controller';
import { ListaPreciosService } from 'src/lista-precios/lista-precios.service';
import { PERFILES_SISTEMA_SEED, SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { PrivilegioSelector, resolverSelectores } from 'src/seguridad/seeds/selectores';
import { ProductosController } from './productos.controller';
import { ProductosService } from './productos.service';

/**
 * `GET /productos`, `GET /productos/:id` y `GET /productos/search` (y la respuesta de `PUT /productos/:id`, y el precio
 * resuelto de `GET /lista-precios/precio-producto[s/batch]`) no entregan el costo a quien no tiene `INV_STK_COSTO_VER`.
 * Cada perfil de sistema del seed se resuelve con sus selectores reales: Cajero, Vendedor, Cobrador y Encargado Compras
 * no lo ven; Administrador, Encargado Stock, Supervisor y Solo Lectura (`*.VER`), sí.
 */
const privilegios: PrivilegioSelector[] = SEGURIDAD_SEED.flatMap((m) =>
  m.submodulos.flatMap((s) =>
    s.privilegios.map((p) => ({ id: p.codigo, codigo: p.codigo, accion: p.accion, submodulos: { codigo: s.codigo, modulo_id: m.codigo } })),
  ),
);
const modulos = SEGURIDAD_SEED.map((m) => ({ id: m.codigo, codigo: m.codigo }));
const delPerfil = (nombre: string) => {
  const p = PERFILES_SISTEMA_SEED.find((x) => x.perfil === nombre);
  if (!p) throw new Error(`no existe el perfil ${nombre}`);
  return new Set(resolverSelectores(p.selectores, privilegios, modulos));
};

/** Prisma de `resolverPermisos`: el usuario tiene los privilegios del perfil (o es superadmin). */
const prismaDe = (otorgados: Set<string>, superadmin = false): any => ({
  usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: superadmin }) },
  perfiles_privilegios: {
    findMany: jest.fn().mockImplementation(async ({ where }: any) =>
      (where.privilegios.codigo.in as string[]).filter((c) => otorgados.has(c)).map((codigo) => ({ privilegios: { codigo } })),
    ),
  },
});

const FILA = () => ({ id: 'p-1', descripcion: 'Heladera', precio: 2400000, precio_costo: 1800000 });
const USER: any = { id: 'u-1', empresa_id: 'emp' };

const armar = (prisma: any) => {
  const service = new ProductosService(prisma, { get: () => undefined } as any, {} as any, {} as any, {} as any, {} as any);
  jest.spyOn(service, 'findAll').mockResolvedValue({ items: [FILA()], total: 1, page: 1, limit: 10, lastPage: 1 } as any);
  jest.spyOn(service, 'search').mockResolvedValue([FILA()] as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ message: 'Producto encontrado exitosamente', data: FILA() } as any);
  jest.spyOn(service, 'update').mockResolvedValue({ message: 'Producto actualizado exitosamente', data: FILA() } as any);
  const controller = new ProductosController(service, {} as any);

  const precio = { productoId: 'p-1', precioFinal: 2400000, precioCosto: 1800000, topeDescuentoPct: 25 };
  const listaPrecios: any = {
    prisma,
    // El método real: recorta con el mismo helper que productos.
    sinCostoSiNoCorresponde: ListaPreciosService.prototype.sinCostoSiNoCorresponde,
    obtenerPrecioProducto: jest.fn().mockResolvedValue({ ...precio }),
    obtenerPreciosProductosBatch: jest.fn().mockResolvedValue({ 'p-1': { ...precio } }),
  };
  const listas = new ListaPreciosController(listaPrecios);
  return { controller, listas };
};

/** Lo que devuelve cada endpoint, para ver si trae el costo. */
async function respuestas(prisma: any) {
  const { controller, listas } = armar(prisma);
  const listado = await controller.findAll(USER);
  const busqueda = await controller.search('hel', '20', undefined as any, undefined as any, undefined as any, undefined as any, USER);
  const uno = await controller.findOne('p-1', USER);
  const editado = await controller.update('p-1', {} as any, USER);
  const precio = await listas.obtenerPrecioProducto(USER, 'p-1');
  const batch = await listas.obtenerPreciosProductosBatch(USER, 'p-1');
  return {
    productos: [listado.data[0], busqueda.data[0], uno.data, editado.data] as Record<string, unknown>[],
    precios: [precio!.data, (batch!.data as any)['p-1']] as Record<string, unknown>[],
  };
}

describe('costo de productos según el perfil del seed', () => {
  it.each(['Cajero', 'Vendedor', 'Cobrador', 'Encargado Compras'])('%s: los 4 endpoints de productos y el precio resuelto sin costo', async (perfil) => {
    const otorgados = delPerfil(perfil);
    expect(otorgados.has('INV_STK_COSTO_VER')).toBe(false);
    const r = await respuestas(prismaDe(otorgados));
    for (const p of r.productos) {
      expect(p).not.toHaveProperty('precio_costo');
      expect(p.precio).toBe(2400000);
    }
    for (const p of r.precios) {
      expect(p).not.toHaveProperty('precioCosto');
      // El tope de descuento del POS (Fase 3) sigue saliendo: lo calcula el servidor con el costo.
      expect(p.topeDescuentoPct).toBe(25);
    }
  });

  it.each(['Administrador', 'Encargado Stock', 'Supervisor', 'Solo Lectura'])('%s: con INV_STK_COSTO_VER ve el costo', async (perfil) => {
    const otorgados = delPerfil(perfil);
    expect(otorgados.has('INV_STK_COSTO_VER')).toBe(true);
    const r = await respuestas(prismaDe(otorgados));
    for (const p of r.productos) expect(p.precio_costo).toBe(1800000);
    for (const p of r.precios) expect(p.precioCosto).toBe(1800000);
  });

  it('el superadmin ve el costo sin consultar perfiles', async () => {
    const prisma = prismaDe(new Set(), true);
    const r = await respuestas(prisma);
    for (const p of r.productos) expect(p.precio_costo).toBe(1800000);
    expect(prisma.perfiles_privilegios.findMany).not.toHaveBeenCalled();
  });

  it('una sola consulta de permisos por pedido, aunque la página traiga muchos productos', async () => {
    const prisma = prismaDe(delPerfil('Cajero'));
    const { controller } = armar(prisma);
    jest.spyOn((controller as any).productosService, 'search').mockResolvedValue([FILA(), FILA(), FILA()]);
    const r = await controller.search('hel', '20', undefined as any, undefined as any, undefined as any, undefined as any, USER);
    expect(r.data).toHaveLength(3);
    r.data.forEach((p: any) => expect(p).not.toHaveProperty('precio_costo'));
    expect(prisma.perfiles_privilegios.findMany).toHaveBeenCalledTimes(1);
  });
});
