import { FacturasService } from './facturas.service';

/**
 * Reportes › Ventas y Ventas por producto por moneda (carril A, T1).
 * Primero la caracterización: los campos de siempre de `/facturas/resumen` y `/facturas/reporte/productos` fijados con
 * la salida del código anterior al cambio. Lo de moneda (`en_moneda`, `por_moneda`, `sin_cotizacion`) es aditivo.
 */

const PYG_ID = '11111111-1111-4111-8111-111111111111';
const USD_ID = '22222222-2222-4222-8222-222222222222';
const MONEDAS: Record<string, { id: string; codigo: string }> = {
  [PYG_ID]: { id: PYG_ID, codigo: 'PYG' },
  [USD_ID]: { id: USD_ID, codigo: 'USD' },
};

const crearPrisma = () => ({
  usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: true }) },
  empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'subsidiary' }) },
  rubros: { findFirst: jest.fn().mockResolvedValue(null) },
  asignacion_sucursal_caja_usuario: { findMany: jest.fn().mockResolvedValue([]) },
  empresas_sucursales: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn().mockResolvedValue(null) },
  empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG_ID }) },
  moneda: {
    findUnique: jest.fn((a: any) => Promise.resolve(MONEDAS[a.where.id] ?? null)),
    findFirst: jest.fn().mockResolvedValue({ id: PYG_ID }),
  },
  factura_cab: { count: jest.fn(), findMany: jest.fn() },
  factura_det: { findMany: jest.fn(), count: jest.fn(), aggregate: jest.fn() },
});

const servicio = (prisma: any) => {
  const service: any = Object.create(FacturasService.prototype);
  service.prisma = prisma;
  return service;
};

const subtotales = (s: Record<string, number | null>) => [{ dtotope: 0, dtotiva: 0, diva10: null, diva5: null, dliqtotiva10: 0, dliqtotiva5: 0, dtotalgs: 0, ...s }];

/** PYG contado, USD crédito con cotización, USD sin cotización (sin condición = crédito) y una sin moneda (base). */
const FACTURAS_RESUMEN = [
  {
    moneda_id: PYG_ID,
    dticam: null,
    moneda: { codigo: 'PYG' },
    condicion_operacion: { codigo: 1 },
    factura_subtotales: subtotales({ dtotope: 1100000, diva10: 100000, dliqtotiva10: 100000, dtotalgs: 1100000 }),
  },
  {
    moneda_id: USD_ID,
    dticam: 7500,
    moneda: { codigo: 'USD' },
    condicion_operacion: { codigo: 2 },
    factura_subtotales: subtotales({ dtotope: 110, diva10: 10, diva5: 0, dliqtotiva10: 10, dtotalgs: 825000 }),
  },
  {
    moneda_id: USD_ID,
    dticam: 0,
    moneda: { codigo: 'USD' },
    condicion_operacion: null,
    factura_subtotales: subtotales({ dtotope: 50, diva10: null, dliqtotiva10: 4.55 }),
  },
  {
    moneda_id: null,
    dticam: null,
    moneda: null,
    condicion_operacion: { codigo: 1 },
    factura_subtotales: subtotales({ dtotope: 220000, diva5: 10000, dliqtotiva5: 10000, dtotalgs: 220000 }),
  },
];

const prepararResumen = (facturas = FACTURAS_RESUMEN) => {
  const prisma = crearPrisma();
  // validas, anuladas, pendientesSifen, aprobadosSifen, rechazadosSifen
  prisma.factura_cab.count
    .mockResolvedValueOnce(facturas.length)
    .mockResolvedValueOnce(1)
    .mockResolvedValueOnce(0)
    .mockResolvedValueOnce(facturas.length - 1)
    .mockResolvedValueOnce(0);
  prisma.factura_cab.findMany.mockResolvedValue(facturas);
  return { prisma, service: servicio(prisma) };
};

