import * as XLSX from 'xlsx';
import { resolverPermisos } from 'src/productos/permisos-columnas';
import { PERFILES_SISTEMA_SEED, SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { PrivilegioSelector, resolverSelectores } from 'src/seguridad/seeds/selectores';
import { ReportesProveedorService } from './reportes-proveedor.service';

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

/**
 * Reportes por proveedor (vencidos, próximos, resumen, stock por marcas, ventas por marca y sus Excel/PDF/email):
 * sin `INV_STK_COSTO_VER` no sale ningún costo. Los montos de compra y de venta siguen.
 * «Reporte sin costo» = Encargado Compras (sin COSTO_VER) más los permisos del reporte, como un perfil propio del cliente.
 */
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) => new Set(resolverSelectores(PERFILES_SISTEMA_SEED.find((x) => x.perfil === nombre).selectores, privilegios, modulos));
const REPORTE = privilegios.map((p) => p.codigo).filter((c) => c.startsWith('INV_RPR_'));
const PERFILES: Record<string, Set<string>> = {
  'Reporte sin costo': new Set([...delPerfil('Encargado Compras'), ...REPORTE]),
  'Encargado Stock': delPerfil('Encargado Stock'),
  Administrador: delPerfil('Administrador'),
};
const comoPerfil = (nombre: string) =>
  (resolverPermisos as jest.Mock).mockImplementation((_p: unknown, _u: string, pedidos: string[]) => Promise.resolve(new Set(pedidos.filter((c) => PERFILES[nombre].has(c)))));

const LOTES = [
  { lote_id: 'l1', numero_lote: 'L1', fecha_vencimiento: new Date('2020-01-01T00:00:00Z'), producto_id: 'p1', producto_codigo: 'P1', producto_descripcion: 'Uno', marca: 'ACME', deposito: 'Central', stock_actual: 2, costo_unitario: 1000, costo_total: 2000 },
];
const PROXIMO = [{ ...LOTES[0], lote_id: 'l2', fecha_vencimiento: new Date(Date.now() + 5 * 86400000) }];
const VENTAS = [
  { marca_id: 'm1', marca: 'ACME', producto_id: 'p1', producto_codigo: 'P1', producto_descripcion: 'Uno', moneda_codigo: 'PYG', cantidad_facturas: 3, unidades: 5, monto_vendido: 500000, costo_total: 300000 },
];
const COSTO = /costo|valor/i;

function crear() {
  const prisma: any = {
    proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'prov', personas: { razon_social: 'Prov SA', ruc: '80000001', email: 'p@x.com' } }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ razon_social: 'Emp SA' }) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'm-pyg' }) },
    moneda: { findFirst: jest.fn().mockResolvedValue({ id: 'm-pyg' }), findUnique: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }) },
    proveedor_marca: { count: jest.fn().mockResolvedValue(1) },
    $queryRaw: jest.fn().mockResolvedValue(VENTAS),
    $queryRawUnsafe: jest.fn(),
  };
  const mail: any = { sendProveedorVencidosReport: jest.fn() };
  return { service: new ReportesProveedorService(prisma, mail), prisma, mail };
}
const hoja = (b: Buffer) => {
  const wb = XLSX.read(b, { type: 'buffer' });
  return XLSX.utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]], { header: 1 });
};
/** Todas las claves (a cualquier profundidad) que nombran un costo o una valorización. */
const clavesDeCosto = (v: unknown): string[] =>
  !v || typeof v !== 'object'
    ? []
    : Object.entries(v).flatMap(([k, x]) => [...(COSTO.test(k) ? [k] : []), ...clavesDeCosto(x)]);

afterEach(() => jest.restoreAllMocks());

