import { UnprocessableEntityException } from '@nestjs/common';
import { ConfigMoraService } from './config-mora.service';
import { codigoCotizacionMora, errorFaltaCotizacion, resolverCotizacionDia, respaldosMora, calcularMoraCuota, moraNecesitaCotizacion, calcularMoraCuotaDetalle, decimalesMoraCuota, moraACobrarCuota, sumarIvaPorFuera, diasVencidoCalendario } from './calculo-mora';

const DIA = 86400000;
// Hoy = 8/11/2026 al mediodía en Paraguay; el vencimiento es una columna DATE (medianoche UTC). Sin depender de la zona del servidor.
const hoy = new Date('2026-11-08T15:00:00.000Z');
const vencidaHace = (dias: number) => new Date(Date.UTC(2026, 10, 8) - dias * DIA);

const base = {
  activo: true,
  tipo_calculo: 'diario',
  tasa: 0,
  base_calculo: 'capital',
  periodo_gracia: 0,
  monto_minimo_mora: 0,
  monto_maximo_mora: null as number | null,
};

describe('calcularMoraCuota (un solo cálculo para simulación y cobro)', () => {
  it('monto fijo de Gs. 50.000 por cuota', () => {
    const mora = calcularMoraCuota({
      saldo: 1_000_000,
      montoCuota: 1_000_000,
      fechaVencimiento: vencidaHace(10),
      hoy,
      decimales: 0,
      config: { ...base, tipo_calculo: 'fijo_por_cuota', tasa: 50_000 },
    });
    expect(mora).toBe(50_000);
  });

  it('el monto fijo respeta la gracia', () => {
    const mora = calcularMoraCuota({
      saldo: 1_000_000,
      montoCuota: 1_000_000,
      fechaVencimiento: vencidaHace(3),
      hoy,
      decimales: 0,
      config: { ...base, tipo_calculo: 'fijo_por_cuota', tasa: 50_000, periodo_gracia: 5 },
    });
    expect(mora).toBe(0);
  });

  it('con base USD conserva los centavos', () => {
    // 123,45 × 0,1 % × 7 días = 0,864150 → 0,86
    const mora = calcularMoraCuota({
      saldo: 123.45,
      montoCuota: 123.45,
      fechaVencimiento: vencidaHace(7),
      hoy,
      decimales: 2,
      config: { ...base, tasa: 0.1 },
    });
    expect(mora).toBe(0.86);
  });

  it('en guaraníes redondea a la unidad', () => {
    const mora = calcularMoraCuota({
      saldo: 123_457,
      montoCuota: 123_457,
      fechaVencimiento: vencidaHace(7),
      hoy,
      decimales: 0,
      config: { ...base, tasa: 0.1 },
    });
    expect(mora).toBe(864); // 864,199
  });

  it('aplica el mínimo antes de redondear (orden del cobro)', () => {
    // bruto 0,4 × 1 % × 1 día = 0,004 < mínimo 0,0045 → 0,0045 → redondeo a 2 decimales = 0
    // (redondeando primero daría 0 → mínimo → 0,0045, un monto sin redondear).
    const mora = calcularMoraCuota({
      saldo: 0.4,
      montoCuota: 0.4,
      fechaVencimiento: vencidaHace(1),
      hoy,
      decimales: 2,
      config: { ...base, tasa: 1, monto_minimo_mora: 0.0045 },
    });
    expect(mora).toBe(0);
  });

  it('el tope se aplica antes de redondear (orden del cobro)', () => {
    // bruto 1.000,6 > tope 1.000,4 → 1.000,4 → redondeo a la unidad = 1.000
    // (redondeando primero daría 1.001 → tope → 1.000,4).
    const mora = calcularMoraCuota({
      saldo: 100_060,
      montoCuota: 100_060,
      fechaVencimiento: vencidaHace(1),
      hoy,
      decimales: 0,
      config: { ...base, tasa: 1, monto_maximo_mora: 1000.4 },
    });
    expect(mora).toBe(1000);
  });

  it('mínimo y tope enteros, como los carga la ventanilla', () => {
    const cfg = { ...base, tasa: 0.1, monto_minimo_mora: 5_000, monto_maximo_mora: 20_000 };
    const args = { montoCuota: 0, fechaVencimiento: vencidaHace(10), hoy, decimales: 0 };
    expect(calcularMoraCuota({ ...args, saldo: 1_000_000, config: cfg })).toBe(10_000);
    expect(calcularMoraCuota({ ...args, saldo: 100_000, config: cfg })).toBe(5_000);
    expect(calcularMoraCuota({ ...args, saldo: 10_000_000, config: cfg })).toBe(20_000);
  });

  it('tope 0 o null cuenta como sin tope', () => {
    const args = { saldo: 1_000_000, montoCuota: 0, fechaVencimiento: vencidaHace(10), hoy, decimales: 0 };
    expect(calcularMoraCuota({ ...args, config: { ...base, tasa: 1, monto_maximo_mora: 0 } })).toBe(100_000);
    expect(calcularMoraCuota({ ...args, config: { ...base, tasa: 1, monto_maximo_mora: null } })).toBe(100_000);
  });

  it('mensual prorratea por días y usa la cuota completa si la base lo pide', () => {
    const mora = calcularMoraCuota({
      saldo: 500_000,
      montoCuota: 1_000_000,
      fechaVencimiento: vencidaHace(45),
      hoy,
      decimales: 0,
      config: { ...base, tipo_calculo: 'mensual', tasa: 3, base_calculo: 'cuota_completa' },
    });
    expect(mora).toBe(45_000);
  });

  it('sin vencer, inactiva o dentro de la gracia no genera mora', () => {
    const args = { saldo: 1_000_000, montoCuota: 1_000_000, hoy, decimales: 0 };
    const cfg = { ...base, tasa: 1, monto_minimo_mora: 5_000 };
    expect(calcularMoraCuota({ ...args, fechaVencimiento: hoy, config: cfg })).toBe(0);
    expect(calcularMoraCuota({ ...args, fechaVencimiento: vencidaHace(5), config: { ...cfg, activo: false } })).toBe(0);
    expect(calcularMoraCuota({ ...args, fechaVencimiento: vencidaHace(5), config: { ...cfg, periodo_gracia: 5 } })).toBe(0);
  });
});

