import { UnprocessableEntityException } from '@nestjs/common';
import type { Prisma } from '@prisma/client';
import { decimalesMoneda, redondear } from 'src/common/utils/moneda-cuenta.util';
import { desdeMonedaBase, monedaBaseOpcional, type Cotizable } from 'src/utils/montos-moneda';

/** Lo de `config_mora` que hace falta para calcular la mora de una cuota. */
export interface ConfigMoraCalculo {
  activo: boolean;
  tipo_calculo: string;
  /** % diario o mensual, o el monto fijo por cuota si `tipo_calculo` es `fijo_por_cuota`. */
  tasa: number | string | { toString(): string };
  base_calculo: string;
  periodo_gracia: number | null;
  monto_minimo_mora: number | string | { toString(): string } | null;
  /** null o 0 = sin tope. */
  monto_maximo_mora: number | string | { toString(): string } | null;
}

/**
 * Moneda de la factura de la cuota y su cotización (`factura_cab.moneda.codigo` y `dticam`, guaraníes por unidad):
 * la misma con que el cobro convierte esa factura. Código null = la moneda base.
 */
export type MonedaCuotaMora = Cotizable;

/**
 * Decimales con que se calcula, suma IVA y desglosa la mora de una cuota: los de la moneda de su factura si la empresa
 * tiene moneda base y la factura está en otra; si no, los de la base (sin base, PYG = 0). Lo mismo que el cobro.
 */
export function decimalesMoraCuota(codigoBase: string | null | undefined, codigoCuota: string | null | undefined): number {
  const base = codigoBase ? codigoBase.toUpperCase() : null;
  const cuota = codigoCuota ? codigoCuota.toUpperCase() : null;
  return base && cuota && cuota !== base ? decimalesMoneda(cuota) : decimalesMoneda(base);
}

export interface ParamsMoraCuota {
  /** Saldo pendiente de la cuota (base `capital`), en la moneda de la factura. */
  saldo: number;
  /** Monto original de la cuota (base `cuota_completa`), en la moneda de la factura. */
  montoCuota: number;
  /** Vencimiento de la cuota. Si se pasa `diasVencido`, manda ese número (ya contado a las 00:00). */
  fechaVencimiento?: Date | string | null;
  diasVencido?: number;
  config: ConfigMoraCalculo | null | undefined;
  /** Decimales de la moneda base (`decimalesMoneda`): los de la cuota si está en la base o no se sabe su moneda. */
  decimales: number;
  /** Código de la moneda base de la empresa. Sin él (o sin `moneda`) la cuota se toma en la base. */
  codigoBase?: string | null;
  /** Moneda de la factura de la cuota. */
  moneda?: MonedaCuotaMora | null;
  /**
   * Cotización vigente del día (guaraníes por unidad), de respaldo cuando la factura no trae una válida. El llamador
   * la pide a `MonedasService.getCotizacionVigente` y solo la pasa si `fuente !== 'fallback'`.
   */
  cotizacionRespaldo?: number | null;
  hoy?: Date;
}

/**
 * La regla necesita convertir montos de la base a la moneda de la cuota: tiene monto fijo, mínimo o tope. Una regla
 * porcentual pura (sin fijo, mínimo ni tope) se calcula en la moneda de la cuota sin pedir ninguna cotización.
 */
export function moraNecesitaCotizacion(config: ConfigMoraCalculo | null | undefined): boolean {
  if (!config) return false;
  return (
    config.tipo_calculo === 'fijo_por_cuota' ||
    Number(config.monto_minimo_mora || 0) > 0 ||
    Number(config.monto_maximo_mora || 0) > 0
  );
}

/**
 * Días de atraso de una cuota: el único conteo (cobro, recibos, panel, app, intereses y Mesa de gestión).
 * El vencimiento es una columna DATE (llega como medianoche UTC) y «hoy» es el día de calendario de Paraguay
 * (America/Asuncion), sin importar la zona del servidor ni la hora. Vence el 29/10 y hoy es 10/11: 12 días.
 * Negativo o 0 = no vencida. Devuelve 0 si la fecha no es válida.
 */
export function diasVencidoCalendario(vencimiento: Date | string, ahora: Date = new Date()): number {
  const v = new Date(vencimiento);
  if (Number.isNaN(v.getTime())) return 0;
  const ymdHoy = new Intl.DateTimeFormat('en-CA', { timeZone: 'America/Asuncion' }).format(ahora);
  const hoyUtc = Date.parse(`${ymdHoy}T00:00:00.000Z`);
  const vencUtc = Date.UTC(v.getUTCFullYear(), v.getUTCMonth(), v.getUTCDate());
  return Math.round((hoyUtc - vencUtc) / 86400000);
}

