/**
 * 认证服务
 * 处理用户认证、Token管理、自动重新登录等功能
 */

import { useUserStore } from '@/stores/user'
import { authAPI } from '@/utils/api'

class AuthService {
  constructor() {
    this.isAutoReloginInProgress = false
    this.autoReloginPromise = null
  }

  /**
   * 自动重新登录
   * @returns {Promise<boolean>} 是否成功
   */
  async autoRelogin() {
    // 如果正在进行自动重新登录，返回现有的Promise
    if (this.isAutoReloginInProgress) {
      return this.autoReloginPromise
    }

    this.isAutoReloginInProgress = true
    this.autoReloginPromise = this._performAutoRelogin()

    try {
      const result = await this.autoReloginPromise
      return result
    } finally {
      this.isAutoReloginInProgress = false
      this.autoReloginPromise = null
    }
  }

  /**
   * 执行自动重新登录
   * @private
   */
  async _performAutoRelogin() {
    const userStore = useUserStore()

    try {
      console.log('开始自动重新登录流程...')

      // 1. 检查是否有有效的refresh token
      if (userStore.refreshToken) {
        try {
          console.log('尝试使用refresh token刷新访问令牌...')
          await userStore.refreshAccessToken()
          console.log('使用refresh token自动重新登录成功')
          return true
        } catch (error) {
          console.error('refresh token刷新失败:', error)
          // refresh token可能已过期，继续尝试其他方式
        }
      }

      // 2. 检查是否有记住的登录信息
      const rememberedCredentials = this.getRememberedCredentials()
      if (rememberedCredentials) {
        try {
          console.log('尝试使用记住的登录信息自动登录...')
          const response = await authAPI.login(rememberedCredentials)
          
          if (response.status === 'success') {
            // 更新用户store中的认证信息
            const authData = response.data
            if (authData.accessToken && authData.refreshToken) {
              userStore.setAuthData({
                accessToken: authData.accessToken,
                refreshToken: authData.refreshToken,
                accessTokenExpiresAt: authData.accessTokenExpiresAt,
                refreshTokenExpiresAt: authData.refreshTokenExpiresAt,
                userInfo: authData.userInfo
              })
            }
            
            console.log('使用记住的登录信息自动重新登录成功')
            return true
          }
        } catch (error) {
          console.error('使用记住的登录信息自动登录失败:', error)
        }
      }

      // 3. 尝试静默登录（如果支持）
      if (this.supportsSilentLogin()) {
        try {
          console.log('尝试静默登录...')
          const success = await this.performSilentLogin()
          if (success) {
            console.log('静默登录成功')
            return true
          }
        } catch (error) {
          console.error('静默登录失败:', error)
        }
      }

      console.log('所有自动重新登录方式都失败了')
      return false

    } catch (error) {
      console.error('自动重新登录过程中发生未预期的错误:', error)
      return false
    }
  }

  /**
   * 获取记住的登录凭据
   * 注意：出于安全考虑，这里只是示例，实际项目中不应该保存密码
   */
  getRememberedCredentials() {
    try {
      // 检查localStorage中是否有记住的用户名
      const rememberedUsername = localStorage.getItem('rememberedUsername')
      const rememberLogin = localStorage.getItem('rememberLogin') === 'true'
      
      if (rememberedUsername && rememberLogin) {
        // 注意：这里不应该保存密码，这只是一个示例
        // 实际项目中可以考虑使用设备指纹、生物识别等更安全的方式
        console.log('找到记住的用户名:', rememberedUsername)
        
        // 可以返回用户名，让用户重新输入密码
        // 或者使用其他安全的认证方式
        return null // 暂时返回null，因为不保存密码
      }
      
      return null
    } catch (error) {
      console.error('获取记住的登录凭据失败:', error)
      return null
    }
  }

  /**
   * 检查是否支持静默登录
   */
  supportsSilentLogin() {
    // 可以根据环境、设备能力等判断是否支持静默登录
    // 例如：生物识别、设备证书等
    return false
  }

  /**
   * 执行静默登录
   */
  async performSilentLogin() {
    // 这里可以实现各种静默登录方式
    // 例如：
    // - 生物识别登录
    // - 设备证书登录
    // - SSO单点登录
    // - 第三方OAuth登录
    
    return false
  }

  /**
   * 保存登录凭据（记住登录）
   * @param {string} username 用户名
   * @param {boolean} remember 是否记住
   */
  saveLoginCredentials(username, remember = false) {
    try {
      if (remember) {
        localStorage.setItem('rememberedUsername', username)
        localStorage.setItem('rememberLogin', 'true')
        console.log('已保存记住的登录信息')
      } else {
        localStorage.removeItem('rememberedUsername')
        localStorage.removeItem('rememberLogin')
        console.log('已清除记住的登录信息')
      }
    } catch (error) {
      console.error('保存登录凭据失败:', error)
    }
  }

  /**
   * 清除所有保存的登录凭据
   */
  clearSavedCredentials() {
    try {
      localStorage.removeItem('rememberedUsername')
      localStorage.removeItem('rememberLogin')
      console.log('已清除所有保存的登录凭据')
    } catch (error) {
      console.error('清除保存的登录凭据失败:', error)
    }
  }

  /**
   * 检查认证状态
   */
  async checkAuthStatus() {
    const userStore = useUserStore()
    
    try {
      // 确保Token有效
      const isValid = await userStore.ensureValidToken()
      
      if (!isValid) {
        // 尝试自动重新登录
        const autoLoginSuccess = await this.autoRelogin()
        return autoLoginSuccess
      }
      
      return true
    } catch (error) {
      console.error('检查认证状态失败:', error)
      return false
    }
  }

  /**
   * 登出并清除所有认证信息
   */
  logout() {
    const userStore = useUserStore()
    userStore.logout()
    this.clearSavedCredentials()
    console.log('用户已登出，所有认证信息已清除')
  }
}

// 创建单例实例
const authService = new AuthService()

export default authService