/**
 * TaskForwarder - 任务转发器
 * 
 * 设计说明：
 * - clientId 使用实例 ID（固定不变），实现 WebSocket 连接复用
 * - prompt_id 使用 taskId，便于任务追踪和查询
 * - 同一实例的所有任务共享同一个 WebSocket 连接
 * - 通过 prompt_id 区分不同任务的消息
 */

import { v4 as uuidv4 } from 'uuid';
import logger from '../logger/index.js';
import clusterManager from '../cluster-manager/index.js';
import webSocketClient from '../websocket-client/index.js';
import axios from 'axios';
import taskQueueClient from '../task-queue-client/index.js';
import fileUploader from '../file-uploader/index.js';
import config from '../config/index.js';
import fs from 'fs';
import path from 'path';

class TaskForwarder {
  constructor() {
    this.tasks = new Map();
    this.setupEventListeners();
  }

  setupEventListeners() {
    logger.info('[TaskForwarder] 设置事件监听器');
    
    webSocketClient.on('execution_start', ({ instanceId, promptId }) => {
      logger.info(`[TaskForwarder] 收到 execution_start 事件: instanceId=${instanceId}, promptId=${promptId}`);
      this.handleExecutionStart(instanceId, promptId).catch(err => {
        logger.error('处理 execution_start 事件失败:', err);
      });
    });

    webSocketClient.on('progress', ({ instanceId, data }) => {
      this.handleProgress(instanceId, data).catch(err => {
        logger.error('处理 progress 事件失败:', err);
      });
    });

    webSocketClient.on('executed', ({ instanceId, data }) => {
      logger.info(`[TaskForwarder] 收到 executed 事件: instanceId=${instanceId}, promptId=${data?.prompt_id}`);
      this.handleExecuted(instanceId, data).catch(err => {
        logger.error('处理 executed 事件失败:', err);
      });
    });

    webSocketClient.on('execution_success', ({ instanceId, data }) => {
      logger.info(`[TaskForwarder] 收到 execution_success 事件: instanceId=${instanceId}, promptId=${data?.prompt_id}`);
      this.handleExecutionSuccess(instanceId, data).catch(err => {
        logger.error('处理 execution_success 事件失败:', err);
      });
    });

    webSocketClient.on('execution_error', ({ instanceId, data }) => {
      logger.error(`[TaskForwarder] 收到 execution_error 事件: instanceId=${instanceId}, promptId=${data?.prompt_id}`);
      this.handleExecutionError(instanceId, data).catch(err => {
        logger.error('处理 execution_error 事件失败:', err);
      });
    });
  }

  async submitTask(workflow, nodeInfoList = [], workflowId = null, instanceId = null, webhookUrl = null, queueTaskId = null) {
    const taskId = queueTaskId || uuidv4();
    
    let instance;
    if (instanceId) {
      instance = clusterManager.getInstance(instanceId);
      if (!instance) {
        throw new Error(`实例 ${instanceId} 不存在`);
      }
    } else {
      instance = clusterManager.selectInstance();
      if (!instance) {
        throw new Error('没有可用的实例');
      }
    }

    const task = {
      id: taskId,
      promptId: taskId,
      workflow,
      nodeInfoList,
      workflowId,
      webhookUrl,
      queueTaskId,
      instanceId: instance.id,
      status: 'pending',
      progress: 0,
      createdAt: new Date().toISOString(),
      startedAt: null,
      completedAt: null,
      result: null,
      error: null
    };

    this.tasks.set(taskId, task);
    logger.info(`任务已创建: ${taskId}, 分配到实例: ${instance.id}`);

    try {
      await this.sendTaskToInstance(task, instance);
      return taskId;
    } catch (error) {
      task.status = 'failed';
      task.error = error.message;
      this.tasks.set(taskId, task);
      logger.error(`任务 ${taskId} 提交失败:`, error);
      
      if (webhookUrl) {
        await this.sendWebhookCallback(task, null, error.message);
      }
      
      throw error;
    }
  }

