/**
 * 官网用户认证模块
 * 处理登录、登出、Token管理
 */

class WebAuth {
    constructor() {
        this.tokenKey = 'web_access_token';
        this.userKey = 'web_user_info';
        this.apiBase = '/api/v1/web-auth';
    }

    /**
     * 获取存储的Token
     */
    getToken() {
        return localStorage.getItem(this.tokenKey);
    }

    /**
     * 保存Token
     */
    saveToken(token) {
        localStorage.setItem(this.tokenKey, token);
    }

    /**
     * 清除Token
     */
    clearToken() {
        localStorage.removeItem(this.tokenKey);
        localStorage.removeItem(this.userKey);
    }

    /**
     * 获取用户信息
     */
    getUserInfo() {
        const userStr = localStorage.getItem(this.userKey);
        return userStr ? JSON.parse(userStr) : null;
    }

    /**
     * 保存用户信息
     */
    saveUserInfo(user) {
        localStorage.setItem(this.userKey, JSON.stringify(user));
    }

    /**
     * 用户注册
     */
    async register(username, password, passwordConfirm) {
        try {
            const response = await fetch(`${this.apiBase}/register`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    username,
                    password,
                    password_confirm: passwordConfirm
                })
            });

            if (!response.ok) {
                const error = await response.json();
                throw new Error(error.detail || '注册失败');
            }

            const data = await response.json();
            this.saveToken(data.access_token);
            this.saveUserInfo(data.user);

            return { success: true, user: data.user };
        } catch (error) {
            return { success: false, error: error.message };
        }
    }

    /**
     * 用户登录
     */
    async login(username, password) {
        try {
            const response = await fetch(`${this.apiBase}/login`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ username, password })
            });

            if (!response.ok) {
                const error = await response.json();
                throw new Error(error.detail || '登录失败');
            }

            const data = await response.json();
            this.saveToken(data.access_token);
            this.saveUserInfo(data.user);

            return { success: true, user: data.user };
        } catch (error) {
            return { success: false, error: error.message };
        }
    }

    /**
     * 用户登出
     */
    async logout() {
        const token = this.getToken();
        if (token) {
            try {
                await fetch(`${this.apiBase}/logout`, {
                    method: 'POST',
                    headers: {
                        'Authorization': `Bearer ${token}`
                    }
                });
            } catch (error) {
                console.error('登出请求失败:', error);
            }
        }
        this.clearToken();
    }

    /**
     * 获取当前用户权限配置
     */
    async getPermissions() {
        const token = this.getToken();
        const headers = {};
        if (token) {
            headers['Authorization'] = `Bearer ${token}`;
        }

        try {
            const response = await fetch(`${this.apiBase}/permissions`, {
                headers
            });
            return await response.json();
        } catch (error) {
            console.error('获取权限失败:', error);
            return null;
        }
    }

    /**
     * 检查是否已登录
     */
    isLoggedIn() {
        return !!this.getToken();
    }

    /**
     * 检查Token是否仍然有效
     * @returns {Promise<boolean>} Token是否有效
     */
    async checkTokenValidity() {
        const token = this.getToken();
        if (!token) {
            return false;
        }

        try {
            // 调用轻量级的API端点来验证Token
            const response = await fetch(`${this.apiBase}/verify-token`, {
                method: 'GET',
                headers: {
                    'Authorization': `Bearer ${token}`
                }
            });

            return response.ok;
        } catch (error) {
            console.error('[Token检查] 检查失败:', error);
            return false;
        }
    }
}

// 创建全局实例
const webAuth = new WebAuth();


// ============================================
// 权限检查辅助函数
// ============================================

/**
 * 显示权限不足提示
 * @param {string} feature - 功能名称
 * @param {string} requiredLevel - 所需等级
 */
function showPermissionDenied(feature, requiredLevel) {
    const levelText = {
        'normal': '普通用户',
        'vip': 'VIP用户',
        'pro': 'PRO用户'
    };

    const levelName = levelText[requiredLevel] || requiredLevel;
    alert(`${feature}功能需要${levelName}权限，请升级您的账号等级`);
}

/**
 * 检查功能权限
 * @param {string} feature - 功能名称（traits/advanced_search/goods_detail）
 * @returns {boolean} 是否有权限
 */
function checkFeaturePermission(feature) {
    const userInfo = webAuth.getUserInfo();

    if (!userInfo) {
        alert('请先登录');
        return false;
    }

    const userLevel = userInfo.user_level || 'guest';
    const permissions = userInfo.permissions || {};

    // 根据功能检查权限
    switch(feature) {
        // 已移除 case 'export' - 官网不再提供数据导出功能（2026-01-20）

        case 'traits':
            // 特征查看 - 普通用户及以上
            if (userLevel === 'guest') {
                alert('请先登录查看特征信息');
                return false;
            }
            break;

        case 'advanced_search':
            // 高级搜索（特征搜索）- VIP及以上
            if (!['vip', 'pro'].includes(userLevel)) {
                showPermissionDenied('高级搜索', 'vip');
                return false;
            }
            break;

        case 'goods_detail':
            // 商品详情查看 - 普通用户及以上
            if (userLevel === 'guest') {
                alert('请先登录查看商品详情');
                return false;
            }
            break;

        case 'seller_search':
            // 卖家搜索 - PRO用户
            if (userLevel !== 'pro') {
                showPermissionDenied('卖家搜索', 'pro');
                return false;
            }
            break;

        default:
            console.warn(`未知的功能: ${feature}`);
            return true;
    }

    return true;
}

/**
 * 获取用户等级显示文本
 * @param {string} level - 用户等级
 * @returns {string} 显示文本
 */
function getUserLevelText(level) {
    const levelMap = {
        'guest': '游客',
        'normal': '普通用户',
        'vip': 'VIP用户',
        'pro': 'PRO用户'
    };
    return levelMap[level] || '未知';
}

/**
 * 检查搜索类型权限
 * @param {string} searchType - 搜索类型（name/all/trait/seller）
 * @returns {boolean} 是否有权限
 */
function checkSearchTypePermission(searchType) {
    const userInfo = webAuth.getUserInfo();
    const userLevel = userInfo ? (userInfo.user_level || 'guest') : 'guest';

    const searchTypePermissions = {
        'guest': ['name'],
        'normal': ['name', 'all'],
        'vip': ['name', 'all', 'trait'],
        'pro': ['name', 'all', 'trait', 'seller']
    };

    const allowedTypes = searchTypePermissions[userLevel] || ['name'];

    if (!allowedTypes.includes(searchType)) {
        if (userLevel === 'guest') {
            alert('游客只能使用名称搜索，请登录使用更多搜索功能');
        } else {
            const requiredLevel = searchType === 'seller' ? 'pro' : 'vip';
            showPermissionDenied('此搜索类型', requiredLevel);
        }
        return false;
    }

    return true;
}