/**
 * Caracterización (carril D de Reportes, T1): fija los campos, redondeos y orden que devuelven HOY los reportes de
 * Cobranzas, antes de sumarles moneda. Los campos de siempre no pueden cambiar: si un test de acá falla tras un cambio,
 * el cambio rompió un campo viejo (los nuevos van al lado: `moneda`, `en_moneda`, `por_moneda`, `sin_cotizacion`).
 *
 * Varias cosas que se fijan acá son defectos conocidos que se corrigen en los campos NUEVOS, no en estos:
 *  - `Math.round` a entero en cobrador e intereses (en USD pierde los decimales).
 *  - Totales que suman monedas distintas (cierre `totalGeneral`, morosidad, promesas, rendiciones).
 *  - Cierre: hasta D-T4 `monedaId` filtraba por igualdad (el recibo de `moneda_id` nulo no entraba ni con la base) y
 *    `sucursalId` iba tal cual al SQL. D-T4 lo cambió A PROPÓSITO: la moneda es la del Tablero (con la base entra la
 *    nula, como `whereMonedaTablero`) y la sucursal pasa por el alcance del usuario (fuera de alcance → 403).
 *  - Rendiciones: `cobranzas-dia` suma el monto de las BORRADOR; las RECHAZADO cuentan pero no suman.
 *  - D-T5 (a propósito): Morosidad, Promesas y Libro de retenciones reciben el usuario (alcance) y filtros
 *    `{ sucursal_id, moneda_id }`; Morosidad (R2) toma el vencido de la cartera del Tablero (ver su describe) y el Libro suma `moneda_codigo`/`moneda_cotizacion` a cada fila (ya no devuelve el arreglo del SQL tal cual).
 */
import { Prisma } from '@prisma/client';
import { ReporteCobradorController } from './reporte-cobrador.controller';
import { ReporteInteresesCobradosController } from './reporte-intereses-cobrados.controller';
import { PromesasService } from './promesas.service';
import { CobrosService } from 'src/cobros/cobros.service';
import { RecibosService } from 'src/recibos/recibos.service';
import { RendicionesService } from 'src/rendiciones/rendiciones.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { ESTADOS_FACTURA_NO_COBRABLE_PRISMA } from 'src/utils/estados-factura';

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

const USER = { id: 'usr', empresa_id: 'emp' } as any;
const D = (v: string) => new Prisma.Decimal(v);
const T = (iso: string) => new Date(iso);
/** El SQL de una llamada a `$queryRaw` (tagged template), con los `Prisma.sql` anidados ya expandidos. */
const sqlDe = (call: any[]) => Prisma.sql(call[0], ...call.slice(1));
/** El texto SQL (placeholders `$n`) con los espacios colapsados, para fijar filtros y agregados. */
const textoDe = (call: any[]) => sqlDe(call).text.replace(/\s+/g, ' ').trim();
const contieneTodo = (texto: string, partes: string[]) => {
  for (const parte of partes) expect(texto).toContain(parte);
};

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

/**
 * D-T2 sumó moneda al reporte del cobrador (aditivo): `moneda`, `convertido`, `sin_cotizacion`, `sin_moneda`,
 * `en_moneda`, `por_moneda` y, en el detalle, `moneda`/`monto_en_moneda` por fila. Se quitan para fijar que los campos
 * de siempre siguen idénticos; los nuevos los prueba `reporte-cobrador-moneda.spec.ts`. D-T3 hizo lo mismo en intereses
 * (`monto_cobrado_en_moneda` por fila del detalle; los nuevos en `reporte-intereses-moneda.spec.ts`).
 */
const CAMPOS_MONEDA = ['moneda', 'convertido', 'sin_cotizacion', 'sin_moneda', 'en_moneda', 'por_moneda', 'monto_en_moneda', 'monto_cobrado_en_moneda'];
const deSiempre = (v: any): any => {
  if (Array.isArray(v)) return v.map(deSiempre);
  if (!v || typeof v !== 'object' || v instanceof Date) return v;
  return Object.fromEntries(Object.entries(v).filter(([k]) => !CAMPOS_MONEDA.includes(k)).map(([k, x]) => [k, deSiempre(x)]));
};
/** Lo que necesitan `resolverMonedaTablero` y `monedasDeRecibos`: base PYG; recibos de moneda nula (= base). */
const MONEDA_MOCK = {
  empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'm-pyg' }) },
  moneda: {
    findFirst: jest.fn().mockResolvedValue(null),
    findUnique: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }),
    findMany: jest.fn().mockResolvedValue([{ id: 'm-pyg', codigo: 'PYG' }]),
  },
};
const recibosDeMonedaNula = (a: any) => (a.where.id.in as string[]).map((id) => ({ id, empresa_id: 'emp', moneda_id: null, cotizacion: null }));

describe('GET /reporte-cobrador/por-cobrador', () => {
  const RECIBOS: Record<string, any[]> = {
    cob1: [
      { id: 'r1', monto_total: D('1234.56'), descuento_monto: D('10.4'), mora_total: null, fecha_emision: T('2026-11-02T12:00:00Z') },
      { id: 'r2', monto_total: D('100000'), descuento_monto: null, mora_total: D('500.5'), fecha_emision: T('2026-11-02T15:00:00Z') },
      { id: 'r3', monto_total: D('50000'), descuento_monto: null, mora_total: null, fecha_emision: T('2026-11-03T12:00:00Z') },
    ],
    cob2: [],
  };
  const prisma = () =>
    ({
      vendedores_cobradores: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'cob1', nombre: 'Ana', apellido: null },
          { id: 'cob2', nombre: 'Beto', apellido: 'Paz' },
        ]),
      },
      recibos_cobro: {
        findMany: jest.fn((a: any) => Promise.resolve(a.where.id ? recibosDeMonedaNula(a) : RECIBOS[a.where.cobrador_id])),
      },
      // D-T2: el `count` ×2 + `aggregate` de hoy pasó a un `groupBy` por plan (para la moneda de su factura); los campos
      // de siempre son la suma de los grupos. cob1: 4 pendientes (1 vencida) por 2500,75 en dos planes.
      cuotas_calculadas_detalle: {
        groupBy: jest.fn((a: any) => {
          if (a.where.cuotas_calculadas.factura_cab.OR[0].cobrador_id !== 'cob1') return Promise.resolve([]);
          if (a.where.fecha_vencimiento) return Promise.resolve([{ cuota_calculada_id: 'p1', _count: { _all: 1 } }]);
          return Promise.resolve([
            { cuota_calculada_id: 'p1', _sum: { monto_cuota: D('2000.25') }, _count: { _all: 3 } },
            { cuota_calculada_id: 'p2', _sum: { monto_cuota: D('500.5') }, _count: { _all: 1 } },
          ]);
        }),
      },
      cuotas_calculadas: {
        findMany: jest.fn((a: any) => Promise.resolve(a.where.id.in.map((id: string) => ({ id, factura_cab: { moneda_id: null, dticam: null } })))),
      },
      ...MONEDA_MOCK,
    }) as any;

  it('campos, Math.round a entero, totales sobre lo redondeado y orden de cobradores', async () => {
    const p = prisma();
    const r = await new ReporteCobradorController(p).getPorCobrador(USER, '2026-11-01', '2026-11-07');

    expect(p.vendedores_cobradores.findMany).toHaveBeenCalledWith({
      where: { empresa_id: 'emp', active: true },
      select: { id: true, nombre: true, apellido: true },
      orderBy: { nombre: 'asc' },
    });
    expect(p.recibos_cobro.findMany.mock.calls[0][0]).toEqual({
      where: {
        empresa_id: 'emp',
        cobrador_id: 'cob1',
        estado: { not: 'anulado' },
        fecha_emision: { gte: new Date('2026-11-01T00:00:00'), lte: new Date('2026-11-07T23:59:59') },
      },
      // D-T2: `id` para la moneda del recibo.
      select: { id: true, monto_total: true, descuento_monto: true, mora_total: true, fecha_emision: true },
    });
    expect(p.cuotas_calculadas_detalle.groupBy.mock.calls[0][0].where.monto_pagado).toEqual({ equals: 0 });

    expect(deSiempre(r)).toEqual({
      cobradores: [
        {
          cobrador: { id: 'cob1', nombre: 'Ana', apellido: null },
          cobros: {
            total_cobrado: 151235,
            total_descuentos: 10,
            total_mora_cobrada: 501,
            cantidad_cobros: 3,
            promedio_por_cobro: 50412,
            dias_activos: 2,
            promedio_diario: 75617,
          },
          pendientes: { total_pendientes: 4, total_vencidas: 1, monto_pendiente: 2501, tasa_morosidad: 25 },
        },
        {
          cobrador: { id: 'cob2', nombre: 'Beto', apellido: 'Paz' },
          cobros: {
            total_cobrado: 0,
            total_descuentos: 0,
            total_mora_cobrada: 0,
            cantidad_cobros: 0,
            promedio_por_cobro: 0,
            dias_activos: 0,
            promedio_diario: 0,
          },
          pendientes: { total_pendientes: 0, total_vencidas: 0, monto_pendiente: 0, tasa_morosidad: 0 },
        },
      ],
      totales: {
        total_cobrado: 151235,
        cantidad_cobros: 3,
        total_descuentos: 10,
        total_mora_cobrada: 501,
        total_pendientes: 4,
        total_vencidas: 1,
        monto_pendiente: 2501,
      },
      periodo: {
        desde: new Date('2026-11-01T00:00:00').toISOString(),
        hasta: new Date('2026-11-07T23:59:59').toISOString(),
      },
    });
  });
});

