import { useState } from 'react';
import axios from 'axios';
import Swal from 'sweetalert2';
import {
    BusquedaActivacion,
    ContratoActivacion,
    FechasServicio,
    FormularioActivacion,
    FormularioContratoRapido,
    mensajeError,
} from '../types';

const numeroONulo = (value: string | number | null | undefined) => {
    const texto = String(value ?? '').trim().replace(',', '.');
    return texto === '' ? null : texto;
};

function payloadContrato(form: FormularioActivacion, tipCups: number, periodos: number) {
    const potencias: Record<string, string | null> = {};
    for (let p = 1; p <= 6; p++) {
        potencias[`PotEleConP${p}`] = p <= periodos ? numeroONulo(form[`PotEleConP${p}` as keyof FormularioActivacion]) : null;
    }

    return {
        TipCups: tipCups,
        CodTar: form.CodTar,
        FecActCUPs: form.FecActCUPs,
        FecVenCUPs: form.FecVenCUPs,
        EstConCups: form.EstConCups,
        ConCup: numeroONulo(form.ConCup),
        ...(tipCups === 1 ? potencias : {}),
    };
}

export function useActivaciones() {
    const [busqueda, setBusqueda] = useState<BusquedaActivacion | null>(null);
    const [buscando, setBuscando] = useState(false);
    const [guardando, setGuardando] = useState(false);
    const [sincronizando, setSincronizando] = useState<number | null>(null);

    const reemplazarContrato = (contrato: ContratoActivacion) => {
        setBusqueda((actual) => actual && ({
            ...actual,
            contratos: actual.contratos.map((c) => (c.CodProComCup === contrato.CodProComCup ? contrato : c)),
        }));
    };

    const buscar = async (cups: string): Promise<BusquedaActivacion | null> => {
        const limpio = cups.replace(/\s+/g, '').toUpperCase();
        if (limpio.length < 8) {
            await Swal.fire({ icon: 'warning', title: 'CUPS', text: 'Indique un CUPS válido.' });
            return null;
        }

        setBuscando(true);
        try {
            const { data } = await axios.get<BusquedaActivacion>(route('activaciones.buscar'), { params: { cups: limpio } });
            setBusqueda(data);
            return data;
        } catch (error) {
            setBusqueda(null);
            await Swal.fire({ icon: 'error', title: 'Sin resultados', text: mensajeError(error, 'No se pudo buscar el CUPS.') });
            return null;
        } finally {
            setBuscando(false);
        }
    };

    const actualizar = async (
        contrato: ContratoActivacion,
        form: FormularioActivacion,
        periodos: number,
    ): Promise<ContratoActivacion | null> => {
        setGuardando(true);
        try {
            const { data } = await axios.put<{ message: string; contrato: ContratoActivacion }>(
                route('activaciones.actualizar', contrato.CodProComCup),
                {
                    ...payloadContrato(form, contrato.TipCups, periodos),
                    CodPro: form.CodPro || null,
                    CodAnePro: form.CodAnePro || null,
                    TipPre: form.TipPre || null,
                    CorpoGo: numeroONulo(form.CorpoGo),
                },
            );
            reemplazarContrato(data.contrato);
            await Swal.fire({ icon: 'success', title: '¡Correcto!', text: data.message });
            return data.contrato;
        } catch (error) {
            await Swal.fire({ icon: 'error', title: 'Error', text: mensajeError(error, 'No se pudo actualizar el contrato.') });
            return null;
        } finally {
            setGuardando(false);
        }
    };

    const actualizarFechas = async (
        contrato: ContratoActivacion,
    ): Promise<{ contrato: ContratoActivacion; fechas: FechasServicio } | null> => {
        setSincronizando(contrato.CodProComCup);
        try {
            const { data } = await axios.post<{ message: string; contrato: ContratoActivacion; fechas: FechasServicio }>(
                route('activaciones.fechas-webservice', contrato.CodProComCup),
            );
            reemplazarContrato(data.contrato);
            return { contrato: data.contrato, fechas: data.fechas };
        } catch (error) {
            await Swal.fire({ icon: 'error', title: 'Sin fechas', text: mensajeError(error, 'No se pudieron consultar las fechas.') });
            return null;
        } finally {
            setSincronizando(null);
        }
    };

    const contratoRapido = async (form: FormularioContratoRapido, periodos: number): Promise<boolean> => {
        if (!busqueda) {
            return false;
        }

        setGuardando(true);
        try {
            const { data } = await axios.post<{ message: string }>(route('activaciones.contrato-rapido'), {
                ...payloadContrato(form, busqueda.cups.TipCups, periodos),
                CodCup: busqueda.cups.CodCup,
                CodCom: form.CodCom,
                CodPro: form.CodPro,
                CodAnePro: form.CodAnePro || null,
                TipPre: form.TipPre,
                CorpoGo: numeroONulo(form.CorpoGo),
                comentarios: form.comentarios || null,
            });
            await Swal.fire({ icon: 'success', title: '¡Correcto!', text: data.message });
            await buscar(busqueda.cups.CUPs);
            return true;
        } catch (error) {
            await Swal.fire({ icon: 'error', title: 'Error', text: mensajeError(error, 'No se pudo generar el contrato rápido.') });
            return false;
        } finally {
            setGuardando(false);
        }
    };

    return {
        busqueda,
        buscando,
        guardando,
        sincronizando,
        buscar,
        actualizar,
        actualizarFechas,
        contratoRapido,
    };
}