/**
 * 演示如何使用CozeService
 */

import CozeService from './cozeService';
import { 
  COZE_API_TOKEN, 
  COZE_API_BASE_URL, 
  WORKFLOW_IDS,
  PARAMETER_PRESETS,
  hasValidToken
} from './cozeConfig';
import {
  handleTextStreamResponse,
  handleAudioStreamResponse,
  base64ToBlob,
  blobToBase64
} from './cozeStreamHandler';

// 检查是否有有效的API Token
if (!hasValidToken()) {
  console.warn('警告: 未配置有效的Coze API Token，API调用将会失败。请在环境变量中设置REACT_APP_COZE_API_TOKEN。');
}

/**
 * 初始化Coze服务
 * @param {Object} config - 配置对象，包含超时、并发请求等设置
 * @returns {CozeService} coze服务实例
 */
export const initCozeService = (config = {}) => {
  // 创建服务实例
  const cozeService = new CozeService({
    token: COZE_API_TOKEN,
    baseURL: COZE_API_BASE_URL,
    ...config  // 添加其他配置参数
  });
  
  // 注册工作流ID
  cozeService.registerWorkflows(WORKFLOW_IDS);
  
  return cozeService;
};

/**
 * 语音合成（文本转语音）
 * @param {string} text 要转换的文本
 * @param {Object} options 额外选项
 * @param {Function} onProgress 处理进度更新的回调函数
 * @returns {Promise<Object>} 包含音频Blob的对象
 */
export const textToSpeech = async (text, options = {}, onProgress) => {
  const cozeService = initCozeService();
  
  try {
    // 合并默认参数和用户提供的参数
    const params = {
      ...PARAMETER_PRESETS.textToSpeech,
      ...options,
      text: text
    };
    
    // 调用流式API
    const response = await cozeService.runWorkflowStream('textToSpeech', params);
    
    // 处理流式响应
    return new Promise((resolve, reject) => {
      let audioBlob = null;
      
      handleAudioStreamResponse(
        response,
        // 进度回调
        (progress) => {
          if (onProgress && typeof onProgress === 'function') {
            onProgress(progress);
          }
        },
        // 完成回调
        (blob) => {
          audioBlob = blob;
          resolve({
            audio: blob,
            type: blob.type,
            size: blob.size,
            url: URL.createObjectURL(blob)
          });
        },
        // 错误回调
        (error) => {
          reject(error);
        }
      );
    });
  } catch (error) {
    console.error('文本转语音失败:', error);
    throw error;
  }
};

/**
 * 语音识别（语音转文本）
 * @param {Blob|File} audioFile 音频文件
 * @param {Object} options 额外选项
 * @returns {Promise<Object>} 识别结果
 */
export const speechToText = async (audioFile, options = {}) => {
  const cozeService = initCozeService();
  
  try {
    // 转换音频为Base64
    const base64Audio = await blobToBase64(audioFile);
    
    const params = {
      ...options,
      audio: base64Audio,
      audio_type: audioFile.type || 'audio/wav'
    };
    
    const response = await cozeService.runWorkflow('speechToText', params);
    
    return response;
  } catch (error) {
    console.error('语音识别失败:', error);
    throw error;
  }
};

/**
 * 文本翻译
 * @param {string} text 要翻译的文本
 * @param {string} targetLanguage 目标语言，默认为'zh'（中文）
 * @param {Object} options 额外选项
 * @param {Function} onToken 处理每个翻译token的回调函数
 * @returns {Promise<Object>} 翻译结果
 */
export const translateText = async (text, targetLanguage = 'zh', options = {}, onToken) => {
  const cozeService = initCozeService();
  
  try {
    // 合并默认参数和用户提供的参数
    const params = {
      ...PARAMETER_PRESETS.translation,
      ...options,
      text: text,
      target_language: targetLanguage
    };
    
    // 如果提供了onToken回调，使用流式API
    if (onToken && typeof onToken === 'function') {
      const response = await cozeService.runWorkflowStream('translation', params);
      
      return new Promise((resolve, reject) => {
        let translatedText = '';
        
        handleTextStreamResponse(
          response,
          // token回调
          (token, fullText) => {
            translatedText = fullText;
            onToken(token, fullText);
          },
          // 完成回调
          (fullText) => {
            resolve({
              translated_text: fullText,
              source_language: params.sourceLanguage,
              target_language: params.targetLanguage
            });
          },
          // 错误回调
          (error) => {
            reject(error);
          }
        );
      });
    } else {
      // 如果没有提供onToken回调，使用普通API
      const response = await cozeService.runWorkflow('translation', params);
      return response;
    }
  } catch (error) {
    console.error('文本翻译失败:', error);
    throw error;
  }
};

/**
 * 文本摘要
 * @param {string} text 要摘要的文本
 * @param {Object} options 额外选项
 * @param {Function} onToken 处理每个摘要token的回调函数
 * @returns {Promise<Object>} 摘要结果
 */
export const summarizeText = async (text, options = {}, onToken) => {
  const cozeService = initCozeService();
  
  try {
    // 合并默认参数和用户提供的参数
    const params = {
      ...PARAMETER_PRESETS.summarization,
      ...options,
      text: text
    };
    
    // 如果提供了onToken回调，使用流式API
    if (onToken && typeof onToken === 'function') {
      const response = await cozeService.runWorkflowStream('summarization', params);
      
      return new Promise((resolve, reject) => {
        let summary = '';
        
        handleTextStreamResponse(
          response,
          // token回调
          (token, fullText) => {
            summary = fullText;
            onToken(token, fullText);
          },
          // 完成回调
          (fullText) => {
            resolve({
              summary: fullText,
              original_length: text.length,
              summary_length: fullText.length
            });
          },
          // 错误回调
          (error) => {
            reject(error);
          }
        );
      });
    } else {
      // 如果没有提供onToken回调，使用普通API
      const response = await cozeService.runWorkflow('summarization', params);
      return response;
    }
  } catch (error) {
    console.error('文本摘要失败:', error);
    throw error;
  }
};

/**
 * 获取画风列表示例
 * @returns {Promise<Array>} 可用的画风列表
 */
export const getAvailableStyles = async () => {
  const cozeService = initCozeService();
  
  try {
    console.log('获取可用的画风列表...');
    const styles = await cozeService.getStyleList();
    console.log('获取画风列表成功:', styles);
    return styles;
  } catch (error) {
    console.error('获取画风列表失败:', error);
    throw error;
  }
};

/**
 * 生成图片示例
 * @param {string} prompt - 图片描述提示词
 * @param {string} style - 画风样式
 * @param {Object} options - 额外选项
 * @returns {Promise<Object>} 生成的图片结果
 */
export const createImage = async (prompt, style = '', options = {}) => {
  const cozeService = initCozeService();
  
  try {
    console.log(`开始生成图片，提示词: "${prompt}", 画风: "${style || '默认'}"`);
    
    // 合并默认参数和用户提供的参数
    const params = {
      ...PARAMETER_PRESETS.generateImage,
      ...options,
    };
    
    const result = await cozeService.generateImage(prompt, style, params);
    
    console.log('图片生成成功:', result);
    return result;
  } catch (error) {
    console.error('图片生成失败:', error);
    throw error;
  }
};

// 导出单例
export const cozeService = initCozeService(); 