describe('GET /reporte-cobrador/productividad', () => {
  it('días ordenados, monto redondeado por día, totales y máximo', async () => {
    const p = {
      recibos_cobro: {
        findMany: jest.fn((a: any) => Promise.resolve(a.where.id ? recibosDeMonedaNula(a) : [
          { id: 'r1', monto_total: D('1234.56'), fecha_emision: T('2026-11-02T12:00:00Z'), cobrador_id: 'cob1' },
          { id: 'r2', monto_total: D('100000.5'), fecha_emision: T('2026-11-02T14:00:00Z'), cobrador_id: 'cob1' },
          { id: 'r3', monto_total: D('50000'), fecha_emision: T('2026-11-03T12:00:00Z'), cobrador_id: 'cob1' },
        ])),
      },
      ...MONEDA_MOCK,
    } as any;
    const r = await new ReporteCobradorController(p).getProductividad(USER, '2026-11-01', '2026-11-07', 'cob1');

    expect(p.recibos_cobro.findMany).toHaveBeenCalledWith({
      where: {
        empresa_id: 'emp',
        estado: { not: 'anulado' },
        fecha_emision: { gte: new Date('2026-11-01T00:00:00'), lte: new Date('2026-11-07T23:59:59') },
        cobrador_id: 'cob1',
      },
      // D-T2: `id` para la moneda del recibo.
      select: { id: true, monto_total: true, fecha_emision: true, cobrador_id: true },
      orderBy: { fecha_emision: 'asc' },
    });
    expect(deSiempre(r)).toEqual({
      dias: [
        { fecha: '2026-11-02', monto: 101235, cantidad: 2 },
        { fecha: '2026-11-03', monto: 50000, cantidad: 1 },
      ],
      totales: { monto: 151235, cantidad: 3 },
      max_dia: 101235,
    });
  });
});

describe('GET /reporte-cobrador/detalle', () => {
  it('recibos paginados con cliente y cuotas, montos sin redondear', async () => {
    const p = {
      recibos_cobro: {
        findMany: jest.fn((a: any) => Promise.resolve(a.where.id ? recibosDeMonedaNula(a) : [
          {
            id: 'r1',
            numero_recibo: '001-001-0000001',
            fecha_emision: T('2026-11-03T12:00:00Z'),
            fecha_registro: T('2026-11-02T12:00:00Z'),
            monto_total: D('1234.56'),
            descuento_monto: null,
            mora_total: D('12.3'),
            estado: 'emitido',
            clientes: { id: 'cli1', nombre_fantasia: null, personas: { razon_social: 'Alfa SA', telefono: '0981' } },
            recibo_cobro_detalle: [
              {
                id: 'd1',
                monto_pagado: D('1000.5'),
                descuento_aplicado: D('1.5'),
                mora_monto: null,
                es_pago_parcial: true,
                factura_cuotas: {
                  nro_cuota: 2,
                  dmoncuota: D('2000.25'),
                  dvenccuo: T('2026-10-15T00:00:00Z'),
                  factura_cab: { id: 'f1', dest: '001', dpunexp: '002', dnumdoc: '0000123' },
                },
              },
              { id: 'd2', monto_pagado: D('234.06'), descuento_aplicado: null, mora_monto: D('12.3'), es_pago_parcial: false, factura_cuotas: null },
            ],
          },
          {
            id: 'r2',
            numero_recibo: '001-001-0000002',
            fecha_emision: T('2026-11-01T12:00:00Z'),
            fecha_registro: null,
            monto_total: D('500'),
            descuento_monto: D('0'),
            mora_total: null,
            estado: 'emitido',
            clientes: null,
            recibo_cobro_detalle: [],
          },
        ])),
        count: jest.fn().mockResolvedValue(21),
      },
      ...MONEDA_MOCK,
    } as any;
    const r = await new ReporteCobradorController(p).getDetalle(USER, 'cob1', '2026-11-01', '2026-11-07', '2', '20');

    const args = p.recibos_cobro.findMany.mock.calls[0][0];
    expect(args.where).toEqual({
      empresa_id: 'emp',
      cobrador_id: 'cob1',
      estado: { not: 'anulado' },
      fecha_emision: { gte: new Date('2026-11-01T00:00:00'), lte: new Date('2026-11-07T23:59:59') },
    });
    expect(args.orderBy).toEqual({ fecha_emision: 'desc' });
    expect([args.skip, args.take]).toEqual([20, 20]);
    expect(p.recibos_cobro.count).toHaveBeenCalledWith({ where: args.where });
    expect(deSiempre(r)).toEqual({
      data: [
        {
          id: 'r1',
          numero_recibo: '001-001-0000001',
          fecha: '2026-11-02',
          estado: 'emitido',
          cliente: { id: 'cli1', nombre: 'Alfa SA', telefono: '0981' },
          monto_total: 1234.56,
          descuento_monto: 0,
          mora_total: 12.3,
          detalles: [
            {
              factura: '001-002-0000123',
              nro_cuota: 2,
              vencimiento: '2026-10-15',
              monto_cuota: 2000.25,
              monto_pagado: 1000.5,
              descuento: 1.5,
              mora: 0,
              parcial: true,
            },
            {
              factura: '—',
              nro_cuota: undefined,
              vencimiento: undefined,
              monto_cuota: 0,
              monto_pagado: 234.06,
              descuento: 0,
              mora: 12.3,
              parcial: false,
            },
          ],
        },
        {
          id: 'r2',
          numero_recibo: '001-001-0000002',
          fecha: '2026-11-01',
          estado: 'emitido',
          cliente: { id: undefined, nombre: '—', telefono: undefined },
          monto_total: 500,
          descuento_monto: 0,
          mora_total: 0,
          detalles: [],
        },
      ],
      total: 21,
      page: 2,
      pageSize: 20,
      totalPages: 2,
    });
  });
});

