/**
 * API请求工具
 * 封装了基本的API请求方法，包括处理认证Token
 */

import { API_CONFIG } from '../config/env.js';
import { createSuccessResponse, createErrorResponse, extractData, isValidApiResponse } from './apiResponseFormat.js';

// API基础URL - 支持环境变量配置
const API_BASE_URL = API_CONFIG.baseUrl;

/**
 * 创建请求头，自动添加认证Token
 * @param {Object} headers - 额外的请求头
 * @returns {Object} 合并后的请求头
 */
const createHeaders = (headers = {}) => {
  const token = localStorage.getItem('token');
  const defaultHeaders = {
    'Content-Type': 'application/json',
    'Cache-Control': 'no-cache',
    'Pragma': 'no-cache'
  };
  
  if (token) {
    defaultHeaders['Authorization'] = `Bearer ${token}`;
  } else {
    console.warn('没有找到认证token，请先登录');
    // 重定向到登录页
    window.location.href = '/login';
    throw new Error('未认证，请先登录');
  }
  
  // 如果headers中明确设置了Content-Type为undefined，则移除它
  const mergedHeaders = { ...defaultHeaders, ...headers };
  if (mergedHeaders['Content-Type'] === undefined) {
    delete mergedHeaders['Content-Type'];
  }
  
  return mergedHeaders;
};

/**
 * 处理API响应
 * @param {Response} response - Fetch API响应对象
 * @returns {Promise} 处理后的响应数据
 */
