import { ReportesCrmService, mediana, porcentaje } from './reportes-crm.service';

const ETAPAS = [
  { id: 'e-calif', nombre: 'Calificación', orden: 0, probabilidad: 10, es_ganada: false, es_perdida: false },
  { id: 'e-nego', nombre: 'Negociación', orden: 3, probabilidad: 70, es_ganada: false, es_perdida: false },
  { id: 'e-gana', nombre: 'Ganada', orden: 4, probabilidad: 100, es_ganada: true, es_perdida: false },
  { id: 'e-pierde', nombre: 'Perdida', orden: 5, probabilidad: 0, es_ganada: false, es_perdida: true },
];

const TODAS = { verAjenas: true };

const PYG = '11111111-1111-4111-8111-111111111111';
const USD = '22222222-2222-4222-8222-222222222222';
const EUR = '33333333-3333-4333-8333-333333333333';

/** La empresa tiene PYG (principal) y USD; EUR existe en el sistema pero la empresa no la usa. */
const MONEDAS_PRISMA = () => {
  const empresaMonedas = [
    { empresa_id: 'emp-1', moneda_id: PYG, es_principal: true, active: true, moneda: { id: PYG, codigo: 'PYG' } },
    { empresa_id: 'emp-1', moneda_id: USD, es_principal: false, active: true, moneda: { id: USD, codigo: 'USD' } },
  ];
  const monedas = [
    { id: PYG, codigo: 'PYG' },
    { id: USD, codigo: 'USD' },
    { id: EUR, codigo: 'EUR' },
  ];
  return {
    empresa_monedas: {
      findFirst: jest.fn(({ where }: any) => {
        const m = empresaMonedas.find(
          (x) =>
            x.empresa_id === where.empresa_id &&
            (where.es_principal === undefined || x.es_principal === where.es_principal) &&
            (where.moneda_id === undefined || x.moneda_id === where.moneda_id),
        );
        return Promise.resolve(m ? { moneda_id: m.moneda_id, moneda: m.moneda } : null);
      }),
    },
    moneda: {
      findUnique: jest.fn(({ where }: any) => Promise.resolve(monedas.find((m) => m.id === where.id) ?? null)),
      findFirst: jest.fn(({ where }: any) => Promise.resolve(monedas.find((m) => m.codigo === where.codigo) ?? null)),
    },
  };
};

describe('porcentaje', () => {
  it('redondea a un decimal', () => {
    expect(porcentaje(1, 3)).toBe(33.3);
    expect(porcentaje(2, 4)).toBe(50);
  });

  /** Dividir por cero daría NaN y el frontend mostraría "NaN%". */
  it('sin total devuelve 0', () => {
    expect(porcentaje(5, 0)).toBe(0);
  });
});

describe('mediana', () => {
  it('impar toma el del medio', () => {
    expect(mediana([1, 5, 9])).toBe(5);
  });

  it('par promedia los dos del medio', () => {
    expect(mediana([2, 4, 6, 10])).toBe(5);
  });

  it('vacío es 0', () => {
    expect(mediana([])).toBe(0);
  });

  /** Es el caso que justifica tener mediana además de promedio. */
  it('un valor extremo no la mueve como movería al promedio', () => {
    const dias = [5, 6, 7, 8, 240];
    expect(mediana(dias)).toBe(7);
    expect(Math.round(dias.reduce((a, b) => a + b, 0) / dias.length)).toBe(53);
  });
});

