/**
 * Carril D de Reportes, T2: el reporte por cobrador con moneda como el Tablero (aditivo). Los campos de siempre no
 * cambian (los fija `reportes-cobranza-caracterizacion.spec.ts`); al lado van `moneda`, `convertido`, `sin_cotizacion`,
 * `sin_moneda`, `en_moneda` y `por_moneda`. La moneda del recibo es la de su cabecera (nula = base, `monedasDeRecibos`);
 * la de una cuota pendiente, la de su factura (`factura_cab.moneda_id`, cotización `dticam`).
 */
import { Prisma } from '@prisma/client';
import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { ReporteCobradorController } from './reporte-cobrador.controller';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

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

const PYG = '11111111-1111-4111-8111-111111111111';
const USD = '22222222-2222-4222-8222-222222222222';
const AJENA = '33333333-3333-4333-8333-333333333333';
const CODIGOS: Record<string, string> = { [PYG]: 'PYG', [USD]: 'USD' };
const USER = { id: 'usr', empresa_id: 'emp' } as any;
const D = (v: string) => new Prisma.Decimal(v);
const T = (iso: string) => new Date(iso);

type Recibo = {
  id: string;
  cobrador_id: string;
  estado: string;
  moneda_id: string | null;
  cotizacion: Prisma.Decimal | null;
  monto_total: Prisma.Decimal;
  descuento_monto: Prisma.Decimal | null;
  mora_total: Prisma.Decimal | null;
  fecha_emision: Date;
};
const rec = (id: string, moneda_id: string | null, cot: string | null, monto: string, extra: Partial<Recibo> = {}): Recibo => ({
  id,
  cobrador_id: 'cob1',
  estado: 'emitido',
  moneda_id,
  cotizacion: cot === null ? null : D(cot),
  monto_total: D(monto),
  descuento_monto: null,
  mora_total: null,
  fecha_emision: T('2026-11-02T12:00:00Z'),
  ...extra,
});

/** Un plan de cuotas pendientes: `pendientes` cuotas por `monto` en total, `vencidas` de ellas vencidas, de una factura. */
type Plan = { id: string; cobrador_id: string; moneda_id: string | null; dticam: string | null; monto: string; pendientes: number; vencidas: number };

function prismaMock(recibos: Recibo[], planes: Plan[] = []) {
  const deEmpresa = recibos.map((r) => ({ ...r, empresa_id: 'emp' }));
  return {
    empresas_sucursales: { findFirst: jest.fn().mockResolvedValue(null), findMany: jest.fn().mockResolvedValue([]) },
    vendedores_cobradores: { findMany: jest.fn().mockResolvedValue([{ id: 'cob1', nombre: 'Ana', apellido: null }]) },
    recibos_cobro: {
      findMany: jest.fn((a: any) => {
        const w = a.where;
        if (w.id?.in) return Promise.resolve(deEmpresa.filter((r) => w.id.in.includes(r.id)));
        return Promise.resolve(
          deEmpresa.filter(
            (r) =>
              (!w.cobrador_id || r.cobrador_id === w.cobrador_id) &&
              r.estado !== w.estado?.not &&
              (!w.AND || w.AND.every((c: any) => (c.OR ? c.OR.some((o: any) => o.moneda_id === r.moneda_id) : c.moneda_id === r.moneda_id))),
          ),
        );
      }),
      count: jest.fn().mockResolvedValue(0),
    },
    cuotas_calculadas_detalle: {
      groupBy: jest.fn((a: any) => {
        const cob = a.where.cuotas_calculadas.factura_cab.OR[0].cobrador_id;
        const vencidas = Boolean(a.where.fecha_vencimiento);
        return Promise.resolve(
          planes
            .filter((p) => p.cobrador_id === cob && (vencidas ? p.vencidas : p.pendientes) > 0)
            .map((p) => ({
              cuota_calculada_id: p.id,
              _sum: { monto_cuota: vencidas ? null : D(p.monto) },
              _count: { _all: vencidas ? p.vencidas : p.pendientes },
            })),
        );
      }),
    },
    cuotas_calculadas: {
      findMany: jest.fn((a: any) =>
        Promise.resolve(
          planes
            .filter((p) => a.where.id.in.includes(p.id))
            .map((p) => ({ id: p.id, factura_cab: { moneda_id: p.moneda_id, dticam: p.dticam === null ? null : D(p.dticam) } })),
        ),
      ),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue(null),
      findUnique: jest.fn((a: any) => Promise.resolve(CODIGOS[a.where.id] ? { id: a.where.id, codigo: CODIGOS[a.where.id] } : null)),
      findMany: jest.fn((a: any) =>
        Promise.resolve((a.where.id.in as string[]).filter((id) => CODIGOS[id]).map((id) => ({ id, codigo: CODIGOS[id] }))),
      ),
    },
  } as any;
}

