import { createStore } from 'vuex'
import service from '../utils/request' 

export default createStore({
  state: {
    user: JSON.parse(sessionStorage.getItem('user')) || null,
    balance: JSON.parse(sessionStorage.getItem('balance')) || 0,
    vipLevel: JSON.parse(sessionStorage.getItem('vipLevel')) || 0,
    borrowedBooks: JSON.parse(sessionStorage.getItem('borrowedBooks')) || [],
    sessionInitialized: false
  },
  getters: {
    isAuthenticated: state => !!state.user,
    isAdmin: state => state.user?.admin || false
  },
  mutations: {
    setUser(state, user) {
      const admin = user.admin === 1;
      const userData = {
        ...user,
        admin
      };

      state.user = user
      console.log("user")
      console.log(user)
      console.log("state.user")
      console.log(state.user)
      sessionStorage.setItem('user', JSON.stringify(user))
    },
    setBalanceAndVip(state, { balance, vip }) {
      state.balance = balance
      state.vipLevel = vip
      sessionStorage.setItem('balance', JSON.stringify(balance))
      sessionStorage.setItem('vipLevel', JSON.stringify(vip))
    },
    setBorrowedBooks(state, books) {
      state.borrowedBooks = books
      sessionStorage.setItem('borrowedBooks', JSON.stringify(books))
    },
    clearUser(state) {
      state.user = null
      state.balance = 0
      state.vipLevel = 0
      state.borrowedBooks = []
      sessionStorage.removeItem('user')
      sessionStorage.removeItem('balance')
      sessionStorage.removeItem('vipLevel')
      sessionStorage.removeItem('borrowedBooks')
    },
    removeBorrowedBook(state, title) {
      state.borrowedBooks = state.borrowedBooks.filter(book => book.title !== title)
    },
    setSessionInitialized(state, value) {
      state.sessionInitialized = value
    }
  },
  actions: {
    async initSession({ commit, dispatch }) {
      try {
        // 静默获取用户信息
        const userData = await service.get('/user/getinfo', {
          silent: true // 避免未登录时显示错误
        })
        
        if (userData && userData.username) {
          const admin = userData.admin === 1;

          commit('setUser', {
            username: userData.username,
            pic: userData.pic || '',
            admin
          })
          
          // 获取关联信息
          try {
            await dispatch('fetchBalanceAndVip')
          } catch (balanceError) {
            console.warn('获取余额信息失败:', balanceError)
          }
          
          try {
            await dispatch('fetchBorrowedBooks')
          } catch (booksError) {
            console.warn('获取借阅书籍失败:', booksError)
          }
        }
      } catch (error) {
        console.log('未检测到有效会话，用户需要重新登录')
        // 清除可能存在的无效数据
        commit('clearUser')
      } finally {
        commit('setSessionInitialized', true)
      }
    },


    // 用户登录
    async login({ dispatch }, { username, password }) {
      const response = await service.post('/user/login', 
        `username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}`,
        { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
      )
      
      // 登录成功后获取用户信息
      const userInfo = await dispatch('fetchUser')
      return {
        ...response.data,
        user: userInfo
      }
    },
    
    // 用户注册
    async register(_, { username, password }) {
      const response = await service.post('/user/register', 
        `username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}`,
        { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
      )
      
      return response.data
    },
    
    // 获取当前用户信息 - 符合接口文档
    async fetchUser({ commit, dispatch }) {
      try {
        const response = await service.get('/user/getinfo')
        const userData = response.data
        console.log("fetchUer userData")
        console.log(userData)
        const admin = userData.admin === 1;
        // 用户信息接口直接返回用户对象
        commit('setUser', {
          username: userData.username || '',
          pic: userData.pic || '',
          admin
        })
        
        // 获取关联信息
        try {
          await dispatch('fetchBalanceAndVip')
        } catch (balanceError) {
          console.error('获取余额信息失败:', balanceError)
        }
        
        try {
          await dispatch('fetchBorrowedBooks')
        } catch (booksError) {
          console.error('获取借阅书籍失败:', booksError)
        }
        
        return userData
      } catch (error) {
        commit('clearUser')
        throw error
      }
    },
    
    // 获取余额和VIP等级 - 符合接口文档1.5
    async fetchBalanceAndVip({ commit }) {
      try {
        const response = await service.post('/user/findmoney')
        const resData = response.data || {}
        if (resData.code === 200) {
          console.log("fetchBalanceAndVip resData")
          console.log(resData)
          const balance = resData.data.balance
          const vip = resData.data.vip

          // const message = resData.message || ''
          // // 使用正则表达式解析余额和VIP等级
          // const balanceMatch = message.match(/余额为：(\d+\.?\d*)元/)
          // const vipMatch = message.match(/当前VIP等级为：(\d+)/)
          console.log("balance:"+balance+",vip:"+vip)
          if (balance && vip) {
            commit('setBalanceAndVip', { balance, vip })
          } else {
            console.warn('无法解析余额或VIP信息:', message)
            commit('setBalanceAndVip', { balance: 0, vip: 0 })
          }
        } else {
          throw new Error(resData.message || '获取余额信息失败')
        }
        
        return resData
      } catch (error) {
        console.error('获取余额失败:', error)
        // 不抛出错误，避免影响其他功能
        return { code: 500, message: '获取余额失败' }
      }
    },

    
    // 账户充值 
    async recharge({ dispatch }, { money }) { // 添加 { dispatch } 解构
      const response = await service.post('/user/recharge', 
        `money=${money}`,
        { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
      )
      
      // 充值后刷新余额
      await dispatch('fetchBalanceAndVip')
      return response.data
    },
    
    // 退出登录
    async logout({ commit }) {
      commit('clearUser')
      return { code: 200, message: '已退出登录' }
    },
    
    // 查询个人借书记录 
    async fetchBorrowRecords() {
      const response = await service.get('/user/findone')
      return response.data
    },
    
    // 获取当前用户已借书籍
    async fetchBorrowedBooks({ commit }) {
  const response = await service.get('/user/borrow/books')
  
  // 按照接口文档处理响应
  if (response.data.code === 200) {
    commit('setBorrowedBooks', response.data.data || [])
  } else {
    throw new Error(response.data.message || '获取已借书籍失败')
  }
  
  return response.data
},
    
   // 租借书籍 
async borrowBook({ dispatch }, { title }) {
  const response = await service.post('/borrow/borrowbook', 
    `title=${encodeURIComponent(title)}`,
    { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
  )
  
  // 借书后刷新用户信息
  await dispatch('fetchUser')
  return response.data
},

// 归还书籍 - 符合接口文档3.2
async returnBook({ dispatch }, { title }) {
  try {
    const response = await service.post('/borrow/returnbook', 
      `title=${encodeURIComponent(title)}`,
      { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
    )
    
    // 还书成功后刷新借阅书籍列表
    await dispatch('fetchBorrowedBooks')
    
    return response.data
  } catch (error) {
    console.error('还书失败:', error)
    throw error
  }
},
   
    // 查询全部书籍 - 符合接口文档
    async fetchBooks(_, params = {}) {
      const config = {
        params: {
          page: params.page || 1,
          pageSize: params.pageSize || 10,
          title: params.keyword || ''
        }
      }
      
      const response = await service.get('/api/select', config)
      const countResponse = await service.get('/api/countArticle')

      // console.log('请求书籍:', params.title)
      // console.log('API响应:', response)
      // 处理不同响应格式
      let list = []
      let total = countResponse.data.data
      if (Array.isArray(response)) {
        list = response
        // total = response.length
      } else if (Array.isArray(response.data)) {
        list = response.data
        // total = response.data.length
      } else if (response.data && Array.isArray(response.data.data)) {
        list = response.data.data
        // total = response.data.total || response.data.data.length
      } else if (response.data && Array.isArray(response.data.list)) {
        list = response.data.list
        // total = response.data.total || response.data.list.length
      }
      
      return {
        data: {
          list,
          total
        }
      }
    },
    
    // 根据书名查单本书 - 符合接口文档2.3
    async fetchBookByTitle(_, payload) {
      const { title } = payload;
      
      try {
        const response = await service.get('/api/selectone', {
          params: { title }
        })
        
        // 根据接口文档处理响应
        if (response.data && response.data.code === 200) {
          return { data: response.data.data }
        } else {
          throw new Error(response.data?.message || '获取书籍信息失败')
        }
      } catch (error) {
        console.error('API请求失败:', error)
        throw error
      }
    },
    async fetchBookById(_, payload) {
      const { id } = payload;
      
      try {
        const response = await service.get('/api/selectById/'+id)
        
        // 根据接口文档处理响应
        if (response.data && response.data.code === 200) {
          return { data: response.data.data }
        } else {
          throw new Error(response.data?.message || '获取书籍信息失败')
        }
      } catch (error) {
        console.error('API请求失败:', error)
        throw error
      }
    },
    
    // 新增书籍 
    async addBook(_, bookData) {
      const response = await service.post('/api/add', bookData, {
        headers: { 'Content-Type': 'application/json' }
      })
      
      return response.data
    },
    
    // 管理员删除书籍 
    async deleteBook(_, { title }) {
      const response = await service.post('/user/delete', 
        `title=${encodeURIComponent(title)}`,
        { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
      )
      
      return response.data
    },
    
    // 本周热租榜 - 符合接口文档
    async fetchWeeklyRank() {
      const response = await service.get('/api/rank/weekly')
      return { data: Array.isArray(response) ? response : response.data || [] }
    },
    
    // 本月热租榜 - 符合接口文档
    async fetchMonthlyRank() {
      const response = await service.get('/api/rank/monthly')
      return { data: Array.isArray(response) ? response : response.data || [] }
    }
  }
})