/**
 * Mora de una cuota vencida: el único cálculo, que usan el cobro (cobros.service), los recibos, el panel y la app
 * del cobrador y la simulación de intereses (intereses-moratorios.service).
 *
 * Orden (el del cobro, el que ya se aplicó a clientes): gracia → monto bruto → mínimo → tope → redondeo a los
 * decimales de la moneda de la cuota (0 en PYG, 2 en USD). Por mes prorratea por días (días/30). El tope 0 cuenta
 * como sin tope.
 *
 * El monto fijo, el mínimo y el tope se cargan en la moneda base: en una factura en otra moneda se convierten con la
 * cotización de la factura (`desdeMonedaBase`) o, si no trae una válida, con la vigente del día (`cotizacionRespaldo`).
 * Una regla porcentual pura no necesita cotización y se calcula en la moneda de la cuota. Si la regla la necesita y no
 * hay ninguna, la mora es 0 y `sinCotizacion` lo anota: el cobro lo rechaza (nunca se cobra mora 0 sin avisar).
 */
export function calcularMoraCuotaDetalle(params: ParamsMoraCuota): { mora: number; decimales: number; sinCotizacion: boolean } {
  const { config } = params;
  const base = params.codigoBase ? params.codigoBase.toUpperCase() : null;
  const codigoCuota = (params.moneda?.codigo || base)?.toUpperCase() ?? null;
  const otraMoneda = !!base && !!codigoCuota && codigoCuota !== base;
  const decimales = otraMoneda ? decimalesMoneda(codigoCuota) : params.decimales;
  const propia: Cotizable = { codigo: codigoCuota, cotizacion: params.moneda?.cotizacion ?? null };
  // La de la factura manda; sin una válida, la vigente del día si el llamador la trajo.
  const cotizable: Cotizable =
    otraMoneda && desdeMonedaBase(1, propia, base!) === null && params.cotizacionRespaldo
      ? { codigo: codigoCuota, cotizacion: params.cotizacionRespaldo }
      : propia;
  const nada = { mora: 0, decimales, sinCotizacion: false };
  if (!config?.activo) return nada;

  let diasVencido: number;
  if (params.diasVencido !== undefined) {
    diasVencido = params.diasVencido;
  } else {
    if (!params.fechaVencimiento) return nada;
    diasVencido = diasVencidoCalendario(params.fechaVencimiento, params.hoy);
  }
  if (diasVencido <= 0) return nada;
  const diasEfectivos = diasVencido - (config.periodo_gracia ?? 0);
  if (diasEfectivos <= 0) return nada;

  // Otra moneda, regla que convierte montos y ninguna cotización válida: mora 0, marcada.
  if (otraMoneda && moraNecesitaCotizacion(config) && desdeMonedaBase(1, cotizable, base!) === null) {
    return { mora: 0, decimales, sinCotizacion: true };
  }
  // Monto cargado en la moneda base → moneda de la cuota (la cotización ya se validó).
  const enMonedaCuota = (valorBase: number): number =>
    !valorBase || !otraMoneda ? valorBase : (desdeMonedaBase(valorBase, cotizable, base!) ?? 0);

  const baseMonto = config.base_calculo === 'cuota_completa' ? params.montoCuota : params.saldo;
  const tasa = Number(config.tasa || 0);
  let mora = 0;
  if (config.tipo_calculo === 'diario') mora = baseMonto * (tasa / 100) * diasEfectivos;
  else if (config.tipo_calculo === 'mensual') mora = baseMonto * (tasa / 100) * (diasEfectivos / 30);
  else if (config.tipo_calculo === 'fijo_por_cuota') mora = enMonedaCuota(tasa);

  const minimo = enMonedaCuota(Number(config.monto_minimo_mora || 0));
  const tope = enMonedaCuota(Number(config.monto_maximo_mora || 0));
  if (minimo && mora < minimo) mora = minimo;
  if (tope && mora > tope) mora = tope;
  return { mora: redondear(mora, decimales), decimales, sinCotizacion: false };
}

/** Lo mínimo de `MonedasService` que hace falta para la cotización del día. */
interface CotizacionDelDia {
  getCotizacionVigente(empresaId: string, codigo: string): Promise<{ tasa: number; fuente: string }>;
}

/** Cotización vigente del día de una moneda, o null si no hay ninguna cargada. */
export type ResolverCotizacionDia = (codigo: string) => Promise<number | null>;