describe('FacturasService.getResumen — caracterización de los campos de siempre', () => {
  it('cuenta, suma por moneda sin convertir, contado/crédito por código y el IVA crudo de todas las monedas', async () => {
    const { service } = prepararResumen();
    const r = await service.getResumen('emp-1', { fechaDesde: '2026-10-01', fechaHasta: '2026-10-31', usuarioId: 'usr-1' });

    expect(r).toMatchObject({
      facturas: 4,
      anuladas: 1,
      pendientesSifen: 0,
      aprobadosSifen: 3,
      rechazadosSifen: 0,
      ventasPorMoneda: { PYG: 1320000, USD: 160 },
      ventasPorCondicion: {
        contado: { cantidad: 2, porMoneda: { PYG: 1320000 } },
        credito: { cantidad: 2, porMoneda: { USD: 160 } },
      },
      totalIva5: 10000,
    });
    // diva10 ?? dliqtotiva10: 100000 + 10 + 4.55 (USD sumado como si fuera PYG: el bug que el contrato de moneda evita)
    expect(r.totalIva10).toBeCloseTo(100014.55, 6);
  });
});

/** Líneas de factura: prod-1 vendido en PYG y en USD (cotización 7500), prod-2 en una factura sin moneda. */
const cab = (id: string, moneda: string | null, dticam: number | null, dtotope: number, dtotalgs: number) => ({
  id,
  moneda_id: moneda,
  dticam,
  moneda: moneda ? { codigo: MONEDAS[moneda].codigo } : null,
  factura_subtotales: [{ dtotope, dtotalgs }],
});
const PROD1 = { id: 'prod-1', descripcion: 'JAMONADA', cod_producto: 'JAM', precio: 0, precio_costo: 80000, tipo: 'producto', categoria: { id: 'cat-a', descripcion: 'Fiambres' } };
const PROD2 = { id: 'prod-2', descripcion: 'QUESO', cod_producto: 'QUE', precio: 0, precio_costo: 0, tipo: 'producto', categoria: { id: 'cat-b', descripcion: 'Lácteos' } };
const L1 = {
  producto_id: 'prod-1', factura_cab_id: 'fac-1', ddesproser: 'JAMONADA', dcantproser: 10, dtotbruopeitem: 1100000, dtotopeitem: 1100000,
  ddescitem: 0, ddescgloitem: 0, dliqivaitem: 100000, duniproser: 110000, dticamit: null, productos: PROD1, factura_cab: cab('fac-1', PYG_ID, null, 1100000, 1100000),
};
const L2 = {
  producto_id: 'prod-1', factura_cab_id: 'fac-2', ddesproser: 'JAMONADA', dcantproser: 1, dtotbruopeitem: 12, dtotopeitem: 11,
  ddescitem: 1, ddescgloitem: 0, dliqivaitem: 1, duniproser: 12, dticamit: null, productos: PROD1, factura_cab: cab('fac-2', USD_ID, 7500, 11, 82500),
};
const L3 = {
  producto_id: 'prod-2', factura_cab_id: 'fac-3', ddesproser: 'QUESO', dcantproser: 2, dtotbruopeitem: 50000, dtotopeitem: 50000,
  ddescitem: 0, ddescgloitem: 0, dliqivaitem: 4545.45, duniproser: 25000, dticamit: null, productos: PROD2, factura_cab: cab('fac-3', null, null, 50000, 50000),
};

/**
 * Lo que haría la base con el filtro de moneda de la cabecera: `moneda_id` directo y los `moneda_id`/`OR` de moneda
 * dentro de `AND` (el resto del where no se evalúa: las líneas ya son del período).
 */
const cumpleMoneda = (whereCab: any, monedaId: string | null): boolean => {
  const cond = (c: any): boolean => {
    if (!c || typeof c !== 'object') return true;
    if ('moneda_id' in c && Object.keys(c).length === 1) return c.moneda_id === monedaId;
    if (Array.isArray(c.OR) && c.OR.every((o: any) => Object.keys(o).length === 1 && 'moneda_id' in o)) return c.OR.some(cond);
    return true;
  };
  if ('moneda_id' in whereCab && whereCab.moneda_id !== monedaId) return false;
  return (whereCab.AND ?? []).every(cond);
};

const prepararProductos = (lineas: any[]) => {
  const prisma = crearPrisma();
  prisma.factura_det.findMany.mockImplementation((a: any) => Promise.resolve(lineas.filter((l) => cumpleMoneda(a.where.factura_cab, l.factura_cab.moneda_id))));
  return { prisma, service: servicio(prisma) };
};

