import axios from 'axios';

const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || '';

// AI换脸换装API接口
const apiRequest = async (endpoint, options = {}) => {
  const baseURL = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8000';
  const url = `${baseURL}${endpoint}`;
  
  // 获取认证token
  const token = localStorage.getItem('authToken');
  
  const defaultOptions = {
    headers: {
      'Content-Type': 'application/json',
      ...(token && { 'Authorization': `Bearer ${token}` }),
    },
    ...options,
  };

  try {
    const response = await fetch(url, defaultOptions);
    
    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`HTTP error! status: ${response.status} - ${errorText}`);
    }
    
    return await response.json();
  } catch (error) {
    console.error('API request failed:', error);
    throw error;
  }
};

// AI换脸换装API类
export class AISwapAPI {
  constructor() {
    this.baseURL = '/api/v1';
  }

  /**
   * 执行AI换脸换装任务
   * @param {Object} swapData - 换脸换装数据
   * @param {number} swapData.user_id - 用户ID
   * @param {number} swapData.face_image_id - 人脸图片ID
   * @param {number} swapData.cloth_image_id - 服装图片ID
   * @param {string} swapData.prompt - 提示词
   * @param {string} [swapData.face_prompt] - 人脸识别提示词（可选）
   * @param {string} [swapData.cloth_prompt] - 服装识别提示词（可选）
   * @param {string} [swapData.prompt_prompt] - 提示词优化（可选）
   * @returns {Promise<Object>} 任务提交结果
   */
  async processSwap(swapData) {
    return await apiRequest(`${this.baseURL}/swap`, {
      method: 'POST',
      body: JSON.stringify(swapData),
    });
  }

  /**
   * 获取任务状态
   * @param {string} taskId - 任务ID
   * @returns {Promise<Object>} 任务状态信息
   */
  async getTaskStatus(taskId) {
    return await apiRequest(`${this.baseURL}/tasks/${taskId}`);
  }

  /**
   * 获取用户任务列表
   * @param {number} userId - 用户ID
   * @returns {Promise<Object>} 用户任务列表
   */
  async getUserTasks(userId) {
    return await apiRequest(`${this.baseURL}/users/${userId}/tasks`);
  }

  /**
   * 取消任务
   * @param {string} taskId - 任务ID
   * @returns {Promise<Object>} 取消结果
   */
  async cancelTask(taskId) {
    return await apiRequest(`${this.baseURL}/tasks/${taskId}`, {
      method: 'DELETE',
    });
  }

  /**
   * 获取队列统计信息
   * @returns {Promise<Object>} 队列统计信息
   */
  async getQueueStats() {
    return await apiRequest(`${this.baseURL}/tasks/queue/stats`);
  }

  /**
   * 获取用户处理历史记录
   * @param {number} userId - 用户ID
   * @param {number} page - 页码
   * @param {number} pageSize - 每页数量
   * @returns {Promise<Object>} 处理历史记录
   */
  async getUserProcessHistory(userId, page = 1, pageSize = 20) {
    const params = new URLSearchParams({
      page: page.toString(),
      page_size: pageSize.toString(),
    });
    return await apiRequest(`${this.baseURL}/users/${userId}/process-history?${params}`);
  }

  /**
   * 获取处理记录详情
   * @param {number} processId - 处理记录ID
   * @param {number} [userId] - 用户ID（可选）
   * @returns {Promise<Object>} 处理记录详情
   */
  async getProcessDetail(processId, userId = null) {
    let url = `${this.baseURL}/process/${processId}`;
    if (userId) {
      url += `?user_id=${userId}`;
    }
    return await apiRequest(url);
  }

  /**
   * 删除处理记录的结果图片
   * @param {number} processId 处理记录ID
   * @param {number} userId 当前用户ID
   */
  async deleteResultImage(processId, userId) {
    const url = `${this.baseURL}/process/${processId}/result-image`;
    const payload = { user_id: userId };
    return await apiRequest(url, {
      method: 'DELETE',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });
  }

  // 更新处理记录文本内容
  async updateProcessText(processId, userId, textData) {
    try {
      const url = `${this.baseURL}/process/${processId}/text`;
      const requestData = {
        user_id: userId,
        title: textData.title || '',
        content: textData.content || '',
        label: textData.label || ''
      };

      console.log('发送更新请求:', {
        url,
        requestData
      });

      return await apiRequest(url, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestData)
      });
    } catch (error) {
      console.error('更新处理记录文本失败:', error);
      throw error;
    }
  }

  /**
   * 审核处理记录
   * @param {number} processId - 处理记录ID
   * @param {number} userId - 用户ID
   * @returns {Promise<Object>} 审核结果
   */
  async approveProcessRecord(processId, userId) {
    try {
      const url = `${this.baseURL}/process/${processId}/approve`;
      const requestData = {
        user_id: userId
      };

      console.log('发送审核请求:', {
        url,
        requestData
      });

      return await apiRequest(url, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestData)
      });
    } catch (error) {
      console.error('审核处理记录失败:', error);
      throw error;
    }
  }
}

// 创建单例实例
export const aiSwapAPI = new AISwapAPI(); 