/**
 * Resolver de la cotización del día para el respaldo de la mora (un resolver por operación: recuerda lo ya pedido). Ignora
 * la de fuente `fallback` (no es una cotización cargada) y toda tasa <= 1. Sin servicio de monedas no hay respaldo.
 */
export function resolverCotizacionDia(monedas: CotizacionDelDia | null | undefined, empresaId: string): ResolverCotizacionDia {
  const memo = new Map<string, Promise<number | null>>();
  return (codigo) => {
    const clave = codigo.toUpperCase();
    if (!memo.has(clave)) {
      memo.set(
        clave,
        monedas
          ? monedas.getCotizacionVigente(empresaId, clave).then((v) => (v && v.fuente !== 'fallback' && v.tasa > 1 ? v.tasa : null))
          : Promise.resolve(null),
      );
    }
    return memo.get(clave)!;
  };
}

/**
 * Código de la moneda cuya cotización hace falta para convertir los montos de la regla (cargados en la base) a la moneda
 * de la cuota: la de la cuota; si la cuota está en guaraníes y la base no, la de la base. Null = misma moneda, no hace falta.
 */
export function codigoCotizacionMora(codigoBase: string | null | undefined, codigoCuota: string | null | undefined): string | null {
  const base = codigoBase?.toUpperCase();
  const cuota = codigoCuota?.toUpperCase();
  if (!base || !cuota || base === cuota) return null;
  return cuota === 'PYG' ? base : cuota;
}

/**
 * Respaldos para una tanda de cuotas: por código de moneda de la cuota (mayúsculas), la cotización del día cuando hace falta
 * (la regla convierte montos, la cuota está en otra moneda y su factura no trae cotización válida). Valor null = no hay.
 */
export async function respaldosMora(
  ctx: Pick<ContextoMora, 'config' | 'codigoBase'>,
  resolver: ResolverCotizacionDia,
  cuotas: Array<{ codigo?: string | null; cotizacion?: Cotizable['cotizacion'] }>,
): Promise<Map<string, number | null>> {
  const out = new Map<string, number | null>();
  if (!ctx.config?.activo || !ctx.codigoBase || !moraNecesitaCotizacion(ctx.config)) return out;
  for (const c of cuotas) {
    const codigoCuota = c.codigo?.toUpperCase();
    const codigoCot = codigoCotizacionMora(ctx.codigoBase, codigoCuota);
    if (!codigoCuota || !codigoCot || out.has(codigoCuota)) continue;
    if (desdeMonedaBase(1, { codigo: codigoCuota, cotizacion: c.cotizacion ?? null }, ctx.codigoBase) !== null) continue;
    out.set(codigoCuota, await resolver(codigoCot));
  }
  return out;
}

/** El 422 de «falta cotización»: dice cuál cargar y dónde. El cobro no se hace con mora 0 sin avisar. */
export function errorFaltaCotizacion(codigoCotizacion: string, cuotas: string[]): UnprocessableEntityException {
  return new UnprocessableEntityException(
    `No hay cotización registrada para ${codigoCotizacion}: la mora de ${cuotas.join(', ')} necesita convertir el mínimo, el tope o el monto fijo. ` +
      `Cargá la cotización del día en Configuración › Monedas › Cotizaciones del día y volvé a cobrar.`,
  );
}

/** Texto del estado «falta cotización, no se puede cobrar» que el panel y la app del cobrador muestran en la cuota. */
export function mensajeFaltaCotizacion(codigoCotizacion: string | null): string {
  return `Falta la cotización de ${codigoCotizacion ?? 'la moneda'}: la mora de esta cuota no se puede calcular y no se puede cobrar. Cargala en Configuración › Monedas › Cotizaciones del día.`;
}

/** La mora de `calcularMoraCuotaDetalle`, sin el detalle. */
export function calcularMoraCuota(params: ParamsMoraCuota): number {
  return calcularMoraCuotaDetalle(params).mora;
}

/** Mora + IVA por fuera (`cob_config_intereses.iva_modo = POR_FUERA`), como la cobra la ventanilla. */
export function sumarIvaPorFuera(mora: number, ivaPorFueraPct: number, decimales: number): number {
  if (!(ivaPorFueraPct > 0) || !(mora > 0)) return mora;
  return redondear(mora + redondear((mora * ivaPorFueraPct) / 100, decimales), decimales);
}