describe('FacturasService.getReporteProductos — caracterización de los campos de siempre', () => {
  it('agrupa por producto sumando crudo cualquier moneda y el costo en base', async () => {
    const { service } = prepararProductos([L1, L2, L3]);
    const r = await service.getReporteProductos('emp-1', { limit: 50 }, 'usr-1');

    expect(r.productos).toHaveLength(2);
    const [p1, p2] = r.productos;
    expect(p1).toMatchObject({
      producto_id: 'prod-1',
      descripcion: 'JAMONADA',
      cod_producto: 'JAM',
      categoria: 'Fiambres',
      categoria_id: 'cat-a',
      tipo: 'producto',
      moneda: 'PYG',
      cantidad_vendida: 11,
      ingresos_brutos: 1100012,
      descuentos: 1,
      ingresos_netos: 1100011,
      iva_generado: 100001,
      costo_total: 880000,
      precio_promedio: 55006,
      facturas_count: 2,
    });
    expect(p1.margen).toBeCloseTo(((1100011 - 880000) / 1100011) * 100, 9);
    expect(p1.precios).toBeUndefined();
    expect(p2).toMatchObject({ producto_id: 'prod-2', moneda: 'PYG', ingresos_netos: 50000, costo_total: 0, margen: null, facturas_count: 1 });

    expect(r.kpis).toEqual({
      total_ingresos: 1150011,
      total_cantidad: 13,
      total_iva: 104546.45,
      total_descuentos: 1,
      productos_unicos: 2,
    });
    expect(r.categorias).toEqual([
      { nombre: 'Fiambres', ingresos: 1100011, cantidad: 11, productos: 1 },
      { nombre: 'Lácteos', ingresos: 50000, cantidad: 2, productos: 1 },
    ]);
  });

  it('con moneda_id filtra la cabecera por esa moneda exacta (las sin moneda no entran en los campos de siempre)', async () => {
    const { service } = prepararProductos([L1, L2, L3]);
    const r = await service.getReporteProductos('emp-1', { moneda_id: PYG_ID, limit: 50 }, 'usr-1');
    expect(r.productos.map((p: any) => p.producto_id)).toEqual(['prod-1']);
    expect(r.productos[0]).toMatchObject({ cantidad_vendida: 10, ingresos_netos: 1100000, costo_total: 800000 });
    expect(r.kpis.total_ingresos).toBe(1100000);
  });
});

const AJENA = '00000000-0000-0000-0000-000000000000';

