/**
 * Carril D de Reportes, T3: intereses cobrados 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 de cada interés es la de su recibo (cabecera; nula = base,
 * `monedasDeRecibos`). Con `moneda_id` se filtran los recibos (`whereMonedaTablero`): todo el reporte es de esa moneda.
 */
import { Prisma } from '@prisma/client';
import { BadRequestException, ForbiddenException } from '@nestjs/common';
import { ReporteInteresesCobradosController } from './reporte-intereses-cobrados.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;
  estado: string;
  moneda_id: string | null;
  cotizacion: Prisma.Decimal | null;
  cliente_id: string;
  cobrador_id: string | null;
  fecha_emision: Date;
};
const rec = (id: string, moneda_id: string | null, cot: string | null, cliente: string, cobrador: string | null, extra: Partial<Recibo> = {}): Recibo => ({
  id,
  estado: 'emitido',
  moneda_id,
  cotizacion: cot === null ? null : D(cot),
  cliente_id: cliente,
  cobrador_id: cobrador,
  fecha_emision: T('2026-11-02T12:00:00Z'),
  ...extra,
});
const interes = (id: string, recibo: string, bruto: string, exon: string, cobrado: string, iva: string) => ({
  id,
  empresa_id: 'emp',
  recibo_cobro_id: recibo,
  factura_cuota_id: `q-${id}`,
  dias_mora: 5,
  tasa_aplicada: D('3'),
  base_calculo: D('1000'),
  monto_interes_bruto: D(bruto),
  monto_exonerado: D(exon),
  monto_interes_cobrado: D(cobrado),
  monto_iva: D(iva),
  tipo_comprobante: 'FACTURA',
  emitido_at: null,
  autorizacion_descuento_id: null,
  created_at: T('2026-11-05T12:00:00Z'),
});

const CLIENTES: Record<string, string> = { cli1: 'Alfa', cli2: 'Beta', cli3: 'Gama' };

function prismaMock(recibos: Recibo[], intereses: ReturnType<typeof interes>[]) {
  const deEmpresa = recibos.map((r) => ({ ...r, empresa_id: 'emp' }));
  const cumple = (r: Recibo, c: any): boolean => (c.OR ? c.OR.some((o: any) => cumple(r, o)) : c.moneda_id === r.moneda_id);
  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) => r.estado !== w.estado?.not && (!w.AND || w.AND.every((c: any) => cumple(r, c))))
            .map((r) => ({
              id: r.id,
              numero_recibo: `N-${r.id}`,
              fecha_emision: r.fecha_emision,
              cobrador_id: r.cobrador_id,
              cliente_id: r.cliente_id,
              clientes: { id: r.cliente_id, nombre_fantasia: CLIENTES[r.cliente_id], personas: null },
            })),
        );
      }),
    },
    cob_interes_cobrado: {
      findMany: jest.fn((a: any) => Promise.resolve(intereses.filter((i) => a.where.recibo_cobro_id.in.includes(i.recibo_cobro_id)))),
    },
    factura_cuotas: { findMany: jest.fn().mockResolvedValue([]) },
    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 resumen = (p: any, monedaId?: string, sucursalId?: string) =>
  new ReporteInteresesCobradosController(p).getResumen(USER, '2026-11-01', '2026-11-07', undefined, undefined, sucursalId, monedaId);
const detalle = (p: any, monedaId?: string) =>
  new ReporteInteresesCobradosController(p).getDetalle(USER, '2026-11-01', '2026-11-07', undefined, undefined, '1', '20', undefined, monedaId);

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

// Un recibo PYG (cli1, Ana) con dos intereses y uno USD a 7.300 (cli2, sin cobrador) con 50,25 cobrado.
const RECIBOS = [rec('r-pyg', PYG, null, 'cli1', 'cob1'), rec('r-usd', USD, '7300', 'cli2', null, { fecha_emision: T('2026-11-03T12:00:00Z') })];
const INTERESES = [
  interes('i1', 'r-pyg', '1000', '100', '900', '81.82'),
  interes('i2', 'r-pyg', '500.5', '0', '500.5', '45.5'),
  interes('i3', 'r-usd', '60.25', '10', '50.25', '4.57'),
];

