/**
 * 认证服务 - 处理登录、注册、Token 管理
 * @module services/auth
 */
import request from '@/utils/request'
import config from '@/utils/config'

/**
 * 认证相关 API
 */
export const authApi = {
  /**
   * 微信小程序登录
   * @param {Object} data - 登录参数
   * @param {String} data.xcxCode - 微信小程序 code
   * @param {String} data.phoneNumber - 手机号
   * @param {String} data.password - 密码
   * @param {String} data.code - 验证码
   * @returns {Promise<Object>} 登录结果，包含 token 和 userInfo
   */
  wxLogin(data) {
    return request({
      url: config.login.url,
      method: 'POST',
      data,
      loading: true
    })
  },

  /**
   * 获取租户列表
   * @returns {Promise<Array>} 租户列表
   */
  getTenantList() {
    return request({
      url: config.tenant.listUrl,
      method: 'GET'
    })
  },

  /**
   * 获取验证码
   * @param {String} phoneNumber - 手机号
   * @returns {Promise<Object>} 验证码信息
   */
  getCaptcha(phoneNumber) {
    return request({
      url: config.captcha.url,
      method: 'GET',
      data: { phoneNumber }
    })
  },

  /**
   * 刷新 Token
   * @param {String} refreshToken - 刷新令牌
   * @returns {Promise<Object>} 新的 token 信息
   */
  refreshToken(refreshToken) {
    return request({
      url: '/auth/refresh',
      method: 'POST',
      data: { refreshToken }
    })
  },

  /**
   * 验证 Token 有效性
   * @returns {Promise<Boolean>} Token 是否有效
   */
  async verifyToken() {
    try {
      await request({
        url: '/auth/verify',
        method: 'GET'
      })
      return true
    } catch (error) {
      return false
    }
  }
}

/**
 * 用户注册 API
 */
export const registerApi = {
  /**
   * 用户注册
   * @param {Object} data - 注册参数
   * @param {String} data.phoneNumber - 手机号
   * @param {String} data.password - 密码
   * @param {String} data.code - 验证码
   * @param {String} data.nickName - 昵称
   * @returns {Promise<Object>} 注册结果
   */
  register(data) {
    return request({
      url: '/auth/register',
      method: 'POST',
      data,
      loading: true
    })
  },

  /**
   * 检查手机号是否已注册
   * @param {String} phoneNumber - 手机号
   * @returns {Promise<Boolean>} 是否已注册
   */
  async checkPhoneExists(phoneNumber) {
    try {
      const res = await request({
        url: '/auth/check-phone',
        method: 'GET',
        data: { phoneNumber }
      })
      return res.data.exists
    } catch (error) {
      return false
    }
  }
}

/**
 * 用户信息 API
 */
export const userApi = {
  /**
   * 获取用户信息
   * @returns {Promise<Object>} 用户信息
   */
  getUserInfo() {
    return request({
      url: '/system/user/getInfo',
      method: 'GET'
    })
  },

  /**
   * 更新用户信息
   * @param {Object} data - 用户信息
   * @returns {Promise<Object>} 更新结果
   */
  updateUserInfo(data) {
    return request({
      url: '/system/user/update',
      method: 'PUT',
      data
    })
  },

  /**
   * 修改密码
   * @param {Object} data - 密码参数
   * @param {String} data.oldPassword - 旧密码
   * @param {String} data.newPassword - 新密码
   * @returns {Promise<Object>} 修改结果
   */
  changePassword(data) {
    return request({
      url: '/system/user/changePassword',
      method: 'POST',
      data,
      loading: true
    })
  }
}

export default {
  auth: authApi,
  register: registerApi,
  user: userApi
}

/**
 * 微信登录请求封装（包含 uni.login 流程）
 * @param {Object} loginForm - 登录表单数据
 * @returns {Promise<Object>} 登录结果
 */
export const wxLoginRequest = (loginForm) => {
  return new Promise((resolve, reject) => {
    uni.login({
      success: res => {
        console.log('wx.login 调用成功，返回的 code 是：', res)
        if (res.code) {
          const requestData = {
            ...loginForm,
            xcxCode: res.code
          }
          console.log('请求数据：', requestData)
          authApi.wxLogin(requestData)
            .then(response => {
              console.log('服务器返回的数据：', response)
              const data = response.data
              if (data && data.openid && data.access_token) {
                uni.setStorageSync('token', data.access_token)
                resolve(response)
              } else {
                let errorMsg = response.msg || '登录失败'
                console.log('登录失败，错误信息：', errorMsg)
                uni.showToast({ title: '用户名密码不正确', icon: 'none' })
                reject(response)
              }
            })
            .catch(err => {
              console.log('请求服务器失败，错误信息：', err)
              uni.showToast({ title: '请求服务器失败', icon: 'none' })
              reject(err)
            })
        } else {
          console.log('获取登录凭证失败，错误信息：', res.errMsg)
          uni.showToast({ title: '获取登录凭证失败', icon: 'none' })
          reject(res)
        }
      },
      fail: err => {
        console.log('调用 wx.login 失败，错误信息：', err)
        uni.showToast({ title: '调用 wx.login 失败', icon: 'none' })
        reject(err)
      }
    })
  })
}

/**
 * 注册请求封装
 * @param {Object} registerForm - 注册表单数据
 * @returns {Promise<Object>} 注册结果
 */
export const registerRequest = (registerForm) => {
  return new Promise((resolve, reject) => {
    console.log('开始注册，提交数据:', registerForm)
    uni.request({
      url: 'https://api.buzhiyushu.cn/auth/register',
      method: 'POST',
      data: registerForm,
      header: {
        clientId: '1400a724f627ddc73d8f4dd344f80a5e',
        isToken: 'false',
        isEncrypt: 'false',
        repeatSubmit: 'false'
      },
      success: response => {
        console.log('服务器返回的数据：', response.data)
        if (response.data.code === 200) {
          uni.showToast({ title: '注册成功', icon: 'success' })
          resolve(response.data)
        } else {
          uni.showToast({ title: response.data.msg || '注册失败', icon: 'none' })
          reject(response.data)
        }
      },
      fail: err => {
        console.log('请求服务器失败，错误信息：', err)
        uni.showToast({ title: '请求服务器失败', icon: 'none' })
        reject(err)
      }
    })
  })
}

/**
 * 验证手机号格式
 * @param {String} phoneNumber - 手机号
 * @returns {Boolean} 是否有效
 */
export const validatePhoneNumber = (phoneNumber) => {
  const phoneRegex = /^1[3-9]\d{9}$/
  return phoneRegex.test(phoneNumber)
}

/**
 * 验证密码强度
 * @param {String} password - 密码
 * @returns {{valid: Boolean, message: String}} 验证结果
 */
export const validatePassword = (password) => {
  if (password.length < 6) {
    return { valid: false, message: '密码长度不能少于6位' }
  }
  return { valid: true, message: '' }
}