describe('FacturasService.getResumen — moneda como el Tablero', () => {
  const conFiltro = (facturas: any[]) => {
    const r = prepararResumen(facturas);
    r.prisma.factura_cab.findMany.mockImplementation((a: any) => Promise.resolve(facturas.filter((f) => cumpleMoneda(a.where, f.moneda_id))));
    return r;
  };

  it('sin moneda_id convierte cada factura con su cotización y deja el crudo en por_moneda', async () => {
    const { service } = conFiltro(FACTURAS_RESUMEN.slice(0, 2));
    const r = await service.getResumen('emp-1', { usuarioId: 'usr-1' });

    expect(r.moneda).toEqual({ id: PYG_ID, codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda).toEqual({
      total: 1925000,
      iva10: 175000,
      iva5: 0,
      contado: { cantidad: 1, total: 1100000 },
      credito: { cantidad: 1, total: 825000 },
    });
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total: '1100000.00', iva10: '100000.00', iva5: '0.00', contado: { cantidad: 1, total: '1100000.00' }, credito: { cantidad: 0, total: '0.00' } },
      { codigo: 'USD', total: '110.00', iva10: '10.00', iva5: '0.00', contado: { cantidad: 0, total: '0.00' }, credito: { cantidad: 1, total: '110.00' } },
    ]);
  });

  it('una factura sin cotización queda fuera de en_moneda y cuenta en sin_cotizacion; los campos de siempre no cambian', async () => {
    const { service } = conFiltro(FACTURAS_RESUMEN);
    const r = await service.getResumen('emp-1', { usuarioId: 'usr-1' });

    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda).toEqual({
      total: 2145000,
      iva10: 175000,
      iva5: 10000,
      contado: { cantidad: 2, total: 1320000 },
      credito: { cantidad: 1, total: 825000 },
    });
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total: '1320000.00', iva10: '100000.00', iva5: '10000.00', contado: { cantidad: 2, total: '1320000.00' }, credito: { cantidad: 0, total: '0.00' } },
      // La USD sin cotización sigue en el crudo, en crédito (sin condición = crédito).
      { codigo: 'USD', total: '160.00', iva10: '14.55', iva5: '0.00', contado: { cantidad: 0, total: '0.00' }, credito: { cantidad: 2, total: '160.00' } },
    ]);
    expect(r).toMatchObject({
      facturas: 4,
      ventasPorMoneda: { PYG: 1320000, USD: 160 },
      ventasPorCondicion: { contado: { cantidad: 2 }, credito: { cantidad: 2, porMoneda: { USD: 160 } } },
      totalIva5: 10000,
    });
    expect(r.totalIva10).toBeCloseTo(100014.55, 6);
  });

  it('con moneda_id USD filtra (dentro de AND) y no convierte', async () => {
    const { service, prisma } = conFiltro(FACTURAS_RESUMEN);
    const r = await service.getResumen('emp-1', { monedaId: USD_ID, usuarioId: 'usr-1' });

    const where = prisma.factura_cab.findMany.mock.calls[0][0].where;
    expect(where.AND).toContainEqual({ moneda_id: USD_ID });
    expect(where.moneda_id).toBeUndefined();
    for (const [a] of prisma.factura_cab.count.mock.calls) expect(a.where.AND).toContainEqual({ moneda_id: USD_ID });
    expect(r.moneda).toEqual({ id: USD_ID, codigo: 'USD' });
    expect(r.convertido).toBe(false);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda).toEqual({ total: 160, iva10: 14.55, iva5: 0, contado: { cantidad: 0, total: 0 }, credito: { cantidad: 2, total: 160 } });
    expect(r.por_moneda).toEqual([
      { codigo: 'USD', total: '160.00', iva10: '14.55', iva5: '0.00', contado: { cantidad: 0, total: '0.00' }, credito: { cantidad: 2, total: '160.00' } },
    ]);
    expect(r.ventasPorMoneda).toEqual({ USD: 160 });
  });

  it('con la moneda base incluye las facturas sin moneda', async () => {
    const { service, prisma } = conFiltro(FACTURAS_RESUMEN);
    const r = await service.getResumen('emp-1', { monedaId: PYG_ID, usuarioId: 'usr-1' });
    expect(prisma.factura_cab.findMany.mock.calls[0][0].where.AND).toContainEqual({ OR: [{ moneda_id: PYG_ID }, { moneda_id: null }] });
    expect(r.en_moneda.total).toBe(1320000);
    expect(r.convertido).toBe(false);
  });

  it('moneda_id que no existe → 400 MONEDA_INVALIDA', async () => {
    const { service } = conFiltro(FACTURAS_RESUMEN);
    await expect(service.getResumen('emp-1', { monedaId: AJENA, usuarioId: 'usr-1' })).rejects.toMatchObject({
      status: 400,
      response: { codigo: 'MONEDA_INVALIDA' },
    });
  });
});

describe('FacturasService.findAll — filtro moneda_id', () => {
  const preparar = () => {
    const prisma: any = crearPrisma();
    prisma.factura_cab.findMany.mockResolvedValue([]);
    prisma.factura_cab.count.mockResolvedValue(0);
    prisma.$transaction = jest.fn(async (ops: any[]) => Promise.all(ops));
    prisma.cob_gestion_mora = { findMany: jest.fn().mockResolvedValue([]) };
    return { prisma, service: servicio(prisma) };
  };

  it('sin moneda_id no filtra ni consulta monedas (igual que antes)', async () => {
    const { service, prisma } = preparar();
    await service.findAll(1, 10, 'emp-1', { usuarioId: 'usr-1' });
    expect(JSON.stringify(prisma.factura_cab.findMany.mock.calls[0][0].where)).not.toContain('moneda_id');
    expect(prisma.moneda.findUnique).not.toHaveBeenCalled();
    expect(prisma.empresa_monedas.findFirst).not.toHaveBeenCalled();
  });

  it('con moneda_id filtra dentro de AND (la base incluye las sin moneda)', async () => {
    const { service, prisma } = preparar();
    await service.findAll(1, 10, 'emp-1', { monedaId: USD_ID, usuarioId: 'usr-1' });
    expect(prisma.factura_cab.findMany.mock.calls[0][0].where.AND).toContainEqual({ moneda_id: USD_ID });
    expect(prisma.factura_cab.count.mock.calls[0][0].where.AND).toContainEqual({ moneda_id: USD_ID });
    await service.findAll(1, 10, 'emp-1', { monedaId: PYG_ID, usuarioId: 'usr-1' });
    expect(prisma.factura_cab.findMany.mock.calls[1][0].where.AND).toContainEqual({ OR: [{ moneda_id: PYG_ID }, { moneda_id: null }] });
  });

  it('moneda_id que no existe → 400', async () => {
    const { service } = preparar();
    await expect(service.findAll(1, 10, 'emp-1', { monedaId: AJENA, usuarioId: 'usr-1' })).rejects.toMatchObject({ status: 400 });
  });
});

