import { useState, useEffect, useRef } from 'react';
import { useForm, router, usePage } from '@inertiajs/react';
import Swal from 'sweetalert2';
import { FormDataElectrico, FormDataGas, ContratoFormChildRef, Cliente } from '../../Interfaces/Interfaces';
import {
    aplicarValidacionInline,
    construirErroresCamposObligatorios,
    programarEnfoqueCampoFormulario,
} from '../../utils/validacionFormulario';

const CAMPOS_OBLIGATORIOS_CLIENTE = ['documento_fiscal', 'fecha_propuesta'] as const;

const ETIQUETAS_CAMPOS_CLIENTE: Record<string, string> = {
    documento_fiscal: 'Nº Documento Fiscal',
    fecha_propuesta: 'Fecha del Contrato',
};

const IDS_DOM_CAMPOS_CLIENTE: Record<string, string> = {
    documento_fiscal: 'documento_fiscal',
    fecha_propuesta: 'fecha_propuesta',
};

interface UseContratoUniClienteUniPuntoProps {
    clientes: Cliente[];
}

interface ContratoFormData {
    razon_social: string;
    documento_fiscal: string;
    fecha_propuesta: string;
    tipo_contrato: number;
    numero_propuesta: string;
    estatus: string;
    direccion: string;
    escalera_planta_puerta: string;
    localidad: string;
    provincia: string;
    codigo_postal: string;
    tarifa: string;
    consumo_kw: string;
    comercializadora: string;
    producto: string;
    anexo: string;
    tipo_precio: string;
    comentarios: string;
    electrico: any[];
    gas: any[];
}

