/**
 * D-T5: Dashboard de morosidad por moneda y por alcance de sucursal, sobre la MISMA cartera que el Tablero (R2):
 *  - Las cuotas salen de `carteraPendiente` (factura cobrable, NC prorrateadas sobre las cuotas más viejas); vencida =
 *    `diasVencidoCartera > 0` (lo que vence hoy está al día). Por R1 tampoco entran las cuotas anuladas.
 *  - `sucursal_id` pasa por `exigirSucursalEnAlcance` (403) ANTES de resolver la moneda (400). Sin pedirla, las facturas
 *    se recortan por `dest` (`filtroFiscalPorSucursal`) y los recibos por `sucursal_id`.
 *  - `moneda_id` como el Tablero: con la base entra la moneda nula; sin elegir, `en_moneda` es «Convertido» a la base
 *    (cada cuota con la `dticam` de su factura, cada recibo con su cotización vía `monedasDeRecibos`).
 *  - Nuevos (al lado de los de siempre): `moneda`, `convertido`, `sin_cotizacion`, `sin_moneda`,
 *    `en_moneda { resumen{ total_vencido, clientes_morosos, mora_cobrada_mes, mora_cobrada_anio, tasa_morosidad },
 *    aging_buckets, mora_por_mes, top_morosos[+saldo_vencido, dias_max] }` y `por_moneda`.
 */
import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { CobrosService } from './cobros.service';
import { CobrosController } from './cobros.controller';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));

const PYG = { id: '11111111-1111-4111-8111-111111111111', codigo: 'PYG' };
const USD = { id: '22222222-2222-4222-8222-222222222222', codigo: 'USD' };
const RARA = { id: '33333333-3333-4333-8333-333333333333', codigo: null };
const SUC_A = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
const SUC_B = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
const sqlDe = (call: any[]) => Prisma.sql(call[0], ...call.slice(1));
const textoDe = (call: any[]) => sqlDe(call).text.replace(/\s+/g, ' ');
const restringido = (sucursalIds: string[]) => ({ sucursalIds, puntosEstablecimiento: [], depositoIds: [] });

/** Fecha de vencimiento de hace `dias` días (UTC medianoche, como `@db.Date`); negativo = futuro, 0 = hoy. */
const vence = (dias: number) => {
  const hoy = new Date();
  hoy.setHours(0, 0, 0, 0);
  const d = new Date(Date.UTC(hoy.getFullYear(), hoy.getMonth(), hoy.getDate()));
  d.setUTCDate(d.getUTCDate() - dias);
  return d;
};
type Op = { cliente?: string | null; razon?: string; moneda?: string | null; cot?: string | null; saldo: string; dias?: number; factura?: string; nc?: string; dmon?: string };
let n = 0;
/** Una cuota con la forma del `findMany` de `carteraPendiente` (factura_cab con clientes.personas y moneda). */
const cuota = (o: Op) => {
  n++;
  const cliente = o.cliente === undefined ? 'cA' : o.cliente;
  return {
    id: `q${n}`,
    dvenccuo: vence(o.dias ?? 10),
    saldo_pendiente: new Prisma.Decimal(o.saldo),
    dmoncuota: new Prisma.Decimal(o.dmon ?? o.saldo),
    estado: 'Pendiente',
    factura_cab: {
      id: o.factura ?? `f${n}`,
      moneda_id: o.moneda === undefined ? PYG.id : o.moneda,
      dticam: o.cot ? new Prisma.Decimal(o.cot) : null,
      total_notas_credito: o.nc ? new Prisma.Decimal(o.nc) : null,
      clientes: cliente ? { id: cliente, personas: { razon_social: o.razon ?? (cliente === 'cA' ? 'Alfa' : cliente) } } : null,
    },
  };
};
type ReciboMora = { id: string; mora: string; moneda_id: string | null; cotizacion: string | null; es_mes: boolean; es_anio: boolean; mes: string | null };