  async sendTaskToInstance(task, instance) {
    logger.info(`[TaskForwarder] 准备发送任务 ${task.id} 到实例 ${instance.id}`);
    logger.info(`[TaskForwarder] 实例信息: ${JSON.stringify({ id: instance.id, wsUrl: instance.wsUrl, apiUrl: instance.apiUrl })}`);
    
    const wsClientId = instance.id;
    const wsUrlWithClientId = `${instance.wsUrl}?clientId=${wsClientId}`;
    logger.info(`[TaskForwarder] WebSocket URL (clientId=实例ID): ${wsUrlWithClientId}`);
    
    await webSocketClient.connect(instance.id, wsUrlWithClientId);
    
    const promptPayload = {
      prompt: task.workflow,
      prompt_id: task.id,
      client_id: wsClientId
    };

    logger.info(`[TaskForwarder] 发送的 prompt 消息结构: prompt_id=${task.id}, client_id=${wsClientId}, workflow节点数=${Object.keys(task.workflow || {}).length}`);
    logger.info(`[TaskForwarder] 通过 HTTP POST /prompt 提交任务到 ${instance.apiUrl}/prompt`);

    try {
      const response = await axios.post(`${instance.apiUrl}/prompt`, promptPayload, {
        headers: {
          'Content-Type': 'application/json'
        },
        timeout: 30000
      });
      
      logger.info(`[TaskForwarder] HTTP POST /prompt 响应: ${JSON.stringify(response.data)}`);
      
      if (response.data?.node_errors && Object.keys(response.data.node_errors).length > 0) {
        const nodeErrors = response.data.node_errors;
        const errorMessages = [];
        
        for (const [nodeId, errorInfo] of Object.entries(nodeErrors)) {
          if (errorInfo.errors && errorInfo.errors.length > 0) {
            for (const err of errorInfo.errors) {
              errorMessages.push(`节点 ${nodeId}: ${err.message}${err.details ? ` (${err.details})` : ''}`);
            }
          }
        }
        
        const fullErrorMessage = `工作流节点错误: ${errorMessages.join('; ')}`;
        logger.error(`[TaskForwarder] ${fullErrorMessage}`);
        throw new Error(fullErrorMessage);
      }
      
      const returnedPromptId = response.data?.prompt_id || response.data?.promptId;
      logger.info(`[TaskForwarder] 任务 ${task.id} 已提交，ComfyUI 返回 prompt_id: ${returnedPromptId}`);
      
    } catch (error) {
      let errorMessage = error.message;
      
      if (error.response && error.response.data) {
        const comfyError = error.response.data;
        logger.error(`[TaskForwarder] 错误响应: ${JSON.stringify(comfyError)}`);
        
        if (comfyError.error && comfyError.error.message) {
          errorMessage = comfyError.error.message;
        } else if (comfyError.message) {
          errorMessage = comfyError.message;
        } else if (typeof comfyError === 'string') {
          errorMessage = comfyError;
        } else {
          errorMessage = JSON.stringify(comfyError);
        }
        logger.error(`[TaskForwarder] 提取的错误信息: ${errorMessage}`);
      }
      
      throw new Error(errorMessage);
    }

    task.status = 'submitted';
    logger.info(`任务 ${task.id} 已发送到实例 ${instance.id}`);
  }

  async handleExecutionStart(instanceId, promptId) {
    logger.info(`[TaskForwarder] handleExecutionStart: instanceId=${instanceId}, promptId=${promptId}`);
    
    const task = this.tasks.get(promptId);
    if (!task) {
      logger.warn(`[TaskForwarder] 未找到任务: promptId=${promptId}`);
      return;
    }
    
    if (task.instanceId !== instanceId) {
      logger.warn(`[TaskForwarder] 任务实例不匹配: taskId=${promptId}, task.instanceId=${task.instanceId}, event.instanceId=${instanceId}`);
      return;
    }
    
    if (task.status !== 'submitted') {
      logger.warn(`[TaskForwarder] 任务状态不正确: taskId=${promptId}, status=${task.status}`);
      return;
    }
    
    task.status = 'running';
    task.startedAt = new Date().toISOString();
    this.tasks.set(promptId, task);
    clusterManager.updateInstanceStatus(instanceId, 'busy');
    logger.info(`任务 ${task.id} 开始执行`);
  }

  async handleProgress(instanceId, data) {
    if (!data?.prompt_id) {
      return;
    }
    
    const task = this.tasks.get(data.prompt_id);
    if (!task || task.instanceId !== instanceId) {
      return;
    }
    
    if (data.max && data.max > 0) {
      task.progress = Math.round((data.value / data.max) * 100);
      this.tasks.set(data.prompt_id, task);
      logger.info(`[TaskForwarder] 任务 ${data.prompt_id} 进度: ${task.progress}%`);
    }
  }