describe('calcularMoraCuota con días ya contados e IVA por fuera', () => {

  it('diasVencido manda sobre la fecha', () => {
    expect(calcularMoraCuota({ saldo: 100_000, montoCuota: 100_000, diasVencido: 3, decimales: 0, config: { ...base, tasa: 1 } })).toBe(3_000);
  });

  it('IVA por fuera redondeado por moneda', () => {
    expect(sumarIvaPorFuera(0.86, 10, 2)).toBe(0.95);
    expect(sumarIvaPorFuera(45_000, 10, 0)).toBe(49_500);
    expect(sumarIvaPorFuera(45_000, 0, 0)).toBe(45_000);
  });

  it('moraACobrarCuota = mora + IVA por fuera', () => {
    const ctx = { config: { ...base, tipo_calculo: 'mensual', tasa: 3 }, decimales: 0, ivaPorFueraPct: 10 };
    expect(moraACobrarCuota(ctx, { saldo: 1_000_000, montoCuota: 1_000_000, fechaVencimiento: vencidaHace(45) }, hoy)).toBe(49_500);
  });
});

describe('mora de una factura en otra moneda que la base (I3)', () => {
  const usd = { codigo: 'USD', cotizacion: 7_500 };

  it('redondea con los decimales de la moneda de la factura: USD 3,40 no se cobra como USD 3', () => {
    // 1% diario × 34 días sobre USD 10
    const r = calcularMoraCuotaDetalle({ saldo: 10, montoCuota: 10, diasVencido: 34, decimales: 0, codigoBase: 'PYG', moneda: usd, config: { ...base, tasa: 1 } });
    expect(r).toEqual({ mora: 3.4, decimales: 2, sinCotizacion: false });
  });

  it('el mínimo cargado en guaraníes se convierte con la cotización de la factura: Gs. 5.000 → USD 0,67, no USD 5.000', () => {
    const mora = calcularMoraCuota({ saldo: 10, montoCuota: 10, diasVencido: 1, decimales: 0, codigoBase: 'PYG', moneda: usd, config: { ...base, tasa: 1, monto_minimo_mora: 5_000 } });
    expect(mora).toBe(0.67);
  });

  it('el tope cargado en guaraníes se convierte igual', () => {
    const mora = calcularMoraCuota({ saldo: 1_000, montoCuota: 1_000, diasVencido: 30, decimales: 0, codigoBase: 'PYG', moneda: usd, config: { ...base, tasa: 1, monto_maximo_mora: 75_000 } });
    expect(mora).toBe(10);
  });

  it('el monto fijo por cuota (en guaraníes) se convierte a la moneda de la factura', () => {
    const mora = calcularMoraCuota({ saldo: 1_000, montoCuota: 1_000, diasVencido: 5, decimales: 0, codigoBase: 'PYG', moneda: usd, config: { ...base, tipo_calculo: 'fijo_por_cuota', tasa: 15_000 } });
    expect(mora).toBe(2);
  });

  it('sin cotización válida la mora porcentual es 0 entera (no se cobra sin tope) y lo anota', () => {
    const r = calcularMoraCuotaDetalle({
      saldo: 10, montoCuota: 10, diasVencido: 34, decimales: 0, codigoBase: 'PYG',
      moneda: { codigo: 'USD', cotizacion: null },
      config: { ...base, tasa: 1, monto_minimo_mora: 5_000, monto_maximo_mora: 1_000 },
    });
    expect(r).toEqual({ mora: 0, decimales: 2, sinCotizacion: true });
  });

  it('sin cotización, el monto fijo (en otra moneda) no se aplica y se anota', () => {
    const r = calcularMoraCuotaDetalle({
      saldo: 10, montoCuota: 10, diasVencido: 5, decimales: 0, codigoBase: 'PYG',
      moneda: { codigo: 'USD', cotizacion: 1 },
      config: { ...base, tipo_calculo: 'fijo_por_cuota', tasa: 15_000 },
    });
    expect(r).toEqual({ mora: 0, decimales: 2, sinCotizacion: true });
  });

  it('A5: porcentual puro (sin fijo, mínimo ni tope) sin cotización se calcula en la moneda de la cuota: 0,1 % × 40 días = 4 % del saldo', () => {
    const r = calcularMoraCuotaDetalle({ saldo: 500, montoCuota: 500, diasVencido: 40, decimales: 0, codigoBase: 'PYG', moneda: { codigo: 'USD', cotizacion: null }, config: { ...base, tasa: 0.1 } });
    expect(r).toEqual({ mora: 20, decimales: 2, sinCotizacion: false });
  });

  it('A5: porcentual mensual puro sin cotización tampoco la pide', () => {
    const r = calcularMoraCuotaDetalle({ saldo: 300, montoCuota: 300, diasVencido: 30, decimales: 0, codigoBase: 'PYG', moneda: { codigo: 'USD', cotizacion: 1 }, config: { ...base, tipo_calculo: 'mensual', tasa: 2 } });
    expect(r).toEqual({ mora: 6, decimales: 2, sinCotizacion: false });
  });

  it('A5: con mínimo cargado en la base y sin dticam, usa la cotización vigente del día como respaldo', () => {
    const r = calcularMoraCuotaDetalle({
      saldo: 10, montoCuota: 10, diasVencido: 1, decimales: 0, codigoBase: 'PYG',
      moneda: { codigo: 'USD', cotizacion: null }, cotizacionRespaldo: 7_500,
      config: { ...base, tasa: 1, monto_minimo_mora: 15_000 },
    });
    expect(r).toEqual({ mora: 2, decimales: 2, sinCotizacion: false });
  });

  it('A5: la cotización de la factura manda sobre el respaldo del día', () => {
    const r = calcularMoraCuotaDetalle({
      saldo: 10, montoCuota: 10, diasVencido: 1, decimales: 0, codigoBase: 'PYG',
      moneda: { codigo: 'USD', cotizacion: 7_500 }, cotizacionRespaldo: 5_000,
      config: { ...base, tasa: 1, monto_minimo_mora: 15_000 },
    });
    expect(r.mora).toBe(2);
  });

  it('A5: con mínimo y sin ninguna cotización (ni de la factura ni del día): 0 marcada, para que el cobro se rechace', () => {
    const r = calcularMoraCuotaDetalle({ saldo: 10, montoCuota: 10, diasVencido: 34, decimales: 0, codigoBase: 'PYG', moneda: { codigo: 'USD', cotizacion: null }, config: { ...base, tasa: 1, monto_minimo_mora: 5_000 } });
    expect(r).toEqual({ mora: 0, decimales: 2, sinCotizacion: true });
  });

  it('A5: respaldo inválido (<= 1) no cuenta', () => {
    const r = calcularMoraCuotaDetalle({ saldo: 10, montoCuota: 10, diasVencido: 5, decimales: 0, codigoBase: 'PYG', moneda: { codigo: 'USD', cotizacion: null }, cotizacionRespaldo: 1, config: { ...base, tipo_calculo: 'fijo_por_cuota', tasa: 15_000 } });
    expect(r.sinCotizacion).toBe(true);
  });

  it('A5: moraNecesitaCotizacion es verdadero con fijo, mínimo o tope, y falso con porcentual puro', () => {
    expect(moraNecesitaCotizacion({ ...base, tasa: 1 })).toBe(false);
    expect(moraNecesitaCotizacion({ ...base, tasa: 1, monto_minimo_mora: 1 })).toBe(true);
    expect(moraNecesitaCotizacion({ ...base, tasa: 1, monto_maximo_mora: 1 })).toBe(true);
    expect(moraNecesitaCotizacion({ ...base, tipo_calculo: 'fijo_por_cuota', tasa: 1 })).toBe(true);
  });

  it('sin cotización pero sin mora (dentro de la gracia): nada que marcar', () => {
    const r = calcularMoraCuotaDetalle({ saldo: 10, montoCuota: 10, diasVencido: 3, decimales: 0, codigoBase: 'PYG', moneda: { codigo: 'USD', cotizacion: null }, config: { ...base, tasa: 1, periodo_gracia: 5 } });
    expect(r).toEqual({ mora: 0, decimales: 2, sinCotizacion: false });
  });

  it('decimalesMoraCuota: los de la factura solo si hay base y es otra moneda', () => {
    expect(decimalesMoraCuota('PYG', 'USD')).toBe(2);
    expect(decimalesMoraCuota('USD', 'PYG')).toBe(0);
    expect(decimalesMoraCuota('PYG', null)).toBe(0);
    expect(decimalesMoraCuota(null, 'USD')).toBe(0);
  });

  it('factura en la moneda base (o sin moneda): igual que antes', () => {
    const conf = { ...base, tasa: 1, monto_minimo_mora: 5_000 };
    expect(calcularMoraCuota({ saldo: 10_000, montoCuota: 10_000, diasVencido: 1, decimales: 0, codigoBase: 'PYG', moneda: { codigo: 'PYG', cotizacion: null }, config: conf })).toBe(5_000);
    expect(calcularMoraCuota({ saldo: 10_000, montoCuota: 10_000, diasVencido: 1, decimales: 0, codigoBase: 'PYG', moneda: { codigo: null, cotizacion: null }, config: conf })).toBe(5_000);
  });

  it('empresa con base USD y factura en guaraníes: mínimo en USD × cotización, a la unidad', () => {
    const mora = calcularMoraCuota({ saldo: 100_000, montoCuota: 100_000, diasVencido: 1, decimales: 2, codigoBase: 'USD', moneda: { codigo: 'PYG', cotizacion: 7_500 }, config: { ...base, tasa: 1, monto_minimo_mora: 2 } });
    expect(mora).toBe(15_000);
  });

  it('moraACobrarCuota: IVA por fuera con los decimales de la factura', () => {
    const ctx = { config: { ...base, tasa: 1 }, decimales: 0, codigoBase: 'PYG', ivaPorFueraPct: 10 };
    expect(moraACobrarCuota(ctx, { saldo: 10, montoCuota: 10, diasVencido: 34, moneda: usd })).toBe(3.74);
  });
});