/** Prisma falso: cuotas de `factura_cuotas.findMany`; cada `$queryRaw` (recibos) se reconoce por su texto. */
function prismaCon(cuotas: any[], recibos: ReciboMora[] = [], viejas: { porMes?: any[] } = {}) {
  const monedas = [PYG, USD, RARA];
  return {
    factura_cuotas: { findMany: jest.fn().mockResolvedValue(cuotas) },
    $queryRaw: jest.fn((...call: any[]) => {
      const t = textoDe(call);
      if (t.includes('AS es_mes')) return Promise.resolve(recibos.map((r) => ({ id: r.id, mora: r.mora, es_mes: r.es_mes, es_anio: r.es_anio, mes: r.mes })));
      if (t.includes('AS mora_anio')) return Promise.resolve([{ mora_mes: 0, mora_anio: 0 }]);
      if (t.includes('AS mora_cobrada')) return Promise.resolve(viejas.porMes ?? []);
      return Promise.resolve([]);
    }),
    empresas_sucursales: {
      findFirst: jest.fn().mockResolvedValue({ id: 'x' }),
      findMany: jest.fn().mockResolvedValue([{ punto_establecimiento: '001', config: null }]),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG.id }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue(null),
      findUnique: jest.fn(({ where }: any) => Promise.resolve(monedas.find((m) => m.id === where.id) ?? null)),
      findMany: jest.fn(({ where }: any) => Promise.resolve(monedas.filter((m) => where.id.in.includes(m.id)))),
    },
    recibos_cobro: {
      findMany: jest.fn((a: any) =>
        Promise.resolve(
          recibos
            .filter((r) => a.where.id.in.includes(r.id))
            .map((r) => ({ id: r.id, empresa_id: 'emp', moneda_id: r.moneda_id, cotizacion: r.cotizacion === null ? null : new Prisma.Decimal(r.cotizacion) })),
        ),
      ),
    },
  };
}
const servicio = (prisma: any) => new (CobrosService as any)(prisma) as CobrosService;
const llamadas = (prisma: any) => prisma.$queryRaw.mock.calls.map(textoDe) as string[];
const whereCuotas = (prisma: any) => prisma.factura_cuotas.findMany.mock.calls[0][0].where;

beforeEach(() => {
  (alcanceSucursalUsuario as jest.Mock).mockReset().mockResolvedValue(null);
});

describe('Morosidad: alcance de sucursal', () => {
  it('restringido a A que pide B → 403 sin consultar', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await expect(servicio(prisma).getDashboardMorosidad('emp', { sucursal_id: SUC_B }, 'usr')).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
    expect(prisma.factura_cuotas.findMany).not.toHaveBeenCalled();
    expect(alcanceSucursalUsuario).toHaveBeenCalledWith(prisma, 'usr', 'emp');
  });

  it('el 403 sale antes que el 400 de moneda', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    await expect(
      servicio(prismaCon([])).getDashboardMorosidad('emp', { sucursal_id: SUC_B, moneda_id: 'no-es-uuid' }, 'usr'),
    ).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('admin que pide una sucursal de otra empresa → 403', async () => {
    const prisma = prismaCon([]);
    prisma.empresas_sucursales.findFirst.mockResolvedValue(null);
    await expect(servicio(prisma).getDashboardMorosidad('emp', { sucursal_id: SUC_B }, 'usr')).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('restringido a A sin pedir: facturas por dest de A y recibos de A en las 3 consultas de recibos', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon([]);
    await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(prisma.empresas_sucursales.findMany.mock.calls[0][0].where).toEqual({ id: { in: [SUC_A] } });
    expect(whereCuotas(prisma).factura_cab.dest).toEqual({ in: ['001'] });
    const calls = prisma.$queryRaw.mock.calls;
    expect(calls).toHaveLength(3);
    for (const call of calls) {
      expect(textoDe(call)).toMatch(/AND r\.sucursal_id = \$\d+::uuid/);
      expect(sqlDe(call).values).toContain(SUC_A);
    }
  });

  it('alcance vacío → nada (dest in [] y AND FALSE)', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([]));
    const prisma = prismaCon([]);
    await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(whereCuotas(prisma).factura_cab.dest).toEqual({ in: [] });
    for (const t of llamadas(prisma)) expect(t).toContain('AND FALSE');
  });

  it('admin sin pedir sucursal: ningún recorte', async () => {
    const prisma = prismaCon([]);
    await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(whereCuotas(prisma).factura_cab.dest).toBeUndefined();
    for (const t of llamadas(prisma)) {
      expect(t).not.toContain('sucursal_id');
      expect(t).not.toContain('FALSE');
    }
  });
});