describe('GET /reporte-intereses-cobrados/{resumen,detalle}', () => {
  const RECIBOS = [
    {
      id: 'r1',
      numero_recibo: 'R1',
      fecha_emision: T('2026-11-02T12:00:00Z'),
      cobrador_id: 'cob1',
      cliente_id: 'cli1',
      clientes: { id: 'cli1', nombre_fantasia: 'Alfa', personas: { razon_social: 'Alfa SA' } },
    },
    {
      id: 'r2',
      numero_recibo: 'R2',
      fecha_emision: T('2026-11-03T12:00:00Z'),
      cobrador_id: null,
      cliente_id: 'cli2',
      clientes: { id: 'cli2', nombre_fantasia: null, personas: { razon_social: 'Beta SA' } },
    },
  ];
  const interes = (id: string, recibo: string, cuota: string, bruto: string, exon: string, cobrado: string, iva: string) => ({
    id,
    empresa_id: 'emp',
    recibo_cobro_id: recibo,
    factura_cuota_id: cuota,
    dias_mora: 10,
    tasa_aplicada: D('3.5'),
    base_calculo: D('10000.5'),
    monto_interes_bruto: D(bruto),
    monto_exonerado: D(exon),
    monto_interes_cobrado: D(cobrado),
    monto_iva: D(iva),
    tipo_comprobante: 'FACTURA',
    emitido_at: id === 'i1' ? T('2026-11-02T12:00:00Z') : null,
    autorizacion_descuento_id: id === 'i3' ? 'aut1' : null,
    created_at: T('2026-11-05T12:00:00Z'),
  });
  const INTERESES = [
    interes('i1', 'r1', 'q1', '1000.4', '100.2', '900.2', '81.84'),
    interes('i2', 'r1', 'q2', '500', '0', '500', '45.45'),
    interes('i3', 'r2', 'q3', '2000.6', '1000.1', '1000.5', '90.94'),
  ];
  const prisma = () =>
    ({
      // D-T3: la segunda lectura (por `id`) es la de `monedasDeRecibos`: recibos de moneda nula (= base).
      recibos_cobro: { findMany: jest.fn((a: any) => Promise.resolve(a.where.id ? recibosDeMonedaNula(a) : RECIBOS)) },
      vendedores_cobradores: { findMany: jest.fn().mockResolvedValue([{ id: 'cob1', nombre: 'Ana', apellido: null }]) },
      ...MONEDA_MOCK,
      cob_interes_cobrado: { findMany: jest.fn().mockResolvedValue(INTERESES) },
      factura_cuotas: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'q1', nro_cuota: 1, dvenccuo: T('2026-10-01T00:00:00Z'), factura_cab: { dest: '001', dpunexp: '001', dnumdoc: '0000007' } },
        ]),
      },
    }) as any;

  it('resumen: totales, rankings (orden por monto cobrado), serie diaria, todo con Math.round', async () => {
    const p = prisma();
    const r = deSiempre(await new ReporteInteresesCobradosController(p).getResumen(USER, '2026-11-01', '2026-11-07', 'cob1', 'cli1'));

    expect(p.recibos_cobro.findMany.mock.calls[0][0].where).toEqual({
      empresa_id: 'emp',
      estado: { not: 'anulado' },
      fecha_emision: { gte: new Date('2026-11-01T00:00:00'), lte: new Date('2026-11-07T23:59:59') },
      cobrador_id: 'cob1',
      cliente_id: 'cli1',
    });
    expect(p.cob_interes_cobrado.findMany).toHaveBeenCalledWith({ where: { empresa_id: 'emp', recibo_cobro_id: { in: ['r1', 'r2'] } } });
    expect(r).toEqual({
      totales: {
        cantidad_cuotas: 3,
        cantidad_recibos: 2,
        monto_bruto: 3501,
        monto_exonerado: 1100,
        monto_cobrado: 2401,
        monto_iva: 218,
        tasa_exoneracion: 31,
      },
      ranking_clientes: [
        { cliente_id: 'cli1', cliente_nombre: 'Alfa', cantidad_cuotas: 2, cantidad_recibos: 1, monto_bruto: 1500, monto_exonerado: 100, monto_cobrado: 1400 },
        { cliente_id: 'cli2', cliente_nombre: 'Beta SA', cantidad_cuotas: 1, cantidad_recibos: 1, monto_bruto: 2001, monto_exonerado: 1000, monto_cobrado: 1001 },
      ],
      ranking_cobradores: [
        { cobrador_id: 'cob1', cobrador_nombre: 'Ana', cantidad_cuotas: 2, cantidad_recibos: 1, monto_bruto: 1500, monto_exonerado: 100, monto_cobrado: 1400 },
        {
          cobrador_id: null,
          cobrador_nombre: 'Sin cobrador asignado',
          cantidad_cuotas: 1,
          cantidad_recibos: 1,
          monto_bruto: 2001,
          monto_exonerado: 1000,
          monto_cobrado: 1001,
        },
      ],
      serie: [
        { fecha: '2026-11-02', monto_cobrado: 1400, monto_exonerado: 100, cantidad: 2 },
        { fecha: '2026-11-03', monto_cobrado: 1001, monto_exonerado: 1000, cantidad: 1 },
      ],
      periodo: {
        desde: new Date('2026-11-01T00:00:00').toISOString(),
        hasta: new Date('2026-11-07T23:59:59').toISOString(),
      },
    });
  });

  it('resumen sin recibos: todo en 0, sin NaN', async () => {
    const p = prisma();
    p.recibos_cobro.findMany.mockResolvedValue([]);
    const r = deSiempre(await new ReporteInteresesCobradosController(p).getResumen(USER, '2026-11-01', '2026-11-07'));
    expect(r.totales).toEqual({
      cantidad_cuotas: 0,
      cantidad_recibos: 0,
      monto_bruto: 0,
      monto_exonerado: 0,
      monto_cobrado: 0,
      monto_iva: 0,
      tasa_exoneracion: 0,
    });
    expect([r.ranking_clientes, r.ranking_cobradores, r.serie]).toEqual([[], [], []]);
    expect(p.cob_interes_cobrado.findMany).not.toHaveBeenCalled();
  });

  it('detalle: orden por fecha desc (estable), paginado, montos sin redondear', async () => {
    const p = prisma();
    const r = deSiempre(await new ReporteInteresesCobradosController(p).getDetalle(USER, '2026-11-01', '2026-11-07', undefined, undefined, '1', '2'));

    expect(p.factura_cuotas.findMany.mock.calls[0][0].where).toEqual({ id: { in: ['q3', 'q1'] } });
    expect(r).toEqual({
      data: [
        {
          id: 'i3',
          fecha: '2026-11-03',
          recibo: { id: 'r2', numero: 'R2' },
          cliente: { id: 'cli2', nombre: 'Beta SA' },
          cobrador: null,
          factura: '—',
          nro_cuota: null,
          vencimiento: null,
          dias_mora: 10,
          tasa_aplicada: 3.5,
          base_calculo: 10000.5,
          monto_bruto: 2000.6,
          monto_exonerado: 1000.1,
          monto_cobrado: 1000.5,
          monto_iva: 90.94,
          tipo_comprobante: 'FACTURA',
          emitido: false,
          autorizacion_descuento_id: 'aut1',
        },
        {
          id: 'i1',
          fecha: '2026-11-02',
          recibo: { id: 'r1', numero: 'R1' },
          cliente: { id: 'cli1', nombre: 'Alfa' },
          cobrador: { id: 'cob1', nombre: 'Ana' },
          factura: '001-001-0000007',
          nro_cuota: 1,
          vencimiento: '2026-10-01',
          dias_mora: 10,
          tasa_aplicada: 3.5,
          base_calculo: 10000.5,
          monto_bruto: 1000.4,
          monto_exonerado: 100.2,
          monto_cobrado: 900.2,
          monto_iva: 81.84,
          tipo_comprobante: 'FACTURA',
          emitido: true,
          autorizacion_descuento_id: null,
        },
      ],
      total: 3,
      page: 1,
      pageSize: 2,
      totalPages: 2,
    });
  });
});

