/**
 * 登录状态检查和管理工具
 */

/**
 * 检查当前登录状态
 * @returns {Object} 登录状态信息
 */
export const checkLoginStatus = () => {
    const token = localStorage.getItem('X-Access-Token');
    const userData = localStorage.getItem('user');
    const isAuthor = localStorage.getItem('isAuthor') === 'true';
    
    try {
        const user = userData ? JSON.parse(userData) : null;
        return {
            isLoggedIn: !!(token && user),
            token,
            user,
            isAuthor
        };
    } catch (error) {
        console.warn('[Auth Utils] 解析用户数据失败:', error);
        return {
            isLoggedIn: false,
            token: null,
            user: null,
            isAuthor: false
        };
    }
};

/**
 * 刷新用户信息（从后端获取最新数据）
 * @returns {Promise<Object>} 最新的用户信息
 */
export const refreshUserInfo = async () => {
    const { isLoggedIn } = checkLoginStatus();
    
    if (!isLoggedIn) {
        throw new Error('用户未登录');
    }
    
    const store = window.$store;
    if (store && typeof store.fetchLatestUserInfo === 'function') {
        try {
            const userInfo = await store.fetchLatestUserInfo();
            return userInfo;
        } catch (error) {
            console.error('[Auth Utils] 刷新用户信息失败:', error);
            throw error;
        }
    } else {
        throw new Error('Store不可用');
    }
};

/**
 * 检查是否已登录，如果未登录则触发登录弹窗
 * @param {Function} callback 登录成功后的回调函数
 * @returns {Boolean} 是否已登录
 */
export const requireLogin = (callback) => {
    const { isLoggedIn } = checkLoginStatus();
    
    if (isLoggedIn) {
        callback && callback();
        return true;
    }
    
    // 未登录，触发登录弹窗
    triggerLogin(callback);
    return false;
};

/**
 * 检查是否为作家身份，如果不是则触发相应弹窗
 * @param {Function} callback 申请成功后的回调函数
 * @returns {Boolean} 是否为作家
 */
export const requireAuthor = (callback) => {
    const { isLoggedIn, isAuthor } = checkLoginStatus();
    
    if (!isLoggedIn) {
        // 未登录，先登录再申请作家
        triggerLogin(() => {
            triggerAuthorApplication(callback);
        });
        return false;
    }
    
    if (isAuthor) {
        return true;
    }
    
    // 已登录但不是作家，触发作家申请
    triggerAuthorApplication(callback);
    return false;
};

/**
 * 触发登录弹窗
 * @param {Function} callback 登录成功后的回调函数
 */
export const triggerLogin = (callback) => {
    const authContext = window.$authContext;
    
    if (authContext && typeof authContext.openLogin === 'function') {
        authContext.openLogin(callback);
    } else {
        // 如果authContext还未挂载，则设置事件供之后触发
        const triggerLoginEvent = () => {
            const context = window.$authContext;
            if (context && typeof context.openLogin === 'function') {
                context.openLogin(callback);
            }
        };
        
        if (window.routerEvents) {
            window.routerEvents.triggerLogin = triggerLoginEvent;
        } else {
            console.warn('[Auth Utils] 无法触发登录弹窗，routerEvents不可用');
        }
    }
};

/**
 * 触发作家申请弹窗
 * @param {Function} callback 申请成功后的回调函数
 */
export const triggerAuthorApplication = (callback) => {
    const authorContext = window.$authorApplicationContext;
    
    if (authorContext && typeof authorContext.openApplicationModal === 'function') {
        authorContext.openApplicationModal(callback);
    } else {
        console.warn('[Auth Utils] 无法触发作家申请弹窗，authorApplicationContext不可用');
    }
};

/**
 * 清除登录状态（登出）
 */
export const clearLoginStatus = () => {
    // 清除本地存储
    localStorage.removeItem('X-Access-Token');
    localStorage.removeItem('token');
    localStorage.removeItem('user');
    localStorage.removeItem('isAuthor');
    localStorage.removeItem('bookshelf');
    
    console.log('[Auth Utils] 登录状态已清除');
    
    // 如果有store，也清除store状态
    if (window.$store) {
        window.$store.clearAuthStatus();
    }
};

/**
 * 页面按钮点击前的登录检查装饰器
 * @param {Function} fn 原始点击处理函数
 * @param {Object} options 配置选项
 * @param {Boolean} options.requireAuth 是否需要登录
 * @param {Boolean} options.requireAuthor 是否需要作家身份
 * @returns {Function} 包装后的点击处理函数
 */
export const withAuthCheck = (fn, options = {}) => {
    return (...args) => {
        const { requireAuth = false, requireAuthor = false } = options;
        
        if (requireAuthor) {
            // 需要作家身份
            if (requireAuthor(() => fn(...args))) {
                fn(...args);
            }
        } else if (requireAuth) {
            // 需要登录
            if (requireLogin(() => fn(...args))) {
                fn(...args);
            }
        } else {
            // 不需要任何权限
            fn(...args);
        }
    };
};

/**
 * Vue组合式API版本的登录检查hook
 * @returns {Object} 登录检查相关的方法
 */
export const useAuthCheck = () => {
    return {
        checkLoginStatus,
        requireLogin,
        requireAuthor,
        triggerLogin,
        triggerAuthorApplication,
        clearLoginStatus,
        withAuthCheck,
        refreshUserInfo
    };
};

export default {
    checkLoginStatus,
    requireLogin,
    requireAuthor,
    triggerLogin,
    triggerAuthorApplication,
    clearLoginStatus,
    withAuthCheck,
    useAuthCheck,
    refreshUserInfo
}; 