/**
 * API请求工具
 * @file api.js
 * @description 封装银行系统API请求方法
 */
import { API_CONFIG, SECURITY_CONFIG } from '@/config/env'

/**
 * 创建请求头，自动添加认证Token
 * @param {Object} headers - 额外的请求头
 * @returns {Object} 合并后的请求头
 */
const createHeaders = (headers = {}) => {
  const token = localStorage.getItem(SECURITY_CONFIG.tokenKey)
  const defaultHeaders = {
    'Content-Type': 'application/json',
  }
  
  if (token) {
    defaultHeaders['Authorization'] = `Bearer ${token}`
  }
  
  return { ...defaultHeaders, ...headers }
}

/**
 * 处理API响应
 * @param {Response} response - Fetch API响应对象
 * @returns {Promise} 处理后的响应数据
 */
const handleResponse = async (response) => {
  // 检查HTTP状态
  if (!response.ok) {
    // 处理常见错误
    if (response.status === 401) {
      // 清除无效的认证信息
      localStorage.removeItem(SECURITY_CONFIG.tokenKey)
      localStorage.removeItem(SECURITY_CONFIG.userKey)
      throw new Error('认证已过期，请重新登录')
    }
    
    if (response.status === 403) {
      throw new Error('您没有权限访问此资源，请联系管理员')
    }
    
    if (response.status === 404) {
      throw new Error('请求的资源不存在')
    }
    
    if (response.status === 500) {
      try {
        const errorData = await response.json()
        throw new Error(errorData.message || '服务器内部错误，请联系管理员')
      } catch (e) {
        throw new Error('服务器内部错误，请联系管理员')
      }
    }
    
    // 尝试获取详细错误信息
    try {
      const errorData = await response.json()
      throw new Error(errorData.message || `请求失败: ${response.status} ${response.statusText}`)
    } catch (e) {
      throw new Error(`请求失败: ${response.status} ${response.statusText}`)
    }
  }
  
  // 检查响应类型
  const contentType = response.headers.get('content-type')
  
  // 如果是blob类型（如文件下载），直接返回blob
  if (contentType && (contentType.includes('text/csv') || 
                     contentType.includes('application/octet-stream') || 
                     contentType.includes('application/vnd.ms-excel') ||
                     contentType.includes('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'))) {
    return await response.blob()
  }
  
  // 返回JSON数据
  const result = await response.json()
  
  // 兼容数组响应
  if (Array.isArray(result)) {
    return result
  }
  
  if (!result.success) {
    throw new Error(result.message || 'API请求失败')
  }
  return result
}

/**
 * API请求方法
 */