describe('Morosidad: misma cartera que el Tablero (D-T5 R1 y R2)', () => {
  it('factura no cobrable y cuota pagada o anulada quedan fuera del where (criterio del Tablero + anuladas)', async () => {
    const prisma = prismaCon([]);
    await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    const w = whereCuotas(prisma);
    expect(w.factura_cab.empresa_id).toBe('emp');
    expect(w.factura_cab.estado.notIn).toEqual(expect.arrayContaining(['anulado', 'Anulado', 'cancelado', 'Cancelado', 'inutilizado', 'INUTILIZADO']));
    expect(w.estado.notIn).toEqual(expect.arrayContaining(['pagado', 'Pagado', 'pagada', 'anulado', 'Anulado', 'ANULADA']));
    expect(prisma.factura_cuotas.findMany.mock.calls[0][0].orderBy).toEqual({ dvenccuo: 'asc' });
  });

  it('descuenta la NC de la factura sobre las cuotas más viejas (como el Tablero)', async () => {
    const prisma = prismaCon([
      cuota({ factura: 'f1', saldo: '1000000', nc: '300000', dias: 40 }),
      cuota({ factura: 'f1', saldo: '1000000', nc: '300000', dias: 10 }),
    ]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.resumen.total_vencido).toBe(1700000);
    expect(r.aging_buckets).toEqual([
      { bucket: '0-30', total_vencido: 1000000, cantidad: 1 },
      { bucket: '31-60', total_vencido: 700000, cantidad: 1 },
    ]);
    expect(r.en_moneda.resumen.total_vencido).toBe(1700000);
  });

  it('cuota cubierta entera por la NC no cuenta (ni cuota ni cliente)', async () => {
    const prisma = prismaCon([cuota({ cliente: 'cZ', saldo: '500', nc: '500', dias: 20 }), cuota({ saldo: '100', dias: 20 })]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.resumen).toMatchObject({ total_vencido: 100, clientes_morosos: 1 });
    expect(r.top_morosos.map((c: any) => c.cliente_id)).toEqual(['cA']);
  });

  it('lo que vence hoy está al día: no es vencido ni moroso, pero entra a la tasa como pendiente', async () => {
    const prisma = prismaCon([cuota({ saldo: '1000', dias: 0 }), cuota({ saldo: '1000', dias: 1 })]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.resumen.total_vencido).toBe(1000);
    expect(r.aging_buckets).toEqual([{ bucket: '0-30', total_vencido: 1000, cantidad: 1 }]);
    expect(r.top_morosos[0]).toMatchObject({ cuotas_vencidas: 1, dias_promedio_vencimiento: 1 });
    expect(r.en_moneda.resumen.tasa_morosidad).toBe(50);
  });

  it('cuota sin cliente: suma al vencido y al aging (como el Tablero), no al top ni a clientes_morosos', async () => {
    const prisma = prismaCon([cuota({ cliente: null, saldo: '1000' }), cuota({ saldo: '2000' })]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.resumen).toMatchObject({ total_vencido: 3000, clientes_morosos: 1 });
    expect(r.en_moneda.resumen).toMatchObject({ total_vencido: 3000, clientes_morosos: 1 });
    expect(r.en_moneda.aging_buckets).toEqual([{ bucket: '0-30', total_vencido: 3000, cantidad: 2 }]);
    expect(r.top_morosos).toHaveLength(1);
    expect(r.por_moneda[0].total_vencido).toBe('3000.00');
  });

  it('campos de siempre: top por cliente con promedio de días y cuotas; tramos por días de atraso', async () => {
    const prisma = prismaCon([
      cuota({ saldo: '100', dias: 31 }),
      cuota({ saldo: '50.5', dias: 61 }),
      cuota({ cliente: 'cB', razon: 'Beta', saldo: '1000', dias: 91 }),
    ]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.resumen).toEqual({ total_vencido: 1150.5, clientes_morosos: 2, mora_cobrada_mes: 0, mora_cobrada_anio: 0 });
    expect(r.top_morosos).toEqual([
      { cliente_id: 'cB', razon_social: 'Beta', total_vencido: 1000, dias_promedio_vencimiento: 91, cuotas_vencidas: 1 },
      { cliente_id: 'cA', razon_social: 'Alfa', total_vencido: 150.5, dias_promedio_vencimiento: 46, cuotas_vencidas: 2 },
    ]);
    expect(r.aging_buckets.map((b: any) => b.bucket)).toEqual(['31-60', '61-90', '90+']);
  });
});

