/** Reglas puras de Requisiciones (sin Prisma ni Nest): estados, totales, niveles por monto y ejecución. */

export const ESTADOS_REQUISICION = [
  'borrador',
  'pendiente_aprobacion',
  'aprobada',
  'ejecutada_parcial',
  'ejecutada_total',
  'rechazada',
  'cancelada',
] as const;
export type EstadoRequisicion = (typeof ESTADOS_REQUISICION)[number];

export const ORIGENES_REQUISICION = ['compra', 'gasto'] as const;
export type OrigenRequisicion = (typeof ORIGENES_REQUISICION)[number];

export const ACCIONES_REQUISICION = [
  'creada',
  'actualizada',
  'enviada_aprobacion',
  'aprobada_nivel',
  'aprobada',
  'rechazada',
  'cancelada',
  'oc_creada',
  'oc_cancelada',
  'vuelta_a_borrador_precio_estimado',
  'rechazada_por_oc_cancelada',
] as const;
export type AccionRequisicion = (typeof ACCIONES_REQUISICION)[number];

/** Moneda en que se expresan los precios estimados de toda requisición. */
export const MONEDA_PRECIOS_REQUISICION = 'PYG';

/** A 2 decimales, mitad lejos de cero (simétrico con negativos). El backend no tiene un helper compartido. */
const redondear2 = (n: number): number => {
  const r = Math.round((Math.abs(n) + Number.EPSILON) * 100) / 100;
  return n < 0 ? -r : r;
};

/**
 * Totales de la requisición.
 * - `total_estimado` = Σ cantidad × precio.
 * - `total_para_aprobacion` = Σ cantidad × max(precio, costo_referencia) por línea; con `costo_referencia` null
 *   (ítem libre o de gasto) usa el precio.
 * Convención: `costo_referencia` vale 0 en un producto sin costo ni precio de lista y null solo en ítems libres o de
 * gasto. Con 0, max(precio, 0) = precio, así que `total_para_aprobacion` usa el precio.
 */
export function totalesRequisicion(
  lineas: Array<{ cantidad: number; precio: number; costo_referencia: number | null }>,
): { total_estimado: number; total_para_aprobacion: number } {
  let estimado = 0;
  let aprobacion = 0;
  for (const l of lineas) {
    estimado += l.cantidad * l.precio;
    const base = l.costo_referencia == null ? l.precio : Math.max(l.precio, l.costo_referencia);
    aprobacion += l.cantidad * base;
  }
  return { total_estimado: redondear2(estimado), total_para_aprobacion: redondear2(aprobacion) };
}

/** Niveles activos que cubren el monto (`monto_desde <= monto` y `monto_hasta` null o `monto <= monto_hasta`), por nivel. */
export function nivelesParaMonto<T extends { nivel: number; monto_desde: number; monto_hasta: number | null; activo: boolean }>(
  configs: T[],
  monto: number,
): T[] {
  return configs
    .filter((c) => c.activo && c.monto_desde <= monto && (c.monto_hasta == null || monto <= c.monto_hasta))
    .sort((a, b) => a.nivel - b.nivel);
}

/** Subtotal en la moneda de la requisición: igual si ya es `PYG`, si no `subtotal × cotizacion` a 2 decimales. */
export function montoEnMonedaRequisicion(subtotal: number, monedaCodigo: string, cotizacion: number): number {
  if (monedaCodigo === MONEDA_PRECIOS_REQUISICION) return subtotal;
  return redondear2(subtotal * cotizacion);
}

export type EstadoLineaRequisicion = 'pendiente' | 'ejecutada_parcial' | 'ejecutada_total';

export function estadoLinea(solicitada: number, ejecutada: number): EstadoLineaRequisicion {
  if (ejecutada <= 0) return 'pendiente';
  return ejecutada >= solicitada ? 'ejecutada_total' : 'ejecutada_parcial';
}

/** Estado de la cabecera según sus líneas: todas totales = total; alguna ejecutada = parcial; ninguna = aprobada. */
export function estadoPorEjecucion(
  lineas: Array<{ cantidad_solicitada: number; cantidad_ejecutada: number }>,
): 'aprobada' | 'ejecutada_parcial' | 'ejecutada_total' {
  if (lineas.length === 0) return 'aprobada';
  const estados = lineas.map((l) => estadoLinea(l.cantidad_solicitada, l.cantidad_ejecutada));
  if (estados.every((e) => e === 'ejecutada_total')) return 'ejecutada_total';
  if (estados.some((e) => e !== 'pendiente')) return 'ejecutada_parcial';
  return 'aprobada';
}

export interface DiferenciaReferencia {
  id: string;
  precio: number;
  referencia: number;
  diferencia: number;
  porcentaje: number;
}

/**
 * Líneas de producto cuyo precio difiere de la referencia. Excluye las de referencia null (libres y gastos) y las de
 * referencia <= 0 (producto sin costo: se guarda 0), para no dividir por 0. `diferencia` y `porcentaje` son por
 * unidad (precio - referencia, sobre la referencia, a 2 decimales); `suma` = Σ cantidad × diferencia.
 */
export function diferenciasContraReferencia(
  lineas: Array<{ id: string; cantidad: number; precio: number; costo_referencia: number | null }>,
): { lineas: DiferenciaReferencia[]; suma: number } {
  const out: DiferenciaReferencia[] = [];
  let suma = 0;
  for (const l of lineas) {
    const ref = l.costo_referencia;
    if (ref == null || ref <= 0) continue;
    const diferencia = redondear2(l.precio - ref);
    if (diferencia === 0) continue; // iguales o con diferencia menor a un centavo
    out.push({
      id: l.id,
      precio: l.precio,
      referencia: ref,
      diferencia,
      porcentaje: redondear2(((l.precio - ref) / ref) * 100),
    });
    suma += l.cantidad * (l.precio - ref);
  }
  return { lineas: out, suma: redondear2(suma) };
}
