import type { ValidationResult } from '../../hooks/useValidateCupsBeforeSave';
import { obtenerIdDomCeldaTabla } from '../../utils/validacionFormulario';

export interface UbicacionPrimerErrorCups {
    tipo: 'electrico' | 'gas';
    rowIndex: number;
    campo: string;
    idDom: string;
    tabId: 'electricoTab' | 'gasTab';
}

function invertirEtiquetas(etiquetas: Record<string, string>): Record<string, string> {
    const invertido: Record<string, string> = {};

    for (const [campo, etiqueta] of Object.entries(etiquetas)) {
        invertido[etiqueta] = campo;
    }

    return invertido;
}

function construirErroresPorFila(
    erroresValidacion: ValidationResult['errors']['electrico'],
    etiquetas: Record<string, string>,
): Record<number, Record<string, string>> {
    const erroresPorFila: Record<number, Record<string, string>> = {};
    const etiquetaACampo = invertirEtiquetas(etiquetas);

    for (const error of erroresValidacion) {
        const rowIndex = error.rowIndex - 1;

        if (!erroresPorFila[rowIndex]) {
            erroresPorFila[rowIndex] = {};
        }

        for (const etiquetaOCampo of error.missingFields) {
            const campo = etiquetaACampo[etiquetaOCampo] ?? etiquetaOCampo;
            const etiqueta = etiquetas[campo] ?? etiquetaOCampo;
            erroresPorFila[rowIndex][campo] = `El campo ${etiqueta} es obligatorio.`;
        }
    }

    return erroresPorFila;
}

function buscarPrimeraUbicacionEnFilas(
    tipo: 'electrico' | 'gas',
    erroresPorFila: Record<number, Record<string, string>>,
    camposOrdenados: readonly string[],
    tabId: 'electricoTab' | 'gasTab',
): UbicacionPrimerErrorCups | null {
    const indices = Object.keys(erroresPorFila)
        .map(Number)
        .sort((a, b) => a - b);

    for (const rowIndex of indices) {
        for (const campo of camposOrdenados) {
            if (erroresPorFila[rowIndex]?.[campo]) {
                return {
                    tipo,
                    rowIndex,
                    campo,
                    idDom: obtenerIdDomCeldaTabla(tipo, rowIndex, campo),
                    tabId,
                };
            }
        }
    }

    return null;
}

export function mapearErroresValidacionCups(
    result: ValidationResult,
    etiquetas: Record<string, string>,
    camposOrdenElectrico: readonly string[],
    camposOrdenGas: readonly string[],
): {
    erroresFilasElectrico: Record<number, Record<string, string>>;
    erroresFilasGas: Record<number, Record<string, string>>;
    primeraUbicacionCups: UbicacionPrimerErrorCups | null;
} {
    const erroresFilasElectrico = construirErroresPorFila(result.errors.electrico, etiquetas);
    const erroresFilasGas = construirErroresPorFila(result.errors.gas, etiquetas);

    const primeraUbicacionCups =
        buscarPrimeraUbicacionEnFilas('electrico', erroresFilasElectrico, camposOrdenElectrico, 'electricoTab')
        ?? buscarPrimeraUbicacionEnFilas('gas', erroresFilasGas, camposOrdenGas, 'gasTab');

    return {
        erroresFilasElectrico,
        erroresFilasGas,
        primeraUbicacionCups,
    };
}