export const useContratoUniClienteUniPunto = ({ clientes }: UseContratoUniClienteUniPuntoProps) => {
    // Form state
    const { data, setData, post, processing, errors } = useForm<ContratoFormData>({
        razon_social: '',
        documento_fiscal: '',
        fecha_propuesta: '',
        tipo_contrato: 1,
        numero_propuesta: '',
        estatus: '',
        direccion: '',
        escalera_planta_puerta: '',
        localidad: '',
        provincia: '',
        codigo_postal: '',
        tarifa: '',
        consumo_kw: '',
        comercializadora: '',
        producto: '',
        anexo: '',
        tipo_precio: '',
        comentarios: '',
        electrico: [],
        gas: []
    });

    // Refs for child forms
    const formHijoElectrico = useRef<ContratoFormChildRef>(null);
    const formHijoGas = useRef<ContratoFormChildRef>(null);

    // Local state
    const [selectedCliente, setSelectedCliente] = useState<Cliente[]>([]);
    const [clientesOptions, setClientesOptions] = useState<Cliente[]>([]);
    const [showCupsElectric, setShowCupsElectric] = useState(true);
    const [showCupsGas, setShowCupsGas] = useState(true);
    const [procedeGuardar, setProcedeGuardar] = useState(false);
    const [erroresCliente, setErroresCliente] = useState<Record<string, string>>({});
    const [mostrarErroresCliente, setMostrarErroresCliente] = useState(false);

    const { flash } = usePage().props as any;

    useEffect(() => {
        setClientesOptions(clientes);
    }, [clientes]);

    // Listen for flash messages from backend (e.g. 400 Bad Request handled with back()->with('error', ...))
    useEffect(() => {
        if (flash?.success) {
            Swal.fire('¡Éxito!', flash.success, 'success');
        }
        if (flash?.error) {
            Swal.fire('Error', flash.error, 'error');
        }
    }, [flash]);

    useEffect(() => {
        // T004/T005/T006 — Fix: `data` en las deps causaba re-evaluación en cada
        // keystroke (cualquier campo del formulario disparaba el efecto).
        // El callback funcional de setData lee `prev` sin necesitar `data` como dep.
        // La guarda condicional era consecuencia del bug, ya no es necesaria.
        const cliente = selectedCliente[0] ?? null;
        setData(prev => ({
            ...prev,
            documento_fiscal: cliente?.NumCifCli ?? '',
            razon_social: cliente?.RazSocCli ?? '',
        }));
    }, [selectedCliente]);

    // Handle save contrato
    useEffect(() => {
        if (procedeGuardar && (data.electrico.length > 0 || data.gas.length > 0)) {
            post(route("contratos.save-multi-punto"), {
                onSuccess: (page: any) => {
                    const flash = page.props.flash as any;
                    if (flash?.success) {
                        Swal.fire(
                            "¡Correcto!",
                            "Contrato UniCliente Unipunto registrado correctamente",
                            "success"
                        );
                        router.visit(route("contratos.index"));
                    }
                },
                onError: (errors) => {
                    // This handles 422 Validation Errors from Laravel
                    if (Object.keys(errors).length > 0) {
                        const mensaje = Object.values(errors).join('\n');
                        Swal.fire(
                            "Error de Validación",
                            `Por favor revise los siguientes errores:\n${mensaje}`,
                            "error"
                        );
                    } else {
                        // Fallback for other errors if not caught by flash
                        Swal.fire(
                            "¡Error!",
                            "Ocurrió un error interno del servidor. Por favor, contacte con soporte técnico.",
                            "error"
                        );
                    }
                },
                onFinish: () => {
                    // Allow retrying save after either success or failure
                    setProcedeGuardar(false);
                }
            });
        }
    }, [procedeGuardar]);

    // Handlers
    const handleClienteChange = (selected: any[]) => {
        const cliente = selected.length > 0 ? (selected[0] as Cliente) : null;
        if (cliente) {
            setSelectedCliente([cliente]);
        } else {
            setSelectedCliente([]);
        }

        if (mostrarErroresCliente) {
            setErroresCliente({});
            setMostrarErroresCliente(false);
        }
    };

    const handleChangeElectrico = (formData: FormDataElectrico) => {
        setData("electrico", [formData]);
    };

    const handleChangeGas = (formData: FormDataGas) => {
        setData("gas", [formData]);
    };

    const limpiarErroresCliente = () => {
        setErroresCliente({});
        setMostrarErroresCliente(false);
    };

    const validarCliente = (): boolean => {
        const datosCliente = {
            documento_fiscal: selectedCliente[0]?.NumCifCli ?? data.documento_fiscal,
            fecha_propuesta: data.fecha_propuesta,
        };

        const errores = construirErroresCamposObligatorios(
            datosCliente,
            [...CAMPOS_OBLIGATORIOS_CLIENTE],
            ETIQUETAS_CAMPOS_CLIENTE,
        );

        if (Object.keys(errores).length > 0) {
            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],
                IDS_DOM_CAMPOS_CLIENTE,
            );

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

            return false;
        }

        setErroresCliente({});
        setMostrarErroresCliente(false);

        return true;
    };

    const saveContrato = () => {
        if (!validarCliente()) {
            return;
        }

        let electricoValid = true;
        
        // Validate Electrico if visible
        if (showCupsElectric) {
            if (formHijoElectrico.current?.saveElectricoForm) {
                electricoValid = formHijoElectrico.current.saveElectricoForm();
            } else {
                // If ref is not attached but it should be visible, treat as invalid or skip? 
                // Usually means component not mounted yet or something. 
                // Assuming component is mounted if showCupsElectric is true.
                console.warn("Ref de formulario eléctrico no disponible");
            }
        }

        let gasValid = true;
        // Validate Gas if visible
        if (showCupsGas) {
            if (formHijoGas.current?.saveGasForm) {
                gasValid = formHijoGas.current.saveGasForm();
            } else {
                 console.warn("Ref de formulario gas no disponible");
            }
        }

        // Check if at least one is shown
        if (!showCupsElectric && !showCupsGas) {
            Swal.fire("Atención", "Debe habilitar al menos un tipo de suministro (Eléctrico o Gas) para continuar.", "warning");
            return;
        }

        // Proceed only if ALL visible forms are valid
        if (electricoValid && gasValid) {
            setProcedeGuardar(true);
        }
    };



    const toggleCupsElectric = () => setShowCupsElectric(!showCupsElectric);
    const toggleCupsGas = () => setShowCupsGas(!showCupsGas);

    return {
        // Form data
        data,
        setData,
        errors,
        processing,

        // Refs
        formHijoElectrico,
        formHijoGas,

        // State
        selectedCliente,
        clientesOptions,
        showCupsElectric,
        showCupsGas,

        // Errores cliente
        erroresCliente,
        mostrarErroresCliente,
        limpiarErroresCliente,

        // Handlers
        handleClienteChange,
        handleChangeElectrico,
        handleChangeGas,
        saveContrato,
        toggleCupsElectric,
        toggleCupsGas,
    };
};