describe('getCierreCobros (GET /cobros/reportes/cierre-cobros)', () => {
  const RECIBOS = [
    { recibo_id: 'r1', numero_recibo: 'R1', fecha: T('2026-11-02T00:00:00Z'), cliente_razon: 'Alfa SA', cobrador_nombre: 'Ana', usuario_nombre: 'Caja 1', modo: 'MULTI', monto_total: '1234.56', moneda_codigo: 'USD' },
    { recibo_id: 'r2', numero_recibo: 'R2', fecha: T('2026-11-02T00:00:00Z'), cliente_razon: 'Beta SA', cobrador_nombre: '', usuario_nombre: 'Caja 1', modo: 'MULTI', monto_total: '100000', moneda_codigo: null },
    { recibo_id: 'r3', numero_recibo: 'R3', fecha: T('2026-11-03T00:00:00Z'), cliente_razon: 'Gama SA', cobrador_nombre: 'Ana', usuario_nombre: 'Caja 2', modo: 'LEGACY', monto_total: '50000', moneda_codigo: 'PYG' },
  ];
  const LINEAS = [
    { recibo_id: 'r1', factura_cab_id: 'f1', monto_pagado: '1234.56', condicion_codigo: 1, dcuotas: null, cuotas_count: 1, avg_dias_intervalo: null },
    { recibo_id: 'r2', factura_cab_id: 'f2', monto_pagado: '60000', condicion_codigo: 2, dcuotas: 3, cuotas_count: 3, avg_dias_intervalo: 30 },
    { recibo_id: 'r2', factura_cab_id: 'f3', monto_pagado: '40000', condicion_codigo: 2, dcuotas: 1, cuotas_count: 1, avg_dias_intervalo: null },
    { recibo_id: 'r3', factura_cab_id: 'f4', monto_pagado: '50000', condicion_codigo: 2, dcuotas: 4, cuotas_count: 4, avg_dias_intervalo: 7 },
  ];
  const MEDIOS_MULTI = [
    { recibo_id: 'r1', medio: 'EFECTIVO', monto: '1234.56' },
    { recibo_id: 'r2', medio: 'Transferencia bancaria', monto: '100000' },
  ];
  const MEDIOS_LEGACY = [{ recibo_id: 'r3', medio: 'Cheque', monto: '50000' }];
  /** D-T4: moneda base + cabecera de los recibos (nula = base) para `resolverMonedaTablero`/`monedasDeRecibos`. */
  const conMoneda = (p: any) => ({
    ...MONEDA_MOCK,
    recibos_cobro: { findMany: jest.fn(recibosDeMonedaNula) },
    empresas_sucursales: { findFirst: jest.fn().mockResolvedValue({ id: SUC_X }) },
    ...p,
  });
  const SUC_X = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
  const M_PYG = '11111111-1111-4111-8111-111111111111';
  const servicio = (prisma: any) => new (CobrosService as any)(conMoneda(prisma)) as CobrosService;
  // El detalle por recibo (columnas por medio, retención, anulados) lo cubre src/cobros/cierre-cobros.spec.ts:
  // acá se caracteriza lo de siempre.
  const DETALLE_RECIBO = ['columnasRecibo', 'recibosAnulados', 'totalRetenciones', 'cliente_ruc', 'efectivo', 'cheque_al_dia', 'cheque_diferido', 'transferencia', 'tarjeta', 'nc_saldo_favor', 'otros', 'retencion', 'total_con_retencion'];
  const sinDetalle = (v: any): any => {
    if (Array.isArray(v)) return v.map(sinDetalle);
    if (!v || typeof v !== 'object' || v instanceof Date) return v;
    return Object.fromEntries(Object.entries(v).filter(([k]) => !DETALLE_RECIBO.includes(k)).map(([k, x]) => [k, sinDetalle(x)]));
  };
  const ceros = { Efectivo: 0, Cheque: 0, Transferencia: 0, Tarjeta: 0, 'NC / Saldo a favor': 0, Retención: 0, Otros: 0 };

  it('recibos, porDia, porCondicion, porMedio, porMonedaTotales y totalGeneral (que mezcla monedas)', async () => {
    const prisma = {
      $queryRaw: jest
        .fn()
        .mockResolvedValueOnce(RECIBOS)
        .mockResolvedValueOnce([]) // anulados del período (detalle por recibo)
        .mockResolvedValueOnce(LINEAS)
        .mockResolvedValueOnce(MEDIOS_MULTI)
        .mockResolvedValueOnce(MEDIOS_LEGACY),
    };
    const filtros = { fechaDesde: '2026-11-01', fechaHasta: '2026-11-07' };
    const r = await servicio(prisma).getCierreCobros('emp', filtros, 'usr');

    expect(sinDetalle(deSiempre(r))).toEqual({
      recibos: [
        { recibo_id: 'r1', numero_recibo: 'R1', fecha: '2026-11-02', cliente_razon: 'Alfa SA', cobrador_nombre: 'Ana', usuario_nombre: 'Caja 1', modo: 'MULTI', monto_total: 1234.56, moneda_codigo: 'USD' },
        { recibo_id: 'r2', numero_recibo: 'R2', fecha: '2026-11-02', cliente_razon: 'Beta SA', cobrador_nombre: '', usuario_nombre: 'Caja 1', modo: 'MULTI', monto_total: 100000, moneda_codigo: 'PYG' },
        { recibo_id: 'r3', numero_recibo: 'R3', fecha: '2026-11-03', cliente_razon: 'Gama SA', cobrador_nombre: 'Ana', usuario_nombre: 'Caja 2', modo: 'LEGACY', monto_total: 50000, moneda_codigo: 'PYG' },
      ],
      porDia: [
        { fecha: '2026-11-02', recibos: 2, total_cobrado: 101234.56, por_medio: { ...ceros, Efectivo: 1234.56, Transferencia: 100000 } },
        { fecha: '2026-11-03', recibos: 1, total_cobrado: 50000, por_medio: { ...ceros, Cheque: 50000 } },
      ],
      porCondicion: [
        { condicion: 'Mensual', cantidad_recibos: 1, cantidad_lineas: 1, monto: 60000 },
        { condicion: 'Semanal', cantidad_recibos: 1, cantidad_lineas: 1, monto: 50000 },
        { condicion: 'Contado / 1 pago', cantidad_recibos: 1, cantidad_lineas: 1, monto: 40000 },
        { condicion: 'Contado', cantidad_recibos: 1, cantidad_lineas: 1, monto: 1234.56 },
      ],
      porMedio: [
        { medio: 'Transferencia', monto: 100000 },
        { medio: 'Cheque', monto: 50000 },
        { medio: 'Efectivo', monto: 1234.56 },
      ],
      porMonedaTotales: [
        { codigo: 'PYG', monto: 150000 },
        { codigo: 'USD', monto: 1234.56 },
      ],
      totalGeneral: 151234.56,
      mediosBuckets: ['Efectivo', 'Cheque', 'Transferencia', 'Tarjeta', 'NC / Saldo a favor', 'Retención', 'Otros'],
      filtros,
    });
  });

  it('sin recibos: forma vacía y no consulta líneas ni medios', async () => {
    const prisma = { $queryRaw: jest.fn().mockResolvedValueOnce([]).mockResolvedValueOnce([]) };
    const r = await servicio(prisma).getCierreCobros('emp', { monedaId: M_PYG }, 'usr');
    expect(sinDetalle(deSiempre(r))).toEqual({
      recibos: [],
      porDia: [],
      porCondicion: [],
      porMedio: [],
      totalGeneral: 0,
      mediosBuckets: [],
      porMonedaTotales: [],
      filtros: { monedaId: M_PYG },
    });
    expect(prisma.$queryRaw).toHaveBeenCalledTimes(2); // emitidos + anulados
  });

  // D-T4 (cambio a propósito): con la moneda base entra el recibo de moneda nula, como el Tablero (antes era igualdad
  // y la base perdía esos recibos); la sucursal pedida se valida contra el alcance (acá, de la empresa) y va al SQL.
  it('SQL: solo emitidos; monedaId base incluye la nula (Tablero) y sucursalId validada', async () => {
    const prisma = { $queryRaw: jest.fn().mockResolvedValueOnce([]).mockResolvedValueOnce([]) };
    await servicio(prisma).getCierreCobros('emp', { cobradorId: 'cob1', sucursalId: SUC_X, monedaId: M_PYG }, 'usr');
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.text).toMatch(/r\.estado = \$2/);
    expect(q.text).toMatch(/AND \(r\.moneda_id = \$\d+::uuid OR r\.moneda_id IS NULL\)/);
    expect(q.text).toMatch(/AND r\.sucursal_id = \$\d+::uuid/);
    expect(q.values).toEqual(['emp', 'emitido', 'cob1', SUC_X, 'm-pyg']);
  });

  it('SQL de líneas y medios (MULTI + LEGACY): montos, uniones y agrupados de hoy', async () => {
    const prisma = {
      $queryRaw: jest
        .fn()
        .mockResolvedValueOnce(RECIBOS)
        .mockResolvedValueOnce([]) // anulados del período (detalle por recibo)
        .mockResolvedValueOnce(LINEAS)
        .mockResolvedValueOnce(MEDIOS_MULTI)
        .mockResolvedValueOnce(MEDIOS_LEGACY),
    };
    await servicio(prisma).getCierreCobros('emp', { fechaDesde: '2026-11-01', fechaHasta: '2026-11-07' }, 'usr');
    expect(prisma.$queryRaw).toHaveBeenCalledTimes(5); // emitidos, anulados, líneas, medios MULTI y LEGACY

    const recibos = textoDe(prisma.$queryRaw.mock.calls[0]);
    contieneTodo(recibos, [
      'r.monto_total, r.total_retenciones, m.codigo AS moneda_codigo',
      'FROM recibos_cobro r JOIN clientes cl ON cl.id = r.cliente_id JOIN personas p ON p.id = cl.persona_id',
      'LEFT JOIN moneda m ON m.id = r.moneda_id',
      'WHERE r.empresa_id = $1::uuid AND r.estado = $2',
      'AND r.fecha_emision::date >= $3::date AND r.fecha_emision::date <= $4::date',
      'ORDER BY r.fecha_emision ASC',
    ]);
    expect(sqlDe(prisma.$queryRaw.mock.calls[0]).values).toEqual(['emp', 'emitido', '2026-11-01', '2026-11-07']);

    const ids = ['r1', 'r2', 'r3'];
    const lineas = textoDe(prisma.$queryRaw.mock.calls[2]);
    contieneTodo(lineas, [
      'SELECT rf.recibo_cobro_id AS recibo_id, rf.factura_cab_id, rf.monto_pagado FROM recibo_cobro_facturas rf WHERE rf.recibo_cobro_id IN ($1::uuid,$2::uuid,$3::uuid) UNION ALL',
      'SELECT rcd.recibo_cobro_id AS recibo_id, fcu.factura_cab_id, rcd.monto_pagado FROM recibo_cobro_detalle rcd JOIN factura_cuotas fcu ON fcu.id = rcd.factura_cuota_id WHERE rcd.recibo_cobro_id IN ($4::uuid,$5::uuid,$6::uuid)',
      'COUNT(*)::int AS cuotas_count',
      'ELSE ((MAX(dvenccuo) - MIN(dvenccuo))::numeric / NULLIF(COUNT(*) - 1, 0))::int',
      'FROM factura_cuotas WHERE factura_cab_id IN (SELECT DISTINCT factura_cab_id FROM lineas) GROUP BY factura_cab_id',
      'JOIN factura_cab cab ON cab.id = l.factura_cab_id LEFT JOIN condicion_operacion co ON co.id = cab.condicion_operacion_id',
    ]);
    expect(sqlDe(prisma.$queryRaw.mock.calls[2]).values).toEqual([...ids, ...ids]);

    const multi = textoDe(prisma.$queryRaw.mock.calls[3]);
    expect(multi).toBe(
      // `diferido`: el cheque con vencimiento posterior al recibo (columna Cheque diferido del detalle por recibo).
      'SELECT mp.recibo_cobro_id AS recibo_id, mp.medio, mp.monto, COALESCE(mp.cheque_fecha_vencimiento > r.fecha_emision::date, false) AS diferido FROM recibo_cobro_medios_pago mp JOIN recibos_cobro r ON r.id = mp.recibo_cobro_id WHERE mp.recibo_cobro_id IN ($1::uuid,$2::uuid,$3::uuid)',
    );
    expect(sqlDe(prisma.$queryRaw.mock.calls[3]).values).toEqual(ids);

    const legacy = textoDe(prisma.$queryRaw.mock.calls[4]);
    expect(legacy).toBe(
      "SELECT rcd.recibo_cobro_id AS recibo_id, COALESCE(mp.descripcion, 'Otro') AS medio, SUM(rcd.monto_pagado)::text AS monto FROM recibo_cobro_detalle rcd LEFT JOIN medio_pago mp ON mp.id = rcd.medio_pago_id WHERE rcd.recibo_cobro_id IN ($1::uuid,$2::uuid,$3::uuid) GROUP BY rcd.recibo_cobro_id, mp.descripcion",
    );
    expect(sqlDe(prisma.$queryRaw.mock.calls[4]).values).toEqual(ids);
  });

  it('PDF: pasa la empresa, los filtros tal cual y (D-T4) el usuario a getCierreCobros', async () => {
    const s = servicio({});
    const espia = jest.spyOn(s, 'getCierreCobros').mockRejectedValue(new Error('corte'));
    const filtros = { fechaDesde: '2026-11-01', fechaHasta: '2026-11-07', cobradorId: 'cob1', sucursalId: 'suc-x', monedaId: 'm-usd' };
    await expect(s.exportarCierreCobrosPDF('emp', filtros, 'usr')).rejects.toThrow('corte');
    expect(espia).toHaveBeenCalledWith('emp', filtros, 'usr');
  });
});

