import axios from 'axios'

// 创建axios实例
const api = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL,
  timeout: 300000, // 5分钟超时时间（300秒）
  withCredentials: true, // 关键：支持跨域携带cookie和session
  headers: {
    'Content-Type': 'application/json'
  }
})

// 防止重复提示的标志
let isKickedOut = false

// 响应拦截器
api.interceptors.response.use(
  response => {
    const data = response.data
    
    // 检查是否是session过期的响应
    if (data && data.success === false) {
      // 可以根据后端返回的错误码或消息判断是否是session过期
      const message = data.message || ''
      
      // 专门处理账号在其他设备登录的情况
      if (message.includes('其他设备登录') || message.includes('当前会话已失效')) {
        if (!isKickedOut) {
          isKickedOut = true
          console.log('检测到账号在其他设备登录，正在踢出当前会话...')
          
          // 动态导入 Element Plus 的消息组件
          import('element-plus').then(({ ElMessage }) => {
            ElMessage.warning({
              message: '您的账号已在其他设备登录，请重新登录',
              duration: 3000,
              showClose: true
            })
          })
          
          // 检查当前路径是否为后台管理路径
          if (window.location.pathname.startsWith('/cpzsadmin') && window.location.pathname !== '/cpzsadmin/login') {
            // 后台管理会话
            import('../store/user.js').then(({ userStore }) => {
              userStore.adminLogout(true) // 标记为被踢出
              setTimeout(() => {
                window.location.href = '/cpzsadmin/login'
                isKickedOut = false // 重置标志
              }, 1500)
            })
          } else {
            // 前台用户会话
            import('../store/user.js').then(({ userStore }) => {
              userStore.logout(true) // 标记为被踢出
              setTimeout(() => {
                isKickedOut = false // 重置标志
              }, 3000)
            })
          }
        }
        return data
      }
      
      // 处理其他登录/权限相关的错误
      if (message.includes('未登录') || message.includes('登录过期') || message.includes('无权限') || message.includes('Invalid session')) {
        console.log('检测到session过期，清除本地登录状态')
        
        // 检查当前路径是否为后台管理路径
        if (window.location.pathname.startsWith('/cpzsadmin') && window.location.pathname !== '/cpzsadmin/login') {
          console.log('后台管理会话过期，正在注销...')
          // 动态导入userStore避免循环依赖
          import('../store/user.js').then(({ userStore }) => {
            userStore.adminLogout()
            window.location.href = '/cpzsadmin/login'
          })
        } else {
          // 前台用户会话过期处理
          import('../store/user.js').then(({ userStore }) => {
            userStore.logout()
          })
        }
      }
    }
    
    return data
  },
  error => {
    console.error('API请求错误:', error)
    
    // 检查HTTP状态码，401/403通常表示未授权/session过期
    if (error.response && (error.response.status === 401 || error.response.status === 403)) {
      console.log('检测到401/403错误，可能是session过期或无权限')
      
      // 检查当前路径是否为后台管理路径
      if (window.location.pathname.startsWith('/cpzsadmin') && window.location.pathname !== '/cpzsadmin/login') {
        console.log('后台管理会话过期，正在注销...')
        // 动态导入userStore避免循环依赖
        import('../store/user.js').then(({ userStore }) => {
          userStore.adminLogout()
          window.location.href = '/cpzsadmin/login'
        })
      } else {
        // 前台用户会话过期处理
        import('../store/user.js').then(({ userStore }) => {
          userStore.logout()
        })
      }
    }
    
    return Promise.reject(error)
  }
)