  /**
   * 处理节点执行完成事件
   * 
   * 说明：
   * - 每个节点执行完成后，ComfyUI会发送executed WebSocket消息
   * - 如果节点有输出（如PreviewImage），会包含output字段
   * - 这里仅收集部分结果，完整结果在handleExecutionSuccess中处理
   * 
   * @param {string} instanceId - ComfyUI实例ID
   * @param {Object} data - WebSocket消息数据
   * @param {string} data.prompt_id - 任务ID
   * @param {string} data.node - 节点ID
   * @param {Object} data.output - 节点输出（可选）
   */
  async handleExecuted(instanceId, data) {
    logger.info(`[TaskForwarder] handleExecuted: instanceId=${instanceId}, promptId=${data?.prompt_id}, node=${data?.node}`);
    
    // 检查是否有输出数据
    if (!data?.output) {
      logger.info(`[TaskForwarder] executed 消息无输出，跳过处理`);
      return;
    }
    
    const promptId = data.prompt_id;
    const task = this.tasks.get(promptId);
    if (!task || task.instanceId !== instanceId) {
      return;
    }
    
    // 初始化部分结果数组
    if (!task.partialResults) {
      task.partialResults = [];
    }
    // 收集当前节点的输出结果
    task.partialResults.push(data);
    logger.info(`[TaskForwarder] 收集节点 ${data.node} 的输出结果`);
  }

  async handleExecutionError(instanceId, data) {
    logger.error(`[TaskForwarder] handleExecutionError: instanceId=${instanceId}, promptId=${data?.prompt_id}`);
    
    const promptId = data.prompt_id;
    const task = this.tasks.get(promptId);
    if (!task || task.instanceId !== instanceId) {
      return;
    }
    
    task.status = 'failed';
    task.completedAt = new Date().toISOString();
    task.error = data.exception_message || data.error || JSON.stringify(data);
    this.tasks.set(promptId, task);
    clusterManager.updateInstanceStatus(instanceId, 'online');
    logger.error(`任务 ${task.id} 执行失败: ${task.error}`);
    
    if (task.webhookUrl) {
      await this.sendWebhookCallback(task, null, task.error);
    }
    
    if (task.queueTaskId) {
      taskQueueClient.notifyTaskComplete(task.queueTaskId, null, task.error);
    }
  }

  /**
   * 处理任务执行成功事件
   * 
   * 这是文件上传流程的入口点：
   * 1. 收到ComfyUI的execution_success WebSocket消息后触发
   * 2. 调用ComfyUI的/history/{prompt_id} API获取任务输出信息
   * 3. 从history返回的outputs中提取文件信息
   * 4. 调用processHistoryOutputs处理并上传所有输出文件
   * 
   * @param {string} instanceId - ComfyUI实例ID
   * @param {Object} data - WebSocket消息数据，包含prompt_id
   */
  async handleExecutionSuccess(instanceId, data) {
    logger.info(`[TaskForwarder] handleExecutionSuccess: instanceId=${instanceId}, promptId=${data?.prompt_id}`);
    
    const promptId = data.prompt_id;
    const task = this.tasks.get(promptId);
    if (!task) {
      logger.warn(`[TaskForwarder] 未找到任务: promptId=${promptId}`);
      return;
    }
    
    if (task.instanceId !== instanceId) {
      logger.warn(`[TaskForwarder] 任务实例不匹配: taskId=${promptId}`);
      return;
    }
    
    logger.info(`[TaskForwarder] 找到匹配的任务: ${promptId}, 准备获取结果`);
    
    const instance = clusterManager.getInstance(instanceId);
    if (!instance) {
      logger.error(`[TaskForwarder] 无法找到实例: ${instanceId}`);
      return;
    }

    try {
      // ========== 步骤1：调用ComfyUI history API获取任务输出信息 ==========
      // history API返回格式: { [prompt_id]: { outputs: { [nodeId]: { images: [...] } } } }
      const historyResponse = await axios.get(`${instance.apiUrl}/history/${promptId}`, {
        timeout: 10000
      });
      
      const historyData = historyResponse.data;
      logger.info(`[TaskForwarder] 获取到历史记录: ${JSON.stringify(historyData)}`);
      
      // ========== 步骤2：从history数据中提取outputs ==========
      // outputs包含所有输出节点的文件信息
      let outputs = null;
      if (historyData && historyData[promptId] && historyData[promptId].outputs) {
        outputs = historyData[promptId].outputs;
      } else if (historyData && historyData.outputs) {
        outputs = historyData.outputs;
      }
      
      // ========== 步骤3：处理并上传输出文件 ==========
      if (outputs) {
        // 调用processHistoryOutputs处理所有输出文件
        // 这是上传流程的核心方法
        const resultData = await this.processHistoryOutputs(outputs, instanceId);
        
        // 更新任务状态为完成
        task.status = 'completed';
        task.completedAt = new Date().toISOString();
        task.result = outputs;
        this.tasks.set(promptId, task);
        clusterManager.updateInstanceStatus(instanceId, 'online');
        logger.info(`任务 ${task.id} 执行完成，结果数量: ${resultData.length}`);
        
        // 发送webhook回调通知调用方
        if (task.webhookUrl) {
          await this.sendWebhookCallback(task, { output: outputs }, null);
        }
        
        // 通知任务队列客户端任务完成
        if (task.queueTaskId) {
          taskQueueClient.notifyTaskComplete(task.queueTaskId, resultData);
        }
      } else {
        logger.warn(`[TaskForwarder] 历史记录中没有 outputs`);
      }
    } catch (error) {
      logger.error(`[TaskForwarder] 获取历史记录失败: ${error.message}`);
      task.status = 'failed';
      task.error = `获取结果失败: ${error.message}`;
      this.tasks.set(promptId, task);
      
      if (task.webhookUrl) {
        await this.sendWebhookCallback(task, null, task.error);
      }
      
      if (task.queueTaskId) {
        taskQueueClient.notifyTaskComplete(task.queueTaskId, null, task.error);
      }
    }
  }