describe('getDashboardMorosidad (GET /cobros/morosidad/dashboard)', () => {
  /*
   * D-T5 R2 (A PROPÓSITO, cambia campos de siempre): el vencido sale de la cartera del Tablero (`carteraPendiente`:
   * factura cobrable, NC prorrateadas sobre las cuotas más viejas; lo que vence hoy está al día) en vez de las 2
   * consultas SQL de cuotas, que sumaban `saldo_pendiente` sin descontar NC, contaban lo que vence hoy y (hasta R1) las
   * facturas anuladas. Así Morosidad y el Tablero dan el mismo saldo vencido. La forma de la respuesta no cambia; el
   * tramo '0-30' pasa a ser 1 a 30 días y `resumen.total_vencido` incluye la cuota sin cliente (como el Tablero).
   * La mora cobrada (2 consultas sobre recibos) sigue igual.
   */
  const hoyMenos = (dias: number) => {
    const h = new Date();
    h.setHours(0, 0, 0, 0);
    const d = new Date(Date.UTC(h.getFullYear(), h.getMonth(), h.getDate()));
    d.setUTCDate(d.getUTCDate() - dias);
    return d;
  };
  const cuota = (id: string, cliente: string | null, saldo: string, dias: number, nc: string | null = null, factura = `f-${id}`) => ({
    id,
    dvenccuo: hoyMenos(dias),
    saldo_pendiente: D(saldo),
    dmoncuota: D(saldo),
    estado: 'Pendiente',
    factura_cab: {
      id: factura,
      moneda_id: null,
      dticam: null,
      total_notas_credito: nc === null ? null : D(nc),
      clientes: cliente ? { id: cliente, personas: { razon_social: `Cliente ${cliente}` } } : null,
    },
  });

  it('resumen, aging y top 10 desde la cartera del Tablero; mora tal cual del SQL', async () => {
    const cuotas = Array.from({ length: 12 }, (_, i) => cuota(`q${i}`, `c${i}`, String(1000.5 * (12 - i)), 40));
    cuotas.push(cuota('qh', 'c0', '999', 0)); // vence hoy: al día
    cuotas.push(cuota('qn', 'c0', '500', 100, '200')); // con NC: suma 300
    const moraPorMes = [{ mes: '2026-10', mora_cobrada: 300.25 }];
    const prisma = {
      factura_cuotas: { findMany: jest.fn().mockResolvedValue(cuotas) },
      $queryRaw: jest.fn().mockResolvedValueOnce([{ mora_mes: 1500.5, mora_anio: 9000 }]).mockResolvedValueOnce(moraPorMes).mockResolvedValue([]),
      ...MONEDA_MOCK,
    };
    const r: any = await (new (CobrosService as any)(prisma) as CobrosService).getDashboardMorosidad('emp', {}, 'usr');
    expect(deSiempre(r)).toEqual({
      resumen: { total_vencido: 78039 + 300, clientes_morosos: 12, mora_cobrada_mes: 1500.5, mora_cobrada_anio: 9000 },
      aging_buckets: [
        { bucket: '31-60', total_vencido: 78039, cantidad: 12 },
        { bucket: '90+', total_vencido: 300, cantidad: 1 },
      ],
      mora_por_mes: moraPorMes,
      top_morosos: [
        { cliente_id: 'c0', razon_social: 'Cliente c0', total_vencido: 1000.5 * 12 + 300, dias_promedio_vencimiento: 70, cuotas_vencidas: 2 },
        ...Array.from({ length: 9 }, (_, j) => ({
          cliente_id: `c${j + 1}`,
          razon_social: `Cliente c${j + 1}`,
          total_vencido: 1000.5 * (11 - j),
          dias_promedio_vencimiento: 40,
          cuotas_vencidas: 1,
        })),
      ],
    });
  });

  it('cartera: where del Tablero (+ cuotas anuladas fuera); SQL de las 2 consultas de mora de hoy', async () => {
    const prisma = { factura_cuotas: { findMany: jest.fn().mockResolvedValue([]) }, $queryRaw: jest.fn().mockResolvedValue([]), ...MONEDA_MOCK };
    await (new (CobrosService as any)(prisma) as CobrosService).getDashboardMorosidad('emp', {}, 'usr');
    const args = prisma.factura_cuotas.findMany.mock.calls[0][0];
    expect(args.where.factura_cab).toEqual({ empresa_id: 'emp', estado: { notIn: ESTADOS_FACTURA_NO_COBRABLE_PRISMA } });
    expect(args.where.estado.notIn).toEqual(expect.arrayContaining(['pagado', 'Pagado', 'anulado', 'Anulado']));
    expect(args.orderBy).toEqual({ dvenccuo: 'asc' });

    // 2 de mora (siempre) + 1 de recibos con mora para `en_moneda`.
    expect(prisma.$queryRaw).toHaveBeenCalledTimes(3);
    const [mora, porMes] = prisma.$queryRaw.mock.calls.slice(0, 2).map(textoDe);
    for (const call of prisma.$queryRaw.mock.calls.slice(0, 2)) expect(sqlDe(call).values).toEqual(['emp']);
    contieneTodo(mora, [
      "COALESCE(SUM(CASE WHEN DATE_TRUNC('month', r.fecha_emision) = DATE_TRUNC('month', NOW()) THEN r.mora_total ELSE 0 END), 0)::float AS mora_mes",
      'COALESCE(SUM(CASE WHEN EXTRACT(year FROM r.fecha_emision) = EXTRACT(year FROM NOW()) THEN r.mora_total ELSE 0 END), 0)::float AS mora_anio',
      "FROM recibos_cobro r WHERE r.empresa_id = $1::uuid AND r.estado != 'anulado' AND r.mora_total > 0",
    ]);
    contieneTodo(porMes, [
      "TO_CHAR(DATE_TRUNC('month', r.fecha_emision), 'YYYY-MM') AS mes",
      'COALESCE(SUM(r.mora_total), 0)::float AS mora_cobrada',
      "WHERE r.empresa_id = $1::uuid AND r.estado != 'anulado' AND r.fecha_emision >= NOW() - INTERVAL '6 months'",
      "GROUP BY DATE_TRUNC('month', r.fecha_emision) ORDER BY DATE_TRUNC('month', r.fecha_emision) ASC",
    ]);
  });

  it('sin cartera ni mora cobrada (fila ausente) → 0', async () => {
    const prisma = { factura_cuotas: { findMany: jest.fn().mockResolvedValue([]) }, $queryRaw: jest.fn().mockResolvedValue([]), ...MONEDA_MOCK };
    const r = await (new (CobrosService as any)(prisma) as CobrosService).getDashboardMorosidad('emp', {}, 'usr');
    expect(deSiempre(r)).toEqual({
      resumen: { total_vencido: 0, clientes_morosos: 0, mora_cobrada_mes: 0, mora_cobrada_anio: 0 },
      aging_buckets: [],
      mora_por_mes: [],
      top_morosos: [],
    });
  });
});

