import { solicitudInvalida } from 'src/common/utils/error-estructurado';

/**
 * Reglas puras de la NC de compra (spec 2026-10-22-nc-compra, secciones 1 y 3).
 * Sin Prisma: el servicio arma los datos y estas funciones deciden.
 */

/** Tolerancia de redondeo para montos (2 decimales). */
const TOLERANCIA_MONTO = 0.009;

const redondear2 = (n: number) => Math.round((Number(n) || 0) * 100) / 100;

/** Cotización válida para una moneda que no es la base: mayor a 0 y distinta de 1. */
const cotizacionValida = (valor: number) => valor > 0 && valor !== 1;

/**
 * Cotización de una moneda que no es la base: obligatoria, mayor a 0 y distinta de 1
 * (la misma regla que Facturas de compra).
 */
function validarCotizacionExtranjera(cotizacion: number | null | undefined): number {
  if (cotizacion === undefined || cotizacion === null || Number.isNaN(Number(cotizacion))) {
    throw solicitudInvalida({
      message: 'Indicá la cotización: la moneda de la nota de crédito no es la moneda base de la empresa.',
      codigo: 'COTIZACION_REQUERIDA',
      campo: 'cotizacion',
    });
  }
  const valor = Number(cotizacion);
  if (!cotizacionValida(valor)) {
    throw solicitudInvalida({
      message: 'La cotización tiene que ser mayor a 0 y distinta de 1 para una moneda que no es la base.',
      codigo: 'COTIZACION_INVALIDA',
      campo: 'cotizacion',
    });
  }
  return valor;
}

/**
 * Moneda y cotización con las que se graba la NC.
 * - Con origen: las del origen; lo que mande el cliente se ignora, salvo que mande otra moneda (400).
 *   Origen sin moneda → PYG. Origen que no está en la moneda base con cotización ≤ 0 o igual a 1
 *   (dato viejo) → la manda el cliente y se valida igual que sin origen. Una cotización menor a 1
 *   es legítima (p. ej. base USD y origen PYG) y se conserva.
 * - Sin origen: la moneda es obligatoria; si no es la base, la cotización también.
 * - Moneda base → cotización 1.
 */
export function resolverMonedaNc(args: {
  origen: { moneda_id: string | null; cotizacion: number } | null;
  dtoMonedaId?: string;
  dtoCotizacion?: number;
  monedaBaseId: string;
  pygId: string;
}): { moneda_id: string; cotizacion: number } {
  const { origen, dtoMonedaId, dtoCotizacion, monedaBaseId, pygId } = args;

  if (origen) {
    const monedaOrigen = origen.moneda_id ?? pygId;
    if (dtoMonedaId && dtoMonedaId !== monedaOrigen) {
      throw solicitudInvalida({
        message: 'La moneda de la nota de crédito tiene que ser la del documento origen.',
        codigo: 'MONEDA_DISTINTA_ORIGEN',
        campo: 'moneda_id',
      });
    }
    if (monedaOrigen === monedaBaseId) return { moneda_id: monedaOrigen, cotizacion: 1 };
    const cotizacionOrigen = Number(origen.cotizacion) || 0;
    if (cotizacionValida(cotizacionOrigen)) return { moneda_id: monedaOrigen, cotizacion: cotizacionOrigen };
    return { moneda_id: monedaOrigen, cotizacion: validarCotizacionExtranjera(dtoCotizacion) };
  }

  if (!dtoMonedaId) {
    throw solicitudInvalida({
      message: 'Elegí la moneda de la nota de crédito.',
      codigo: 'MONEDA_REQUERIDA',
      campo: 'moneda_id',
    });
  }
  if (dtoMonedaId === monedaBaseId) return { moneda_id: dtoMonedaId, cotizacion: 1 };
  return { moneda_id: dtoMonedaId, cotizacion: validarCotizacionExtranjera(dtoCotizacion) };
}

/** Lo que todavía se puede acreditar del origen: su total menos las NC vigentes. Nunca negativo. */
export function acreditable(totalOrigen: number, totalesNcVigentes: number[]): number {
  const usado = totalesNcVigentes.reduce((s, t) => s + (Number(t) || 0), 0);
  return Math.max(0, redondear2((Number(totalOrigen) || 0) - usado));
}

/** ¿El total de la NC pasa el tope? Con tolerancia de redondeo. */
export function superaTope(totalNc: number, tope: number): boolean {
  return Number(totalNc) - Number(tope) > TOLERANCIA_MONTO;
}

/** `1-2` o `001-002-0000045`: establecimiento, punto de expedición y, opcional, número. */
const NUMERO_CON_PREFIJO = /^(\d{1,3})-(\d{1,3})(?:-(\d{1,7}))?$/;

/**
 * Si el término de búsqueda tiene forma de comprobante con prefijo, lo parte en
 * establecimiento, punto de expedición y número con los ceros que se guardan (3/3/7).
 * Con cualquier otro texto, `null`.
 */
export function terminoNumeroNc(
  s: string,
): { establecimiento?: string; punto_expedicion?: string; numero?: string } | null {
  const m = NUMERO_CON_PREFIJO.exec((s ?? '').trim());
  if (!m) return null;
  const [, establecimiento, punto, numero] = m;
  return {
    establecimiento: establecimiento.padStart(3, '0'),
    punto_expedicion: punto.padStart(3, '0'),
    ...(numero ? { numero: numero.padStart(7, '0') } : {}),
  };
}

/**
 * Reparte las líneas de un asiento en proporción `factor` (NC contra gasto: neto NC / neto
 * gasto, o total / total). Cada monto se redondea a `decimales` (los de la moneda del asiento:
 * 0 en PYG) y el residuo, para que la suma dé exacto el total redondeado (suma original ×
 * factor), va a la línea de mayor monto original. Conserva el orden, la cuenta y `dims` de
 * cada línea; las que quedan en 0 se omiten.
 */
export function repartoProporcional<D>(
  lineas: Array<{ cuenta_id: string; monto: number; dims: D }>,
  factor: number,
  decimales: number,
): Array<{ cuenta_id: string; monto: number; dims: D }> {
  if (!lineas.length) return [];
  const escala = 10 ** decimales;
  // toPrecision(15) quita el error binario antes de redondear (como `redondear` de moneda-cuenta.util).
  const aUnidades = (n: number) => Math.round(Number((n * escala).toPrecision(15)));
  const total = lineas.reduce((s, l) => s + (Number(l.monto) || 0), 0);
  const objetivo = aUnidades(total * factor);
  const unidades = lineas.map((l) => aUnidades((Number(l.monto) || 0) * factor));
  const residuo = objetivo - unidades.reduce((s, c) => s + c, 0);
  if (residuo !== 0) {
    const mayor = lineas.reduce((m, l, i) => ((Number(l.monto) || 0) > (Number(lineas[m].monto) || 0) ? i : m), 0);
    unidades[mayor] += residuo;
  }
  return lineas
    .map((l, i) => ({ cuenta_id: l.cuenta_id, monto: unidades[i] / escala, dims: l.dims }))
    .filter((l) => l.monto !== 0);
}