  /**
   * 处理历史记录中的输出结果
   * 
   * 流程说明：
   * 1. 从ComfyUI的history API获取的outputs中提取所有类型的媒体文件信息
   * 2. outputs结构: { [nodeId]: { images: [...], gifs: [...], audio: [...], ... } }
   * 3. 自动检测输出中的所有数组类型字段（images/gifs/audio/text等）
   * 4. 每个媒体文件包含: filename, subfolder, type 等信息
   * 5. 遍历所有节点的输出，逐个上传文件到外部服务器
   * 6. 非文件类型输出（如text, value等）会被跳过，不会作为文件处理
   * 
   * @param {Object} outputs - ComfyUI history返回的输出对象
   * @param {string} instanceId - ComfyUI实例ID
   * @returns {Array} 上传结果数组，包含fileUrl、fileType等信息
   */
  async processHistoryOutputs(outputs, instanceId) {
    const resultData = [];
    
    if (!outputs) {
      return resultData;
    }
    
    const instance = clusterManager.getInstance(instanceId);
    if (!instance) {
      logger.error(`[processHistoryOutputs] 无法找到实例: ${instanceId}`);
      return resultData;
    }

    // 定义有效的文件输出类型（这些类型包含filename字段）
    const FILE_OUTPUT_TYPES = ['images', 'gifs', 'video', 'audio', 'files'];
    
    // 定义非文件类型的输出（这些是元数据或简单值，不需要上传）
    const NON_FILE_OUTPUT_TYPES = ['text', 'value', 'string', 'number', 'boolean', 'object'];

    for (const [nodeId, output] of Object.entries(outputs)) {
      if (!output) continue;
      
      const mediaFiles = [];
      const typeCounts = {};
      const processedTypes = new Set();
      
      for (const [key, value] of Object.entries(output)) {
        // 跳过已处理的类型
        if (processedTypes.has(key)) continue;
        processedTypes.add(key);
        
        // 检查是否为数组类型
        if (!Array.isArray(value)) {
          // 如果是非文件类型的非数组值，记录但不处理
          if (NON_FILE_OUTPUT_TYPES.includes(key)) {
            typeCounts[key] = 'skipped (non-file type)';
          }
          continue;
        }
        
        // 检查数组中的元素是否为有效的文件对象（包含filename字段）
        const validFiles = value.filter(item => item && typeof item === 'object' && 'filename' in item);
        
        if (validFiles.length > 0) {
          // 有效的文件数组
          mediaFiles.push(...validFiles);
          typeCounts[key] = validFiles.length;
        } else if (value.length > 0) {
          // 数组但没有有效的filename，可能是text/value等类型
          typeCounts[key] = `skipped (${value.length} items, no filename)`;
          logger.debug(`[processHistoryOutputs] 节点 ${nodeId} 跳过非文件类型: ${key}, 数量: ${value.length}`);
        }
      }
      
      // 打印日志，显示各类型的数量
      const typeCountStr = Object.entries(typeCounts)
        .map(([type, count]) => `${type}=${count}`)
        .join(', ');
      
      if (mediaFiles.length > 0) {
        logger.info(`[processHistoryOutputs] 节点 ${nodeId} 找到 ${mediaFiles.length} 个媒体文件 (${typeCountStr})`);
      } else {
        logger.debug(`[processHistoryOutputs] 节点 ${nodeId} 无有效媒体文件: ${typeCountStr}`);
      }
      
      for (const media of mediaFiles) {
        try {
          // 再次检查filename是否存在
          if (!media.filename) {
            logger.warn(`[processHistoryOutputs] 跳过没有filename的媒体: nodeId=${nodeId}`);
            continue;
          }
          
          logger.info(`[processHistoryOutputs] 正在上传文件: ${media.filename}`);
          const fileUrl = await this.uploadImage(media, instance);
          logger.info(`[processHistoryOutputs] 文件上传成功: ${fileUrl}`);
          resultData.push({
            fileUrl,
            fileType: media.type || 'png',
            taskCostTime: 0,
            nodeId
          });
        } catch (error) {
          logger.error('[processHistoryOutputs] 上传文件失败:', error);
        }
      }
    }
    
    return resultData;
  }