describe('PromesasService: getReporteCumplimiento y getDashboardCashflow', () => {
  const servicio = (prisma: any) => new PromesasService(prisma, {} as any);

  it('cumplimiento: por cobrador en orden de aparición, montos sin redondear, tasa sin redondear', async () => {
    const prisma = {
      promesas_pago: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'p1', estado: 'cumplida', cobrador_id: 'cob1', monto_prometido: D('1000.5'), monto_cumplido: D('1000.5'), cobrador: { id: 'cob1', nombre: 'Ana', apellido: null } },
          { id: 'p2', estado: 'pendiente', cobrador_id: null, monto_prometido: D('100'), monto_cumplido: D('0'), cobrador: null },
          { id: 'p3', estado: 'cumplida_parcial', cobrador_id: 'cob1', monto_prometido: D('2000'), monto_cumplido: D('500'), cobrador: { id: 'cob1', nombre: 'Ana', apellido: null } },
          { id: 'p4', estado: 'incumplida', cobrador_id: 'cob1', monto_prometido: D('300'), monto_cumplido: null, cobrador: { id: 'cob1', nombre: 'Ana', apellido: null } },
        ]),
      },
      ...MONEDA_MOCK,
    };
    const r = deSiempre(await servicio(prisma).getReporteCumplimiento('emp', '2026-11-01', '2026-11-30', {}, 'usr'));
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where).toEqual({
      empresa_id: 'emp',
      fecha_prometida: { gte: new Date('2026-11-01'), lte: new Date('2026-11-30') },
    });
    expect(r).toEqual({
      total_promesas: 4,
      por_cobrador: [
        {
          cobrador_id: 'cob1',
          cobrador_nombre: 'Ana',
          total: 3,
          cumplidas: 1,
          cumplidas_parciales: 1,
          incumplidas: 1,
          canceladas: 0,
          renegociadas: 0,
          pendientes: 0,
          monto_prometido: 3300.5,
          monto_cumplido: 1500.5,
          tasa_cumplimiento: (2 / 3) * 100,
        },
        {
          cobrador_id: null,
          cobrador_nombre: '— Sin cobrador',
          total: 1,
          cumplidas: 0,
          cumplidas_parciales: 0,
          incumplidas: 0,
          canceladas: 0,
          renegociadas: 0,
          pendientes: 1,
          monto_prometido: 100,
          monto_cumplido: 0,
          tasa_cumplimiento: 0,
        },
      ],
    });
  });

  it('cumplimiento sin rango: sin filtro de fecha', async () => {
    const prisma = { promesas_pago: { findMany: jest.fn().mockResolvedValue([]) }, ...MONEDA_MOCK };
    expect(deSiempre(await servicio(prisma).getReporteCumplimiento('emp', undefined, undefined, {}, 'usr'))).toEqual({ total_promesas: 0, por_cobrador: [] });
    expect(prisma.promesas_pago.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp' });
  });

  it('cashflow: pendientes desde hoy, sumadas por fecha en orden', async () => {
    const prisma = {
      promesas_pago: {
        findMany: jest.fn().mockResolvedValue([
          { fecha_prometida: T('2026-11-10T00:00:00Z'), monto_prometido: D('1000.5') },
          { fecha_prometida: T('2026-11-10T00:00:00Z'), monto_prometido: D('99.5') },
          { fecha_prometida: T('2026-11-12T00:00:00Z'), monto_prometido: null },
        ]),
      },
      ...MONEDA_MOCK,
    };
    const r = deSiempre(await servicio(prisma).getDashboardCashflow('emp', {}, 'usr'));
    const args = prisma.promesas_pago.findMany.mock.calls[0][0];
    expect(args.where.empresa_id).toBe('emp');
    expect(args.where.estado).toBe('pendiente');
    expect(args.where.fecha_prometida.gte).toBeInstanceOf(Date);
    expect(args.orderBy).toEqual({ fecha_prometida: 'asc' });
    expect(r).toEqual({
      total_pendiente: 1100,
      total_promesas: 3,
      proyeccion: [
        { fecha: '2026-11-10', monto: 1100 },
        { fecha: '2026-11-12', monto: 0 },
      ],
    });
  });
});

