import { useCallback, useEffect, useRef, useState } from 'react';

export type BulkLoadProgressStatus = 'idle' | 'loading' | 'success' | 'error';

export interface BulkLoadProgressState {
    status: BulkLoadProgressStatus;
    percent: number;
    message: string;
}

export interface BulkLoadProgressControls {
    start: (message?: string) => void;
    update: (current: number, total: number, message?: string) => void;
    setPercent: (percent: number, message?: string) => void;
    complete: (message?: string) => void;
    fail: (message?: string) => void;
}

const ESTADO_INICIAL: BulkLoadProgressState = {
    status: 'idle',
    percent: 0,
    message: '',
};

function calcularPorcentaje(current: number, total: number): number {
    if (total <= 0) {
        return 1;
    }

    return Math.min(100, Math.max(1, Math.round((current / total) * 100)));
}

export function useBulkLoadProgress(autoHideMs = 2200): BulkLoadProgressState & BulkLoadProgressControls {
    const [state, setState] = useState<BulkLoadProgressState>(ESTADO_INICIAL);
    const hideTimerRef = useRef<number | null>(null);

    const clearHideTimer = useCallback(() => {
        if (hideTimerRef.current !== null) {
            window.clearTimeout(hideTimerRef.current);
            hideTimerRef.current = null;
        }
    }, []);

    const scheduleHide = useCallback(() => {
        clearHideTimer();
        hideTimerRef.current = window.setTimeout(() => {
            setState(ESTADO_INICIAL);
        }, autoHideMs);
    }, [autoHideMs, clearHideTimer]);

    useEffect(() => () => clearHideTimer(), [clearHideTimer]);

    const start = useCallback((message = 'Iniciando carga masiva...') => {
        clearHideTimer();
        setState({
            status: 'loading',
            percent: 1,
            message,
        });
    }, [clearHideTimer]);

    const setPercent = useCallback((percent: number, message?: string) => {
        setState((prev) => ({
            status: 'loading',
            percent: Math.min(100, Math.max(1, Math.round(percent))),
            message: message ?? prev.message,
        }));
    }, []);

    const update = useCallback((current: number, total: number, message?: string) => {
        setState((prev) => ({
            status: 'loading',
            percent: calcularPorcentaje(current, total),
            message: message ?? prev.message,
        }));
    }, []);

    const complete = useCallback((message = 'Carga completada') => {
        clearHideTimer();
        setState({
            status: 'success',
            percent: 100,
            message,
        });
        scheduleHide();
    }, [clearHideTimer, scheduleHide]);

    const fail = useCallback((message = 'Error en la carga masiva') => {
        clearHideTimer();
        setState((prev) => ({
            status: 'error',
            percent: prev.percent > 0 ? prev.percent : 100,
            message,
        }));
        scheduleHide();
    }, [clearHideTimer, scheduleHide]);

    return {
        ...state,
        start,
        update,
        setPercent,
        complete,
        fail,
    };
}

/** Una sola capa modal: eléctrico tiene prioridad si ambos están activos. */
export function resolveActiveBulkLoadProgress(
    electrico: BulkLoadProgressState,
    gas: BulkLoadProgressState,
): BulkLoadProgressState | null {
    if (electrico.status !== 'idle') {
        return electrico;
    }
    if (gas.status !== 'idle') {
        return gas;
    }
    return null;
}