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

export type TipoMovimientoManual = 'INGRESO' | 'EGRESO';

export interface CategoriaCatalogo {
  tipo: string | null;
  activo: boolean;
  empresa_id: string | null;
  is_sistema: boolean;
}

export interface MovimientoParaValidar {
  monto: number;
  tipo: TipoMovimientoManual;
  categorias: Array<{ categoria_id: string; monto: number }>;
}

/** ¿La categoría sirve para un movimiento de este tipo? Sin tipo o AMBOS sirve para los dos (la misma tabla que el front). */
export function categoriaAplicaA(c: { tipo: string | null }, tipo: TipoMovimientoManual): boolean {
  return c.tipo == null || c.tipo === 'AMBOS' || c.tipo === tipo;
}

/**
 * Un movimiento pasa a aprobación cuando hay umbral (> 0) y el monto lo alcanza. El umbral está en moneda base, así que
 * `montoBase` es el monto ya llevado a la base; `null` = no se pudo convertir (sin cotización o sin moneda base) y falla
 * del lado seguro: pide aprobación.
 */
export const requiereAprobacion = (montoBase: number | null, umbral: number): boolean => umbral > 0 && (montoBase === null || montoBase >= umbral);

const centavos = (n: number) => Math.round(n * 100);

/** La suma de las categorías tiene que ser el monto del movimiento, comparada en centavos (A5). */
export function validarSumaCategorias(monto: number, categorias: Array<{ monto: number }>): void {
  const suma = categorias.reduce((acc, c) => acc + centavos(c.monto), 0);
  if (suma !== centavos(monto)) {
    const diferencia = (centavos(monto) - suma) / 100;
    throw solicitudInvalida({
      message: `La suma de las categorías (${suma / 100}) no coincide con el monto del movimiento (${monto}).`,
      codigo: 'CATEGORIAS_NO_SUMAN',
      campo: 'categorias',
      diferencia,
    });
  }
}

/**
 * Las reglas del alta (A5): monto > 0, al menos una categoría, cada una con monto > 0 y válida para la empresa y el tipo,
 * y la suma igual al monto. `catalogo` trae las categorías pedidas, por id; la que no está no existe.
 */
export function validarCategoriasMovimiento(mov: MovimientoParaValidar, catalogo: Map<string, CategoriaCatalogo>, empresaId: string): void {
  if (!(mov.monto > 0)) {
    throw solicitudInvalida({ message: 'El monto del movimiento tiene que ser mayor a cero.', codigo: 'MONTO_INVALIDO', campo: 'monto' });
  }
  if (mov.categorias.length === 0) {
    throw solicitudInvalida({ message: 'Elegí al menos una categoría para el movimiento.', codigo: 'CATEGORIAS_VACIAS', campo: 'categorias' });
  }
  mov.categorias.forEach((c, i) => {
    if (!(c.monto > 0)) {
      throw solicitudInvalida({ message: 'El monto de cada categoría tiene que ser mayor a cero.', codigo: 'MONTO_INVALIDO', campo: `categorias.${i}.monto` });
    }
    const categoria = catalogo.get(c.categoria_id);
    const esDeLaEmpresa = categoria != null && (categoria.empresa_id === empresaId || (categoria.empresa_id == null && categoria.is_sistema));
    if (!categoria || !esDeLaEmpresa || !categoria.activo || !categoriaAplicaA(categoria, mov.tipo)) {
      throw solicitudInvalida({
        message: 'La categoría elegida no existe, está inactiva o no corresponde a este tipo de movimiento.',
        codigo: 'CATEGORIA_INVALIDA',
        campo: `categorias.${i}.categoria_id`,
      });
    }
  });
  validarSumaCategorias(mov.monto, mov.categorias);
}
