import { defineStore } from 'pinia';
import { homeApi } from '@/api/modules.js';
import { authApi } from '@/api/auth.js';
import { commentApi } from '@/api/user.js';

export const useMainStore = defineStore('main', {
    state: () => ({
        user: null,
        isLoggedIn: false,
        isAuthor: false,
        token: null,
        unreadMessages: 0,  // 添加未读消息数量
        categories: [],  // 书籍分类列表
        categoriesLoaded: false  // 分类是否已加载
    }),

    getters: {
        // 计算属性：是否已认证（统一检查logic）
        isAuthenticated: (state) => {
            const hasToken = !!state.token || !!localStorage.getItem('X-Access-Token');
            const hasUser = !!state.user || !!localStorage.getItem('user');
            return state.isLoggedIn && hasToken && hasUser;
        },
        
        unreadMessageCount: (state) => state.unreadMessages,  // 添加获取未读消息数量的getter
        
        // 获取前几个分类用于导航栏显示
        navigationCategories: (state) => state.categories.slice(0, 3),
        
        // 获取所有分类
        allCategories: (state) => state.categories,
        
        // 计算属性：当前token（优先使用state中的，否则从localStorage获取）
        currentToken: (state) => state.token || localStorage.getItem('X-Access-Token'),
        
        // 计算属性：是否为作家（统一检查logic）
        isCurrentAuthor: (state) => {
            return state.isAuthor || localStorage.getItem('isAuthor') === 'true';
        }
    },

    actions: {
        /**
         * 处理登录成功后的状态更新
         * @param {Object} result API返回的登录结果
         */
        handleLoginSuccess(result) {
            const { token, userInfo } = result;
            
            if (token) {
                // 保存认证token
                this.token = token;
                localStorage.setItem('X-Access-Token', token);
                localStorage.setItem('token', token);
                
                console.log('[Store] 登录成功，token已保存');
            }
            
            if (userInfo) {
                // 更新用户信息
                this.user = userInfo;
                this.isLoggedIn = true;
                this.isAuthor = userInfo.isUser == 'Y';
                
                // 保存到本地存储
                localStorage.setItem('user', JSON.stringify(userInfo));
                localStorage.setItem('isAuthor', this.isAuthor);
                
                console.log('[Store] 用户状态已更新');
            }
        },

        /**
         * 处理用户信息更新
         * @param {Object} userInfo 用户信息
         */
        handleUserInfoUpdate(userInfo) {
            this.user = userInfo;
            this.isAuthor = userInfo.isUser == 'Y';
            
            // 更新本地存储
            localStorage.setItem('user', JSON.stringify(userInfo));
            localStorage.setItem('isAuthor', this.isAuthor);
            
            console.log('[Store] 用户信息已更新');
        },

        /**
         * 处理401错误，清除登录状态
         */
        handle401Error() {
            console.log('[Store] 处理401错误，清除登录状态');
            
            // 清除状态
            this.user = null;
            this.isLoggedIn = false;
            this.isAuthor = false;
            this.token = null;
            
            // 清除本地存储
            localStorage.removeItem('X-Access-Token');
            localStorage.removeItem('token');
            localStorage.removeItem('user');
            localStorage.removeItem('isAuthor');
            
            // 获取当前路由信息
            const currentPath = window.location.pathname;
            const isProtectedRoute = currentPath.includes('/bookshelf') || 
                                   currentPath.includes('/task-center') || 
                                   currentPath.includes('/gift-box') || 
                                   currentPath.includes('/messages') || 
                                   currentPath.includes('/author');
            
            // 如果当前在受保护的路由上，触发登录弹窗
            if (isProtectedRoute) {
                console.log('[Store] 当前在受保护路由，尝试触发登录弹窗');
                
                // 延迟执行，确保DOM已就绪
                setTimeout(() => {
                    // 尝试调用全局的登录弹窗
                    const authContext = window.$authContext;
                    if (authContext && typeof authContext.openLogin === 'function') {
                        authContext.openLogin(() => {
                            console.log('[Store] 登录成功回调');
                            // 登录成功后可以重新发起原来的请求
                            window.location.reload();
                        });
                    } else {
                        // 如果没有全局登录弹窗，使用路由事件
                        const { routerEvents } = window.$router || {};
                        if (routerEvents) {
                            routerEvents.triggerLogin = () => {
                                const context = window.$authContext;
                                if (context && typeof context.openLogin === 'function') {
                                    context.openLogin(() => {
                                        window.location.reload();
                                    });
                                }
                            };
                        }
                        
                        // 如果都不可用，跳转到首页
                        console.log('[Store] 无法触发登录弹窗，跳转到首页');
                        window.location.href = '/';
                    }
                }, 100);
            } else {
                // 如果在公开页面，只是清除状态，不跳转
                console.log('[Store] 当前在公开页面，只清除状态');
            }
        },

        /**
         * 检查当前登录状态
         */
        checkAuthStatus() {
            const token = localStorage.getItem('X-Access-Token');
            const user = localStorage.getItem('user');
            
            try {
                const userInfo = user ? JSON.parse(user) : null;
                return {
                    isLoggedIn: !!(token && userInfo),
                    token,
                    user: userInfo,
                    isAuthor: userInfo?.isAuthor || localStorage.getItem('isAuthor') === 'true'
                };
            } catch (err) {
                console.warn('[Store] 解析用户信息失败:', err);
                return {
                    isLoggedIn: false,
                    token: null,
                    user: null,
                    isAuthor: false
                };
            }
        },

        /**
         * 手动清除登录状态
         */
        clearAuthStatus() {
            this.user = null;
            this.isLoggedIn = false;
            this.isAuthor = false;
            this.token = null;
            
            // 清除本地存储
            localStorage.removeItem('X-Access-Token');
            localStorage.removeItem('token');
            localStorage.removeItem('user');
            localStorage.removeItem('isAuthor');
            
            console.log('[Store] 登录状态已清除');
        },

        async login(loginData) {
            try {
                const res = await authApi.phoneLogin(loginData);
                if (res.success) {
                    this.handleLoginSuccess(res.result);
                }
                return res.result;
            } catch (error) {
                console.error('登录失败:', error);
                throw new Error('登录失败，请稍后重试');
            }
        },

        logout() {
            console.log('[Store] 手动登出');
            
            // 清除状态
            this.user = null;
            this.isLoggedIn = false;
            this.isAuthor = false;
            this.token = null;
            
            // 清除本地存储
            localStorage.removeItem('X-Access-Token');
            localStorage.removeItem('token');
            localStorage.removeItem('user');
            localStorage.removeItem('isAuthor');
            localStorage.removeItem('bookshelf');
            
            // 跳转到首页
            if (window.location.pathname !== '/') {
                window.location.href = '/';
            }
        },
        
        // 初始化，从本地存储恢复登录状态
        async initializeAuth() {
            // 统一使用X-Access-Token作为主要token存储
            const userData = localStorage.getItem('user');
            const token = localStorage.getItem('X-Access-Token') || localStorage.getItem('token');
            const isAuthor = localStorage.getItem('isAuthor') === 'true';
            
            // 恢复用户数据和登录状态
            if (userData && token) {
                try {
                    this.user = JSON.parse(userData);
                    this.token = token;
                    this.isLoggedIn = true;
                    
                    // 确保X-Access-Token存在（迁移兼容）
                    if (!localStorage.getItem('X-Access-Token')) {
                        localStorage.setItem('X-Access-Token', token);
                    }
                    
                    // 明确设置作家状态，以localStorage为准
                    this.isAuthor = isAuthor;
                    
                    // 确保用户对象中的isAuthor与状态一致
                    if (this.user) {
                        this.user.isAuthor = isAuthor;
                    }
                    
                    console.log('[Store] 本地登录状态已恢复，正在获取最新用户信息...');
                    
                    // 从后端获取最新的用户信息
                    try {
                        await this.fetchLatestUserInfo();
                        console.log('[Store] 用户信息已更新为最新版本');
                    } catch (error) {
                        console.warn('[Store] 获取最新用户信息失败:', error);
                        // 如果是认证错误，清除登录状态
                        if (error.message.includes('401') || error.message.includes('未授权')) {
                            console.log('[Store] Token已过期，清除登录状态');
                            this.clearAuthStatus();
                            return;
                        }
                        // 其他错误不影响已恢复的登录状态，继续使用本地缓存的用户信息
                        console.log('[Store] 使用本地缓存的用户信息');
                    }
                    
                    // 输出最终的调试信息
                    console.log('[Store] Auth initialized:', {
                        isLoggedIn: this.isLoggedIn,
                        isAuthor: this.isAuthor,
                        user: this.user,
                        token: token ? '已设置' : '未设置'
                    });
                } catch (e) {
                    console.error('[Store] Error parsing user data:', e);
                    this.clearAuthStatus();
                }
            } else {
                console.log('[Store] 无有效登录状态，保持未登录状态');
                this.clearAuthStatus();
            }
        },

        // 获取最新用户信息（内部方法）
        async fetchLatestUserInfo() {
            try {
                const res = await authApi.getUserByToken();
                if (res.success && res.result) {
                    // 更新用户信息但保持现有的登录状态
                    this.handleUserInfoUpdate(res.result);
                    return res.result;
                } else {
                    throw new Error(res.message || '获取用户信息失败');
                }
            } catch (error) {
                console.error('[Store] 获取最新用户信息失败:', error);
                throw error;
            }
        },
        
        // 设置为作家身份
        setAsAuthor() {
            if (this.user) {
                this.user.isAuthor = true;
                this.isAuthor = true;
                localStorage.setItem('user', JSON.stringify(this.user));
                localStorage.setItem('isAuthor', 'true');
            }
        },
        
        // 设置未读消息数量
        async getUnreadMessages() {
            // 只有在已登录状态下才获取未读消息
            if (!this.isLoggedIn || !this.token) {
                this.unreadMessages = 0;
                return 0;
            }

            try {
                const res = await commentApi.getMyCommentNum();
                if (res.success) {
                    this.unreadMessages = res.result;
                    return res.result;
                }
            } catch (error) {
                console.error('[Store] 获取未读消息失败:', error);
                // 如果是401错误，说明token已过期，不需要显示错误
                if (!error.message.includes('401') && !error.message.includes('未授权')) {
                    // 只有非认证错误才重置未读消息数
                    this.unreadMessages = 0;
                }
            }
            return 0;
        },

        // 清除未读消息数量
        async clearUnreadMessages() {
            try {
                // 首先获取所有未读评论
                await commentApi.updateCommentRead()
                this.getUnreadMessages()
            } catch (error) {
                console.error('[Store] 清除未读消息失败:', error);
                // 即使API调用失败，也清除本地计数
                this.unreadMessages = 0;
            }
        },

        // 获取书籍分类列表
        async fetchCategories() {
            if (this.categoriesLoaded) {
                return this.categories;
            }

            try {
                const response = await homeApi.getCategoryList();
                if (response.success && response.result) {
                    this.categories = response.result
                    this.categoriesLoaded = true;
                }
                return this.categories;
            } catch (error) {
            }
        },

        // 重置分类数据（用于刷新）
        resetCategories() {
            this.categories = [];
            this.categoriesLoaded = false;
        },

        // 获取用户信息
        async getUserInfo() {
            const res = await authApi.getUserByToken();
            if (res.success) {
                this.handleUserInfoUpdate(res.result);
            }
            return res.result;
        },

        // 更新用户信息
        async updateUserInfo(updateData) {
            try {
                // 这里应该调用更新用户信息的API
                const res = await authApi.updateUserInfo(updateData);
                
                // 更新本地用户信息
                if (this.user) {
                    this.user = { ...this.user, ...updateData };
                    localStorage.setItem('user', JSON.stringify(this.user));
                }
                
                return { success: true };
            } catch (error) {
                console.error('更新用户信息失败:', error);
                throw error;
            }
        },

        // 刷新用户信息
        async fetchUserInfo() {
            try {
                await this.getUserInfo();
            } catch (error) {
                console.error('获取用户信息失败:', error);
            }
        }
    }
}); 