import { useState, useCallback } from 'react';
import Swal from 'sweetalert2';
import type { ContratoFormData } from '../../../../../interfaces';
import type { FormDataElectrico, FormDataGas } from '../../Interfaces/Interfaces';
import type { ValidationResult } from '../../hooks/useValidateCupsBeforeSave';
import {
    aplicarValidacionInline,
    construirErroresCamposObligatorios,
    programarEnfoqueCampoFormulario,
} from '../../utils/validacionFormulario';
import {
    CAMPOS_OBLIGATORIOS_CLIENTE_MULTIPUNTO,
    CAMPOS_OBLIGATORIOS_ELECTRICO_MULTIPUNTO,
    CAMPOS_OBLIGATORIOS_GAS_MULTIPUNTO,
    ETIQUETAS_CAMPOS_CLIENTE_MULTIPUNTO,
    IDS_DOM_CLIENTE_MULTIPUNTO,
} from '../utils/idsDomMultipunto';
import { mapearErroresValidacionCups } from '../utils/mapeoErroresCups';

interface UseValidacionContratoMultipuntoProps {
    data: ContratoFormData;
    etiquetasCups: Record<string, string>;
    validateAllCups: (payload: { electrico: FormDataElectrico[]; gas: FormDataGas[] }) => ValidationResult;
    showValidationErrorDialog: (result: ValidationResult) => Promise<unknown>;
}

export function useValidacionContratoMultipunto({
    data,
    etiquetasCups,
    validateAllCups,
    showValidationErrorDialog,
}: UseValidacionContratoMultipuntoProps) {
    const [erroresCliente, setErroresCliente] = useState<Record<string, string>>({});
    const [mostrarErroresCliente, setMostrarErroresCliente] = useState(false);
    const [erroresFilasElectrico, setErroresFilasElectrico] = useState<Record<number, Record<string, string>>>({});
    const [erroresFilasGas, setErroresFilasGas] = useState<Record<number, Record<string, string>>>({});
    const [mostrarErroresCups, setMostrarErroresCups] = useState(false);

    const limpiarErroresCliente = useCallback(() => {
        setErroresCliente({});
        setMostrarErroresCliente(false);
    }, []);

    const limpiarErrorCampoCliente = useCallback((campo: string) => {
        setErroresCliente((prev) => {
            if (!prev[campo]) {
                return prev;
            }

            const siguiente = { ...prev };
            delete siguiente[campo];

            if (Object.keys(siguiente).length === 0) {
                setMostrarErroresCliente(false);
            }

            return siguiente;
        });
    }, []);

    const limpiarErrorCampoFila = useCallback((tipo: 'electrico' | 'gas', rowIndex: number, campo: string) => {
        const setter = tipo === 'electrico' ? setErroresFilasElectrico : setErroresFilasGas;

        setter((prev) => {
            if (!prev[rowIndex]?.[campo]) {
                return prev;
            }

            const fila = { ...prev[rowIndex] };
            delete fila[campo];

            const siguiente = { ...prev };

            if (Object.keys(fila).length === 0) {
                delete siguiente[rowIndex];
            } else {
                siguiente[rowIndex] = fila;
            }

            return siguiente;
        });
    }, []);

    const limpiarErroresCups = useCallback(() => {
        setErroresFilasElectrico({});
        setErroresFilasGas({});
        setMostrarErroresCups(false);
    }, []);

    const validarCliente = (): boolean => {
        const datosCliente = {
            documento_fiscal: data.documento_fiscal,
            razon_social: data.razon_social,
            fecha_propuesta: data.fecha_propuesta,
        };

        const errores = construirErroresCamposObligatorios(
            datosCliente,
            [...CAMPOS_OBLIGATORIOS_CLIENTE_MULTIPUNTO],
            ETIQUETAS_CAMPOS_CLIENTE_MULTIPUNTO,
        );

        if (Object.keys(errores).length === 0) {
            setErroresCliente({});
            setMostrarErroresCliente(false);

            return true;
        }

        setErroresCliente(errores);
        setMostrarErroresCliente(true);

        const primerMensaje =
            Object.values(errores)[0] ?? 'Revise los datos del cliente antes de continuar.';

        const idDomEnfoque = aplicarValidacionInline(
            errores,
            [...CAMPOS_OBLIGATORIOS_CLIENTE_MULTIPUNTO],
            IDS_DOM_CLIENTE_MULTIPUNTO,
        );

        void Swal.fire({
            title: 'Validación',
            text: primerMensaje,
            icon: 'warning',
            confirmButtonText: 'Entendido',
        }).then(() => {
            if (idDomEnfoque) {
                programarEnfoqueCampoFormulario(idDomEnfoque);
            }
        });

        return false;
    };

    const validarCups = (): boolean => {
        if (data.electrico.length === 0 && data.gas.length === 0) {
            void Swal.fire({
                title: '⚠️ Sin Registros',
                text: 'Debe agregar al menos un registro de CUPS (Eléctrico o Gas) antes de guardar.',
                icon: 'warning',
                confirmButtonText: 'Entendido',
                confirmButtonColor: '#ffc107',
            });

            return false;
        }

        const validationResult = validateAllCups({
            electrico: data.electrico,
            gas: data.gas,
        });

        if (validationResult.isValid) {
            limpiarErroresCups();

            return true;
        }

        const {
            erroresFilasElectrico: erroresElectrico,
            erroresFilasGas: erroresGas,
            primeraUbicacionCups,
        } = mapearErroresValidacionCups(
            validationResult,
            etiquetasCups,
            CAMPOS_OBLIGATORIOS_ELECTRICO_MULTIPUNTO,
            CAMPOS_OBLIGATORIOS_GAS_MULTIPUNTO,
        );

        setErroresFilasElectrico(erroresElectrico);
        setErroresFilasGas(erroresGas);
        setMostrarErroresCups(true);

        void showValidationErrorDialog(validationResult).then(() => {
            if (primeraUbicacionCups) {
                programarEnfoqueCampoFormulario(primeraUbicacionCups.idDom, {
                    tabMultipunto: primeraUbicacionCups.tabId,
                });
            }
        });

        return false;
    };

    const validarAntesDeGuardar = (): boolean => {
        if (!validarCliente()) {
            return false;
        }

        return validarCups();
    };

    return {
        erroresCliente,
        mostrarErroresCliente,
        erroresFilasElectrico,
        erroresFilasGas,
        mostrarErroresCups,
        limpiarErroresCliente,
        limpiarErrorCampoCliente,
        limpiarErrorCampoFila,
        limpiarErroresCups,
        validarAntesDeGuardar,
    };
}