/**
 * Arma el resultado de conciliación (resumen + conciliadas + pendientes) a partir
 * de los movimientos ya interpretados y los matches. Puro. El shape es idéntico
 * al que consume el frontend (ver conciliacionBancariaIa.mock.js → construirResultado).
 */

export interface MovVista {
  id: string;
  origen: string;
  fecha: string;
  concepto: string;
  tipo: string;
  importe: number;
  referencia: string | null;
  confianza_ia: number;
  estado: string;
}

export interface MatchVista {
  id: string;
  movimiento_propio_id: string;
  movimiento_banco_id: string;
  tipo_match: string;
  diferencia_importe: number;
}

export interface ResultadoConciliacion {
  resumen: {
    total_propio: number;
    total_banco: number;
    conciliadas: number;
    pendientes_propio: number;
    pendientes_banco: number;
    con_diferencia: number;
    en_transito: number;
    porcentaje_conciliado: number;
  };
  conciliadas: Array<MatchVista & { propio?: MovVista; banco?: MovVista }>;
  pendientesPropio: MovVista[];
  pendientesBanco: MovVista[];
  enTransito: MovVista[];
  porcentaje: number;
}

/**
 * Los movimientos EN_TRANSITO (partidas propias reservadas para el próximo
 * extracto) se excluyen de los totales y del cálculo del % y se devuelven aparte.
 */
export function construirResultado(
  propios: MovVista[],
  banco: MovVista[],
  matches: MatchVista[],
  enTransito: MovVista[] = [],
): ResultadoConciliacion {
  const matchedPropioIds = new Set(matches.map((m) => m.movimiento_propio_id));
  const matchedBancoIds = new Set(matches.map((m) => m.movimiento_banco_id));

  const propioById = new Map(propios.map((p) => [p.id, p]));
  const bancoById = new Map(banco.map((b) => [b.id, b]));

  const conciliadas = matches.map((mt) => ({
    ...mt,
    propio: propioById.get(mt.movimiento_propio_id),
    banco: bancoById.get(mt.movimiento_banco_id),
  }));

  const pendientesPropio = propios.filter((p) => !matchedPropioIds.has(p.id));
  const pendientesBanco = banco.filter((b) => !matchedBancoIds.has(b.id));

  const totalLineas = propios.length + banco.length;
  const lineasConciliadas = matches.length * 2;
  const porcentaje = totalLineas ? Math.round((lineasConciliadas / totalLineas) * 100) : 0;

  return {
    resumen: {
      total_propio: propios.length,
      total_banco: banco.length,
      conciliadas: matches.length,
      pendientes_propio: pendientesPropio.length,
      pendientes_banco: pendientesBanco.length,
      con_diferencia: matches.filter((m) => Math.abs(m.diferencia_importe) > 0).length,
      en_transito: enTransito.length,
      porcentaje_conciliado: porcentaje,
    },
    conciliadas,
    pendientesPropio,
    pendientesBanco,
    enTransito,
    porcentaje,
  };
}