describe('ReportesCrmService', () => {
  const crear = (over: Record<string, any> = {}) => {
    const prisma: any = {
      crm_etapas: { findMany: jest.fn().mockResolvedValue(ETAPAS) },
      crm_oportunidades: {
        groupBy: jest.fn().mockResolvedValue([]),
        findMany: jest.fn().mockResolvedValue([]),
      },
      crm_origenes: { findMany: jest.fn().mockResolvedValue([{ id: 'ori-wa', codigo: 'WHATSAPP', descripcion: 'WhatsApp' }]) },
      crm_leads: { groupBy: jest.fn().mockResolvedValue([]) },
      crm_motivos: { findMany: jest.fn().mockResolvedValue([]) },
      vendedores_cobradores: { findMany: jest.fn().mockResolvedValue([]) },
      ...MONEDAS_PRISMA(),
      ...over,
    };
    return { service: new ReportesCrmService(prisma), prisma };
  };

  describe('pipeline', () => {
    it('pondera el valor por la probabilidad de la etapa', async () => {
      const { service } = crear({
        crm_oportunidades: {
          groupBy: jest.fn().mockResolvedValue([
            { etapa_id: 'e-nego', _count: { _all: 2 }, _sum: { valor_unico: 10_000_000, valor_mrr: 0 } },
          ]),
        },
      });
      const r = await service.pipeline('emp-1', TODAS, {});
      const nego = r.data.etapas.find((e) => e.etapa_id === 'e-nego');
      expect(nego).toMatchObject({ cantidad: 2, valor: 10_000_000, valor_ponderado: 7_000_000 });
      expect(r.data.totales.valor_ponderado).toBe(7_000_000);
    });

    /** Ganada y Perdida no son embudo: son el resultado. */
    it('excluye las etapas de resultado', async () => {
      const { service } = crear();
      const r = await service.pipeline('emp-1', TODAS, {});
      expect(r.data.etapas.map((e) => e.etapa_id)).toEqual(['e-calif', 'e-nego']);
    });

    it('una etapa sin oportunidades aparece en cero, no desaparece', async () => {
      const { service } = crear();
      const r = await service.pipeline('emp-1', TODAS, {});
      expect(r.data.etapas.every((e) => e.cantidad === 0)).toBe(true);
      expect(r.data.etapas).toHaveLength(2);
    });

    it('sólo cuenta oportunidades abiertas', async () => {
      const { service, prisma } = crear();
      await service.pipeline('emp-1', TODAS, {});
      expect(prisma.crm_oportunidades.groupBy.mock.calls[0][0].where.estado).toBe('abierta');
    });
  });

  describe('visibilidad', () => {
    it('con VER_AJENAS no filtra por vendedor', async () => {
      const { service, prisma } = crear();
      await service.pipeline('emp-1', { verAjenas: true }, {});
      expect(prisma.crm_oportunidades.groupBy.mock.calls[0][0].where.vendedor_id).toBeUndefined();
    });

    it('sin VER_AJENAS filtra por el vendedor del usuario', async () => {
      const { service, prisma } = crear();
      await service.pipeline('emp-1', { verAjenas: false, vendedor_id: 'v-1' }, {});
      expect(prisma.crm_oportunidades.groupBy.mock.calls[0][0].where.vendedor_id).toBe('v-1');
    });

    /** Mejor un reporte vacío que mostrarle el embudo entero a quien no corresponde. */
    it('sin vendedor asociado no ve nada en vez de verlo todo', async () => {
      const { service, prisma } = crear();
      await service.pipeline('emp-1', { verAjenas: false, vendedor_id: null }, {});
      expect(prisma.crm_oportunidades.groupBy.mock.calls[0][0].where.vendedor_id)
        .toBe('00000000-0000-0000-0000-000000000000');
    });
  });

  describe('rango de fechas', () => {
    it('sin fechas no filtra', async () => {
      const { service, prisma } = crear();
      await service.pipeline('emp-1', TODAS, {});
      expect(prisma.crm_oportunidades.groupBy.mock.calls[0][0].where.created_at).toBeUndefined();
    });

    /** Quien pide "hasta el 31" espera que el 31 entre completo. */
    it('hasta es inclusive: suma un día al límite', async () => {
      const { service, prisma } = crear();
      await service.pipeline('emp-1', TODAS, { desde: '2026-01-01', hasta: '2026-12-31' });
      const rango = prisma.crm_oportunidades.groupBy.mock.calls[0][0].where.created_at;
      expect(rango.gte).toEqual(new Date('2026-01-01'));
      expect(rango.lt).toEqual(new Date('2027-01-01'));
    });
  });

  describe('conversion', () => {
    it('calcula la tasa sobre cerradas, no sobre todas', async () => {
      const { service } = crear({
        crm_leads: { groupBy: jest.fn().mockResolvedValue([{ origen_id: 'ori-wa', _count: { _all: 20 } }]) },
        crm_oportunidades: {
          groupBy: jest.fn().mockResolvedValue([
            { origen_id: 'ori-wa', estado: 'ganada', _count: { _all: 3 }, _sum: { valor_unico: 9_000_000 } },
            { origen_id: 'ori-wa', estado: 'perdida', _count: { _all: 1 }, _sum: { valor_unico: 1_000_000 } },
            { origen_id: 'ori-wa', estado: 'abierta', _count: { _all: 6 }, _sum: { valor_unico: 5_000_000 } },
          ]),
        },
      });
      const r = await service.conversion('emp-1', TODAS, {});
      // 3 ganadas sobre 4 cerradas = 75%, no 3 sobre 10.
      expect(r.data[0]).toMatchObject({ leads: 20, oportunidades: 10, ganadas: 3, tasa_conversion: 75, monto_ganado: 9_000_000 });
    });

    it('no muestra orígenes sin movimiento', async () => {
      const { service } = crear();
      expect((await service.conversion('emp-1', TODAS, {})).data).toHaveLength(0);
    });

    it('agrupa aparte lo que vino sin origen', async () => {
      const { service } = crear({
        crm_leads: { groupBy: jest.fn().mockResolvedValue([{ origen_id: null, _count: { _all: 5 } }]) },
      });
      const r = await service.conversion('emp-1', TODAS, {});
      expect(r.data[0]).toMatchObject({ origen: 'Sin origen', leads: 5 });
    });
  });

  describe('motivosPerdida', () => {
    it('ordena por frecuencia y reparte porcentajes', async () => {
      const { service } = crear({
        crm_oportunidades: {
          groupBy: jest.fn().mockResolvedValue([
            { motivo_perdida_id: 'm-precio', _count: { _all: 3 }, _sum: { valor_unico: 3_000_000 } },
            { motivo_perdida_id: 'm-comp', _count: { _all: 7 }, _sum: { valor_unico: 7_000_000 } },
          ]),
        },
        crm_motivos: {
          findMany: jest.fn().mockResolvedValue([
            { id: 'm-precio', descripcion: 'Precio' },
            { id: 'm-comp', descripcion: 'Competencia' },
          ]),
        },
      });
      const r = await service.motivosPerdida('emp-1', TODAS, {});
      expect(r.data.map((m) => m.motivo)).toEqual(['Competencia', 'Precio']);
      expect(r.data[0].porcentaje).toBe(70);
    });

    /** Los motivos se dan de baja lógica, pero igual conviene no mostrar un uuid. */
    it('un motivo dado de baja se nombra, no se deja en blanco', async () => {
      const { service } = crear({
        crm_oportunidades: {
          groupBy: jest.fn().mockResolvedValue([{ motivo_perdida_id: 'm-viejo', _count: { _all: 1 }, _sum: { valor_unico: 0 } }]),
        },
      });
      expect((await service.motivosPerdida('emp-1', TODAS, {})).data[0].motivo).toBe('Motivo dado de baja');
    });

    it('las perdidas sin motivo se agrupan', async () => {
      const { service } = crear({
        crm_oportunidades: {
          groupBy: jest.fn().mockResolvedValue([{ motivo_perdida_id: null, _count: { _all: 2 }, _sum: { valor_unico: 0 } }]),
        },
      });
      expect((await service.motivosPerdida('emp-1', TODAS, {})).data[0].motivo).toBe('Sin motivo');
    });
  });

  describe('vendedores', () => {
    it('ordena por monto ganado y calcula la tasa de cierre', async () => {
      const { service } = crear({
        crm_oportunidades: {
          groupBy: jest.fn().mockResolvedValue([
            { vendedor_id: 'v-1', estado: 'ganada', _count: { _all: 3 }, _sum: { valor_unico: 9_000_000 } },
            { vendedor_id: 'v-1', estado: 'perdida', _count: { _all: 1 }, _sum: { valor_unico: 0 } },
            { vendedor_id: 'v-2', estado: 'ganada', _count: { _all: 1 }, _sum: { valor_unico: 20_000_000 } },
          ]),
        },
        vendedores_cobradores: {
          findMany: jest.fn().mockResolvedValue([
            { id: 'v-1', nombre: 'Ana', apellido: 'Giménez' },
            { id: 'v-2', nombre: 'Luis', apellido: null },
          ]),
        },
      });
      const r = await service.vendedores('emp-1', TODAS, {});
      expect(r.data.map((v) => v.vendedor)).toEqual(['Luis', 'Ana Giménez']);
      expect(r.data[1]).toMatchObject({ ganadas: 3, perdidas: 1, tasa_cierre: 75 });
    });

    it('las oportunidades sin vendedor se muestran como "Sin asignar"', async () => {
      const { service } = crear({
        crm_oportunidades: {
          groupBy: jest.fn().mockResolvedValue([{ vendedor_id: null, estado: 'abierta', _count: { _all: 4 }, _sum: { valor_unico: 1_000 } }]),
        },
      });
      expect((await service.vendedores('emp-1', TODAS, {})).data[0]).toMatchObject({ vendedor: 'Sin asignar', abiertas: 4 });
    });
  });

  describe('cicloVenta', () => {
    it('cuenta días entre el alta y el cierre real', async () => {
      const { service } = crear({
        crm_oportunidades: {
          findMany: jest.fn().mockResolvedValue([
            { created_at: new Date('2026-01-01'), fecha_cierre_real: new Date('2026-01-11'), valor_unico: 1_000_000 },
            { created_at: new Date('2026-02-01'), fecha_cierre_real: new Date('2026-02-21'), valor_unico: 2_000_000 },
          ]),
        },
      });
      const r = await service.cicloVenta('emp-1', TODAS, {});
      expect(r.data).toMatchObject({
        ganadas: 2, dias_promedio: 15, dias_mediana: 15, dias_minimo: 10, dias_maximo: 20,
        monto_ganado: 3_000_000,
      });
    });

    it('sin ventas ganadas devuelve ceros, no NaN', async () => {
      const { service } = crear();
      expect(await service.cicloVenta('emp-1', TODAS, {})).toMatchObject({
        data: { ganadas: 0, dias_promedio: 0, dias_mediana: 0 },
      });
    });

    /** Un cierre cargado con fecha anterior al alta daría días negativos. */
    it('nunca devuelve días negativos', async () => {
      const { service } = crear({
        crm_oportunidades: {
          findMany: jest.fn().mockResolvedValue([
            { created_at: new Date('2026-03-10'), fecha_cierre_real: new Date('2026-03-01'), valor_unico: 0 },
          ]),
        },
      });
      expect((await service.cicloVenta('emp-1', TODAS, {})).data.dias_promedio).toBe(0);
    });
  });

  describe('resumen', () => {
    it('devuelve los cinco reportes juntos y la moneda de sus montos', async () => {
      const { service } = crear();
      const r = await service.resumen('emp-1', TODAS, {});
      expect(Object.keys(r.data)).toEqual([
        'pipeline', 'conversion_por_origen', 'motivos_perdida', 'vendedores', 'ciclo_venta', 'moneda',
      ]);
      expect(r.data.moneda).toEqual({ id: PYG, codigo: 'PYG' });
    });
  });

  /**
   * Los montos nunca suman monedas distintas: cada reporte es de una moneda (sin pedir, la base; las oportunidades
   * sin moneda cuentan como base). La conversión por origen es la excepción en los conteos: la tasa no cambia al
   * cambiar de moneda (ruling del preflight), solo su monto ganado.
   */
  describe('moneda', () => {
    const D = (iso: string) => new Date(iso);
    const OPS = [
      // abiertas
      { id: 'o1', empresa_id: 'emp-1', estado: 'abierta', etapa_id: 'e-nego', moneda_id: PYG, vendedor_id: 'v-1', origen_id: 'ori-wa', motivo_perdida_id: null, valor_unico: 1_000_000, valor_mrr: 0, created_at: D('2026-01-01'), fecha_cierre_real: null },
      { id: 'o2', empresa_id: 'emp-1', estado: 'abierta', etapa_id: 'e-nego', moneda_id: USD, vendedor_id: 'v-1', origen_id: 'ori-wa', motivo_perdida_id: null, valor_unico: 500, valor_mrr: 0, created_at: D('2026-01-01'), fecha_cierre_real: null },
      { id: 'o3', empresa_id: 'emp-1', estado: 'abierta', etapa_id: 'e-calif', moneda_id: null, vendedor_id: 'v-2', origen_id: 'ori-wa', motivo_perdida_id: null, valor_unico: 200_000, valor_mrr: 0, created_at: D('2026-01-01'), fecha_cierre_real: null },
      // ganadas
      { id: 'o4', empresa_id: 'emp-1', estado: 'ganada', etapa_id: 'e-gana', moneda_id: PYG, vendedor_id: 'v-1', origen_id: 'ori-wa', motivo_perdida_id: null, valor_unico: 3_000_000, valor_mrr: 0, created_at: D('2026-01-01'), fecha_cierre_real: D('2026-01-11') },
      { id: 'o5', empresa_id: 'emp-1', estado: 'ganada', etapa_id: 'e-gana', moneda_id: USD, vendedor_id: 'v-1', origen_id: 'ori-wa', motivo_perdida_id: null, valor_unico: 800, valor_mrr: 0, created_at: D('2026-01-01'), fecha_cierre_real: D('2026-01-31') },
      // perdidas
      { id: 'o6', empresa_id: 'emp-1', estado: 'perdida', etapa_id: 'e-pierde', moneda_id: USD, vendedor_id: 'v-2', origen_id: 'ori-wa', motivo_perdida_id: 'm-precio', valor_unico: 100, valor_mrr: 0, created_at: D('2026-01-01'), fecha_cierre_real: null },
    ];

    /** Aplica el where como Postgres (lo que usa el servicio: empresa, estado, vendedor, AND/OR de moneda, cierre). */
    const cumple = (w: any, o: any): boolean =>
      Object.entries(w ?? {}).every(([k, v]: [string, any]) => {
        if (k === 'AND') return (v as any[]).every((x) => cumple(x, o));
        if (k === 'OR') return (v as any[]).some((x) => cumple(x, o));
        if (v && typeof v === 'object' && 'not' in v) return o[k] !== v.not;
        if (v && typeof v === 'object' && ('gte' in v || 'lt' in v)) return true;
        return o[k] === v;
      });

    const fake = () => ({
      crm_oportunidades: {
        groupBy: jest.fn(({ by, where }: any) => {
          const grupos = new Map<string, any>();
          for (const o of OPS.filter((x) => cumple(where, x))) {
            const clave = by.map((b: string) => String(o[b])).join('|');
            const g = grupos.get(clave) ?? {
              ...Object.fromEntries(by.map((b: string) => [b, (o as any)[b]])),
              _count: { _all: 0 },
              _sum: { valor_unico: 0, valor_mrr: 0 },
            };
            g._count._all += 1;
            g._sum.valor_unico += o.valor_unico;
            g._sum.valor_mrr += o.valor_mrr;
            grupos.set(clave, g);
          }
          return Promise.resolve([...grupos.values()]);
        }),
        findMany: jest.fn(({ where }: any) => Promise.resolve(OPS.filter((x) => cumple(where, x)))),
      },
      crm_leads: { groupBy: jest.fn().mockResolvedValue([{ origen_id: 'ori-wa', _count: { _all: 10 } }]) },
      crm_motivos: { findMany: jest.fn().mockResolvedValue([{ id: 'm-precio', descripcion: 'Precio' }]) },
      vendedores_cobradores: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'v-1', nombre: 'Ana', apellido: null },
          { id: 'v-2', nombre: 'Luis', apellido: null },
        ]),
      },
    });

    it('embudo: con la base PYG suma PYG y las sin moneda; con USD solo USD', async () => {
      const { service } = crear(fake());
      const pyg = await service.pipeline('emp-1', TODAS, {});
      expect(pyg.moneda).toEqual({ id: PYG, codigo: 'PYG' });
      expect(pyg.data.totales).toMatchObject({ cantidad: 2, valor: 1_200_000 });
      expect(pyg.data.etapas.find((e) => e.etapa_id === 'e-nego')).toMatchObject({ cantidad: 1, valor: 1_000_000 });
      expect(pyg.data.etapas.find((e) => e.etapa_id === 'e-calif')).toMatchObject({ cantidad: 1, valor: 200_000 });

      const usd = await service.pipeline('emp-1', TODAS, { moneda_id: USD });
      expect(usd.moneda).toEqual({ id: USD, codigo: 'USD' });
      expect(usd.data.totales).toMatchObject({ cantidad: 1, valor: 500 });
    });

    it('pedir la base por id da lo mismo que no pedir nada', async () => {
      const { service } = crear(fake());
      const r = await service.pipeline('emp-1', TODAS, { moneda_id: PYG });
      expect(r.data.totales).toMatchObject({ cantidad: 2, valor: 1_200_000 });
    });

    it('conversión: la tasa y los conteos son de todas las monedas; el monto ganado, de la moneda pedida', async () => {
      const { service, prisma } = crear(fake());
      const pyg = await service.conversion('emp-1', TODAS, {});
      const usd = await service.conversion('emp-1', TODAS, { moneda_id: USD });
      // 2 ganadas sobre 3 cerradas en total, en cualquier moneda.
      for (const r of [pyg, usd]) {
        expect(r.data[0]).toMatchObject({ leads: 10, oportunidades: 6, ganadas: 2, perdidas: 1, tasa_conversion: 66.7 });
      }
      expect(pyg.data[0].monto_ganado).toBe(3_000_000);
      expect(usd.data[0].monto_ganado).toBe(800);
      expect(usd.moneda).toEqual({ id: USD, codigo: 'USD' });
      // Los leads no tienen moneda: nunca se filtran por ella.
      expect(JSON.stringify(prisma.crm_leads.groupBy.mock.calls[0][0].where)).not.toContain('moneda');
    });

    it('motivos de pérdida: cantidad y monto de la moneda pedida', async () => {
      const { service } = crear(fake());
      expect((await service.motivosPerdida('emp-1', TODAS, {})).data).toEqual([]);
      const usd = await service.motivosPerdida('emp-1', TODAS, { moneda_id: USD });
      expect(usd.data).toEqual([expect.objectContaining({ motivo: 'Precio', cantidad: 1, monto: 100, porcentaje: 100 })]);
    });

    /** Como la conversión: una tasa no es un monto. Conteos y tasa de todas las monedas; montos de la elegida. */
    it('vendedores: conteos y tasa de cierre de todas las monedas; montos de la moneda pedida', async () => {
      const { service } = crear(fake());
      const pyg = await service.vendedores('emp-1', TODAS, {});
      const usd = await service.vendedores('emp-1', TODAS, { moneda_id: USD });
      // v-1: 2 abiertas (PYG+USD), 2 ganadas (PYG+USD), 0 perdidas → 100 % en las dos vistas.
      expect(pyg.data.find((v) => v.vendedor_id === 'v-1')).toMatchObject({ abiertas: 2, ganadas: 2, perdidas: 0, tasa_cierre: 100, monto_abierto: 1_000_000, monto_ganado: 3_000_000 });
      expect(usd.data.find((v) => v.vendedor_id === 'v-1')).toMatchObject({ abiertas: 2, ganadas: 2, perdidas: 0, tasa_cierre: 100, monto_abierto: 500, monto_ganado: 800 });
      // v-2: 1 abierta sin moneda (base) y 1 perdida USD → tasa 0 en las dos; montos por moneda.
      expect(pyg.data.find((v) => v.vendedor_id === 'v-2')).toMatchObject({ abiertas: 1, perdidas: 1, monto_abierto: 200_000, monto_ganado: 0 });
      expect(usd.data.find((v) => v.vendedor_id === 'v-2')).toMatchObject({ abiertas: 1, perdidas: 1, monto_abierto: 0 });
    });

    it('vendedores: una sola perdida en USD no da 0 % en la vista USD si ganó en otra moneda', async () => {
      const filas = [
        { vendedor_id: 'v-1', estado: 'ganada', moneda_id: PYG, _count: { _all: 3 }, _sum: { valor_unico: 9_000_000 } },
        { vendedor_id: 'v-1', estado: 'perdida', moneda_id: USD, _count: { _all: 1 }, _sum: { valor_unico: 100 } },
      ];
      const { service, prisma } = crear({
        crm_oportunidades: { groupBy: jest.fn().mockResolvedValue(filas) },
        vendedores_cobradores: { findMany: jest.fn().mockResolvedValue([{ id: 'v-1', nombre: 'Ana', apellido: null }]) },
      });
      const usd = await service.vendedores('emp-1', TODAS, { moneda_id: USD });
      const pyg = await service.vendedores('emp-1', TODAS, {});
      expect(usd.data[0]).toMatchObject({ ganadas: 3, perdidas: 1, tasa_cierre: 75, monto_ganado: 0 });
      expect(pyg.data[0]).toMatchObject({ ganadas: 3, perdidas: 1, tasa_cierre: 75, monto_ganado: 9_000_000 });
      // La consulta no filtra por moneda (sí por empresa y visibilidad) y separa por moneda_id.
      const args = prisma.crm_oportunidades.groupBy.mock.calls[0][0];
      expect(args.by).toEqual(['vendedor_id', 'estado', 'moneda_id']);
      expect(JSON.stringify(args.where)).not.toContain('moneda');
    });

    it('ciclo de venta: ganadas y monto de la moneda pedida', async () => {
      const { service } = crear(fake());
      expect((await service.cicloVenta('emp-1', TODAS, {})).data).toMatchObject({ ganadas: 1, monto_ganado: 3_000_000, dias_promedio: 10 });
      expect((await service.cicloVenta('emp-1', TODAS, { moneda_id: USD })).data).toMatchObject({ ganadas: 1, monto_ganado: 800, dias_promedio: 30 });
    });

    it('resumen: todos los montos de la moneda pedida y la moneda en la respuesta', async () => {
      const { service } = crear(fake());
      const r = await service.resumen('emp-1', TODAS, { moneda_id: USD });
      expect(r.data.moneda).toEqual({ id: USD, codigo: 'USD' });
      expect(r.data.pipeline.totales.valor).toBe(500);
      expect(r.data.ciclo_venta.monto_ganado).toBe(800);
      expect(r.data.conversion_por_origen[0].monto_ganado).toBe(800);
    });

    it.each([
      ['de otra moneda que la empresa no tiene', EUR],
      ['inexistente', '99999999-9999-4999-8999-999999999999'],
      ['que no es un uuid', 'USD'],
    ])('moneda_id %s → 400 MONEDA_INVALIDA', async (_, id) => {
      const { service } = crear(fake());
      for (const llamada of [
        () => service.resumen('emp-1', TODAS, { moneda_id: id }),
        () => service.pipeline('emp-1', TODAS, { moneda_id: id }),
        () => service.conversion('emp-1', TODAS, { moneda_id: id }),
        () => service.motivosPerdida('emp-1', TODAS, { moneda_id: id }),
        () => service.vendedores('emp-1', TODAS, { moneda_id: id }),
        () => service.cicloVenta('emp-1', TODAS, { moneda_id: id }),
      ]) {
        await expect(llamada()).rejects.toMatchObject({
          status: 400,
          response: expect.objectContaining({ codigo: 'MONEDA_INVALIDA', campo: 'moneda_id' }),
        });
      }
    });

    it('la visibilidad CRM-12 sigue igual con el filtro de moneda', async () => {
      const { service, prisma } = crear(fake());
      await service.pipeline('emp-1', { verAjenas: false, vendedor_id: 'v-2' }, { moneda_id: USD });
      const where = prisma.crm_oportunidades.groupBy.mock.calls[0][0].where;
      expect(where.vendedor_id).toBe('v-2');
      expect(where.AND).toEqual([{ moneda_id: USD }]);
      await service.motivosPerdida('emp-1', { verAjenas: false, vendedor_id: null }, {});
      const sinFicha = prisma.crm_oportunidades.groupBy.mock.calls[1][0].where;
      expect(sinFicha.vendedor_id).toBe('00000000-0000-0000-0000-000000000000');
      expect(sinFicha.AND).toEqual([{ OR: [{ moneda_id: PYG }, { moneda_id: null }] }]);
    });
  });
});