describe('GET /reporte-intereses-cobrados/resumen con moneda', () => {
  it('sin moneda_id: convierte cada recibo con su cotización; por_moneda crudo; campos de siempre como hoy', async () => {
    const r: any = await resumen(prismaMock(RECIBOS, INTERESES));

    // Campos de siempre: suman monedas y redondean a entero (los nuevos lo corrigen al lado).
    expect(r.totales).toEqual({
      cantidad_cuotas: 3,
      cantidad_recibos: 2,
      monto_bruto: 1561,
      monto_exonerado: 110,
      monto_cobrado: 1451,
      monto_iva: 132,
      tasa_exoneracion: 7,
    });

    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.sin_cotizacion).toBe(0);
    expect(r.sin_moneda).toBe(0);
    // 60,25 × 7.300 = 439.825; 10 × 7.300 = 73.000; 50,25 × 7.300 = 366.825; 4,57 × 7.300 = 33.361.
    expect(r.en_moneda.totales).toEqual({
      cantidad_cuotas: 3,
      cantidad_recibos: 2,
      monto_bruto: 1500.5 + 439825,
      monto_exonerado: 100 + 73000,
      monto_cobrado: 1400.5 + 366825,
      monto_iva: 127.32 + 33361,
      tasa_exoneracion: 16.56,
    });
    expect(r.en_moneda.ranking_clientes).toEqual([
      { cliente_id: 'cli2', cliente_nombre: 'Beta', cantidad_cuotas: 1, cantidad_recibos: 1, monto_bruto: 439825, monto_exonerado: 73000, monto_cobrado: 366825 },
      { cliente_id: 'cli1', cliente_nombre: 'Alfa', cantidad_cuotas: 2, cantidad_recibos: 1, monto_bruto: 1500.5, monto_exonerado: 100, monto_cobrado: 1400.5 },
    ]);
    expect(r.en_moneda.ranking_cobradores).toEqual([
      {
        cobrador_id: null,
        cobrador_nombre: 'Sin cobrador asignado',
        cantidad_cuotas: 1,
        cantidad_recibos: 1,
        monto_bruto: 439825,
        monto_exonerado: 73000,
        monto_cobrado: 366825,
      },
      { cobrador_id: 'cob1', cobrador_nombre: 'Ana', cantidad_cuotas: 2, cantidad_recibos: 1, monto_bruto: 1500.5, monto_exonerado: 100, monto_cobrado: 1400.5 },
    ]);
    expect(r.en_moneda.serie).toEqual([
      { fecha: '2026-11-02', monto_cobrado: 1400.5, monto_exonerado: 100, cantidad: 2 },
      { fecha: '2026-11-03', monto_cobrado: 366825, monto_exonerado: 73000, cantidad: 1 },
    ]);
    expect(r.por_moneda).toEqual([
      { codigo: 'PYG', monto_bruto: '1500.50', monto_exonerado: '100.00', monto_cobrado: '1400.50', monto_iva: '127.32' },
      { codigo: 'USD', monto_bruto: '60.25', monto_exonerado: '10.00', monto_cobrado: '50.25', monto_iva: '4.57' },
    ]);
  });

  it('con moneda_id = la base: filtra los recibos (incluye el de moneda nula); los rankings quedan solo con PYG', async () => {
    const p = prismaMock([...RECIBOS, rec('r-nulo', null, null, 'cli3', 'cob1')], [...INTERESES, interes('i4', 'r-nulo', '20', '0', '20', '1.82')]);
    const r: any = await resumen(p, PYG);
    expect(p.recibos_cobro.findMany.mock.calls[0][0].where.AND).toEqual([{ OR: [{ moneda_id: PYG }, { moneda_id: null }] }]);
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(false);
    expect(r.totales).toMatchObject({ cantidad_cuotas: 3, cantidad_recibos: 2, monto_cobrado: 1421 });
    expect(r.en_moneda.totales).toMatchObject({ cantidad_cuotas: 3, cantidad_recibos: 2, monto_cobrado: 1420.5 });
    expect(r.en_moneda.ranking_clientes.map((c: any) => c.cliente_id)).toEqual(['cli1', 'cli3']);
    expect(r.en_moneda.ranking_cobradores).toEqual([
      { cobrador_id: 'cob1', cobrador_nombre: 'Ana', cantidad_cuotas: 3, cantidad_recibos: 2, monto_bruto: 1520.5, monto_exonerado: 100, monto_cobrado: 1420.5 },
    ]);
    expect(r.por_moneda.map((f: any) => f.codigo)).toEqual(['PYG']);
  });

  it('con moneda_id=USD: solo el USD, sin convertir y sin redondear a entero', async () => {
    const p = prismaMock(RECIBOS, INTERESES);
    const r: any = await resumen(p, USD);
    expect(p.recibos_cobro.findMany.mock.calls[0][0].where.AND).toEqual([{ moneda_id: USD }]);
    expect(r.convertido).toBe(false);
    expect(r.en_moneda.totales).toEqual({
      cantidad_cuotas: 1,
      cantidad_recibos: 1,
      monto_bruto: 60.25,
      monto_exonerado: 10,
      monto_cobrado: 50.25,
      monto_iva: 4.57,
      tasa_exoneracion: 16.6,
    });
    expect(r.en_moneda.ranking_clientes).toEqual([
      { cliente_id: 'cli2', cliente_nombre: 'Beta', cantidad_cuotas: 1, cantidad_recibos: 1, monto_bruto: 60.25, monto_exonerado: 10, monto_cobrado: 50.25 },
    ]);
    // Campo de siempre: sigue con su Math.round (50,25 → 50); el exacto está en en_moneda.
    expect(r.totales.monto_cobrado).toBe(50);
  });

  it('USD sin cotización: cuenta en sin_cotizacion, fuera de en_moneda y de los rankings en moneda, dentro de por_moneda', async () => {
    const r: any = await resumen(prismaMock([RECIBOS[0], rec('r-usd', USD, null, 'cli2', null)], INTERESES));
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda.totales).toMatchObject({ cantidad_cuotas: 2, cantidad_recibos: 1, monto_cobrado: 1400.5 });
    expect(r.en_moneda.ranking_clientes.map((c: any) => c.cliente_id)).toEqual(['cli1']);
    expect(r.en_moneda.ranking_cobradores.map((c: any) => c.cobrador_id)).toEqual(['cob1']);
    expect(r.en_moneda.serie.map((s: any) => s.fecha)).toEqual(['2026-11-02']);
    expect(r.por_moneda.find((f: any) => f.codigo === 'USD').monto_cobrado).toBe('50.25');
    // Los de siempre siguen sumándolo como hoy.
    expect(r.totales.cantidad_cuotas).toBe(3);
  });

  it('cotización 1 no es cotización: igual que sin cotización', async () => {
    const r: any = await resumen(prismaMock([RECIBOS[0], rec('r-usd', USD, '1', 'cli2', null)], INTERESES));
    expect(r.sin_cotizacion).toBe(1);
    expect(r.en_moneda.totales.monto_cobrado).toBe(1400.5);
  });

  it('recibo de una moneda sin código: cuenta en sin_moneda, fuera de en_moneda y de por_moneda', async () => {
    const r: any = await resumen(prismaMock([RECIBOS[0], rec('r-raro', AJENA, '5', 'cli2', null)], [...INTERESES.slice(0, 2), interes('i5', 'r-raro', '9', '0', '9', '0')]));
    expect(r.sin_moneda).toBe(1);
    expect(r.en_moneda.totales.monto_cobrado).toBe(1400.5);
    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 resumen(prismaMock([...RECIBOS, rec('r-anu', PYG, null, 'cli3', 'cob1', { estado: 'anulado' })], [...INTERESES, interes('i6', 'r-anu', '999', '0', '999', '0')]));
    expect(r.en_moneda.totales.monto_cobrado).toBe(1400.5 + 366825);
    expect(r.por_moneda.find((f: any) => f.codigo === 'PYG').monto_cobrado).toBe('1400.50');
  });

  it('el total en moneda es la suma de cada ranking (así tabla y pie dan lo mismo)', async () => {
    const r: any = await resumen(
      prismaMock(
        [...RECIBOS, rec('r-usd2', USD, '7312.5', 'cli1', 'cob1')],
        [...INTERESES, interes('i7', 'r-usd2', '0.33', '0', '0.33', '0.03'), interes('i8', 'r-usd2', '0.33', '0', '0.33', '0.03')],
      ),
    );
    const suma = (filas: any[]) => filas.reduce((s, f) => s.plus(String(f.monto_cobrado)), D('0')).toNumber();
    expect(suma(r.en_moneda.ranking_clientes)).toBe(r.en_moneda.totales.monto_cobrado);
    expect(suma(r.en_moneda.ranking_cobradores)).toBe(r.en_moneda.totales.monto_cobrado);
    expect(suma(r.en_moneda.serie)).toBe(r.en_moneda.totales.monto_cobrado);
  });

  it('sin recibos: bloques nuevos en 0 y vacíos, sin NaN', async () => {
    const r: any = await resumen(prismaMock([], []));
    expect(r.en_moneda).toEqual({
      totales: { cantidad_cuotas: 0, cantidad_recibos: 0, monto_bruto: 0, monto_exonerado: 0, monto_cobrado: 0, monto_iva: 0, tasa_exoneracion: 0 },
      ranking_clientes: [],
      ranking_cobradores: [],
      serie: [],
    });
    expect(r.por_moneda).toEqual([]);
    expect(r.sin_cotizacion).toBe(0);
  });

  it('moneda_id ajena o no UUID → 400 MONEDA_INVALIDA', async () => {
    await expect(resumen(prismaMock(RECIBOS, INTERESES), AJENA)).rejects.toBeInstanceOf(BadRequestException);
    await expect(resumen(prismaMock(RECIBOS, INTERESES), '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, INTERESES);
    await expect(resumen(p, 'no-uuid', 'suc-b')).rejects.toBeInstanceOf(ForbiddenException);
    expect(p.recibos_cobro.findMany).not.toHaveBeenCalled();
  });
});

