import { ref, onMounted, onUnmounted } from 'vue';
import { useRouter } from 'vue-router';

/**
 * 全局用户空闲超时处理
 * @param {number} timeout - 超时时间（毫秒），默认3分钟
 * @param {string} redirectPath - 超时后跳转的路径，默认指纹登录页
 * @param {Array} excludePaths - 排除的路径列表，不启用超时功能的页面
 */
export function useIdleTimeout(
    timeout = 3 * 60 * 1000, // 3分钟
    redirectPath = '/fingerprint-login',
    excludePaths = ['/', '/fingerprint-login', '/fingerprint-enroll'],
) {
    const router = useRouter();
    const isIdle = ref(false);
    let idleTimer = null;

    // 检查当前路径是否需要排除
    const shouldExclude = () => {
        const currentPath = router.currentRoute.value.path;
        return excludePaths.includes(currentPath);
    };

    // 重置空闲计时器
    const resetIdleTimer = () => {
    // 如果当前页面需要排除，则不启动计时器
        if (shouldExclude()) {
            return;
        }

        // 清除现有计时器
        if (idleTimer) {
            clearTimeout(idleTimer);
            idleTimer = null;
        }

        isIdle.value = false;

        // 设置新的计时器
        idleTimer = setTimeout(() => {
            // 再次检查是否需要排除，避免在计时期间切换到登录页
            if (!shouldExclude()) {
                isIdle.value = true;
                handleIdleTimeout();
            }
        }, timeout);
    };

    // 处理空闲超时
    const handleIdleTimeout = () => {
        console.log('用户空闲超时，跳转到指纹登录页');
    
        // 清理计时器
        clearIdleTimer();
    
        // 跳转到指纹登录页
        router.push(redirectPath);
    };

    // 清理空闲计时器
    const clearIdleTimer = () => {
        if (idleTimer) {
            clearTimeout(idleTimer);
            idleTimer = null;
        }
        isIdle.value = false;
    };

    // 需要监听的用户活动事件
    const events = [
        'mousedown',
        'mousemove', 
        'keypress',
        'scroll',
        'touchstart',
        'click',
        'contextmenu',
        'dblclick',
        'wheel',
    ];

    // 事件处理函数（使用防抖，避免频繁重置）
    let debounceTimer = null;
    const handleUserActivity = () => {
        if (debounceTimer) {
            clearTimeout(debounceTimer);
        }
    
        debounceTimer = setTimeout(() => {
            resetIdleTimer();
        }, 100); // 100ms防抖
    };

    // 启动空闲检测
    const startIdleDetection = () => {
    // 如果当前页面需要排除，则不启动
        if (shouldExclude()) {
            return;
        }

        // 添加事件监听器
        events.forEach(event => {
            document.addEventListener(event, handleUserActivity, true);
        });

        // 启动初始计时器
        resetIdleTimer();
    };

    // 停止空闲检测
    const stopIdleDetection = () => {
    // 移除事件监听器
        events.forEach(event => {
            document.removeEventListener(event, handleUserActivity, true);
        });

        // 清理计时器
        clearIdleTimer();
    
        if (debounceTimer) {
            clearTimeout(debounceTimer);
            debounceTimer = null;
        }
    };

    // 监听路由变化，动态启停空闲检测
    const setupRouteWatcher = () => {
    // 监听路由变化
        router.beforeEach((to, from, next) => {
            // 如果跳转到排除的页面，停止检测
            if (excludePaths.includes(to.path)) {
                stopIdleDetection();
            } else {
                // 如果从排除页面跳转到普通页面，启动检测
                if (excludePaths.includes(from.path)) {
                    // 延迟启动，确保页面已完全加载
                    setTimeout(() => {
                        startIdleDetection();
                    }, 1000);
                }
            }
            next();
        });
    };

    // 组件挂载时启动
    onMounted(() => {
        setupRouteWatcher();
        startIdleDetection();
    });

    // 组件卸载时清理
    onUnmounted(() => {
        stopIdleDetection();
    });

    return {
        isIdle,
        resetIdleTimer,
        startIdleDetection,
        stopIdleDetection,
    };
}