/** Lo que hace falta para calcular la mora a cobrar de las cuotas de una empresa. */
export interface ContextoMora {
  config: ConfigMoraCalculo | null;
  /** Decimales de la moneda base (sin moneda base, PYG = 0). */
  decimales: number;
  /** Código de la moneda base (null si la empresa no tiene): para la mora de facturas en otra moneda. */
  codigoBase: string | null;
  /** % de IVA que se suma a la mora; 0 si el IVA va incluido o no hay. */
  ivaPorFueraPct: number;
}

/** Lo mínimo del cliente Prisma (o de una transacción) que hace falta acá. */
interface DbMora {
  config_mora: { findFirst(args: { where: { empresa_id: string } }): Promise<ConfigMoraCalculo | null> };
  cob_config_intereses: {
    findFirst(args: { where: { empresa_id: string } }): Promise<{ iva_modo?: string | null; iva_porcentaje?: unknown } | null>;
  };
}

/** Carga config de mora, decimales de la moneda base e IVA por fuera, igual que el cobro. */
export async function cargarContextoMora(db: DbMora, empresaId: string): Promise<ContextoMora> {
  const [config, configIntereses] = await Promise.all([
    db.config_mora.findFirst({ where: { empresa_id: empresaId } }),
    db.cob_config_intereses.findFirst({ where: { empresa_id: empresaId } }),
  ]);
  const codigoBase = config?.activo
    ? ((await monedaBaseOpcional(db as unknown as Prisma.TransactionClient, empresaId))?.codigo ?? null)
    : null;
  const decimales = decimalesMoneda(codigoBase);
  const ivaPorFueraPct =
    configIntereses?.iva_modo === 'POR_FUERA'
      ? Number(configIntereses?.iva_porcentaje ?? 0)
      : 0;
  return { config, decimales, codigoBase, ivaPorFueraPct };
}

/**
 * Mora a cobrar de una cuota (mora + IVA por fuera, en la moneda de su factura): lo mismo que suma el cobro
 * (`previewDistribucion`). Con `alSinCotizacion` el llamador se entera de que no se aplicó mínimo, tope o fijo.
 */
export function moraACobrarCuota(
  ctx: ContextoMora,
  cuota: { saldo: number; montoCuota: number; fechaVencimiento?: Date | string | null; diasVencido?: number; moneda?: MonedaCuotaMora | null; cotizacionRespaldo?: number | null },
  hoy?: Date,
  alSinCotizacion?: () => void,
): number {
  const r = calcularMoraCuotaDetalle({ ...cuota, config: ctx.config, decimales: ctx.decimales, codigoBase: ctx.codigoBase, hoy });
  if (r.sinCotizacion) alSinCotizacion?.();
  return sumarIvaPorFuera(r.mora, ctx.ivaPorFueraPct, r.decimales);
}

/**
 * Desglose fiscal de la mora YA cobrada en un recibo (para `cob_interes_cobrado` y la factura de intereses):
 * parte de lo cobrado, no la recalcula (después del recibo la cuota ya está pagada).
 * - `moraBase`: la mora de la regla, sin IVA (`calcularMoraCuota`).
 * - `moraCalculada`: lo que el cobro sumó por la cuota antes de exonerar (con IVA si va por fuera).
 * - `cobrado`: lo que efectivamente pagó el cliente por esa mora (`moraCalculada` − exonerado).
 * POR_FUERA: lo cobrado es neto + IVA; INCLUIDO: el IVA va por dentro de lo cobrado.
 */
export function desgloseMoraCobrada(p: {
  moraBase: number;
  moraCalculada: number;
  cobrado: number;
  ivaModo: 'POR_FUERA' | 'INCLUIDO';
  ivaPct: number;
  decimales: number;
}): { bruto: number; exonerado: number; neto: number; iva: number; total: number } {
  const d = p.decimales;
  const total = redondear(Math.max(0, p.cobrado), d);
  const pct = p.ivaPct > 0 ? p.ivaPct : 0;
  if (p.ivaModo === 'POR_FUERA') {
    const bruto = p.moraBase;
    // Sin exoneración, el neto es exactamente la mora de la regla y el IVA lo que se sumó encima.
    const neto = total === redondear(p.moraCalculada, d) ? bruto : redondear((total * 100) / (100 + pct), d);
    const iva = redondear(total - neto, d);
    return { bruto, exonerado: redondear(Math.max(0, bruto - neto), d), neto, iva, total };
  }
  const bruto = p.moraCalculada;
  const iva = pct > 0 ? redondear((total * pct) / (100 + pct), d) : 0;
  return { bruto, exonerado: redondear(Math.max(0, bruto - total), d), neto: redondear(total - iva, d), iva, total };
}
