import { api } from '@/api/index'

// Token 刷新定时器（每 23 小时自动续期）
let refreshTimer = null
const REFRESH_INTERVAL = 23 * 60 * 60 * 1000

export default {
  namespaced: true,
  state: {
    isLogin: false,
    token: '',
    deviceUuid: '',
    userInfo: {
      id: '',
      username: '',
      isSuper: false,
      permissionEnterpriseIds: ''
    },
    // 企业信息（仅存储在内存中，不缓存本地）
    enterpriseInfo: {
      enterpriseName: '',
      fullEnterpriseName: '',
      enterpriseId: ''
    }
  },
  mutations: {
    SET_LOGIN(state, status) {
      state.isLogin = status
    },
    SET_TOKEN(state, token) {
      state.token = token
    },
    SET_DEVICE_UUID(state, uuid) {
      state.deviceUuid = uuid
    },
    SET_USER_INFO(state, userInfo) {
      state.userInfo = userInfo
    },
    SET_ENTERPRISE_INFO(state, enterpriseInfo) {
      state.enterpriseInfo = { ...state.enterpriseInfo, ...enterpriseInfo }
    },
    CLEAR_ENTERPRISE_INFO(state) {
      state.enterpriseInfo = {
        enterpriseName: '',
        fullEnterpriseName: '',
        enterpriseId: ''
      }
    },
    LOGOUT(state) {
      state.isLogin = false
      state.token = ''
      state.deviceUuid = ''
      state.userInfo = {
        id: '',
        username: '',
        isSuper: false,
        permissionEnterpriseIds: ''
      }
      // 清除企业信息
      state.enterpriseInfo = {
        enterpriseName: '',
        fullEnterpriseName: '',
        enterpriseId: ''
      }
    }
  },
  actions: {
    login({ commit, dispatch }, { token, userInfo, deviceUuid }) {
      commit('SET_TOKEN', token)
      commit('SET_USER_INFO', userInfo)
      commit('SET_DEVICE_UUID', deviceUuid || '')
      commit('SET_LOGIN', true)

      // 保存到本地存储
      uni.setStorageSync('token', token)
      uni.setStorageSync('userInfo', userInfo)
      uni.setStorageSync('deviceUuid', deviceUuid || '')

      // 启动 Token 自动续期定时器
      dispatch('startTokenRefresh')
    },
    logout({ commit }) {
      // 清除定时器
      if (refreshTimer) {
        clearInterval(refreshTimer)
        refreshTimer = null
      }

      // 尝试通知服务端登出
      api.logout().catch(() => {})

      commit('LOGOUT')

      // 清除本地存储
      uni.removeStorageSync('token')
      uni.removeStorageSync('userInfo')
      uni.removeStorageSync('deviceUuid')
      uni.reLaunch({ url: '/pages/login/login' })
    },
    startTokenRefresh({ state }) {
      if (refreshTimer) {
        clearInterval(refreshTimer)
      }
      refreshTimer = setInterval(() => {
        if (state.token) {
          api.refreshToken().catch(() => {})
        }
      }, REFRESH_INTERVAL)
    },
    updateUserInfo({ commit, state }, updates) {
      const newUserInfo = { ...state.userInfo, ...updates }
      commit('SET_USER_INFO', newUserInfo)

      // 更新本地存储
      uni.setStorageSync('userInfo', newUserInfo)
    },
    // 获取企业信息（有缓存则直接返回，否则从网络获取）
    async getEnterpriseInfo({ commit, state }) {
      // 如果已有企业信息，直接返回
      if (state.enterpriseInfo.enterpriseName || state.enterpriseInfo.fullEnterpriseName) {
        return state.enterpriseInfo
      }
      
      // 否则从网络获取
      try {
        const res = await api.defaultInfo()
        console.log('获取企业信息', res)
        if (res.code === 1000) {
          const enterpriseInfo = {
            enterpriseName: res.data.enterprise_name || '',
            fullEnterpriseName: res.data.full_enterprise_name || '',
            enterpriseId: res.data.eid || ''
          }
          commit('SET_ENTERPRISE_INFO', enterpriseInfo)
          return enterpriseInfo
        }
        return null
      } catch (error) {
        console.error('获取企业信息失败:', error)
        return null
      }
    }
  },
  getters: {
    isAdmin: state => state.userInfo.isSuper,
    hasPermission: state => permission => {
      return state.userInfo.permissionEnterpriseIds === '*' ||
        (state.userInfo.permissionEnterpriseIds || '').split(',').includes(permission)
    },
    enterpriseName: state => state.enterpriseInfo.fullEnterpriseName || state.enterpriseInfo.enterpriseName || '',
    enterpriseInfo: state => state.enterpriseInfo
  }
}