  /**
   * 上传单个媒体文件到外部服务器
   * 
   * 支持的文件类型：
   * - 图片：images (png, jpg等)
   * - 动图：gifs
   * - 音频：audio (flac, mp3, wav等)
   * 
   * 上传流程（两种方式）：
   * 
   * 方式一：本地文件直接上传（优先）
   * - 条件：环境变量 COMFYUI_OUTPUT_DIR 已配置，且文件存在于本地
   * - 适用场景：bridge服务与ComfyUI在同一台服务器，可直接访问output目录
   * - 流程：直接读取本地文件 → 上传到外部服务器
   * 
   * 方式二：通过ComfyUI HTTP API获取文件（回退方案）
   * - 条件：本地文件不存在或COMFYUI_OUTPUT_DIR未配置
   * - 适用场景：bridge服务与ComfyUI不在同一台服务器
   * - 流程：调用ComfyUI的/view API → 保存到本地临时目录 → 上传到外部服务器 → 删除临时文件
   * 
   * @param {Object} media - 媒体文件信息对象
   * @param {string} media.filename - 文件名
   * @param {string} media.subfolder - 子文件夹路径（可选）
   * @param {string} media.type - 文件类型（output/temp/input）
   * @param {Object} instance - ComfyUI实例对象
   * @returns {string} 上传后的文件URL
   */
  async uploadImage(media, instance) {
    const comfyuiOutputDir = process.env.COMFYUI_OUTPUT_DIR;
    
    // ========== 方式一：本地文件直接上传 ==========
    if (comfyuiOutputDir) {
      // 构建本地文件完整路径
      let localFilePath = path.join(comfyuiOutputDir, media.filename);
      if (media.subfolder) {
        localFilePath = path.join(comfyuiOutputDir, media.subfolder, media.filename);
      }
      
      // 检查本地文件是否存在
      if (fs.existsSync(localFilePath)) {
        logger.info(`从本地目录读取文件: ${localFilePath}`);
        // 直接上传本地文件
        const uploadResult = await fileUploader.uploadToExternalServer(localFilePath, media.filename);
        return uploadResult.url || uploadResult.data?.url;
      } else {
        logger.warn(`本地文件不存在: ${localFilePath}, 回退到 HTTP API`);
      }
    }
    
    // ========== 方式二：通过HTTP API获取文件 ==========
    // 构建ComfyUI /view API的URL
    // API格式: http://host:port/view?filename=xxx&subfolder=xxx&type=output
    const mediaUrl = `${instance.apiUrl}/view?filename=${media.filename}&subfolder=${media.subfolder || ''}&type=${media.type}`;
    
    // 通过HTTP请求获取文件内容（二进制数据）
    const response = await axios.get(mediaUrl, {
      responseType: 'arraybuffer'
    });
    
    // 创建本地临时目录用于存放下载的文件
    const uploadsDir = path.resolve(process.cwd(), 'uploads');
    if (!fs.existsSync(uploadsDir)) {
      fs.mkdirSync(uploadsDir, { recursive: true });
    }
    
    // 从文件名中提取扩展名，或使用media.type
    let ext = media.type;
    if (media.filename) {
      const match = media.filename.match(/\.([a-zA-Z0-9]+)$/);
      if (match) {
        ext = match[1];
      }
    }
    
    // 生成唯一的临时文件名，避免冲突
    const tempPath = path.join(uploadsDir, `${uuidv4()}.${ext}`);
    
    // 将下载的文件内容写入临时文件
    await fs.promises.writeFile(tempPath, response.data);
    
    // 上传临时文件到外部服务器
    const uploadResult = await fileUploader.uploadToExternalServer(tempPath, media.filename);
    
    // 上传完成后删除临时文件，释放磁盘空间
    await fs.promises.unlink(tempPath);
    
    return uploadResult.url || uploadResult.data?.url;
  }