describe('cotización del día como respaldo de la mora (A5, ronda 1)', () => {
  const vigente = (tasa: number, fuente: string) => ({ getCotizacionVigente: jest.fn().mockResolvedValue({ tasa, fuente }) });
  const ctx = (extra: Record<string, unknown> = {}) => ({ config: { ...base, tasa: 1, monto_minimo_mora: 15_000, ...extra }, codigoBase: 'PYG' });

  it('el resolver ignora la cotización con fuente fallback, o con tasa <= 1, y recuerda lo ya pedido', async () => {
    const m = vigente(1, 'fallback');
    const r = resolverCotizacionDia(m, 'emp');
    expect(await r('USD')).toBeNull();
    expect(await r('USD')).toBeNull();
    expect(m.getCotizacionVigente).toHaveBeenCalledTimes(1);
    expect(await resolverCotizacionDia(vigente(7_500, 'facturacion'), 'emp')('USD')).toBe(7_500);
    expect(await resolverCotizacionDia(undefined, 'emp')('USD')).toBeNull();
  });

  it('con base USD y cuota en guaraníes pide la cotización de la BASE (USD), no la de PYG', () => {
    expect(codigoCotizacionMora('USD', 'PYG')).toBe('USD');
    expect(codigoCotizacionMora('PYG', 'USD')).toBe('USD');
    expect(codigoCotizacionMora('PYG', 'PYG')).toBeNull();
  });

  it('respaldosMora solo consulta cuando hace falta: regla que convierte, otra moneda y factura sin cotización válida', async () => {
    const m = vigente(7_500, 'contabilidad');
    const r = resolverCotizacionDia(m, 'emp');
    const sinFalta = await respaldosMora(ctx({ monto_minimo_mora: 0 }), r, [{ codigo: 'USD', cotizacion: null }]);
    expect(sinFalta.size).toBe(0);
    const conCotizacionPropia = await respaldosMora(ctx(), r, [{ codigo: 'USD', cotizacion: 7_400 }, { codigo: 'PYG', cotizacion: null }]);
    expect(conCotizacionPropia.size).toBe(0);
    expect(m.getCotizacionVigente).not.toHaveBeenCalled();
    const falta = await respaldosMora(ctx(), r, [{ codigo: 'USD', cotizacion: null }, { codigo: 'usd', cotizacion: 1 }]);
    expect(falta.get('USD')).toBe(7_500);
    expect(m.getCotizacionVigente).toHaveBeenCalledTimes(1);
  });

  it('moraACobrarCuota usa el respaldo (mismo número que el cobro) y avisa solo si no hay ninguna', () => {
    const cuota = { saldo: 10, montoCuota: 10, diasVencido: 1, moneda: { codigo: 'USD', cotizacion: null } };
    const c = { config: { ...base, tasa: 1, monto_minimo_mora: 15_000 }, decimales: 0, codigoBase: 'PYG', ivaPorFueraPct: 0 };
    const aviso = jest.fn();
    expect(moraACobrarCuota(c, { ...cuota, cotizacionRespaldo: 7_500 }, undefined, aviso)).toBe(2);
    expect(aviso).not.toHaveBeenCalled();
    expect(moraACobrarCuota(c, cuota, undefined, aviso)).toBe(0);
    expect(aviso).toHaveBeenCalledTimes(1);
  });

  it('ConfigMoraService.calcularMora recibe el respaldo', () => {
    const svc = new ConfigMoraService({} as never);
    const r = svc.calcularMora(10, 10, new Date(Date.now() - DIA), { ...base, tasa: 1, monto_minimo_mora: 15_000 }, 0, {
      codigoBase: 'PYG', moneda: { codigo: 'USD', cotizacion: null }, cotizacionRespaldo: 7_500,
    });
    expect(r).toEqual({ mora: 2, decimales: 2, sinCotizacion: false });
  });

  it('errorFaltaCotizacion es el 422 que dice qué cargar y dónde', () => {
    const e = errorFaltaCotizacion('USD', ['001-001-0000007 (cuota 1)']);
    expect(e).toBeInstanceOf(UnprocessableEntityException);
    expect(e.message).toMatch(/No hay cotización registrada para USD.*001-001-0000007.*Cotizaciones del día/);
  });
});