describe('GET /reporte-intereses-cobrados/detalle con moneda', () => {
  it('cada fila con moneda y monto_cobrado_en_moneda (null sin cotización o sin código)', async () => {
    const p = prismaMock(
      [...RECIBOS, rec('r-sin', USD, null, 'cli3', null, { fecha_emision: T('2026-11-01T12:00:00Z') })],
      [...INTERESES, interes('i9', 'r-sin', '5', '0', '5', '0')],
    );
    const r: any = await detalle(p);
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.convertido).toBe(true);
    expect(r.data.map((d: any) => [d.id, d.moneda, d.monto_cobrado, d.monto_cobrado_en_moneda])).toEqual([
      ['i3', { codigo: 'USD' }, 50.25, 366825],
      ['i1', { codigo: 'PYG' }, 900, 900],
      ['i2', { codigo: 'PYG' }, 500.5, 500.5],
      ['i9', { codigo: 'USD' }, 5, null],
    ]);
    expect(r.sin_cotizacion).toBe(1);
    expect(r.sin_moneda).toBe(0);
  });

  it('con moneda_id=USD: filtra recibos; monto en USD sin convertir; total del filtro', async () => {
    const p = prismaMock(RECIBOS, INTERESES);
    const r: any = await detalle(p, USD);
    expect(r.convertido).toBe(false);
    expect(r.total).toBe(1);
    expect(r.data).toHaveLength(1);
    expect(r.data[0]).toMatchObject({ moneda: { codigo: 'USD' }, monto_cobrado: 50.25, monto_cobrado_en_moneda: 50.25 });
  });

  it('recibo de moneda sin código: moneda null y monto_cobrado_en_moneda null; cuenta en sin_moneda', async () => {
    const r: any = await detalle(prismaMock([rec('r-raro', AJENA, '5', 'cli2', null)], [interes('i5', 'r-raro', '9', '0', '9', '0')]));
    expect(r.data[0]).toMatchObject({ moneda: null, monto_cobrado_en_moneda: null });
    expect(r.sin_moneda).toBe(1);
  });
});