const porCobrador = (p: any, monedaId?: string, sucursalId?: string) =>
  new ReporteCobradorController(p).getPorCobrador(USER, '2026-11-01', '2026-11-07', sucursalId, monedaId);

beforeEach(() => alcanceMock.mockResolvedValue(null));

describe('GET /reporte-cobrador/por-cobrador con moneda', () => {
  const RECIBOS = [
    rec('r-pyg', PYG, null, '100000', { mora_total: D('500') }),
    rec('r-usd', USD, '7300', '50.25', { descuento_monto: D('1.5'), fecha_emision: T('2026-11-03T12:00:00Z') }),
  ];

  it('sin moneda_id: convierte cada recibo con su cotización; por_moneda sin convertir; campos de siempre como hoy', async () => {
    const r: any = await porCobrador(prismaMock(RECIBOS));
    const c = r.cobradores[0];

    // Campos de siempre: tal cual hoy (suman monedas y redondean a entero; los nuevos corrigen eso al lado).
    expect(c.cobros).toEqual({
      total_cobrado: 100050,
      total_descuentos: 2,
      total_mora_cobrada: 500,
      cantidad_cobros: 2,
      promedio_por_cobro: 50025,
      dias_activos: 2,
      promedio_diario: 50025,
    });

    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.sin_moneda).toBe(0);
    expect(c.en_moneda.cobros).toEqual({
      total_cobrado: 100000 + 366825,
      total_descuentos: 10950,
      total_mora_cobrada: 500,
      cantidad_cobros: 2,
      promedio_por_cobro: 233412.5,
      dias_activos: 2,
      promedio_diario: 233412.5,
    });
    expect(c.por_moneda).toEqual([
      { codigo: 'PYG', total_cobrado: '100000.00', total_descuentos: '0.00', total_mora_cobrada: '500.00', monto_pendiente: '0.00' },
      { codigo: 'USD', total_cobrado: '50.25', total_descuentos: '1.50', total_mora_cobrada: '0.00', monto_pendiente: '0.00' },
    ]);
    expect(r.por_moneda).toEqual(c.por_moneda);
    expect(r.en_moneda.totales).toMatchObject({ total_cobrado: 466825, total_descuentos: 10950, total_mora_cobrada: 500, monto_pendiente: 0 });
  });

  it('con moneda_id=USD: solo el USD, sin convertir y sin redondear', async () => {
    const r: any = await porCobrador(prismaMock(RECIBOS), USD);
    const c = r.cobradores[0];
    expect(r.moneda).toEqual({ codigo: 'USD' });
    expect(r.convertido).toBe(false);
    expect(c.en_moneda.cobros).toMatchObject({ total_cobrado: 50.25, total_descuentos: 1.5, cantidad_cobros: 1, dias_activos: 1, promedio_por_cobro: 50.25 });
    expect(c.por_moneda).toEqual([
      { codigo: 'USD', total_cobrado: '50.25', total_descuentos: '1.50', total_mora_cobrada: '0.00', monto_pendiente: '0.00' },
    ]);
    // Las cantidades de siempre no dependen de la moneda.
    expect(c.cobros.cantidad_cobros).toBe(2);
  });

  it('con moneda_id = la base: incluye el recibo de moneda nula (como el Tablero)', async () => {
    const r: any = await porCobrador(prismaMock([...RECIBOS, rec('r-nulo', null, null, '700')]), PYG);
    expect(r.cobradores[0].en_moneda.cobros).toMatchObject({ total_cobrado: 100700, cantidad_cobros: 2 });
    expect(r.por_moneda.map((f: any) => f.codigo)).toEqual(['PYG']);
  });

  it('USD con cotización 1: fuera de en_moneda (sin_cotizacion), dentro de por_moneda', async () => {
    const r: any = await porCobrador(prismaMock([RECIBOS[0], rec('r-usd1', USD, '1', '80')]));
    expect(r.sin_cotizacion).toBe(1);
    expect(r.cobradores[0].en_moneda.cobros).toMatchObject({ total_cobrado: 100000, cantidad_cobros: 1 });
    expect(r.por_moneda.find((f: any) => f.codigo === 'USD').total_cobrado).toBe('80.00');
  });

  it('recibo de una moneda sin código: cuenta en sin_moneda, fuera de en_moneda y por_moneda', async () => {
    const r: any = await porCobrador(prismaMock([RECIBOS[0], rec('r-raro', AJENA, '5', '10')]));
    expect(r.sin_moneda).toBe(1);
    expect(r.cobradores[0].en_moneda.cobros.total_cobrado).toBe(100000);
    expect(r.por_moneda.map((f: any) => f.codigo)).toEqual(['PYG']);
  });

  it('recibo anulado no suma en ningún bloque', async () => {
    const r: any = await porCobrador(prismaMock([...RECIBOS, rec('r-anu', PYG, null, '999', { estado: 'anulado' })]));
    expect(r.cobradores[0].en_moneda.cobros.total_cobrado).toBe(466825);
    expect(r.por_moneda.find((f: any) => f.codigo === 'PYG').total_cobrado).toBe('100000.00');
  });

  it('cuotas pendientes de una factura USD van a USD (no a PYG), convertidas con su dticam', async () => {
    const planes: Plan[] = [
      { id: 'p-pyg', cobrador_id: 'cob1', moneda_id: PYG, dticam: null, monto: '30000', pendientes: 3, vencidas: 1 },
      { id: 'p-usd', cobrador_id: 'cob1', moneda_id: USD, dticam: '7000', monto: '120.5', pendientes: 2, vencidas: 1 },
      { id: 'p-sin', cobrador_id: 'cob1', moneda_id: USD, dticam: '1', monto: '10', pendientes: 1, vencidas: 0 },
    ];
    const r: any = await porCobrador(prismaMock(RECIBOS, planes));
    const c = r.cobradores[0];
    // Campos de siempre: suman todo tal cual (como el aggregate de hoy).
    expect(c.pendientes).toEqual({ total_pendientes: 6, total_vencidas: 2, monto_pendiente: 30131, tasa_morosidad: 33 });
    expect(c.en_moneda.pendientes).toEqual({ monto_pendiente: 30000 + 843500, total_pendientes: 5, total_vencidas: 2, tasa_morosidad: 40 });
    expect(r.sin_cotizacion).toBe(1);
    expect(c.por_moneda).toEqual([
      { codigo: 'PYG', total_cobrado: '100000.00', total_descuentos: '0.00', total_mora_cobrada: '500.00', monto_pendiente: '30000.00' },
      { codigo: 'USD', total_cobrado: '50.25', total_descuentos: '1.50', total_mora_cobrada: '0.00', monto_pendiente: '130.50' },
    ]);

    const soloUsd: any = await porCobrador(prismaMock(RECIBOS, planes), USD);
    expect(soloUsd.cobradores[0].en_moneda.pendientes).toEqual({ monto_pendiente: 130.5, total_pendientes: 3, total_vencidas: 1, tasa_morosidad: 33.33 });
    expect(soloUsd.sin_cotizacion).toBe(0);
  });

  it('moneda_id ajena → 400 MONEDA_INVALIDA', async () => {
    await expect(porCobrador(prismaMock(RECIBOS), AJENA)).rejects.toBeInstanceOf(BadRequestException);
    await expect(porCobrador(prismaMock(RECIBOS), 'no-uuid')).rejects.toMatchObject({ response: { codigo: 'MONEDA_INVALIDA' } });
  });

  it('restringido a la sucursal A que pide la B → 403 (antes de mirar la moneda)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['suc-a'], puntosEstablecimiento: ['001'], depositoIds: [] });
    const p = prismaMock(RECIBOS);
    await expect(porCobrador(p, USD, 'suc-b')).rejects.toBeInstanceOf(ForbiddenException);
    expect(p.recibos_cobro.findMany).not.toHaveBeenCalled();
  });
});