// API接口方法
export const lotteryApi = {
  // 用户登录
  userLogin(userAccount, userPassword) {
    return api.post('/user/login', {
      userAccount,
      userPassword
    })
  },

  // 用户注册
  userRegister(userAccount, userPassword, checkPassword, userName) {
    return api.post('/user/register', {
      userAccount,
      userPassword,
      checkPassword,
      userName
    })
  },

  // 用户注销
  userLogout() {
    return api.post('/user/logout')
  },

  // 获取当前登录用户信息
  getLoginUser() {
    return api.get('/user/get/login')
  },

  // 获取用户信息（用于编辑）
  getUserInfo() {
    return api.get('/user/get/login')
  },

  // 更新用户信息
  updateUserInfo(userInfo) {
    console.log('调用更新用户信息接口:', userInfo)
    return api.post('/user/update', userInfo, {
      headers: {
        'Content-Type': 'application/json'
      }
    })
  },

  // 上传文件
  uploadFile(file) {
    const formData = new FormData()
    formData.append('file', file)
    return api.post('/file/upload', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    })
  },

  // 获取用户统计信息（总用户数和VIP用户数）
  getUserCount() {
    return api.get('/user/count')
  },

  // 检查当前用户VIP是否过期
  checkVipExpire() {
    return api.get('/user/check-vip-expire')
  },

  // 获取用户推测记录（支持分页）
  getPredictRecordsByUserId(userId, page = 1) {
    return api.get(`/ball-analysis/predict-records/${userId}?page=${page}`)
  },

  // 按条件查询推测记录（支持分页和状态筛选）
  queryPredictRecords(userId, predictStatus, page = 1, pageSize = 10) {
    return api.post('/data-analysis/query-predict-records', {
      userId: userId,
      predictStatus,
      current: page,
      pageSize
    })
  },

  // 获取近期开奖信息
  getRecentDraws(limit = 6) {
    return api.get(`/ball-analysis/recent-draws?limit=${limit}`)
  },

  // 获取最新100条开奖信息（表相查询）
  getRecent100Draws() {
    return api.get('/ball-analysis/recent-100-draws')
  },

  // 按日期范围查询开奖信息
  queryDraws(startDate, endDate) {
    const params = new URLSearchParams()
    if (startDate) params.append('startDate', startDate)
    if (endDate) params.append('endDate', endDate)
    return api.get(`/ball-analysis/query-draws?${params.toString()}`)
  },

  // 根据期号查询开奖信息
  getDrawById(drawId) {
    return api.get(`/ball-analysis/draw/${drawId}`)
  },

  // 创建推测记录
  createPredictRecord(userId, drawId, drawDate, redBalls, blueBall) {
    const params = new URLSearchParams()
    params.append('userId', userId)
    params.append('drawId', drawId)
    params.append('drawDate', drawDate)
    params.append('redBalls', redBalls)
    params.append('blueBall', blueBall)
    
    return api.post('/ball-analysis/create-predict', params, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    })
  },

  // 首球算法
  analyzeBalls(userId, level, redBalls, blueBall) {
    const params = new URLSearchParams()
    params.append('userId', userId)
    params.append('level', level)
    params.append('redBalls', redBalls)
    params.append('blueBall', blueBall)
    
    return api.post('/ball-analysis/analyze', params, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    })
  },

  // 精推版双色球第一步分析
  jtssqFirstStepAnalysis(level, redBalls, blueBall) {
    const params = new URLSearchParams()
    params.append('level', level)
    params.append('redBalls', redBalls)
    params.append('blueBall', blueBall)
    
    return api.post('/jtssq/analysis/first-step', params, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    })
  },

  // 精推版双色球第二步分析
  jtssqSecondStepAnalysis(level, redBalls, blueBall, nextFirstBall) {
    const params = new URLSearchParams()
    params.append('level', level)
    params.append('redBalls', redBalls)
    params.append('blueBall', blueBall)
    params.append('nextFirstBall', nextFirstBall)
    
    return api.post('/jtssq/analysis/second-step', params, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    })
  },

  // 精推版双色球第三步分析
  jtssqThirdStepAnalysis(level, redBalls, blueBall, nextRedBalls) {
    const params = new URLSearchParams()
    params.append('level', level)
    params.append('redBalls', redBalls)
    params.append('blueBall', blueBall)
    params.append('nextRedBalls', nextRedBalls)
    
    return api.post('/jtssq/analysis/third-step', params, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    })
  },

  // 跟随球号分析算法
  fallowBallAnalysis(userId, level, firstThreeRedBalls, lastSixRedBalls, blueBall) {
    const params = new URLSearchParams()
    params.append('userId', userId)
    params.append('level', level)
    params.append('firstThreeRedBalls', firstThreeRedBalls)
    params.append('lastSixRedBalls', lastSixRedBalls)
    params.append('blueBall', blueBall)
    
    return api.post('/ball-analysis/fallow', params, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    })
  },

  // 蓝球分析算法
  blueBallAnalysis(userId, level, predictedRedBalls, predictedBlueBalls, lastRedBalls, lastBlueBall) {
    const params = new URLSearchParams()
    params.append('userId', userId)
    params.append('level', level)
    params.append('predictedRedBalls', predictedRedBalls)
    params.append('predictedBlueBalls', predictedBlueBalls)
    params.append('lastRedBalls', lastRedBalls)
    params.append('lastBlueBall', lastBlueBall)
    
    return api.post('/ball-analysis/blue-ball', params, {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    })
  },

  // 获取用户推测统计数据
  getUserPredictStat(userId, lotteryType) {
    return api.get(`/data-analysis/user-predict-stat/${userId}`, {
      params: { lotteryType }
    })
  },

  // 获取首球命中率统计
  getFirstBallHitRate(lotteryType) {
    return api.get('/ball-analysis/first-ball-hit-rate', {
      params: { lotteryType }
    })
  },

  // 获取蓝球命中率统计
  getBlueBallHitRate(lotteryType) {
    return api.get('/ball-analysis/blue-ball-hit-rate', {
      params: { lotteryType }
    })
  },

  // 获取红球命中率统计
  getRedBallHitRate(lotteryType) {
    return api.get('/ball-analysis/red-ball-hit-rate', {
      params: { lotteryType }
    })
  },

  // 获取奖金统计
  getPrizeStatistics() {
    return api.get('/ball-analysis/prize-statistics')
  },

  // 激活会员码
  activateVipCode(userId, code) {
    return api.post('/user/activate-vip', {
      userId,
      code
    })
  },

  // 批量生成会员码
  generateVipCodes(numCodes, vipExpireTime) {
    return api.post('/vip-code/generate', {
      numCodes,
      vipExpireTime
    })
  },

  // 获取可用会员码
  getAvailableVipCode(vipExpireTime) {
    return api.get(`/vip-code/available?vipExpireTime=${vipExpireTime}`)
  },

  // 上传Excel文件导入数据（T1-T7 sheet）
  uploadExcelFile(file) {
    const formData = new FormData()
    formData.append('file', file)
    return api.post('/excel/upload', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    })
  },

  // 上传Excel文件导入开奖数据（T10工作表）
  uploadLotteryDrawsFile(file) {
    const formData = new FormData()
    formData.append('file', file)
    return api.post('/excel/upload-lottery-draws', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    })
  },

  // 上传Excel文件追加导入开奖数据（T10工作表）
  appendLotteryDrawsFile(file) {
    const formData = new FormData()
    formData.append('file', file)
    return api.post('/excel/append-lottery-draws', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    })
  },

  // 获取用户兑换记录
  getExchangeRecordsByUserId(userId) {
    return api.get(`/vip-exchange-record/user/${userId}`)
  },

  // 获取用户列表
  getUserList(params) {
    console.log('调用获取用户列表接口:', params)
    const queryParams = new URLSearchParams()
    
    // 添加查询参数
    if (params?.userAccount) {
      queryParams.append('userAccount', params.userAccount)
    }
    
    if (params?.userName) {
      queryParams.append('userName', params.userName)
    }
    
    if (params?.phone) {
      queryParams.append('phone', params.phone)
    }
    
    if (params?.userRole) {
      queryParams.append('userRole', params.userRole)
    }
    
    if (params?.status !== undefined && params?.status !== '') {
      queryParams.append('status', params.status)
    }
    
    if (params?.isVip !== undefined && params?.isVip !== '') {
      queryParams.append('isVip', params.isVip)
    }
    
    // 分页参数
    if (params?.page) {
      queryParams.append('page', params.page)
    }
    
    if (params?.size) {
      queryParams.append('size', params.size)
    }
    
    return api.get(`/user/list${queryParams.toString() ? '?' + queryParams.toString() : ''}`)
  },
  
  // 更新用户状态
  updateUserStatus(params) {
    console.log('调用更新用户状态接口:', params)
    // 使用Content-Type: application/json 调用接口
    return api.post('/user/update-status', params, {
      headers: {
        'Content-Type': 'application/json'
      },
      timeout: 10000 // 设置10秒超时
    }).then(response => {
      console.log('更新用户状态接口响应:', response)
      return response
    }).catch(error => {
      console.error('更新用户状态接口错误:', error)
      throw error
    })
  },
  
  // 添加用户
  addUser(userForm) {
    console.log('调用添加用户接口:', userForm)
    return api.post('/user/add', userForm)
  },
  
  // 更新用户
  updateUser(userForm) {
    console.log('调用更新用户接口:', userForm)
    return api.post('/user/update', userForm)
  },
  
  // 删除用户
  deleteUser(userId) {
    console.log('调用删除用户接口:', userId)
    return api.post('/user/delete', { id: userId }, {
      headers: {
        'Content-Type': 'application/json'
      }
    })
  },

  // 获取所有推测记录总数
  getTotalPredictCount() {
    console.log('调用getTotalPredictCount接口...')
    return api.get('/data-analysis/total-predict-count').then(response => {
      console.log('getTotalPredictCount接口响应:', response)
      return response
    }).catch(error => {
      console.error('getTotalPredictCount接口错误:', error)
      throw error
    })
  },

  // 根据用户ID和操作模块获取操作历史
  getOperationHistoryByUserIdAndModule(userId, operationModule) {
    return api.get(`/operation-history/user/${userId}/module/${operationModule}`)
  },

  // 管理员登录（复用用户登录接口，后台会根据角色判断权限）
  adminLogin(username, password) {
    return api.post('/user/login', {
      userAccount: username,
      userPassword: password
    })
  },

  // 获取会员码统计数据
  getVipCodeStats() {
    return api.get('/vip-code/stats')
  },
  
  // 获取会员码统计数量
  getVipCodeCount() {
    console.log('调用getVipCodeCount接口...')
    return api.get('/vip-code/count').then(response => {
      console.log('getVipCodeCount接口响应:', response)
      return response
    }).catch(error => {
      console.error('getVipCodeCount接口错误:', error)
      throw error
    })
  },

  // 获取会员码列表
  getVipCodeList(params) {
    // 构建查询参数
    const queryParams = new URLSearchParams()
    
    // 分页参数
    if (params.page) queryParams.append('current', params.page)
    if (params.size) queryParams.append('pageSize', params.size)
    
    // 搜索关键词（会员码）
    if (params.keyword) queryParams.append('code', params.keyword)
    
    // 状态筛选
    if (params.status !== undefined && params.status !== '') {
      // 直接使用status值作为isUse参数
      queryParams.append('isUse', params.status)
    }
    
    // 有效期筛选
    if (params.expireTime) queryParams.append('vipExpireTime', params.expireTime)
    
    // 时间范围筛选
    if (params.startTime) queryParams.append('startTime', params.startTime)
    if (params.endTime) queryParams.append('endTime', params.endTime)
    
    // 发起请求
    return api.get(`/vip-code/list/page?${queryParams.toString()}`)
  },

  // 删除会员码
  deleteVipCode(id) {
    return api.post(`/vip-code/delete/${id}`)
  },

  // 获取红球历史数据全部记录
  getHistoryAll() {
    return api.get('/ball-analysis/history-all')
  },

  // 获取红球最近100期数据记录
  getHistory100() {
    return api.get('/ball-analysis/history-100')
  },

  // 获取红球历史数据排行记录
  getHistoryTop() {
    return api.get('/ball-analysis/history-top')
  },

  // 获取红球100期数据排行记录
  getHistoryTop100() {
    return api.get('/ball-analysis/history-top-100')
  },

  // 获取蓝球历史数据全部记录
  getBlueHistoryAll() {
    return api.get('/ball-analysis/blue-history-all')
  },

  // 获取蓝球最近100期数据记录
  getBlueHistory100() {
    return api.get('/ball-analysis/blue-history-100')
  },

  // 获取蓝球历史数据排行记录
  getBlueHistoryTop() {
    return api.get('/ball-analysis/blue-history-top')
  },

  // 获取蓝球100期数据排行记录
  getBlueHistoryTop100() {
    return api.get('/ball-analysis/blue-history-top-100')
  },
  
  // 发送短信验证码
  sendSmsCode(phoneNumber) {
    return api.post('/sms/sendCode', null, {
      params: {
        phoneNumber
      }
    })
  },
  
  // 手机号登录
  userPhoneLogin(phone, code) {
    return api.post('/user/phone/login', {
      phone,
      code
    })
  },
  
  // 手机号注册
  userPhoneRegister(userAccount, userPassword, checkPassword, phone, code, userName) {
    return api.post('/user/phone/register', {
      userAccount,
      userPassword,
      checkPassword,
      phone,
      code,
      userName
    })
  },

  // 重置密码
  resetPassword(phone, code, newPassword, confirmPassword) {
    console.log('调用重置密码接口:', { phone, code, newPassword, confirmPassword })
    return api.post('/user/reset-password', {
      phone,
      code,
      newPassword,
      confirmPassword
    }, {
      headers: {
        'Content-Type': 'application/json'
      }
    })
  },

  // 红球组合分析
  redBallCombinationAnalysis(masterBall, slaveBall) {
    const params = new URLSearchParams()
    params.append('masterBall', masterBall)
    params.append('slaveBall', slaveBall)
    
    return api.get(`/ball-analysis/red-ball-combination-analysis?${params.toString()}`)
  },

  // 红球与蓝球的组合性分析
  redBlueCombinationAnalysis(masterBall, slaveBall) {
    const params = new URLSearchParams()
    params.append('masterBall', masterBall)
    params.append('slaveBall', slaveBall)
    
    return api.get(`/ball-analysis/red-blue-combination-analysis?${params.toString()}`)
  },

  // 蓝球与红球的组合性分析
  blueRedCombinationAnalysis(masterBall, slaveBall) {
    const params = new URLSearchParams()
    params.append('masterBall', masterBall)
    params.append('slaveBall', slaveBall)
    
    return api.get(`/ball-analysis/blue-red-combination-analysis?${params.toString()}`)
  },

  // 红球与红球的接续性分析
  redRedPersistenceAnalysis(masterBall, slaveBall) {
    const params = new URLSearchParams()
    params.append('masterBall', masterBall)
    params.append('slaveBall', slaveBall)
    
    return api.get(`/ball-analysis/red-red-persistence-analysis?${params.toString()}`)
  },

  // 蓝球与蓝球的接续性分析
  blueBluePersistenceAnalysis(masterBall, slaveBall) {
    const params = new URLSearchParams()
    params.append('masterBall', masterBall)
    params.append('slaveBall', slaveBall)
    
    return api.get(`/ball-analysis/blue-blue-persistence-analysis?${params.toString()}`)
  },

  // 红球与蓝球的接续性分析
  redBluePersistenceAnalysis(masterBall, slaveBall) {
    const params = new URLSearchParams()
    params.append('masterBall', masterBall)
    params.append('slaveBall', slaveBall)
    
    return api.get(`/ball-analysis/red-blue-persistence-analysis?${params.toString()}`)
  },

  // 蓝球与红球的接续性分析
  blueRedPersistenceAnalysis(masterBall, slaveBall) {
    const params = new URLSearchParams()
    params.append('masterBall', masterBall)
    params.append('slaveBall', slaveBall)
    
    return api.get(`/ball-analysis/blue-red-persistence-analysis?${params.toString()}`)
  },

  // 根据开奖期号查询开奖球号
  getDrawNumbersById(drawId) {
    return api.get(`/ball-analysis/draw/${drawId}/numbers`)
  },

  // 获取近10期开奖期号
  getRecent10DrawIds() {
    return api.get('/ball-analysis/recent-10-draw-ids')
  },

  // 根据操作模块获取操作历史（真实接口）
  getOperationHistoryByModule(operationModule) {
    console.log('调用根据操作模块获取操作历史接口:', operationModule)
    return api.get(`/operation-history/module/${operationModule}`)
  },
  
  // 根据操作结果获取操作历史（真实接口）
  getOperationHistoryByResult(operationResult) {
    console.log('调用根据操作结果获取操作历史接口:', operationResult)
    return api.get(`/operation-history/result/${operationResult}`)
  },
  
  // 获取操作历史列表（统一接口）
  getOperationHistoryList(params) {
    console.log('调用获取操作历史列表接口:', params)
    const queryParams = new URLSearchParams()
    
    if (params?.operationModule !== undefined && params.operationModule !== '') {
      queryParams.append('operationModule', params.operationModule)
    }
    
    if (params?.operationResult !== undefined && params.operationResult !== '') {
      queryParams.append('operationResult', params.operationResult)
    }
    
    if (params?.keyword !== undefined && params.keyword !== '') {
      queryParams.append('keyword', params.keyword)
    }
    
    return api.get(`/operation-history/list${queryParams.toString() ? '?' + queryParams.toString() : ''}`)
  },

  // ==================== 公告管理接口 ====================
  
  // 添加公告
  addAnnouncement(data) {
    console.log('调用添加公告接口:', data)
    return api.post('/announcement/add', data)
  },

  // 查询公告列表（分页）
  getAnnouncementList(params) {
    console.log('调用查询公告列表接口:', params)
    const queryParams = new URLSearchParams()
    
    if (params?.current) queryParams.append('current', params.current)
    if (params?.pageSize) queryParams.append('pageSize', params.pageSize)
    if (params?.title) queryParams.append('title', params.title)
    if (params?.status !== undefined && params?.status !== null && params?.status !== '') {
      queryParams.append('status', params.status)
    }
    if (params?.priority !== undefined && params?.priority !== null && params?.priority !== '') {
      queryParams.append('priority', params.priority)
    }
    if (params?.publisherId) queryParams.append('publisherId', params.publisherId)
    if (params?.publisherName) queryParams.append('publisherName', params.publisherName)
    if (params?.startTime) queryParams.append('startTime', params.startTime)
    if (params?.endTime) queryParams.append('endTime', params.endTime)
    
    return api.get(`/announcement/list/page${queryParams.toString() ? '?' + queryParams.toString() : ''}`)
  },

  // 根据ID查询公告详情
  getAnnouncementById(id) {
    console.log('调用根据ID查询公告接口:', id)
    return api.get(`/announcement/${id}`)
  },

  // 更新公告
  updateAnnouncement(data) {
    console.log('调用更新公告接口:', data)
    return api.post('/announcement/update', data)
  },

  // 删除公告
  deleteAnnouncement(id) {
    console.log('调用删除公告接口:', id)
    return api.delete(`/announcement/delete/${id}`)
  },

  // 获取置顶公告
  getTopAnnouncements() {
    console.log('调用获取置顶公告接口')
    return api.get('/announcement/top')
  },

  // 获取所有已发布公告
  getPublishedAnnouncements() {
    console.log('调用获取所有已发布公告接口')
    return api.get('/announcement/published')
  },

  // ==================== 推测管理接口 ====================

  // 管理员获取所有双色球推测记录
  getAllSsqPredictRecords(params) {
    const queryParams = new URLSearchParams()
    if (params?.userId) queryParams.append('userId', params.userId)
    if (params?.predictResult) queryParams.append('predictResult', params.predictResult)
    if (params?.current) queryParams.append('current', params.current)
    if (params?.pageSize) queryParams.append('pageSize', params.pageSize)
    
    return api.get(`/ball-analysis/admin/all-records?${queryParams.toString()}`)
  },

  // 管理员获取所有大乐透推测记录
  getAllDltPredictRecords(params) {
    const queryParams = new URLSearchParams()
    if (params?.userId) queryParams.append('userId', params.userId)
    if (params?.predictResult) queryParams.append('predictResult', params.predictResult)
    if (params?.current) queryParams.append('current', params.current)
    if (params?.pageSize) queryParams.append('pageSize', params.pageSize)
    
    return api.get(`/dlt-predict/admin/all-records?${queryParams.toString()}`)
  },

  // ==================== 奖金统计接口 ====================

  // 管理员获取双色球中奖记录明细
  getAdminPrizeStatistics(params) {
    const queryParams = new URLSearchParams()
    if (params?.userId) queryParams.append('userId', params.userId)
    if (params?.prizeGrade) queryParams.append('prizeGrade', params.prizeGrade)
    if (params?.current) queryParams.append('current', params.current)
    if (params?.pageSize) queryParams.append('pageSize', params.pageSize)
    
    return api.get(`/ball-analysis/admin/prize-statistics?${queryParams.toString()}`)
  },

  // 管理员获取大乐透中奖记录明细
  getAdminDltPrizeStatistics(params) {
    const queryParams = new URLSearchParams()
    if (params?.userId) queryParams.append('userId', params.userId)
    if (params?.prizeGrade) queryParams.append('prizeGrade', params.prizeGrade)
    if (params?.current) queryParams.append('current', params.current)
    if (params?.pageSize) queryParams.append('pageSize', params.pageSize)
    
    return api.get(`/dlt-predict/admin/prize-statistics?${queryParams.toString()}`)
  },

  // 记录页面访问PV
  recordPageView(pagePath) {
    return api.post(`/pv/record?pagePath=${encodeURIComponent(pagePath)}`)
  },

  // 获取总PV
  getTotalPageViews() {
    return api.get('/pv/total')
  },

  // 获取今日PV
  getTodayPageViews() {
    return api.get('/pv/today')
  },

  // 获取近N天PV统计
  getPageViewsByDays(days = 7) {
    return api.get(`/pv/stats?days=${days}`)
  }
}

export default api 