/**
 * Coze工作流API服务
 * 封装Coze API的调用，简化工作流的调用过程
 */

import { CozeAPI } from '@coze/api';

/**
 * CozeService类 - 封装Coze API的调用
 */
class CozeService {
  /**
   * 构造函数
   * @param {Object} config - 配置对象
   * @param {string} config.token - Coze API的访问令牌
   * @param {string} config.baseURL - Coze API的基础URL，默认为'https://api.coze.cn'
   */
  constructor(config) {
    if (!config || !config.token) {
      throw new Error('必须提供Coze API的访问令牌');
    }

    this.token = config.token;
    this.baseURL = config.baseURL || 'https://api.coze.cn';
    
    // 初始化Coze API客户端
    this.apiClient = new CozeAPI({
      token: this.token,
      baseURL: this.baseURL,
      allowPersonalAccessTokenInBrowser: true // 允许在浏览器环境中使用个人访问令牌
    });
    
    // 用于存储工作流ID与名称的映射
    this.workflows = {};
  }

  /**
   * 注册工作流
   * @param {string} name - 工作流的名称
   * @param {string} workflowId - 工作流的ID
   * @returns {CozeService} - 返回当前实例，便于链式调用
   */
  registerWorkflow(name, workflowId) {
    if (!name || !workflowId) {
      throw new Error('必须提供工作流名称和ID');
    }
    
    this.workflows[name] = workflowId;
    return this;
  }

  /**
   * 批量注册工作流
   * @param {Object} workflowMap - 工作流名称与ID的映射对象
   * @returns {CozeService} - 返回当前实例，便于链式调用
   */
  registerWorkflows(workflowMap) {
    if (!workflowMap || typeof workflowMap !== 'object') {
      throw new Error('必须提供有效的工作流映射对象');
    }
    
    Object.entries(workflowMap).forEach(([name, id]) => {
      this.registerWorkflow(name, id);
    });
    
    return this;
  }

  /**
   * 调用工作流流式API
   * @param {string} workflowNameOrId - 工作流的名称或ID
   * @param {Object} parameters - 工作流的参数
   * @param {Object} options - 额外的选项
   * @returns {Promise<Object>} - 返回API调用的响应
   */
  async runWorkflowStream(workflowNameOrId, parameters = {}, options = {}) {
    // 获取工作流ID
    const workflowId = this.workflows[workflowNameOrId] || workflowNameOrId;
    
    if (!workflowId) {
      throw new Error(`找不到工作流: ${workflowNameOrId}`);
    }
    
    try {
      return await this.apiClient.workflows.runs.stream({
        workflow_id: workflowId,
        parameters: parameters,
        ...options
      });
    } catch (error) {
      console.error(`调用工作流[${workflowNameOrId}]失败:`, error);
      throw error;
    }
  }
  
  /**
   * 调用工作流API
   * @param {string} workflowNameOrId - 工作流的名称或ID
   * @param {Object} parameters - 工作流的参数
   * @param {Object} options - 额外的选项
   * @returns {Promise<Object>} - 返回API调用的响应
   */
  async runWorkflow(workflowNameOrId, parameters = {}, options = {}) {
    // 获取工作流ID
    const workflowId = this.workflows[workflowNameOrId] || workflowNameOrId;
    
    if (!workflowId) {
      throw new Error(`找不到工作流: ${workflowNameOrId}`);
    }
    
    try {
      console.log(`调用工作流[${workflowNameOrId}] ID为 ${workflowId}，参数:`, parameters);
      const result = await this.apiClient.workflows.runs.create({
        workflow_id: workflowId,
        parameters: parameters,
        ...options
      });
      console.log(`工作流[${workflowNameOrId}]调用结果:`, result);
      return result;
    } catch (error) {
      console.error(`调用工作流[${workflowNameOrId}]失败:`, error);
      throw error;
    }
  }
  
  /**
   * 获取工作流运行状态
   * @param {string} runId - 工作流运行的ID
   * @returns {Promise<Object>} - 返回工作流运行的状态
   */
  async getWorkflowRunStatus(runId) {
    if (!runId) {
      throw new Error('必须提供工作流运行ID');
    }
    
    try {
      return await this.apiClient.workflows.runs.retrieve({
        run_id: runId
      });
    } catch (error) {
      console.error(`获取工作流运行状态失败:`, error);
      throw error;
    }
  }
  
  /**
   * 取消工作流运行
   * @param {string} runId - 工作流运行的ID
   * @returns {Promise<Object>} - 返回取消操作的结果
   */
  async cancelWorkflowRun(runId) {
    if (!runId) {
      throw new Error('必须提供工作流运行ID');
    }
    
    try {
      return await this.apiClient.workflows.runs.cancel({
        run_id: runId
      });
    } catch (error) {
      console.error(`取消工作流运行失败:`, error);
      throw error;
    }
  }
  
  /**
   * 获取工作流列表
   * @param {Object} options - 查询选项
   * @returns {Promise<Object>} - 返回工作流列表
   */
  async listWorkflows(options = {}) {
    try {
      return await this.apiClient.workflows.list(options);
    } catch (error) {
      console.error('获取工作流列表失败:', error);
      throw error;
    }
  }

  /**
   * 获取画风列表
   * @param {Object} options - 查询选项
   * @returns {Promise<Array>} - 返回可用的画风列表
   */
  async getStyleList(options = {}) {
    try {
      // 使用runWorkflow方法调用画风列表API
      console.log('获取画风列表...');
      const result = await this.runWorkflow('getStyleList', options);
      
      // 假设返回的数据结构中包含了画风列表
      return result|| [];
    } catch (error) {
      console.error('获取画风列表失败:', error);
      // 如果API调用失败，返回一个默认的画风列表
      return [
        { id: 'realistic', name: '写实风格' },
        { id: 'anime', name: '动漫风格' },
        { id: 'watercolor', name: '水彩风格' },
        { id: 'oil', name: '油画风格' },
        { id: 'sketch', name: '素描风格' }
      ];
    }
  }
  
  /**
   * 开始画图
   * @param {string} prompt - 画图的文本提示
   * @param {string} style - 画风样式
   * @param {Object} options - 额外的选项，如尺寸、数量等
   * @returns {Promise<Object>} - 返回生成的图片信息
   */
  async generateImage(prompt, style = '', options = {}) {
    try {
      if (!prompt) {
        throw new Error('必须提供画图的文本提示');
      }
      
      // 准备参数
      const parameters = {
        prompt: prompt,
        style: style,
        ...options
      };
      
      console.log('开始生成图像，参数:', parameters);
      
      // 使用runWorkflow方法调用画图API
      const result = await this.runWorkflow('generateImage', parameters);
      
      // 返回结果
      return result;
    } catch (error) {
      console.error('画图失败:', error);
      throw error;
    }
  }
}

// 导出CozeService类
export default CozeService; 