describe('GET /reporte-cobrador/productividad con moneda', () => {
  const RECIBOS = [
    rec('a', PYG, null, '1000.4'),
    rec('b', USD, '7300', '10.5'),
    rec('c', USD, null, '3', { fecha_emision: T('2026-11-03T12:00:00Z') }),
  ];
  const prod = (p: any, monedaId?: string) => new ReporteCobradorController(p).getProductividad(USER, '2026-11-01', '2026-11-07', 'cob1', undefined, monedaId);

  it('por día: en_moneda convertido y por_moneda; campos de siempre como hoy', async () => {
    const r: any = await prod(prismaMock(RECIBOS));
    expect(r.dias.map(({ fecha, monto, cantidad }: any) => ({ fecha, monto, cantidad }))).toEqual([
      { fecha: '2026-11-02', monto: 1011, cantidad: 2 },
      { fecha: '2026-11-03', monto: 3, cantidad: 1 },
    ]);
    expect(r.totales).toEqual({ monto: 1014, cantidad: 3 });
    expect(r.max_dia).toBe(1011);
    expect(r.dias[0].en_moneda).toEqual({ monto: 1000.4 + 76650, cantidad: 2 });
    expect(r.dias[0].por_moneda).toEqual([
      { codigo: 'PYG', monto: '1000.40' },
      { codigo: 'USD', monto: '10.50' },
    ]);
    expect(r.dias[1].en_moneda).toEqual({ monto: 0, cantidad: 0 });
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda).toEqual({ totales: { monto: 77650.4, cantidad: 2 }, max_dia: 77650.4 });
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', monto: '1000.40' },
      { codigo: 'USD', monto: '13.50' },
    ]);
  });

  it('con moneda_id=USD: solo USD, sin convertir', async () => {
    const r: any = await prod(prismaMock(RECIBOS), USD);
    expect(r.convertido).toBe(false);
    expect(r.en_moneda.totales).toEqual({ monto: 13.5, cantidad: 2 });
    expect(r.sin_cotizacion).toBe(0);
    expect(r.dias[0].en_moneda).toEqual({ monto: 10.5, cantidad: 1 });
  });
});