describe('FacturasService.getReporteProductos — moneda como el Tablero', () => {
  /** USD sin cotización: ni dticam ni dtotalgs. */
  const L4 = {
    ...L2,
    factura_cab_id: 'fac-4',
    dtotbruopeitem: 5,
    dtotopeitem: 5,
    ddescitem: 0,
    dliqivaitem: 0.45,
    duniproser: 5,
    factura_cab: cab('fac-4', USD_ID, 0, 5, 0),
  };

  it('sin moneda_id: un producto vendido en PYG y USD es una sola fila convertida, con margen contra el costo en base', async () => {
    const { service } = prepararProductos([L1, L2, L3]);
    const r = await service.getReporteProductos('emp-1', { limit: 50 }, 'usr-1');

    expect(r.moneda).toEqual({ id: PYG_ID, codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    const filas = r.en_moneda.productos.filter((p: any) => p.producto_id === 'prod-1');
    expect(filas).toHaveLength(1);
    expect(filas[0]).toMatchObject({
      moneda: 'PYG',
      cantidad_vendida: 11,
      ingresos_brutos: 1190000,
      descuentos: 7500,
      ingresos_netos: 1182500,
      iva_generado: 107500,
      costo_total: 880000,
      precio_promedio: 100000,
      facturas_count: 2,
    });
    expect(filas[0].margen).toBeCloseTo(((1182500 - 880000) / 1182500) * 100, 9);
    expect(filas[0].precios).toBeUndefined();
    expect(r.en_moneda.kpis).toEqual({
      total_ingresos: 1232500,
      total_cantidad: 13,
      total_iva: 112045.45,
      total_descuentos: 7500,
      productos_unicos: 2,
    });
    expect(r.en_moneda.categorias).toEqual([
      { nombre: 'Fiambres', ingresos: 1182500, cantidad: 11, productos: 1 },
      { nombre: 'Lácteos', ingresos: 50000, cantidad: 2, productos: 1 },
    ]);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total_ingresos: '1150000.00', total_iva: '104545.45', total_descuentos: '0.00' },
      { codigo: 'USD', total_ingresos: '11.00', total_iva: '1.00', total_descuentos: '1.00' },
    ]);
    // Los de siempre, sin tocar.
    expect(r.kpis.total_ingresos).toBe(1150011);
    expect(r.productos[0].costo_total).toBe(880000);
  });

  it('con moneda_id USD: solo USD, sin convertir, y el costo pasado a USD con la cotización de la factura', async () => {
    const { service, prisma } = prepararProductos([L1, L2, L3]);
    const r = await service.getReporteProductos('emp-1', { moneda_id: USD_ID, limit: 50 }, 'usr-1');

    expect(prisma.factura_det.findMany.mock.calls[0][0].where.factura_cab.AND).toContainEqual({ moneda_id: USD_ID });
    expect(r.moneda).toEqual({ id: USD_ID, codigo: 'USD' });
    expect(r.convertido).toBe(false);
    expect(r.en_moneda.productos).toHaveLength(1);
    expect(r.en_moneda.productos[0]).toMatchObject({ moneda: 'USD', cantidad_vendida: 1, ingresos_netos: 11, costo_total: 10.67 });
    expect(r.en_moneda.productos[0].margen).toBeCloseTo(((11 - 10.67) / 11) * 100, 9);
    expect(r.por_moneda).toEqual([{ codigo: 'USD', total_ingresos: '11.00', total_iva: '1.00', total_descuentos: '1.00' }]);
    // Los de siempre: el costo en base mezclado, como antes.
    expect(r.productos[0]).toMatchObject({ moneda: 'USD', ingresos_netos: 11, costo_total: 80000 });
  });

  it('una factura sin cotización queda fuera de en_moneda (cuenta en sin_cotizacion) y sigue en por_moneda', async () => {
    const { service } = prepararProductos([L1, L2, L4]);
    const r = await service.getReporteProductos('emp-1', { limit: 50 }, 'usr-1');
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda.productos[0]).toMatchObject({ cantidad_vendida: 11, ingresos_netos: 1182500, facturas_count: 2 });
    expect(r.por_moneda.find((m: any) => m.codigo === 'USD')).toEqual({ codigo: 'USD', total_ingresos: '16.00', total_iva: '1.45', total_descuentos: '1.00' });
    expect(r.productos[0]).toMatchObject({ cantidad_vendida: 12, ingresos_netos: 1100016 });
  });

  it('con la moneda base: en_moneda incluye las facturas sin moneda; los de siempre siguen con el filtro exacto', async () => {
    const { service } = prepararProductos([L1, L2, L3]);
    const r = await service.getReporteProductos('emp-1', { moneda_id: PYG_ID, limit: 50 }, 'usr-1');
    expect(r.en_moneda.productos.map((p: any) => p.producto_id)).toEqual(['prod-1', 'prod-2']);
    expect(r.en_moneda.kpis.total_ingresos).toBe(1150000);
    expect(r.productos.map((p: any) => p.producto_id)).toEqual(['prod-1']);
    expect(r.kpis.total_ingresos).toBe(1100000);
  });

  it('moneda_id que no existe → 400', async () => {
    const { service } = prepararProductos([L1]);
    await expect(service.getReporteProductos('emp-1', { moneda_id: AJENA }, 'usr-1')).rejects.toMatchObject({
      status: 400,
      response: { codigo: 'MONEDA_INVALIDA' },
    });
  });
});