export const api = {
  /**
   * 登录
   * @param {string} username - 用户名
   * @param {string} password - 密码
   * @returns {Promise} 登录结果
   */
  async login(username, password) {
    const response = await fetch(`${API_CONFIG.baseUrl}/auth/login`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ username, password }),
    })
    
    return handleResponse(response)
  },

  /**
   * GET请求
   * @param {string} endpoint - API端点
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async get(endpoint, options = {}) {
    let url = `${API_CONFIG.baseUrl}${endpoint}`
    
    // 处理查询参数
    if (options.params && Object.keys(options.params).length > 0) {
      const searchParams = new URLSearchParams()
      for (const [key, value] of Object.entries(options.params)) {
        if (value !== null && value !== undefined) {
          searchParams.append(key, value)
        }
      }
      url += `?${searchParams.toString()}`
    }
    
    const response = await fetch(url, {
      ...options,
      method: 'GET',
      headers: createHeaders(options.headers),
      params: undefined,
    })
    
    // 如果指定了responseType为blob，直接返回blob
    if (options.responseType === 'blob') {
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`)
      }
      return await response.blob()
    }
    
    return handleResponse(response)
  },
  
  /**
   * POST请求
   * @param {string} endpoint - API端点
   * @param {Object} data - 请求数据
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async post(endpoint, data, options = {}) {
    const url = `${API_CONFIG.baseUrl}${endpoint}`
    const response = await fetch(url, {
      method: 'POST',
      headers: createHeaders(options.headers),
      body: JSON.stringify(data),
      ...options,
    })
    return handleResponse(response)
  },
  
  /**
   * PUT请求
   * @param {string} endpoint - API端点
   * @param {Object} data - 请求数据
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async put(endpoint, data, options = {}) {
    const url = `${API_CONFIG.baseUrl}${endpoint}`
    const response = await fetch(url, {
      method: 'PUT',
      headers: createHeaders(options.headers),
      body: JSON.stringify(data),
      ...options,
    })
    return handleResponse(response)
  },
  
  /**
   * DELETE请求
   * @param {string} endpoint - API端点
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async delete(endpoint, options = {}) {
    const url = `${API_CONFIG.baseUrl}${endpoint}`
    const response = await fetch(url, {
      method: 'DELETE',
      headers: createHeaders(options.headers),
      ...options,
    })
    return handleResponse(response)
  },

  // 认证相关API
  auth: {
    /**
     * 用户登录
     * @param {string} username - 用户名
     * @param {string} password - 密码
     * @returns {Promise} 登录结果
     */
    async login(username, password) {
      return api.post('/auth/login', { username, password })
    },

    /**
     * 用户登出
     * @returns {Promise} 登出结果
     */
    async logout() {
      return api.post('/auth/logout')
    },

    /**
     * 刷新令牌
     * @returns {Promise} 刷新结果
     */
    async refreshToken() {
      return api.post('/auth/refresh')
    },

    /**
     * 获取当前用户信息
     * @returns {Promise} 用户信息
     */
    async getCurrentUser() {
      return api.get('/auth/me')
    },

    /**
     * 修改密码
     * @param {Object} data - 密码数据
     * @returns {Promise} 修改结果
     */
    async changePassword(data) {
      return api.post('/auth/change-password', data)
    }
  },

  // 仪表盘API
  dashboard: {
    /**
     * 获取仪表盘统计数据
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/dashboard')
    },

    /**
     * 获取图表数据
     * @param {Object} params - 查询参数
     * @returns {Promise} 图表数据
     */
    async getChartData(params = {}) {
      return api.get('/dashboard/charts', { params })
    },

    /**
     * 获取最近交易记录
     * @param {Object} params - 查询参数
     * @returns {Promise} 交易记录
     */
    async getRecentTransactions(params = {}) {
      return api.get('/dashboard/recent-transactions', { params })
    }
  },

  // 用户管理API
  users: {
    /**
     * 获取用户列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 用户列表
     */
    async getList(params = {}) {
      return api.get('/users', { params })
    },

    /**
     * 获取用户详情
     * @param {number} id - 用户ID
     * @returns {Promise} 用户详情
     */
    async getById(id) {
      return api.get(`/users/${id}`)
    },

    /**
     * 创建用户
     * @param {Object} data - 用户数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/users', data)
    },

    /**
     * 更新用户信息
     * @param {number} id - 用户ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/users/${id}`, data)
    },

    /**
     * 删除用户
     * @param {number} id - 用户ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/users/${id}`)
    },

    /**
     * 更新用户状态
     * @param {number} id - 用户ID
     * @param {Object} data - 状态数据
     * @returns {Promise} 更新结果
     */
    async updateStatus(id, data) {
      return api.put(`/users/${id}/status`, data)
    },

    /**
     * 重置用户密码
     * @param {number} id - 用户ID
     * @param {Object} data - 密码数据
     * @returns {Promise} 重置结果
     */
    async resetPassword(id, data) {
      return api.post(`/users/${id}/reset-password`, data)
    },

    /**
     * 获取用户账户列表
     * @param {number} userId - 用户ID
     * @returns {Promise} 账户列表
     */
    async getAccounts(userId) {
      return api.get(`/users/${userId}/accounts`)
    },

    /**
     * 获取当前用户信息
     * @returns {Promise} 用户信息
     */
    async getProfile() {
      return api.get('/users/profile')
    },

    /**
     * 更新当前用户信息
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新结果
     */
    async updateProfile(data) {
      return api.put('/users/profile', data)
    },

    /**
     * 修改当前用户密码
     * @param {Object} data - 密码数据
     * @returns {Promise} 修改结果
     */
    async changePassword(data) {
      return api.put('/users/change-password', data)
    }
  },

  // 账户管理API
  accounts: {
    /**
     * 获取账户列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 账户列表
     */
    async getList(params = {}) {
      return api.get('/accounts', { params })
    },

    /**
     * 获取账户详情
     * @param {number} id - 账户ID
     * @returns {Promise} 账户详情
     */
    async getById(id) {
      return api.get(`/accounts/${id}`)
    },

    /**
     * 创建账户
     * @param {Object} data - 账户数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/accounts', data)
    },

    /**
     * 更新账户状态
     * @param {number} id - 账户ID
     * @param {Object} data - 状态数据
     * @returns {Promise} 更新结果
     */
    async updateStatus(id, data) {
      return api.put(`/accounts/${id}/status`, data)
    },

    /**
     * 存款
     * @param {number} id - 账户ID
     * @param {Object} data - 存款数据
     * @returns {Promise} 存款结果
     */
    async deposit(id, data) {
      return api.post(`/accounts/${id}/deposit`, data)
    },

    /**
     * 取款
     * @param {number} id - 账户ID
     * @param {Object} data - 取款数据
     * @returns {Promise} 取款结果
     */
    async withdraw(id, data) {
      return api.post(`/accounts/${id}/withdraw`, data)
    }
  },

  // 贷款产品API
  loanProducts: {
    /**
     * 获取贷款产品列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 产品列表
     */
    async getList(params = {}) {
      return api.get('/loan-products', { params })
    },

    /**
     * 获取产品详情
     * @param {number} id - 产品ID
     * @returns {Promise} 产品详情
     */
    async getById(id) {
      return api.get(`/loan-products/${id}`)
    },

    /**
     * 创建产品
     * @param {Object} data - 产品数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/loan-products', data)
    },

    /**
     * 更新产品
     * @param {number} id - 产品ID
     * @param {Object} data - 产品数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/loan-products/${id}`, data)
    },

    /**
     * 删除产品
     * @param {number} id - 产品ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/loan-products/${id}`)
    },

    /**
     * 更新产品状态
     * @param {number} id - 产品ID
     * @param {Object} data - 状态数据
     * @returns {Promise} 更新结果
     */
    async updateStatus(id, data) {
      return api.put(`/loan-products/${id}/status`, data)
    },

    /**
     * 获取产品统计
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/loan-products/stats/overview')
    }
  },

  // 员工管理API
  employees: {
    /**
     * 获取员工列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 员工列表
     */
    async getList(params = {}) {
      return api.get('/employees', { params })
    },

    /**
     * 获取员工详情
     * @param {number} id - 员工ID
     * @returns {Promise} 员工详情
     */
    async getById(id) {
      return api.get(`/employees/${id}`)
    },

    /**
     * 创建员工
     * @param {Object} data - 员工数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/employees', data)
    },

    /**
     * 更新员工
     * @param {number} id - 员工ID
     * @param {Object} data - 员工数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/employees/${id}`, data)
    },

    /**
     * 删除员工
     * @param {number} id - 员工ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/employees/${id}`)
    },

    /**
     * 获取员工统计
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/employees/stats/overview')
    }
  },

  // 报表统计API
  reports: {
    /**
     * 获取交易报表
     * @param {Object} params - 查询参数
     * @returns {Promise} 交易报表
     */
    async getTransactions(params = {}) {
      return api.get('/reports/transactions', { params })
    },

    /**
     * 获取用户报表
     * @param {Object} params - 查询参数
     * @returns {Promise} 用户报表
     */
    async getUsers(params = {}) {
      return api.get('/reports/users', { params })
    },

    /**
     * 获取账户报表
     * @param {Object} params - 查询参数
     * @returns {Promise} 账户报表
     */
    async getAccounts(params = {}) {
      return api.get('/reports/accounts', { params })
    },

    /**
     * 导出报表
     * @param {string} type - 报表类型
     * @param {string} format - 导出格式
     * @param {Object} params - 查询参数
     * @returns {Promise} 导出结果
     */
    async export(type, format = 'excel', params = {}) {
      return api.get(`/reports/export/${type}`, { 
        params: { format, ...params } 
      })
    }
  },

  // 交易管理API
  transactions: {
    /**
     * 获取交易记录列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 交易记录列表
     */
    async getList(params = {}) {
      return api.get('/transactions', { params })
    },

    /**
     * 获取交易详情
     * @param {number} id - 交易ID
     * @returns {Promise} 交易详情
     */
    async getById(id) {
      return api.get(`/transactions/${id}`)
    },

    /**
     * 转账
     * @param {Object} data - 转账数据
     * @returns {Promise} 转账结果
     */
    async transfer(data) {
      return api.post('/transactions/transfer', data)
    },

    /**
     * 撤销交易
     * @param {number} id - 交易ID
     * @returns {Promise} 撤销结果
     */
    async reverse(id) {
      return api.post(`/transactions/${id}/reverse`)
    },

    /**
     * 获取交易统计
     * @param {Object} params - 查询参数
     * @returns {Promise} 交易统计
     */
    async getStats(params = {}) {
      return api.get('/transactions/stats', { params })
    }
  },

  // 项目清单API
  projects: {
    /**
     * 获取项目列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 项目列表
     */
    async getList(params = {}) {
      return api.get('/projects', { params })
    },

    /**
     * 获取项目详情
     * @param {number} id - 项目ID
     * @returns {Promise} 项目详情
     */
    async getById(id) {
      return api.get(`/projects/${id}`)
    },

    /**
     * 创建项目
     * @param {Object} data - 项目数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/projects', data)
    },

    /**
     * 更新项目
     * @param {number} id - 项目ID
     * @param {Object} data - 项目数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/projects/${id}`, data)
    },

    /**
     * 删除项目
     * @param {number} id - 项目ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/projects/${id}`)
    },

    /**
     * 获取项目统计
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/projects/stats')
    },

    /**
     * 批量更新项目状态
     * @param {Object} data - 批量更新数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/projects/batch/status', data)
    }
  },

  // 监管任务API
  supervisionTasks: {
    /**
     * 获取监管任务列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 监管任务列表
     */
    async getList(params = {}) {
      return api.get('/supervision-tasks', { params })
    },

    /**
     * 获取监管任务详情
     * @param {number} id - 监管任务ID
     * @returns {Promise} 监管任务详情
     */
    async getById(id) {
      return api.get(`/supervision-tasks/${id}`)
    },

    /**
     * 创建监管任务
     * @param {Object} data - 监管任务数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/supervision-tasks', data)
    },

    /**
     * 更新监管任务
     * @param {number} id - 监管任务ID
     * @param {Object} data - 监管任务数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/supervision-tasks/${id}`, data)
    },

    /**
     * 删除监管任务
     * @param {number} id - 监管任务ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/supervision-tasks/${id}`)
    },

    /**
     * 获取监管任务统计
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/supervision-tasks/stats')
    },

    /**
     * 批量更新监管任务状态
     * @param {Object} data - 批量更新数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/supervision-tasks/batch/status', data)
    },

    /**
     * 批量删除监管任务
     * @param {Object} data - 批量删除数据
     * @returns {Promise} 删除结果
     */
    async batchDelete(data) {
      return api.delete('/supervision-tasks/batch', { data })
    }
  },

  // 待安装任务API
  installationTasks: {
    /**
     * 获取待安装任务列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 待安装任务列表
     */
    async getList(params = {}) {
      return api.get('/installation-tasks', { params })
    },

    /**
     * 获取待安装任务详情
     * @param {number} id - 待安装任务ID
     * @returns {Promise} 待安装任务详情
     */
    async getById(id) {
      return api.get(`/installation-tasks/${id}`)
    },

    /**
     * 创建待安装任务
     * @param {Object} data - 待安装任务数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/installation-tasks', data)
    },

    /**
     * 更新待安装任务
     * @param {number} id - 待安装任务ID
     * @param {Object} data - 待安装任务数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/installation-tasks/${id}`, data)
    },

    /**
     * 删除待安装任务
     * @param {number} id - 待安装任务ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/installation-tasks/${id}`)
    },

    /**
     * 获取待安装任务统计
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/installation-tasks/stats')
    },

    /**
     * 批量更新待安装任务状态
     * @param {Object} data - 批量更新数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/installation-tasks/batch/status', data)
    },

    /**
     * 批量删除待安装任务
     * @param {Object} data - 批量删除数据
     * @returns {Promise} 删除结果
     */
    async batchDelete(data) {
      return api.delete('/installation-tasks/batch/delete', { data })
    }
  },

  // 监管任务已结项API
  completedSupervisions: {
    /**
     * 获取监管任务已结项列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 监管任务已结项列表
     */
    async getList(params = {}) {
      return api.get('/completed-supervisions', { params })
    },

    /**
     * 获取监管任务已结项详情
     * @param {number} id - 监管任务已结项ID
     * @returns {Promise} 监管任务已结项详情
     */
    async getById(id) {
      return api.get(`/completed-supervisions/${id}`)
    },

    /**
     * 创建监管任务已结项
     * @param {Object} data - 监管任务已结项数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/completed-supervisions', data)
    },

    /**
     * 更新监管任务已结项
     * @param {number} id - 监管任务已结项ID
     * @param {Object} data - 监管任务已结项数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/completed-supervisions/${id}`, data)
    },

    /**
     * 删除监管任务已结项
     * @param {number} id - 监管任务已结项ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/completed-supervisions/${id}`)
    },

    /**
     * 获取监管任务已结项统计
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/completed-supervisions/stats')
    },

    /**
     * 批量更新结清状态
     * @param {Object} data - 批量更新数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/completed-supervisions/batch/status', data)
    },

    /**
     * 批量删除监管任务已结项
     * @param {Object} data - 批量删除数据
     * @returns {Promise} 删除结果
     */
    async batchDelete(data) {
      return api.delete('/completed-supervisions/batch/delete', { data })
    }
  },

  // 贷款商品API
  loanProducts: {
    /**
     * 获取贷款商品列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 贷款商品列表
     */
    async getList(params = {}) {
      return api.get('/loan-products', { params })
    },

    /**
     * 获取贷款商品详情
     * @param {number} id - 贷款商品ID
     * @returns {Promise} 贷款商品详情
     */
    async getById(id) {
      return api.get(`/loan-products/${id}`)
    },

    /**
     * 创建贷款商品
     * @param {Object} data - 贷款商品数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/loan-products', data)
    },

    /**
     * 更新贷款商品
     * @param {number} id - 贷款商品ID
     * @param {Object} data - 贷款商品数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/loan-products/${id}`, data)
    },

    /**
     * 删除贷款商品
     * @param {number} id - 贷款商品ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/loan-products/${id}`)
    },

    /**
     * 获取贷款商品统计
     * @returns {Promise} 统计数据
     */
    async getStats() {
      return api.get('/loan-products/stats')
    },

    /**
     * 批量更新在售状态
     * @param {Object} data - 批量更新数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/loan-products/batch/status', data)
    },

    /**
     * 批量删除贷款商品
     * @param {Object} data - 批量删除数据
     * @returns {Promise} 删除结果
     */
    async batchDelete(data) {
      return api.delete('/loan-products/batch/delete', { data })
    }
  },

  // 贷款申请API
  loanApplications: {
    /**
     * 获取贷款申请列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 申请列表
     */
    async getList(params = {}) {
      return api.get('/loan-applications', { params })
    },

    /**
     * 获取贷款申请详情
     * @param {number} id - 申请ID
     * @returns {Promise} 申请详情
     */
    async getById(id) {
      return api.get(`/loan-applications/${id}`)
    },

    /**
     * 审核贷款申请
     * @param {number} id - 申请ID
     * @param {Object} data - 审核数据
     * @returns {Promise} 审核结果
     */
    async audit(id, data) {
      return api.post(`/loan-applications/${id}/audit`, data)
    },

    /**
     * 获取申请统计信息
     * @returns {Promise} 统计信息
     */
    async getStats() {
      return api.get('/loan-applications/stats')
    },

    /**
     * 批量更新申请状态
     * @param {Object} data - 批量操作数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/loan-applications/batch/status', data)
    }
  },

  // 贷款合同API
  loanContracts: {
    /**
     * 获取贷款合同列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 合同列表
     */
    async getList(params = {}) {
      return api.get('/loan-contracts', { params })
    },

    /**
     * 获取贷款合同详情
     * @param {number} id - 合同ID
     * @returns {Promise} 合同详情
     */
    async getById(id) {
      return api.get(`/loan-contracts/${id}`)
    },

    /**
     * 创建贷款合同
     * @param {Object} data - 合同数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/loan-contracts', data)
    },

    /**
     * 更新贷款合同
     * @param {number} id - 合同ID
     * @param {Object} data - 合同数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/loan-contracts/${id}`, data)
    },

    /**
     * 删除贷款合同
     * @param {number} id - 合同ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/loan-contracts/${id}`)
    },

    /**
     * 获取合同统计信息
     * @returns {Promise} 统计信息
     */
    async getStats() {
      return api.get('/loan-contracts/stats')
    },

    /**
     * 批量更新合同状态
     * @param {Object} data - 批量操作数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/loan-contracts/batch/status', data)
    }
  },

  // 贷款解押API
  loanReleases: {
    /**
     * 获取贷款解押列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 解押列表
     */
    async getList(params = {}) {
      return api.get('/loan-releases', { params })
    },

    /**
     * 获取贷款解押详情
     * @param {number} id - 解押ID
     * @returns {Promise} 解押详情
     */
    async getById(id) {
      return api.get(`/loan-releases/${id}`)
    },

    /**
     * 创建贷款解押申请
     * @param {Object} data - 解押数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/loan-releases', data)
    },

    /**
     * 更新贷款解押申请
     * @param {number} id - 解押ID
     * @param {Object} data - 解押数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/loan-releases/${id}`, data)
    },

    /**
     * 处理贷款解押申请
     * @param {number} id - 解押ID
     * @param {Object} data - 处理数据
     * @returns {Promise} 处理结果
     */
    async process(id, data) {
      return api.post(`/loan-releases/${id}/process`, data)
    },

    /**
     * 完成贷款解押
     * @param {number} id - 解押ID
     * @param {Object} data - 完成数据
     * @returns {Promise} 完成结果
     */
    async complete(id, data) {
      return api.post(`/loan-releases/${id}/complete`, data)
    },

    /**
     * 删除贷款解押申请
     * @param {number} id - 解押ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/loan-releases/${id}`)
    },

    /**
     * 获取解押统计信息
     * @returns {Promise} 统计信息
     */
    async getStats() {
      return api.get('/loan-releases/stats')
    }
  },

  // 员工管理API
  employees: {
    /**
     * 获取员工列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 员工列表
     */
    async getList(params = {}) {
      return api.get('/employees', { params })
    },

    /**
     * 获取员工详情
     * @param {number} id - 员工ID
     * @returns {Promise} 员工详情
     */
    async getById(id) {
      return api.get(`/employees/${id}`)
    },

    /**
     * 创建员工
     * @param {Object} data - 员工数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/employees', data)
    },

    /**
     * 更新员工信息
     * @param {number} id - 员工ID
     * @param {Object} data - 员工数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/employees/${id}`, data)
    },

    /**
     * 重设密码
     * @param {number} id - 员工ID
     * @param {Object} data - 密码数据
     * @returns {Promise} 重设结果
     */
    async resetPassword(id, data) {
      return api.put(`/employees/${id}/reset-password`, data)
    },

    /**
     * 删除员工
     * @param {number} id - 员工ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/employees/${id}`)
    },

    /**
     * 获取员工统计信息
     * @returns {Promise} 统计信息
     */
    async getStats() {
      return api.get('/employees/stats')
    },

    /**
     * 批量更新员工状态
     * @param {Object} data - 批量操作数据
     * @returns {Promise} 更新结果
     */
    async batchUpdateStatus(data) {
      return api.put('/employees/batch/status', data)
    }
  }
}

export default api