describe('RecibosService.libroRetenciones (GET /retenciones/libro)', () => {
  it('filas del SQL tal cual; solo MULTI emitidos del año/mes del comprobante', async () => {
    const filas = [{ retencion_id: 'ret1', recibo_id: 'r1', monto: D('1500.5'), declarada: false }];
    const prisma = { $queryRaw: jest.fn().mockResolvedValue(filas), ...MONEDA_MOCK, recibos_cobro: { findMany: jest.fn(recibosDeMonedaNula) } };
    const r = await new RecibosService(prisma as any, {} as any, {} as any).libroRetenciones('emp', '2026-11', {}, 'usr');
    // D-T5: cada fila suma la moneda de su recibo (nula = base); el resto de la fila, tal cual del SQL.
    expect(r).toEqual([{ ...filas[0], moneda_codigo: 'PYG', moneda_cotizacion: null }]);
    const q = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(q.sql).toMatch(/rm\.modo = 'MULTI'/);
    expect(q.sql).toMatch(/rm\.estado = 'emitido'/);
    expect(q.sql).toMatch(/r\.id AS retencion_id/);
    expect(q.sql).toMatch(/r\.declarada_set AS declarada/);
    expect(q.sql).toMatch(/ORDER BY r\.fecha_comprobante, rm\.numero_recibo/);
    expect(q.values).toEqual(['emp', 2026, 11]);
  });
});