describe('Morosidad: moneda', () => {
  it('moneda ajena o que no es UUID → 400 MONEDA_INVALIDA', async () => {
    await expect(servicio(prismaCon([])).getDashboardMorosidad('emp', { moneda_id: 'x' }, 'usr')).rejects.toBeInstanceOf(BadRequestException);
    await expect(
      servicio(prismaCon([])).getDashboardMorosidad('emp', { moneda_id: '44444444-4444-4444-8444-444444444444' }, 'usr'),
    ).rejects.toBeInstanceOf(BadRequestException);
  });

  it('USD elegida: igualdad en facturas y recibos, sin convertir', async () => {
    const prisma = prismaCon([cuota({ moneda: USD.id, saldo: '100.25' })]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', { moneda_id: USD.id }, 'usr');
    expect(whereCuotas(prisma).factura_cab.AND).toEqual([{ moneda_id: USD.id }]);
    for (const call of prisma.$queryRaw.mock.calls) {
      expect(textoDe(call)).toMatch(/AND r\.moneda_id = \$\d+::uuid/);
      expect(textoDe(call)).not.toContain('moneda_id IS NULL');
    }
    expect(r.moneda).toEqual(USD);
    expect(r.convertido).toBe(false);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda.resumen.total_vencido).toBe(100.25);
  });

  it('base elegida: entra la moneda nula', async () => {
    const prisma = prismaCon([]);
    await servicio(prisma).getDashboardMorosidad('emp', { moneda_id: PYG.id }, 'usr');
    expect(whereCuotas(prisma).factura_cab.AND).toEqual([{ OR: [{ moneda_id: PYG.id }, { moneda_id: null }] }]);
    for (const t of llamadas(prisma)) expect(t).toMatch(/AND \(r\.moneda_id = \$\d+::uuid OR r\.moneda_id IS NULL\)/);
  });

  it('PYG 1.000.000 + USD 100 a 7.300 vencidas → por_moneda separa; convertido 1.730.000', async () => {
    const prisma = prismaCon([
      cuota({ saldo: '600000', dias: 30 + 1 }),
      cuota({ saldo: '400000', dias: 49 + 1 }),
      cuota({ cliente: 'cB', razon: 'Beta', moneda: USD.id, cot: '7300', saldo: '100', dias: 120 }),
    ]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.moneda).toEqual(PYG);
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.en_moneda.resumen).toEqual({
      total_vencido: 1730000,
      clientes_morosos: 2,
      mora_cobrada_mes: 0,
      mora_cobrada_anio: 0,
      tasa_morosidad: 100,
    });
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total_vencido: '1000000.00', mora_cobrada_mes: '0.00', mora_cobrada_anio: '0.00' },
      { codigo: 'USD', total_vencido: '100.00', mora_cobrada_mes: '0.00', mora_cobrada_anio: '0.00' },
    ]);
    expect(r.en_moneda.aging_buckets).toEqual([
      { bucket: '31-60', total_vencido: 1000000, cantidad: 2 },
      { bucket: '90+', total_vencido: 730000, cantidad: 1 },
    ]);
    expect(r.en_moneda.top_morosos).toEqual([
      { cliente_id: 'cA', razon_social: 'Alfa', total_vencido: 1000000, saldo_vencido: 1000000, dias_promedio_vencimiento: 40.5, dias_max: 50, cuotas_vencidas: 2 },
      { cliente_id: 'cB', razon_social: 'Beta', total_vencido: 730000, saldo_vencido: 730000, dias_promedio_vencimiento: 120, dias_max: 120, cuotas_vencidas: 1 },
    ]);
    // los de siempre suman tal cual (mezclan monedas)
    expect(r.resumen.total_vencido).toBe(1000100);
  });

  it('factura USD sin cotización (nula o 1) → sin_cotizacion por cuota, fuera de todo en_moneda, sigue en por_moneda', async () => {
    const prisma = prismaCon([
      cuota({ saldo: '500000' }),
      cuota({ cliente: 'cB', moneda: USD.id, cot: null, saldo: '60' }),
      cuota({ cliente: 'cB', moneda: USD.id, cot: null, saldo: '40' }),
      cuota({ cliente: 'cB', moneda: USD.id, cot: '1', saldo: '50' }),
    ]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.sin_cotizacion).toBe(3);
    expect(r.en_moneda.resumen.total_vencido).toBe(500000);
    expect(r.en_moneda.resumen.clientes_morosos).toBe(1);
    expect(r.en_moneda.top_morosos.map((c: any) => c.cliente_id)).toEqual(['cA']);
    expect(r.en_moneda.aging_buckets).toEqual([{ bucket: '0-30', total_vencido: 500000, cantidad: 1 }]);
    expect(r.por_moneda.find((m: any) => m.codigo === 'USD').total_vencido).toBe('150.00');
  });

  it('tasa de morosidad = vencido / pendiente (vencido + al día) en la moneda, 2 decimales', async () => {
    const prisma = prismaCon([cuota({ saldo: '1000000' }), cuota({ saldo: '2000000', dias: -5 })]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.en_moneda.resumen.tasa_morosidad).toBe(33.33);
    expect(r.en_moneda.resumen.total_vencido).toBe(1000000);
    expect(r.en_moneda.aging_buckets).toHaveLength(1);
    expect(r.en_moneda.top_morosos[0].cuotas_vencidas).toBe(1);
  });

  it('sin cartera → tasa 0 y bloques vacíos', async () => {
    const r: any = await servicio(prismaCon([])).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.en_moneda).toEqual({
      resumen: { total_vencido: 0, clientes_morosos: 0, mora_cobrada_mes: 0, mora_cobrada_anio: 0, tasa_morosidad: 0 },
      aging_buckets: [],
      mora_por_mes: [],
      top_morosos: [],
    });
    expect(r.por_moneda).toEqual([]);
    expect(r.sin_moneda).toBe(0);
  });

  it('top 10 en la moneda, ordenado por el convertido (no por el saldo crudo)', async () => {
    const cuotas = Array.from({ length: 11 }, (_, i) => cuota({ cliente: `c${i}`, razon: `C${i}`, saldo: String(1000 * (i + 1)) }));
    cuotas.push(cuota({ cliente: 'cUSD', razon: 'Dolar', moneda: USD.id, cot: '7000', saldo: '5' }));
    const r: any = await servicio(prismaCon(cuotas)).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.en_moneda.top_morosos).toHaveLength(10);
    expect(r.en_moneda.top_morosos[0]).toMatchObject({ cliente_id: 'cUSD', total_vencido: 35000 });
    expect(r.en_moneda.resumen.clientes_morosos).toBe(12);
  });

  it('factura con moneda sin código → sin_moneda, fuera de en_moneda y de por_moneda', async () => {
    const prisma = prismaCon([cuota({ moneda: RARA.id, saldo: '6' }), cuota({ moneda: RARA.id, saldo: '4' }), cuota({ cliente: 'cB', saldo: '20' })]);
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.sin_moneda).toBe(2);
    expect(r.en_moneda.resumen.total_vencido).toBe(20);
    expect(r.por_moneda).toEqual([{ codigo: 'PYG', total_vencido: '20.00', mora_cobrada_mes: '0.00', mora_cobrada_anio: '0.00' }]);
  });

  it('mora cobrada: cada recibo con su moneda y cotización (monedasDeRecibos); meses = los de siempre', async () => {
    const prisma = prismaCon(
      [],
      [
        { id: 'r1', mora: '5000', moneda_id: PYG.id, cotizacion: null, es_mes: true, es_anio: true, mes: '2026-11' },
        { id: 'r2', mora: '10', moneda_id: USD.id, cotizacion: '7000', es_mes: true, es_anio: true, mes: '2026-11' },
        { id: 'r3', mora: '300', moneda_id: null, cotizacion: null, es_mes: false, es_anio: true, mes: '2026-09' },
        { id: 'r4', mora: '2', moneda_id: USD.id, cotizacion: null, es_mes: false, es_anio: true, mes: null },
      ],
      { porMes: [{ mes: '2026-09', mora_cobrada: 300 }, { mes: '2026-10', mora_cobrada: 0 }, { mes: '2026-11', mora_cobrada: 5010 }] },
    );
    const r: any = await servicio(prisma).getDashboardMorosidad('emp', {}, 'usr');
    expect(r.en_moneda.resumen.mora_cobrada_mes).toBe(75000);
    expect(r.en_moneda.resumen.mora_cobrada_anio).toBe(75300);
    expect(r.en_moneda.mora_por_mes).toEqual([
      { mes: '2026-09', mora_cobrada: 300 },
      { mes: '2026-10', mora_cobrada: 0 },
      { mes: '2026-11', mora_cobrada: 75000 },
    ]);
    expect(r.sin_cotizacion).toBe(1); // r4: USD sin cotización
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', total_vencido: '0.00', mora_cobrada_mes: '5000.00', mora_cobrada_anio: '5300.00' },
      { codigo: 'USD', total_vencido: '0.00', mora_cobrada_mes: '10.00', mora_cobrada_anio: '12.00' },
    ]);
    const nueva = llamadas(prisma).find((t) => t.includes('AS es_mes'));
    expect(nueva).toContain("r.estado != 'anulado'");
    expect(nueva).toContain('r.mora_total > 0');
  });
});

describe('Morosidad: controller', () => {
  it('pasa empresa, filtros y user.id', async () => {
    const svc = { getDashboardMorosidad: jest.fn().mockResolvedValue({}) };
    const ctrl = new (CobrosController as any)(svc) as CobrosController;
    await ctrl.getDashboardMorosidad({ id: 'usr', empresa_id: 'emp' } as any, SUC_A, USD.id);
    expect(svc.getDashboardMorosidad).toHaveBeenCalledWith('emp', { sucursal_id: SUC_A, moneda_id: USD.id }, 'usr');
  });
});