describe('GET /reporte-cobrador/detalle con moneda', () => {
  const fila = (id: string, moneda_id: string | null, cot: string | null, monto: string) => ({
    ...rec(id, moneda_id, cot, monto),
    numero_recibo: id,
    fecha_registro: null,
    clientes: null,
    recibo_cobro_detalle: [
      { id: `${id}-d`, monto_pagado: D(monto), descuento_aplicado: null, mora_monto: null, es_pago_parcial: false, factura_cuotas: null },
    ],
  });
  const det = (p: any, monedaId?: string) => new ReporteCobradorController(p).getDetalle(USER, 'cob1', '2026-11-01', '2026-11-07', '1', '20', undefined, monedaId);

  it('cada recibo y cuota con moneda y monto_en_moneda (null sin cotización)', async () => {
    const p = prismaMock([fila('r1', USD, '7300', '50.25'), fila('r2', USD, null, '5'), fila('r3', null, null, '700')] as any);
    const r: any = await det(p);
    expect(r.convertido).toBe(true);
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.data.map((d: any) => [d.moneda, d.monto_total, d.monto_en_moneda])).toEqual([
      [{ codigo: 'USD' }, 50.25, 366825],
      [{ codigo: 'USD' }, 5, null],
      [{ codigo: 'PYG' }, 700, 700],
    ]);
    expect(r.data[0].detalles[0]).toMatchObject({ moneda: { codigo: 'USD' }, monto_pagado: 50.25, monto_en_moneda: 366825 });
    expect(r.data[1].detalles[0].monto_en_moneda).toBeNull();
    expect(r.sin_cotizacion).toBe(1);
  });

  it('con moneda_id: el where de hoy más la moneda (la base incluye la nula); total y páginas del filtro', async () => {
    const p = prismaMock([fila('r1', USD, '7300', '50.25'), fila('r3', null, null, '700')] as any);
    await det(p, PYG);
    const where = p.recibos_cobro.findMany.mock.calls[0][0].where;
    expect(where.AND).toEqual([{ OR: [{ moneda_id: PYG }, { moneda_id: null }] }]);
    expect(p.recibos_cobro.count).toHaveBeenCalledWith({ where });
    const usd: any = await det(prismaMock([fila('r1', USD, '7300', '50.25')] as any), USD);
    expect(usd.data[0].monto_en_moneda).toBe(50.25);
  });
});