const handleResponse = async (response) => {
  // 检查HTTP状态
  if (!response.ok) {
    // 处理常见错误
    if (response.status === 401) {
      // 清除无效的认证信息
      localStorage.removeItem('token');
      localStorage.removeItem('user');
      console.warn('认证token已过期，请重新登录');
      throw new Error('认证已过期，请重新登录');
    }
    
    if (response.status === 403) {
      console.error('API 403错误详情:', {
        url: response.url,
        method: response.method,
        headers: response.headers
      });
      throw new Error('您没有权限访问此资源，请联系管理员');
    }
    
    if (response.status === 404) {
      throw new Error('请求的资源不存在');
    }
    
    if (response.status === 500) {
      try {
        const errorData = await response.json();
        console.error('API 500错误详情:', errorData);
        throw new Error(errorData.message || '服务器繁忙，请稍后重试');
      } catch (e) {
        console.error('API处理错误:', e.message);
        if (e.message.includes('Failed to fetch')) {
          throw new Error('网络连接失败，请检查网络');
        } else if (e.message.includes('Unexpected end of JSON input') || e.message.includes('JSON')) {
          throw new Error('服务器返回非法响应，请联系管理员');
        } else {
          throw new Error('服务器内部错误，请联系管理员');
        }
      }
    }
    
    // 尝试获取详细错误信息
    try {
      const errorData = await response.json();
      const errorMessage = errorData.message || `请求失败: ${response.status} ${response.statusText}`;
      console.error(`API请求失败 [${response.status}]:`, {
        url: response.url,
        method: response.method,
        error: errorData,
        headers: response.headers
      });
      throw new Error(errorMessage);
    } catch (e) {
      console.error(`API请求解析失败:`, {
        url: response.url,
        method: response.method,
        status: response.status,
        statusText: response.statusText,
        headers: response.headers
      });
      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数据
  let result;
  try {
    result = await response.json();
  } catch (e) {
    console.error('JSON解析失败:', e.message);
    if (e.message.includes('Unexpected end of JSON input')) {
      throw new Error('服务器返回空响应，请联系管理员');
    } else {
      throw new Error('服务器返回数据格式错误');
    }
  }
  
  // 兼容数组响应
  if (Array.isArray(result)) {
    return result;
  }
  
  // 验证响应格式
  if (!isValidApiResponse(result)) {
    console.warn('API响应格式不符合标准:', result);
    return result;
  }
  
  if (!result.success) {
    console.error(`API业务逻辑失败:`, {
      url: response.url,
      method: response.method,
      response: result
    });
    throw new Error(result.message || 'API请求失败');
  }
  
  return result;
};

/**
 * 更新农场信息
 * @param {string} id - 农场ID
 * @param {Object} data - 更新的农场数据
 * @returns {Promise} 更新后的农场数据
 */
const updateFarm = async (id, data) => {
  const response = await fetch(`${API_BASE_URL}/farms/${id}`, {
    method: 'PUT',
    headers: createHeaders(),
    body: JSON.stringify(data),
  });
  return handleResponse(response);
};

/**
 * 创建完整URL
 * @param {string} endpoint - API端点
 * @returns {string} 完整URL
 */
const createFullUrl = (endpoint) => {
  if (API_CONFIG.useProxy) {
    return `${API_BASE_URL}${endpoint}`;
  } else {
    return `${API_CONFIG.fullBaseUrl}${endpoint}`;
  }
};

/**
 * 直接API调用工具（用于需要完整URL的场景）
 */
export const directApi = {
  /**
   * 直接GET请求
   * @param {string} endpoint - API端点
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async get(endpoint, options = {}) {
    const url = createFullUrl(endpoint);
    const response = await fetch(url, {
      ...options,
      method: 'GET',
      headers: createHeaders(options.headers),
    });
    return handleResponse(response);
  },

  /**
   * 直接POST请求
   * @param {string} endpoint - API端点
   * @param {Object} data - 请求数据
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async post(endpoint, data, options = {}) {
    const url = createFullUrl(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 = createFullUrl(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 = createFullUrl(endpoint);
    const response = await fetch(url, {
      method: 'DELETE',
      headers: createHeaders(options.headers),
      ...options,
    });
    return handleResponse(response);
  }
};

/**
 * API请求方法
 */
export const api = {
  /**
   * 登录
   * @param {string} username - 用户名
   * @param {string} password - 密码
   * @returns {Promise} 登录结果
   */
  async login(username, password) {
    const response = await fetch(`${API_BASE_URL}/auth/login`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'no-cache',
        'Pragma': 'no-cache'
      },
      body: JSON.stringify({ username, password }),
    });
    
    // 检查HTTP状态
    if (!response.ok) {
      if (response.status === 401) {
        throw new Error('用户名或密码错误');
      }
      if (response.status === 500) {
        throw new Error('服务器错误，请稍后重试');
      }
      throw new Error(`登录失败: ${response.status} ${response.statusText}`);
    }
    
    const result = await response.json();
    
    // 检查业务逻辑是否成功
    if (!result.success) {
      throw new Error(result.message || '登录失败');
    }
    
    // 保存token到localStorage
    if (result.token) {
      localStorage.setItem('token', result.token);
    }
    
    // 返回完整的结果对象，保持与后端响应格式一致
    return result;
  },

  /**
   * GET请求
   * @param {string} endpoint - API端点
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async get(endpoint, options = {}) {
    let url = `${API_BASE_URL}${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，因为已经添加到URL中了
      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|FormData} data - 请求数据
   * @param {Object} options - 请求选项
   * @returns {Promise} 响应数据
   */
  async post(endpoint, data, options = {}) {
    const url = `${API_BASE_URL}${endpoint}`;
    
    // 如果是FormData，不设置Content-Type，让浏览器自动处理
    const isFormData = data instanceof FormData;
    const headers = isFormData 
      ? createHeaders({ ...options.headers, 'Content-Type': undefined })
      : createHeaders(options.headers);
    
    // 如果是FormData，直接使用data；否则使用JSON.stringify
    const body = isFormData ? data : JSON.stringify(data);
    
    const response = await fetch(url, {
      method: 'POST',
      headers: headers,
      body: body,
      ...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_BASE_URL}${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_BASE_URL}${endpoint}`;
    const response = await fetch(url, {
      method: 'DELETE',
      headers: createHeaders(options.headers),
      ...options,
    });
    return handleResponse(response);
  },

  // 电子围栏相关API
  electronicFence: {
    /**
     * 获取围栏列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 围栏列表
     */
    async getFences(params = {}) {
      return api.get('/electronic-fence', { params });
    },

    /**
     * 获取围栏详情
     * @param {number} id - 围栏ID
     * @returns {Promise} 围栏详情
     */
    async getFenceById(id) {
      return api.get(`/electronic-fence/${id}`);
    },

    /**
     * 创建围栏
     * @param {Object} data - 围栏数据
     * @returns {Promise} 创建的围栏
     */
    async createFence(data) {
      return api.post('/electronic-fence', data);
    },

    /**
     * 更新围栏
     * @param {number} id - 围栏ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新后的围栏
     */
    async updateFence(id, data) {
      return api.put(`/electronic-fence/${id}`, data);
    },

    /**
     * 删除围栏
     * @param {number} id - 围栏ID
     * @returns {Promise} 删除结果
     */
    async deleteFence(id) {
      return api.delete(`/electronic-fence/${id}`);
    },

    /**
     * 更新围栏统计信息
     * @param {number} id - 围栏ID
     * @param {Object} stats - 统计信息
     * @returns {Promise} 更新结果
     */
    async updateFenceStats(id, stats) {
      return api.put(`/electronic-fence/${id}/stats`, stats);
    },

    /**
     * 检查点是否在围栏内
     * @param {number} id - 围栏ID
     * @param {number} lng - 经度
     * @param {number} lat - 纬度
     * @returns {Promise} 检查结果
     */
    async checkPointInFence(id, lng, lat) {
      return api.get(`/electronic-fence/${id}/check-point`, {
        params: { lng, lat }
      });
    },

    /**
     * 获取围栏统计概览
     * @returns {Promise} 统计概览
     */
    async getFenceStats() {
      return api.get('/electronic-fence/stats/overview');
    }
  },

  // 电子围栏坐标点相关API
  electronicFencePoints: {
    /**
     * 获取围栏的所有坐标点
     * @param {number} fenceId - 围栏ID
     * @param {Object} params - 查询参数
     * @returns {Promise} 坐标点列表
     */
    async getByFenceId(fenceId, params = {}) {
      return api.get(`/electronic-fence-points/fence/${fenceId}`, { params });
    },

    /**
     * 获取坐标点详情
     * @param {number} id - 坐标点ID
     * @returns {Promise} 坐标点详情
     */
    async getById(id) {
      return api.get(`/electronic-fence-points/${id}`);
    },

    /**
     * 创建坐标点
     * @param {Object} data - 坐标点数据
     * @returns {Promise} 创建的坐标点
     */
    async create(data) {
      return api.post('/electronic-fence-points', data);
    },

    /**
     * 批量创建坐标点
     * @param {Object} data - 批量创建数据
     * @returns {Promise} 创建的坐标点列表
     */
    async createPoints(data) {
      return api.post('/electronic-fence-points/batch', data);
    },

    /**
     * 更新坐标点
     * @param {number} id - 坐标点ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新后的坐标点
     */
    async update(id, data) {
      return api.put(`/electronic-fence-points/${id}`, data);
    },

    /**
     * 更新围栏的所有坐标点
     * @param {number} fenceId - 围栏ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新后的坐标点列表
     */
    async updateFencePoints(fenceId, data) {
      return api.put(`/electronic-fence-points/fence/${fenceId}`, data);
    },

    /**
     * 删除坐标点
     * @param {number} id - 坐标点ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/electronic-fence-points/${id}`);
    },

    /**
     * 删除围栏的所有坐标点
     * @param {number} fenceId - 围栏ID
     * @returns {Promise} 删除结果
     */
    async deleteFencePoints(fenceId) {
      return api.delete(`/electronic-fence-points/fence/${fenceId}`);
    },

    /**
     * 获取围栏边界框
     * @param {number} fenceId - 围栏ID
     * @returns {Promise} 边界框数据
     */
    async getBounds(fenceId) {
      return api.get(`/electronic-fence-points/fence/${fenceId}/bounds`);
    },

    /**
     * 搜索坐标点
     * @param {Object} params - 搜索参数
     * @returns {Promise} 搜索结果
     */
    async search(params = {}) {
      return api.get('/electronic-fence-points/search', { params });
    }
  },

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

    /**
     * 获取栏舍详情
     * @param {number} id - 栏舍ID
     * @returns {Promise} 栏舍详情
     */
    async getById(id) {
      return api.get(`/pens/public/${id}`);
    },

    /**
     * 创建栏舍
     * @param {Object} data - 栏舍数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/pens', data);
    },

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

    /**
     * 删除栏舍
     * @param {number} id - 栏舍ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/pens/${id}`);
    },

    /**
     * 批量删除栏舍
     * @param {Array} ids - 栏舍ID数组
     * @returns {Promise} 删除结果
     */
    async batchDelete(ids) {
      return api.delete('/pens/batch', { ids });
    },

    /**
     * 获取栏舍统计信息
     * @param {Object} params - 查询参数
     * @returns {Promise} 统计信息
     */
    async getStats(params = {}) {
      return api.get('/pens/public/stats/summary', { params });
    }
  },

  // 栏舍设置API
  cattlePens: {
    /**
     * 获取栏舍设置列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 栏舍设置列表
     */
    async getList(params = {}) {
      return api.get('/cattle-pens', { params });
    },

    /**
     * 获取栏舍设置详情
     * @param {number} id - 栏舍设置ID
     * @returns {Promise} 栏舍设置详情
     */
    async getById(id) {
      return api.get(`/cattle-pens/${id}`);
    },

    /**
     * 创建栏舍设置
     * @param {Object} data - 栏舍设置数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/cattle-pens', data);
    },

    /**
     * 更新栏舍设置
     * @param {number} id - 栏舍设置ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/cattle-pens/${id}`, data);
    },

    /**
     * 删除栏舍设置
     * @param {number} id - 栏舍设置ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/cattle-pens/${id}`);
    },

    /**
     * 批量删除栏舍设置
     * @param {Array} ids - 栏舍设置ID数组
     * @returns {Promise} 删除结果
     */
    async batchDelete(ids) {
      return api.post('/cattle-pens/batch-delete', { ids });
    },

    /**
     * 获取栏舍中的牛只
     * @param {number} id - 栏舍设置ID
     * @param {Object} params - 查询参数
     * @returns {Promise} 牛只列表
     */
    async getAnimals(id, params = {}) {
      return api.get(`/cattle-pens/${id}/animals`, { params });
    }
  },

  // 批次设置API
  cattleBatches: {
    /**
     * 获取批次设置列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 批次设置列表
     */
    async getList(params = {}) {
      return api.get('/cattle-batches', { params });
    },

    /**
     * 获取批次设置详情
     * @param {number} id - 批次设置ID
     * @returns {Promise} 批次设置详情
     */
    async getById(id) {
      return api.get(`/cattle-batches/${id}`);
    },

    /**
     * 创建批次设置
     * @param {Object} data - 批次设置数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/cattle-batches', data);
    },

    /**
     * 更新批次设置
     * @param {number} id - 批次设置ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/cattle-batches/${id}`, data);
    },

    /**
     * 删除批次设置
     * @param {number} id - 批次设置ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/cattle-batches/${id}`);
    },

    /**
     * 批量删除批次设置
     * @param {Array} ids - 批次设置ID数组
     * @returns {Promise} 删除结果
     */
    async batchDelete(ids) {
      return api.post('/cattle-batches/batch-delete', { ids });
    },

    /**
     * 获取批次中的牛只
     * @param {number} id - 批次设置ID
     * @param {Object} params - 查询参数
     * @returns {Promise} 牛只列表
     */
    async getAnimals(id, params = {}) {
      return api.get(`/cattle-batches/${id}/animals`, { params });
    },

    /**
     * 添加牛只到批次
     * @param {number} id - 批次设置ID
     * @param {Array} animalIds - 牛只ID数组
     * @returns {Promise} 添加结果
     */
    async addAnimals(id, animalIds) {
      return api.post(`/cattle-batches/${id}/animals`, { animalIds });
    },

    /**
     * 从批次中移除牛只
     * @param {number} id - 批次设置ID
     * @param {number} animalId - 牛只ID
     * @returns {Promise} 移除结果
     */
    async removeAnimal(id, animalId) {
      return api.delete(`/cattle-batches/${id}/animals/${animalId}`);
    }
  },

  // 转栏记录API
  cattleTransferRecords: {
    /**
     * 获取转栏记录列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 转栏记录列表
     */
    async getList(params = {}) {
      return api.get('/cattle-transfer-records', { params });
    },

    /**
     * 获取转栏记录详情
     * @param {number} id - 转栏记录ID
     * @returns {Promise} 转栏记录详情
     */
    async getById(id) {
      return api.get(`/cattle-transfer-records/${id}`);
    },

    /**
     * 创建转栏记录
     * @param {Object} data - 转栏记录数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/cattle-transfer-records', data);
    },

    /**
     * 更新转栏记录
     * @param {number} id - 转栏记录ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/cattle-transfer-records/${id}`, data);
    },

    /**
     * 删除转栏记录
     * @param {number} id - 转栏记录ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/cattle-transfer-records/${id}`);
    },

    /**
     * 批量删除转栏记录
     * @param {Array} ids - 转栏记录ID数组
     * @returns {Promise} 删除结果
     */
    async batchDelete(ids) {
      return api.post('/cattle-transfer-records/batch-delete', { ids });
    },

    /**
     * 获取可用的牛只列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 牛只列表
     */
    async getAvailableAnimals(params = {}) {
      return api.get('/cattle-transfer-records/available-animals', { params });
    }
  },

  // 离栏记录API
  cattleExitRecords: {
    /**
     * 获取离栏记录列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 离栏记录列表
     */
    async getList(params = {}) {
      return api.get('/cattle-exit-records', { params });
    },

    /**
     * 获取离栏记录详情
     * @param {number} id - 离栏记录ID
     * @returns {Promise} 离栏记录详情
     */
    async getById(id) {
      return api.get(`/cattle-exit-records/${id}`);
    },

    /**
     * 创建离栏记录
     * @param {Object} data - 离栏记录数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/cattle-exit-records', data);
    },

    /**
     * 更新离栏记录
     * @param {number} id - 离栏记录ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/cattle-exit-records/${id}`, data);
    },

    /**
     * 删除离栏记录
     * @param {number} id - 离栏记录ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/cattle-exit-records/${id}`);
    },

    /**
     * 批量删除离栏记录
     * @param {Array} ids - 离栏记录ID数组
     * @returns {Promise} 删除结果
     */
    async batchDelete(ids) {
      return api.post('/cattle-exit-records/batch-delete', { ids });
    },

    /**
     * 确认离栏记录
     * @param {number} id - 离栏记录ID
     * @returns {Promise} 确认结果
     */
    async confirm(id) {
      return api.post(`/cattle-exit-records/${id}/confirm`);
    },

    /**
     * 获取可用的牛只列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 牛只列表
     */
    async getAvailableAnimals(params = {}) {
      return api.get('/cattle-exit-records/available-animals', { params });
    }
  },

  // 表单日志相关API
  formLogs: {
    /**
     * 添加表单日志
     * @param {Object} logData - 日志数据
     * @returns {Promise} 添加结果
     */
    async add(logData) {
      return api.post('/form-logs/add', logData);
    },

    /**
     * 获取表单日志列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 日志列表
     */
    async getList(params = {}) {
      return api.get('/form-logs/list', { params });
    },

    /**
     * 获取日志详情
     * @param {number} id - 日志ID
     * @returns {Promise} 日志详情
     */
    async getDetail(id) {
      return api.get(`/form-logs/detail/${id}`);
    },

    /**
     * 删除日志
     * @param {number} id - 日志ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/form-logs/delete/${id}`);
    },

    /**
     * 批量删除日志
     * @param {Array} ids - 日志ID数组
     * @returns {Promise} 删除结果
     */
    async batchDelete(ids) {
      return api.delete('/form-logs/batch-delete', { ids });
    },

    /**
     * 获取日志统计信息
     * @param {Object} params - 查询参数
     * @returns {Promise} 统计信息
     */
    async getStats(params = {}) {
      return api.get('/form-logs/stats', { params });
    }
  },

  // 日志相关API（兼容性）
  logs: {
    /**
     * 添加表单日志（兼容性方法）
     * @param {Object} logData - 日志数据
     * @returns {Promise} 添加结果
     */
    async addFormLog(logData) {
      return api.formLogs.add(logData);
    },

    /**
     * 添加搜索日志（兼容性方法）
     * @param {Object} logData - 日志数据
     * @returns {Promise} 添加结果
     */
    async addSearchLog(logData) {
      return api.formLogs.add({
        ...logData,
        action: 'search'
      });
    }
  },

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

    /**
     * 获取养殖场详情
     * @param {number} id - 养殖场ID
     * @returns {Promise} 养殖场详情
     */
    async getById(id) {
      return api.get(`/farms/${id}`);
    },

    /**
     * 创建养殖场
     * @param {Object} data - 养殖场数据
     * @returns {Promise} 创建结果
     */
    async create(data) {
      return api.post('/farms', data);
    },

    /**
     * 更新养殖场
     * @param {number} id - 养殖场ID
     * @param {Object} data - 更新数据
     * @returns {Promise} 更新结果
     */
    async update(id, data) {
      return api.put(`/farms/${id}`, data);
    },

    /**
     * 删除养殖场
     * @param {number} id - 养殖场ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
      return api.delete(`/farms/${id}`);
    },

    /**
     * 搜索养殖场
     * @param {string} name - 养殖场名称
     * @returns {Promise} 搜索结果
     */
    async search(name) {
      return api.get('/farms/search', { params: { name } });
    }
  },

  // 操作日志API
  operationLogs: {
    /**
     * 获取操作日志列表
     * @param {Object} params - 查询参数
     * @returns {Promise} 操作日志列表
     */
    async getOperationLogs(params = {}) {
      return api.get('/operation-logs', { params });
    },

    /**
     * 获取操作日志详情
     * @param {number} id - 操作日志ID
     * @returns {Promise} 操作日志详情
     */
    async getOperationLogById(id) {
      return api.get(`/operation-logs/${id}`);
    },

    /**
     * 获取操作统计
     * @param {Object} params - 查询参数
     * @returns {Promise} 操作统计
     */
    async getOperationStats(params = {}) {
      return api.get('/operation-logs/stats/overview', { params });
    },

    /**
     * 获取操作日志图表数据
     * @param {Object} params - 查询参数
     * @returns {Promise} 图表数据
     */
    async getOperationChartData(params = {}) {
      return api.get('/operation-logs/stats/chart', { params });
    },

    /**
     * 清理过期日志
     * @param {Object} data - 清理参数
     * @returns {Promise} 清理结果
     */
    async cleanExpiredLogs(data = {}) {
      return api.post('/operation-logs/clean', data);
    },

    /**
     * 导出操作日志
     * @param {Object} params - 查询参数
     * @returns {Promise} 导出结果
     */
    async exportOperationLogs(params = {}) {
      return api.get('/operation-logs/export', { 
        params,
        responseType: 'blob'
      });
    }
  }
};

/**
 * 使用示例：
 * // 登录
 * api.login('admin', 'password')
 *   .then(response => {
 *     console.log('登录成功', response);
 *     // 之后的其他API调用会自动携带token
 *   })
 *   .catch(error => {
 *     console.error('登录失败', error);
 *   });
 */