describe('diasVencidoCalendario (un solo conteo de días, hora de Paraguay)', () => {
  const venc = new Date('2026-10-29T00:00:00.000Z'); // columna DATE
  it('vence el 29/10 y hoy es 10/11: 12 días, a cualquier hora del día paraguayo', () => {
    // 10/11 00:00 y 23:59 en Paraguay (UTC-3)
    expect(diasVencidoCalendario(venc, new Date('2026-11-10T03:00:00.000Z'))).toBe(12);
    expect(diasVencidoCalendario(venc, new Date('2026-11-11T02:59:00.000Z'))).toBe(12);
    // pasada la medianoche paraguaya ya es otro día
    expect(diasVencidoCalendario(venc, new Date('2026-11-11T03:00:00.000Z'))).toBe(13);
    // las 21:00 de la víspera (00:00 UTC) todavía es el día anterior en Paraguay
    expect(diasVencidoCalendario(venc, new Date('2026-11-10T00:00:00.000Z'))).toBe(11);
  });
  it('vence hoy = 0; vence mañana = negativo; fecha inválida = 0; acepta texto', () => {
    expect(diasVencidoCalendario(new Date('2026-11-10T00:00:00.000Z'), new Date('2026-11-10T15:00:00.000Z'))).toBe(0);
    expect(diasVencidoCalendario('2026-11-11', new Date('2026-11-10T15:00:00.000Z'))).toBe(-1);
    expect(diasVencidoCalendario('xx')).toBe(0);
  });
  it('la mora usa ese conteo: gracia 2, 12 días = 10 días efectivos, no 11', () => {
    const config = { activo: true, tipo_calculo: 'diario', tasa: 1, periodo_gracia: 2, base_calculo: 'saldo_pendiente' } as any;
    const r = calcularMoraCuotaDetalle({
      saldo: 250000, montoCuota: 250000, fechaVencimiento: venc, config, decimales: 0, codigoBase: 'PYG',
      moneda: { codigo: 'PYG', cotizacion: 1 }, hoy: new Date('2026-11-10T15:00:00.000Z'),
    } as any);
    expect(r.mora).toBe(25000);
  });
});
