/**
 * 任务队列管理器
 * 用于确保API请求按顺序串行执行，避免并发请求
 */

class TaskQueueManager {
  constructor() {
    this.queue = [];           // 任务队列
    this.isProcessing = false; // 处理状态标志
    this.currentTask = null;   // 当前正在处理的任务
  }

  /**
   * 添加任务到队列
   * @param {Function} taskFunction - 任务函数，必须返回Promise
   * @param {String} taskName - 任务名称，用于日志记录
   * @returns {Promise} - 返回一个Promise，在任务执行完成后resolve
   */
  addTask(taskFunction, taskName = '未命名任务') {
    console.log(`[TaskQueue] 添加任务到队列: ${taskName}`);
    
    return new Promise((resolve, reject) => {
      // 将任务添加到队列
      this.queue.push({
        execute: taskFunction,
        name: taskName,
        resolve,
        reject
      });
      
      // 如果当前没有任务在处理，则启动处理
      if (!this.isProcessing) {
        this.processQueue();
      } else {
        console.log(`[TaskQueue] 当前有任务正在处理，${taskName} 已加入队列，等待执行。队列长度: ${this.queue.length}`);
      }
    });
  }

  /**
   * 处理队列中的任务
   * @private
   */
  async processQueue() {
    // 如果队列为空或已经在处理中，则直接返回
    if (this.queue.length === 0 || this.isProcessing) {
      return;
    }

    // 设置处理状态为true
    this.isProcessing = true;
    
    // 获取队列中的第一个任务
    this.currentTask = this.queue.shift();
    
    console.log(`[TaskQueue] 开始处理任务: ${this.currentTask.name}，剩余队列任务数: ${this.queue.length}`);
    
    try {
      // 执行任务
      const result = await this.currentTask.execute();
      
      // 任务成功，调用resolve
      console.log(`[TaskQueue] 任务成功完成: ${this.currentTask.name}`);
      this.currentTask.resolve(result);
    } catch (error) {
      // 任务失败，调用reject
      console.error(`[TaskQueue] 任务执行失败: ${this.currentTask.name}`, error);
      this.currentTask.reject(error);
    } finally {
      // 设置当前任务为null
      this.currentTask = null;
      
      // 设置处理状态为false
      this.isProcessing = false;
      
      // 添加延迟，确保系统有足够时间处理完成当前请求
      console.log(`[TaskQueue] 任务处理完成，等待1秒后处理下一个任务`);
      setTimeout(() => {
        // 处理队列中的下一个任务
        if (this.queue.length > 0) {
          console.log(`[TaskQueue] 开始处理队列中的下一个任务，队列长度: ${this.queue.length}`);
          this.processQueue();
        } else {
          console.log(`[TaskQueue] 队列中没有更多任务`);
        }
      }, 1000);
    }
  }

  /**
   * 清空队列中的所有任务
   * @returns {Number} - 返回被清空的任务数量
   */
  clearQueue() {
    const taskCount = this.queue.length;
    
    // 拒绝所有未处理的任务
    this.queue.forEach(task => {
      task.reject(new Error(`任务 ${task.name} 被取消`));
    });
    
    // 清空队列
    this.queue = [];
    
    console.log(`[TaskQueue] 队列已清空，取消了 ${taskCount} 个任务`);
    
    return taskCount;
  }

  /**
   * 获取队列中待处理的任务数量
   * @returns {Number} - 返回队列长度
   */
  getQueueLength() {
    return this.queue.length;
  }

  /**
   * 判断是否有任务正在处理
   * @returns {Boolean} - 如果有任务正在处理则返回true，否则返回false
   */
  isBusy() {
    return this.isProcessing;
  }

  /**
   * 获取当前正在处理的任务名称
   * @returns {String|null} - 返回当前任务名称，如果没有则返回null
   */
  getCurrentTaskName() {
    return this.currentTask ? this.currentTask.name : null;
  }
}

// 创建单例实例
const taskQueueManager = new TaskQueueManager();

export default taskQueueManager; 