describe('RendicionesService: reportes', () => {
  const rendicion = (o: Record<string, unknown>) => ({
    cobrador_id: 'cob1',
    cobrador: { id: 'cob1', nombre: 'Ana', apellido: null },
    cantidad_recibos: 0,
    monto_cobrado: null,
    monto_efectivo: null,
    monto_cheque: null,
    monto_transferencia: null,
    monto_tarjeta: null,
    total_declarado: null,
    total_verificado: null,
    diferencia: null,
    ...o,
  });
  // D-T4: moneda base + `recibos_cobro` para la moneda de las comisiones; la de las rendiciones sale de `moneda_id`.
  const prismaRend = (rows: any[]) => ({
    ...MONEDA_MOCK,
    empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'empresa' }) },
    rendiciones_cobranza: { findMany: jest.fn().mockResolvedValue(rows) },
    recibos_cobro: { findMany: jest.fn(recibosDeMonedaNula) },
    $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 'v1' }]),
  });

  it('cobranzas-dia: por cobrador (orden por total cobrado), RECHAZADO sin monto, BORRADOR con monto, 2 decimales', async () => {
    const prisma = prismaRend([
      rendicion({
        estado: 'APROBADO',
        cantidad_recibos: 2,
        monto_cobrado: D('1000.5'),
        monto_efectivo: D('500.25'),
        monto_transferencia: D('500.25'),
        monto_tarjeta: D('0'),
        total_declarado: D('1000.5'),
        diferencia: D('0'),
      }),
      rendicion({ estado: 'RECHAZADO', cantidad_recibos: 5, monto_cobrado: D('999'), total_declarado: D('999') }),
      rendicion({ estado: 'BORRADOR', cantidad_recibos: 1, monto_cobrado: D('10'), monto_efectivo: D('10'), total_declarado: D('10') }),
      rendicion({
        cobrador_id: 'cob2',
        cobrador: { id: 'cob2', nombre: 'Beto', apellido: 'Paz' },
        estado: 'PENDIENTE',
        cantidad_recibos: 1,
        monto_cobrado: D('2000'),
        monto_efectivo: D('2000'),
        total_declarado: D('2000'),
        total_verificado: D('1990.1'),
        diferencia: D('-9.9'),
      }),
    ]);
    const r = deSiempre(await new RendicionesService(prisma as any).reporteCobranzasDia('emp', '2026-11-01', '2026-11-07'));

    expect(prisma.rendiciones_cobranza.findMany.mock.calls[0][0]).toEqual({
      where: {
        empresa_id: 'emp',
        deleted_at: null,
        fecha_cobranza: { gte: new Date('2026-11-01'), lte: new Date('2026-11-07') },
        estado: { notIn: ['ANULADO'] },
      },
      include: { cobrador: { select: { id: true, nombre: true, apellido: true } } },
      orderBy: [{ cobrador_id: 'asc' }, { fecha_rendicion: 'asc' }],
    });
    const cero = { aprobadas: 0, pendientes: 0, observadas: 0, rechazadas: 0 };
    expect(r).toEqual({
      fecha_desde: '2026-11-01',
      fecha_hasta: '2026-11-07',
      fecha: '2026-11-01',
      por_cobrador: [
        {
          cobrador_id: 'cob2',
          cobrador: 'Beto Paz',
          rendiciones: 1,
          recibos: 1,
          total_cobrado: 2000,
          total_efectivo: 2000,
          total_cheque: 0,
          total_transferencia: 0,
          total_tarjeta: 0,
          declarado: 2000,
          verificado: 1990.1,
          diferencia: -9.9,
          ...cero,
          pendientes: 1,
        },
        {
          cobrador_id: 'cob1',
          cobrador: 'Ana',
          rendiciones: 3,
          recibos: 3,
          total_cobrado: 1010.5,
          total_efectivo: 510.25,
          total_cheque: 0,
          total_transferencia: 500.25,
          total_tarjeta: 0,
          declarado: 1010.5,
          verificado: 1010.5,
          diferencia: 0,
          ...cero,
          aprobadas: 1,
          rechazadas: 1,
        },
      ],
      totales: {
        rendiciones: 4,
        recibos: 4,
        total_cobrado: 3010.5,
        total_efectivo: 2510.25,
        total_cheque: 0,
        total_transferencia: 500.25,
        total_tarjeta: 0,
        declarado: 3010.5,
        verificado: 3000.6,
        diferencia: -9.9,
      },
    });
  });

  it('pendientes: PENDIENTE/OBSERVADO con antigüedad desde el envío (o la rendición), montos crudos', async () => {
    jest.spyOn(Date, 'now').mockReturnValue(T('2026-11-07T12:00:00Z').getTime());
    const prisma = prismaRend([
      rendicion({
        id: 'rd1',
        codigo: 'RND-1',
        estado: 'PENDIENTE',
        fecha_cobranza: T('2026-11-01T00:00:00Z'),
        fecha_rendicion: T('2026-11-01T10:00:00Z'),
        fecha_envio_tesoreria: T('2026-11-05T11:00:00Z'),
        total_declarado: D('1000.5'),
        monto_cobrado: D('1000.5'),
        cantidad_recibos: 2,
      }),
      rendicion({
        id: 'rd2',
        codigo: 'RND-2',
        cobrador: null,
        estado: 'OBSERVADO',
        fecha_cobranza: T('2026-11-06T00:00:00Z'),
        fecha_rendicion: T('2026-11-07T02:30:00Z'),
        fecha_envio_tesoreria: null,
      }),
    ]);
    // D-T4 suma `moneda` por fila (se quita acá; `deSiempre` no sirve con los Decimal crudos).
    const r = (await new RendicionesService(prisma as any).reportePendientes('emp')).map((fila) => {
      const { moneda, ...deSiempreFila } = fila;
      expect(moneda).toEqual({ codigo: 'PYG' });
      return deSiempreFila;
    });
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[0][0].where).toEqual({
      empresa_id: 'emp',
      deleted_at: null,
      estado: { in: ['PENDIENTE', 'OBSERVADO'] },
    });
    expect(prisma.rendiciones_cobranza.findMany.mock.calls[0][0].orderBy).toEqual({ fecha_envio_tesoreria: 'asc' });
    expect(r).toEqual([
      {
        id: 'rd1',
        codigo: 'RND-1',
        cobrador_id: 'cob1',
        cobrador: 'Ana',
        fecha_cobranza: T('2026-11-01T00:00:00Z'),
        fecha_envio_tesoreria: T('2026-11-05T11:00:00Z'),
        estado: 'PENDIENTE',
        total_declarado: D('1000.5'),
        monto_cobrado: D('1000.5'),
        cantidad_recibos: 2,
        antiguedad_horas: 49,
        antiguedad_dias: 2,
      },
      {
        id: 'rd2',
        codigo: 'RND-2',
        cobrador_id: 'cob1',
        cobrador: '—',
        fecha_cobranza: T('2026-11-06T00:00:00Z'),
        fecha_envio_tesoreria: null,
        estado: 'OBSERVADO',
        total_declarado: null,
        monto_cobrado: null,
        cantidad_recibos: 0,
        antiguedad_horas: 9,
        antiguedad_dias: 0,
      },
    ]);
    (Date.now as jest.Mock).mockRestore();
  });

  // D-T4 (cambio a propósito): diferencias deja de ser un array; las filas de siempre van en `filas` y al lado
  // `moneda`/`sin_moneda`/`por_moneda` (el front viejo lee `filas`). Comisiones sigue siendo un array (+ `moneda`).
  it('diferencias y comisiones: filas de la vista tal cual, con sus filtros', async () => {
    const prisma = prismaRend([]);
    const s = new RendicionesService(prisma as any);
    expect(deSiempre((await s.reporteDiferencias('emp', { nivel: 'mayor', fecha_desde: '2026-11-01', fecha_hasta: '2026-11-07' })).filas)).toEqual([{ id: 'v1' }]);
    expect(prisma.$queryRawUnsafe.mock.calls[0]).toEqual([
      'SELECT * FROM vw_rendiciones_diferencias WHERE empresa_id::text = ANY($1::text[]) AND nivel = $2 AND fecha_rendicion >= $3 AND fecha_rendicion <= $4 ORDER BY diferencia_abs DESC LIMIT 500',
      ['emp'],
      'mayor',
      new Date('2026-11-01'),
      new Date('2026-11-07'),
    ]);
    expect(deSiempre(await s.reporteComisionesLiquidar('emp', 'cob1'))).toEqual([{ id: 'v1' }]);
    expect(prisma.$queryRawUnsafe.mock.calls[1]).toEqual([
      'SELECT * FROM vw_comisiones_a_liquidar WHERE empresa_id::text = ANY($1::text[]) AND cobrador_id = $2::uuid ORDER BY fecha_aprobacion DESC NULLS LAST LIMIT 1000',
      ['emp'],
      'cob1',
    ]);
  });
});