describe('FacturasController.findAll — errores del servicio', () => {
  it('un 400 del servicio (moneda que no existe) sale como 400, no como 500', async () => {
    const { FacturasController } = await import('./facturas.controller');
    const { BadRequestException } = await import('@nestjs/common');
    const service = { findAll: jest.fn().mockRejectedValue(new BadRequestException({ codigo: 'MONEDA_INVALIDA' })) };
    const ctrl = new FacturasController(service as any, {} as any);
    await expect(
      ctrl.findAll({ empresa_id: 'emp-1', id: 'usr-1' } as any, '1', '10', undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, AJENA),
    ).rejects.toMatchObject({ status: 400 });
    expect(service.findAll.mock.calls[0][3]).toMatchObject({ monedaId: AJENA });
  });
});

describe('FacturasService.getReporteProductos — Ronda 1', () => {
  it('una factura sin cotización en la cabecera queda fuera entera aunque una de sus líneas traiga dticamit', async () => {
    const sinCot = cab('fac-9', USD_ID, 0, 20, 0);
    const conTcItem = { ...L2, factura_cab_id: 'fac-9', dticamit: 7500, factura_cab: sinCot };
    const sinTcItem = { ...L2, factura_cab_id: 'fac-9', producto_id: 'prod-2', productos: PROD2, dticamit: null, factura_cab: sinCot };
    const { service } = prepararProductos([L1, conTcItem, sinTcItem]);
    const r = await service.getReporteProductos('emp-1', { limit: 50 }, 'usr-1');
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda.productos).toHaveLength(1);
    expect(r.en_moneda.productos[0]).toMatchObject({ producto_id: 'prod-1', cantidad_vendida: 10, ingresos_netos: 1100000, facturas_count: 1 });
  });

  it('en_moneda.kpis suma todos los productos, no solo el top; los de siempre siguen sobre el top', async () => {
    const { service } = prepararProductos([L1, L2, L3]);
    const r = await service.getReporteProductos('emp-1', { limit: 1 }, 'usr-1');
    expect(r.en_moneda.productos).toHaveLength(1);
    expect(r.en_moneda.kpis).toMatchObject({ total_ingresos: 1232500, total_cantidad: 13, productos_unicos: 2 });
    expect(r.kpis).toMatchObject({ total_ingresos: 1100011, total_cantidad: 11, productos_unicos: 1 });
  });
});