describe.each([
  ['Reporte sin costo', false],
  ['Encargado Stock', true],
  ['Administrador', true],
])('%s: costo en los reportes por proveedor', (perfil, ve) => {
  beforeEach(() => comoPerfil(perfil));

  it('el perfil tiene el permiso del reporte', () => {
    expect(PERFILES[perfil].has('INV_RPR_REPORTE_VENCIDOS_PROVEEDOR_VER')).toBe(true);
    expect(PERFILES[perfil].has('INV_STK_COSTO_VER')).toBe(ve);
  });

  it('vencidos', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue(LOTES);
    const rows = await service.vencidos('emp', 'prov', {}, 'usr');
    expect(rows[0]).toMatchObject({ lote_id: 'l1', stock_actual: 2 });
    expect(clavesDeCosto(rows).length > 0).toBe(ve);
  });

  it('próximos a vencer (filas, totales por tramo y total general)', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue(PROXIMO);
    const r: any = await service.proximosVencer('emp', 'prov', { dias: 30 }, 'usr');
    expect(r.buckets['0-30']).toHaveLength(1);
    expect(clavesDeCosto(r).length > 0).toBe(ve);
    expect('totales' in r).toBe(ve);
  });

  it('resumen: los conteos siguen, el valor vencido no', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValueOnce(LOTES).mockResolvedValueOnce(PROXIMO);
    const r: any = await service.resumen('emp', 'prov', 'usr');
    expect(r).toMatchObject({ marcas_que_provee: 1, lotes_vencidos: 1, lotes_proximos_30: 1 });
    expect(clavesDeCosto(r).length > 0).toBe(ve);
  });

  it('stock por marcas: sin valorización', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue([{ marca_id: 'm1', marca: 'ACME', cantidad_productos: 1, stock_total: 3, valor_total: 3000 }]);
    const rows: any[] = await service.stockMarcas('emp', 'prov', {}, 'usr');
    expect(rows[0]).toMatchObject({ stock_total: 3 });
    expect(clavesDeCosto(rows).length > 0).toBe(ve);
  });

  it.each(['vinculo', 'lote'] as const)('ventas por marca (%s): el monto vendido sigue, el costo no', async (modo) => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue(VENTAS);
    const r: any = await service.ventasPorMarca('emp', 'prov', { modo }, 'usr');
    expect(r.rows[0]).toMatchObject({ monto_vendido: 500000, moneda: { codigo: 'PYG' } });
    expect(clavesDeCosto(r).length > 0).toBe(ve);
  });

  it('marcas compradas: el monto de compra sigue para todos', async () => {
    const { service, prisma } = crear();
    prisma.$queryRaw.mockResolvedValue([{ marca_id: 'm1', marca: 'ACME', moneda_codigo: 'PYG', monto_total: 1500, vinculado: true }]);
    const rows: any[] = await service.marcasCompradas('emp', 'prov', {}, 'usr');
    expect(rows[0].monto_total).toBe(1500);
  });

  it('Excel de vencidos y de ventas por marca', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValueOnce(LOTES).mockResolvedValueOnce(VENTAS);
    const venc = hoja(await service.exportarVencidosExcel('emp', 'prov', {}, 'usr'));
    const vent = hoja(await service.exportarVentasPorMarcaExcel('emp', 'prov', {}, 'usr'));
    expect((venc[0] as string[]).some((c) => COSTO.test(c))).toBe(ve);
    expect((vent[0] as string[]).some((c) => COSTO.test(c))).toBe(ve);
    expect(vent[0]).toContain('Monto Vendido');
    expect(venc[0]).toContain('Stock');
  });

  it('PDF de vencidos', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue(LOTES);
    const fetchMock = jest.spyOn(global, 'fetch' as any).mockResolvedValue({ ok: true, arrayBuffer: () => Promise.resolve(new ArrayBuffer(1)) } as any);
    await service.exportarVencidosPDF('emp', 'prov', {}, 'usr');
    const [url, init] = fetchMock.mock.calls[0] as [string, any];
    const body = JSON.parse(init.body);
    // Sin costo va a la tabla genérica (la plantilla de vencidos siempre dibuja el costo).
    expect(url.endsWith('/api/vencidos-proveedor/generate-pdf')).toBe(ve);
    expect(clavesDeCosto(body.items ?? body.rows).length > 0).toBe(ve);
    expect(JSON.stringify(body.columns ?? []).match(/costo/i) !== null).toBe(false);
    if (!ve) expect(body.rows[0]).toMatchObject({ numero_lote: 'L1', stock_actual: 2 });
  });

  it('PDF de ventas por marca: sin columna de costo para nadie', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue(VENTAS);
    const fetchMock = jest.spyOn(global, 'fetch' as any).mockResolvedValue({ ok: true, arrayBuffer: () => Promise.resolve(new ArrayBuffer(1)) } as any);
    await service.exportarVentasPorMarcaPDF('emp', 'prov', {}, 'usr');
    const body = JSON.parse((fetchMock.mock.calls[0][1] as any).body);
    expect(clavesDeCosto(body.rows).length > 0).toBe(ve);
  });

  it('email: el cuerpo, la respuesta y el adjunto', async () => {
    const { service, prisma, mail } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue(LOTES);
    const r: any = await service.enviarVencidosEmail('emp', 'prov', {}, 'usr');
    const enviado = mail.sendProveedorVencidosReport.mock.calls[0][0];
    expect(enviado.totalLotes).toBe(1);
    expect(enviado.totalCosto !== undefined).toBe(ve);
    expect(clavesDeCosto(r).length > 0).toBe(ve);
    expect((hoja(enviado.excelBuffer)[0] as string[]).some((c) => COSTO.test(c))).toBe(ve);
  });
});