  /**
   * 发送Webhook回调通知
   * 
   * 说明：
   * - 任务完成或失败时，通过webhook通知调用方
   * - 成功时会重新处理一遍输出文件并上传
   * - 失败时直接返回错误信息
   * 
   * 回调消息格式：
   * {
   *   event: 'TASK_END',
   *   taskId: 'xxx',
   *   eventData: JSON.stringify({
   *     code: 0 | 1,  // 0成功，1失败
   *     msg: 'success' | 'error message',
   *     data: [...]  // 成功时包含文件URL列表
   *   })
   * }
   * 
   * @param {Object} task - 任务对象
   * @param {Object|null} resultData - 成功时的结果数据（包含output）
   * @param {string|null} error - 失败时的错误信息
   */
  async sendWebhookCallback(task, resultData, error = null) {
    if (!task.webhookUrl) {
      return;
    }

    let eventData;
    if (error) {
      // 失败情况：返回错误信息
      eventData = JSON.stringify({
        code: 1,
        msg: error,
        data: []
      });
    } else {
      // 成功情况：重新处理输出文件并上传
      const processedData = await this.processHistoryOutputs(resultData?.output, task.instanceId);
      eventData = JSON.stringify({
        code: 0,
        msg: 'success',
        data: processedData
      });
    }

    // 构建回调消息
    const callbackMessage = {
      event: 'TASK_END',
      taskId: task.queueTaskId || task.id,
      instanceId: task.instanceId,  // 添加 instanceId 字段
      eventData
    };

    try {
      logger.info(`发送Webhook回调到: ${task.webhookUrl}`);
      await axios.post(task.webhookUrl, callbackMessage, {
        timeout: 10000
      });
      logger.info(`Webhook回调发送成功: ${task.id}`);
    } catch (error) {
      logger.error('发送Webhook回调失败:', error.message);
    }
  }

  async getTask(taskId) {
    return this.tasks.get(taskId) || null;
  }

  async getTasks(status = null) {
    let tasks = Array.from(this.tasks.values());
    if (status) {
      tasks = tasks.filter(t => t.status === status);
    }
    return tasks;
  }

  async cancelTask(taskId) {
    const task = this.tasks.get(taskId);
    if (!task) {
      return false;
    }

    if (task.status === 'completed' || task.status === 'failed') {
      return false;
    }

    if (task.status === 'running' && task.promptId) {
      try {
        const instance = clusterManager.getInstance(task.instanceId);
        if (instance) {
          await axios.post(`${instance.apiUrl}/interrupt`);
        }
      } catch (error) {
        logger.error(`中断任务失败:`, error);
      }
    }

    task.status = 'cancelled';
    task.completedAt = new Date().toISOString();
    this.tasks.set(taskId, task);
    logger.info(`任务 ${taskId} 已取消`);
    return true;
  }

  async getTaskStatus(taskId) {
    const task = this.tasks.get(taskId);
    if (!task) {
      return null;
    }
    
    return {
      id: task.id,
      promptId: task.promptId,
      status: task.status,
      progress: task.progress,
      instanceId: task.instanceId,
      createdAt: task.createdAt,
      startedAt: task.startedAt,
      completedAt: task.completedAt,
      error: task.error
    };
  }
}

export default new TaskForwarder();