/**
 * 语音 API 封装
 * TTS (文字转语音) 和 STT (语音转文字)
 */

import { getSettings } from './config.js';

/**
 * 获取语音 API 配置
 * @param {Object} contact - 角色对象（可选，用于获取角色独立配置）
 * @returns {Object} 配置对象
 */
export function getVoiceApiConfig(contact = null) {
  const settings = getSettings();

  // 基础配置
  const config = {
    stt: {
      url: settings.sttApiUrl || '',
      key: settings.sttApiKey || '',
      model: settings.sttModel || ''
    },
    tts: {
      url: settings.ttsApiUrl || '',
      key: settings.ttsApiKey || '',
      model: settings.ttsModel || '',
      voice: settings.ttsVoice || '',
      speed: settings.ttsSpeed || 1,
      emotion: settings.ttsEmotion || '默认',
      proxyUrl: settings.ttsProxyUrl || ''
    }
  };

  // 角色独立 TTS 配置
  if (contact?.useCustomVoice && contact.customTtsVoice) {
    config.tts.voice = contact.customTtsVoice;
  }

  return config;
}

/**
 * 根据 Blob 类型获取文件名
 */
function getAudioFileName(blob) {
  const type = blob.type || 'audio/webm';
  if (type.includes('webm')) return 'audio.webm';
  if (type.includes('ogg')) return 'audio.ogg';
  if (type.includes('mp4')) return 'audio.mp4';
  if (type.includes('mpeg') || type.includes('mp3')) return 'audio.mp3';
  if (type.includes('wav')) return 'audio.wav';
  if (type.includes('flac')) return 'audio.flac';
  return 'audio.webm';
}

/**
 * 将音频 Blob 转换为 WAV 格式（更好的兼容性）
 * 导出供其他模块使用
 */
export async function convertToWav(audioBlob) {
  try {
    const audioContext = new (window.AudioContext || window.webkitAudioContext)();
    const arrayBuffer = await audioBlob.arrayBuffer();
    const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);

    // 创建 WAV 文件
    const numChannels = audioBuffer.numberOfChannels;
    const sampleRate = audioBuffer.sampleRate;
    const format = 1; // PCM
    const bitDepth = 16;

    const bytesPerSample = bitDepth / 8;
    const blockAlign = numChannels * bytesPerSample;

    const samples = audioBuffer.length;
    const dataSize = samples * blockAlign;
    const buffer = new ArrayBuffer(44 + dataSize);
    const view = new DataView(buffer);

    // WAV 头部
    const writeString = (offset, str) => {
      for (let i = 0; i < str.length; i++) {
        view.setUint8(offset + i, str.charCodeAt(i));
      }
    };

    writeString(0, 'RIFF');
    view.setUint32(4, 36 + dataSize, true);
    writeString(8, 'WAVE');
    writeString(12, 'fmt ');
    view.setUint32(16, 16, true);
    view.setUint16(20, format, true);
    view.setUint16(22, numChannels, true);
    view.setUint32(24, sampleRate, true);
    view.setUint32(28, sampleRate * blockAlign, true);
    view.setUint16(32, blockAlign, true);
    view.setUint16(34, bitDepth, true);
    writeString(36, 'data');
    view.setUint32(40, dataSize, true);

    // 写入音频数据
    const channelData = [];
    for (let i = 0; i < numChannels; i++) {
      channelData.push(audioBuffer.getChannelData(i));
    }

    let offset = 44;
    for (let i = 0; i < samples; i++) {
      for (let ch = 0; ch < numChannels; ch++) {
        const sample = Math.max(-1, Math.min(1, channelData[ch][i]));
        const intSample = sample < 0 ? sample * 0x8000 : sample * 0x7FFF;
        view.setInt16(offset, intSample, true);
        offset += 2;
      }
    }

    await audioContext.close();
    return new Blob([buffer], { type: 'audio/wav' });
  } catch (err) {
    console.warn('[可乐] WAV 转换失败，使用原格式:', err);
    return audioBlob;
  }
}

/**
 * STT: 语音转文字
 * @param {Blob} audioBlob - 音频数据
 * @param {Object} options - 选项
 * @returns {Promise<string>} 识别的文字
 */
export async function speechToText(audioBlob, options = {}) {
  const config = getVoiceApiConfig();

  if (!config.stt.url || !config.stt.key) {
    throw new Error('请先配置语音识别 (STT) API');
  }

  // 自动补全 URL 路径
  let sttUrl = config.stt.url.trim().replace(/\/+$/, '');
  if (!sttUrl.includes('/audio/transcriptions')) {
    sttUrl = sttUrl + '/audio/transcriptions';
  }

  // 如果不是 WAV 格式，尝试转换以提高兼容性
  let processedBlob = audioBlob;
  if (!audioBlob.type.includes('wav')) {
    console.log('[可乐] 转换音频为 WAV 格式...');
    processedBlob = await convertToWav(audioBlob);
  }

  // 根据音频类型设置正确的文件名
  const fileName = getAudioFileName(processedBlob);

  const formData = new FormData();
  formData.append('file', processedBlob, fileName);

  if (config.stt.model) {
    formData.append('model', config.stt.model);
  }

  try {
    console.log('[可乐] STT 请求:', {
      url: sttUrl,
      model: config.stt.model,
      originalType: audioBlob.type,
      processedType: processedBlob.type,
      audioSize: processedBlob.size,
      fileName: fileName
    });

    const response = await fetch(sttUrl, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${config.stt.key}`
      },
      body: formData
    });

    if (!response.ok) {
      const errorText = await response.text();
      console.error('[可乐] STT API 错误:', response.status, errorText);
      // 尝试解析 JSON 错误
      try {
        const errorJson = JSON.parse(errorText);
        const errorMsg = errorJson.error?.message || errorJson.message || errorText;
        throw new Error(errorMsg);
      } catch (parseErr) {
        // 如果不是 JSON 解析错误，而是 throw 的错误，重新抛出
        if (parseErr.message && !parseErr.message.includes('JSON')) {
          throw parseErr;
        }
        throw new Error(`HTTP ${response.status}: ${errorText.substring(0, 200)}`);
      }
    }

    const result = await response.json();
    console.log('[可乐] STT 响应:', result);
    return result.text || '';
  } catch (err) {
    console.error('[可乐] STT 请求失败:', err);
    throw err;
  }
}

/**
 * TTS: 文字转语音
 * @param {string} text - 要合成的文字
 * @param {Object} contact - 角色对象（用于获取角色独立音色）
 * @param {Object} options - 选项
 * @returns {Promise<Blob>} 音频 Blob
 */
export async function textToSpeech(text, contact = null, options = {}) {
  const config = getVoiceApiConfig(contact);

  if (!config.tts.url || !config.tts.key) {
    throw new Error('请先配置语音合成 (TTS) API');
  }

  if (!text || !text.trim()) {
    throw new Error('合成文字不能为空');
  }

  // 自动补全 URL 路径
  let ttsUrl = config.tts.url.trim().replace(/\/+$/, '');
  if (!ttsUrl.includes('/audio/speech')) {
    ttsUrl = ttsUrl + '/audio/speech';
  }

  // 构建请求体
  const model = (options.model || config.tts.model || '').trim();
  const voice = (options.voice || config.tts.voice || '').trim();

  // 检查必填字段
  if (!model) {
    throw new Error('请先配置 TTS 模型');
  }
  if (!voice) {
    throw new Error('请先配置 TTS 音色');
  }

  // 检测是否是 Gemini TTS 模型
  const isGeminiTTS = model.toLowerCase().includes('gemini') && model.toLowerCase().includes('tts');
  // 检测是否是 GSVI 模型 (gsv2p.acgnai.top)
  const isGSVI = model.toLowerCase().includes('gsvi');
  // 检测是否是 MiniMax TTS API
  const isMiniMax = ttsUrl.toLowerCase().includes('minimax') || ttsUrl.includes('/t2a_v2');

  // MiniMax API 使用完全不同的格式
  if (isMiniMax) {
    // 修正 URL：MiniMax 使用 /v1/t2a_v2 而不是 /audio/speech
    ttsUrl = ttsUrl.replace(/\/audio\/speech$/, '/t2a_v2');
    if (!ttsUrl.includes('/t2a_v2')) {
      ttsUrl = ttsUrl.replace(/\/+$/, '') + '/t2a_v2';
    }

    // 如果配置了代理 URL，使用代理（解决 CORS 问题）
    if (config.tts.proxyUrl) {
      const proxyBase = config.tts.proxyUrl.trim().replace(/\/+$/, '');
      // 提取 MiniMax URL 的路径部分
      const urlObj = new URL(ttsUrl);
      ttsUrl = proxyBase + urlObj.pathname;
      console.log('[可乐] MiniMax 使用代理:', ttsUrl);
    }
  }

  // 构建请求体
  let requestBody;

  if (isMiniMax) {
    // MiniMax API 格式
    const speed = options.speed || config.tts.speed || 1;
    const emotion = options.emotion || config.tts.emotion;

    requestBody = {
      model: model,
      text: text.trim(),
      stream: false,
      voice_setting: {
        voice_id: voice,
        speed: speed,
        vol: 1,
        pitch: 0
      },
      audio_setting: {
        sample_rate: 32000,
        bitrate: 128000,
        format: 'mp3',
        channel: 1
      }
    };

    // 添加情绪参数（只有有效值才添加）
    if (emotion && emotion !== '默认') {
      const emotionMap = {
        '高兴': 'happy',
        '悲伤': 'sad',
        '愤怒': 'angry',
        '害怕': 'fearful',
        '厌恶': 'disgusted',
        '惊讶': 'surprised',
        '中性': 'calm',
        '生动': 'fluent',
        '低语': 'whisper'
      };
      // 只有在 emotionMap 中有对应值时才添加
      const mappedEmotion = emotionMap[emotion];
      if (mappedEmotion) {
        requestBody.voice_setting.emotion = mappedEmotion;
      }
    }
  } else {
    requestBody = {
      model: model,
      voice: voice
    };

    // GSVI 模型只需要基本参数
    if (isGSVI) {
      requestBody.input = text.trim();
      // GSVI API 不需要 language 和 emotion 参数
    } else {
      // OpenAI 标准格式使用 input
      requestBody.input = text.trim();

      // 非 Gemini TTS 时才添加额外参数
      if (!isGeminiTTS) {
        // 只有非默认语速才添加 speed 参数
        const speed = options.speed || config.tts.speed || 1;
        if (speed !== 1) {
          requestBody.speed = speed;
        }

        // 扩展参数 (GPT-SoVITS 等支持)
        const emotion = options.emotion || config.tts.emotion;
        if (emotion && emotion !== '默认') {
          requestBody.other_params = {
            text_lang: '中英混合',
            prompt_lang: '中文',
            emotion: emotion
          };
        }
      }
    }
  }

  try {
    const textContent = requestBody.input || requestBody.text || '';
    console.log('[可乐] TTS 请求:', {
      url: ttsUrl,
      model: model,
      voice: voice,
      isGSVI: isGSVI,
      isGeminiTTS: isGeminiTTS,
      isMiniMax: isMiniMax,
      textLength: textContent.length,
      textFull: textContent  // 打印完整文本
    });

    const response = await fetch(ttsUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Accept': isMiniMax ? 'application/json' : 'audio/mpeg, audio/wav, audio/*',
        'Authorization': `Bearer ${config.tts.key}`
      },
      body: JSON.stringify(requestBody)
    });

    if (!response.ok) {
      const errorText = await response.text();
      console.error('[可乐] TTS API 错误:');
      console.error('  状态码:', response.status);
      console.error('  响应内容:', errorText);
      console.error('  请求URL:', ttsUrl);
      console.error('  请求体:', JSON.stringify(requestBody, null, 2));

      // 尝试解析 JSON 错误
      try {
        const errorJson = JSON.parse(errorText);
        // MiniMax 错误格式: base_resp.status_msg
        const errorMsg = errorJson.base_resp?.status_msg || errorJson.error?.message || errorJson.message || errorJson.error || errorText;
        throw new Error(typeof errorMsg === 'string' ? errorMsg : JSON.stringify(errorMsg));
      } catch (parseErr) {
        if (parseErr.message && !parseErr.message.includes('JSON')) {
          throw parseErr;
        }
        throw new Error(`HTTP ${response.status}: ${errorText.substring(0, 300)}`);
      }
    }

    // MiniMax API 返回 JSON，需要特殊处理
    if (isMiniMax) {
      const jsonResp = await response.json();
      console.log('[可乐] MiniMax TTS 响应:', {
        status_code: jsonResp.base_resp?.status_code,
        status_msg: jsonResp.base_resp?.status_msg,
        audio_length: jsonResp.extra_info?.audio_length,
        audio_format: jsonResp.extra_info?.audio_format
      });

      // 检查 MiniMax 错误
      if (jsonResp.base_resp?.status_code !== 0) {
        throw new Error('MiniMax TTS 错误: ' + (jsonResp.base_resp?.status_msg || '未知错误'));
      }

      if (!jsonResp.data?.audio) {
        throw new Error('MiniMax TTS 未返回音频数据');
      }

      // 将 hex 编码的音频转换为 Blob
      const hexAudio = jsonResp.data.audio;
      const bytes = new Uint8Array(hexAudio.length / 2);
      for (let i = 0; i < hexAudio.length; i += 2) {
        bytes[i / 2] = parseInt(hexAudio.substr(i, 2), 16);
      }

      const audioFormat = jsonResp.extra_info?.audio_format || 'mp3';
      const mimeType = `audio/${audioFormat}`;
      return new Blob([bytes], { type: mimeType });
    }

    const audioBlob = await response.blob();
    console.log('[可乐] TTS 响应:', {
      音频大小: audioBlob.size,
      类型: audioBlob.type,
      响应头ContentType: response.headers.get('content-type')
    });

    // 先检查是否返回了错误的 JSON（有些 API 错误时返回 JSON）
    const contentType = response.headers.get('content-type') || audioBlob.type;
    if (contentType.includes('application/json') || contentType.includes('text/')) {
      const text = await audioBlob.text();
      console.error('[可乐] TTS 返回了文本而非音频:', text);
      try {
        const errJson = JSON.parse(text);
        const errMsg = errJson.error?.message || errJson.message || errJson.error || JSON.stringify(errJson);
        throw new Error('TTS 错误: ' + errMsg);
      } catch (e) {
        if (e.message.includes('TTS')) throw e;
        throw new Error('TTS 返回了非音频数据: ' + text.substring(0, 100));
      }
    }

    // 检查是否返回了有效的音频数据
    if (audioBlob.size < 100) {
      console.error('[可乐] TTS 返回的数据太小，可能不是有效音频');
      throw new Error('TTS 返回的音频数据无效');
    }

    // 修复：如果 blob 类型为空或不是音频类型，手动指定 MIME 类型
    // 某些 TTS API（如 GPT-SoVITS）返回的音频没有正确的 Content-Type
    let finalBlob = audioBlob;
    if (!audioBlob.type || audioBlob.type === '' || !audioBlob.type.startsWith('audio/')) {
      // 尝试从 Content-Type 头获取类型，或使用默认的 audio/wav
      let mimeType = 'audio/wav';
      const headerType = response.headers.get('content-type');
      if (headerType && headerType.startsWith('audio/')) {
        mimeType = headerType.split(';')[0].trim();
      } else if (headerType && headerType.includes('octet-stream')) {
        // application/octet-stream 通常是 wav 格式
        mimeType = 'audio/wav';
      }

      console.log('[可乐] TTS blob 类型为空，手动指定为:', mimeType);
      const arrayBuffer = await audioBlob.arrayBuffer();
      finalBlob = new Blob([arrayBuffer], { type: mimeType });
    }

    return finalBlob;
  } catch (err) {
    console.error('[可乐] TTS 请求失败:', err);
    // 检查是否是网络错误
    if (err.message?.includes('Failed to fetch') || err.message?.includes('NetworkError')) {
      throw new Error('网络连接失败，请检查 API 地址是否正确，或尝试使用代理');
    }
    throw err;
  }
}

/**
 * 播放音频
 * @param {Blob|string} audio - 音频 Blob 或 URL
 * @returns {Promise<HTMLAudioElement>} Audio 元素
 */
export function playAudio(audio) {
  return new Promise((resolve, reject) => {
    const audioEl = new Audio();

    if (audio instanceof Blob) {
      audioEl.src = URL.createObjectURL(audio);
    } else {
      audioEl.src = audio;
    }

    audioEl.onended = () => {
      if (audio instanceof Blob) {
        URL.revokeObjectURL(audioEl.src);
      }
      resolve(audioEl);
    };

    audioEl.onerror = (err) => {
      if (audio instanceof Blob) {
        URL.revokeObjectURL(audioEl.src);
      }
      reject(err);
    };

    audioEl.play().catch(reject);
  });
}

/**
 * 录音类
 */
export class AudioRecorder {
  constructor() {
    this.mediaRecorder = null;
    this.audioChunks = [];
    this.stream = null;
    this.isRecording = false;
    this.mimeType = 'audio/webm';
  }

  /**
   * 开始录音
   * @returns {Promise<void>}
   */
  async start() {
    if (this.isRecording) return;

    try {
      this.stream = await navigator.mediaDevices.getUserMedia({ audio: true });

      // 选择最佳支持的音频格式
      this.mimeType = getSupportedMimeType();
      console.log('[可乐] 录音使用格式:', this.mimeType);

      this.mediaRecorder = new MediaRecorder(this.stream, {
        mimeType: this.mimeType
      });
      this.audioChunks = [];

      this.mediaRecorder.ondataavailable = (e) => {
        if (e.data.size > 0) {
          this.audioChunks.push(e.data);
        }
      };

      this.mediaRecorder.start(100); // 每100ms收集一次数据
      this.isRecording = true;
      console.log('[可乐] 开始录音');
    } catch (err) {
      console.error('[可乐] 无法获取麦克风权限:', err);
      throw new Error('无法获取麦克风权限，请检查浏览器设置');
    }
  }

  /**
   * 停止录音
   * @returns {Promise<Blob>} 录音数据
   */
  stop() {
    return new Promise((resolve, reject) => {
      if (!this.isRecording || !this.mediaRecorder) {
        reject(new Error('没有正在进行的录音'));
        return;
      }

      const mimeType = this.mimeType;

      this.mediaRecorder.onstop = () => {
        const audioBlob = new Blob(this.audioChunks, { type: mimeType });
        this.cleanup();
        console.log('[可乐] 录音结束，格式:', mimeType, '大小:', audioBlob.size);
        resolve(audioBlob);
      };

      this.mediaRecorder.stop();
      this.isRecording = false;
    });
  }

  /**
   * 取消录音
   */
  cancel() {
    if (this.mediaRecorder && this.isRecording) {
      this.mediaRecorder.stop();
    }
    this.cleanup();
    this.isRecording = false;
  }

  /**
   * 清理资源
   */
  cleanup() {
    if (this.stream) {
      this.stream.getTracks().forEach(track => track.stop());
      this.stream = null;
    }
    this.mediaRecorder = null;
    this.audioChunks = [];
  }

  /**
   * 检查浏览器是否支持录音
   * @returns {boolean}
   */
  static isSupported() {
    const hasGetUserMedia = !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
    const hasMediaRecorder = typeof MediaRecorder !== 'undefined';
    const isSecureContext = window.isSecureContext;

    console.log('[可乐] 录音支持检测:', {
      getUserMedia: hasGetUserMedia,
      MediaRecorder: hasMediaRecorder,
      isSecureContext: isSecureContext,
      protocol: location.protocol
    });

    return hasGetUserMedia && hasMediaRecorder;
  }

  /**
   * 获取不支持录音的原因
   * @returns {string}
   */
  static getUnsupportedReason() {
    if (!window.isSecureContext) {
      return '需要 HTTPS 安全连接才能使用录音功能';
    }
    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
      return '浏览器不支持 getUserMedia API';
    }
    if (typeof MediaRecorder === 'undefined') {
      return '浏览器不支持 MediaRecorder API（iOS Safari 需要 iOS 14.3+）';
    }
    return '未知原因';
  }
}

/**
 * 获取 MediaRecorder 支持的音频格式
 */
function getSupportedMimeType() {
  const types = [
    'audio/webm;codecs=opus',
    'audio/webm',
    'audio/ogg;codecs=opus',
    'audio/ogg',
    'audio/mp4',
    'audio/mpeg'
  ];

  for (const type of types) {
    if (MediaRecorder.isTypeSupported(type)) {
      return type;
    }
  }
  return 'audio/webm';
}

/**
 * 测试 STT API
 * @returns {Promise<boolean>}
 */
export async function testSttApi() {
  const config = getVoiceApiConfig();

  if (!config.stt.url || !config.stt.key) {
    throw new Error('请先填写 STT API 地址和密钥');
  }

  console.log('[可乐] 开始 STT 测试...');
  console.log('[可乐] STT 配置:', {
    url: config.stt.url,
    model: config.stt.model,
    keyLength: config.stt.key?.length || 0
  });

  // 创建测试音频 (1.5秒，包含一些变化的音调模拟语音)
  const audioContext = new (window.AudioContext || window.webkitAudioContext)();
  const oscillator = audioContext.createOscillator();
  const gainNode = audioContext.createGain();
  const destination = audioContext.createMediaStreamDestination();

  oscillator.connect(gainNode);
  gainNode.connect(destination);

  // 模拟语音的频率变化
  oscillator.frequency.setValueAtTime(200, audioContext.currentTime);
  oscillator.frequency.linearRampToValueAtTime(400, audioContext.currentTime + 0.5);
  oscillator.frequency.linearRampToValueAtTime(300, audioContext.currentTime + 1);
  oscillator.frequency.linearRampToValueAtTime(350, audioContext.currentTime + 1.5);

  // 音量包络
  gainNode.gain.setValueAtTime(0.3, audioContext.currentTime);
  gainNode.gain.linearRampToValueAtTime(0.5, audioContext.currentTime + 0.3);
  gainNode.gain.linearRampToValueAtTime(0.3, audioContext.currentTime + 1.2);
  gainNode.gain.linearRampToValueAtTime(0, audioContext.currentTime + 1.5);

  oscillator.start();

  const mimeType = getSupportedMimeType();
  console.log('[可乐] 录制音频格式:', mimeType);

  const recorder = new MediaRecorder(destination.stream, { mimeType });
  const chunks = [];

  return new Promise((resolve, reject) => {
    recorder.ondataavailable = e => {
      if (e.data.size > 0) {
        chunks.push(e.data);
      }
    };

    recorder.onstop = async () => {
      oscillator.stop();
      audioContext.close();

      const blob = new Blob(chunks, { type: mimeType });
      console.log('[可乐] 测试音频大小:', blob.size, 'bytes');

      if (blob.size < 100) {
        reject(new Error('测试音频生成失败'));
        return;
      }

      try {
        // speechToText 会自动转换为 WAV 格式
        const result = await speechToText(blob);
        console.log('[可乐] STT 测试结果:', result);
        resolve(true);
      } catch (err) {
        reject(err);
      }
    };

    recorder.start(100);
    // 录制 1.5 秒
    setTimeout(() => recorder.stop(), 1500);
  });
}

/**
 * 测试 TTS API
 * @returns {Promise<Blob>}
 */
export async function testTtsApi() {
  const config = getVoiceApiConfig();

  if (!config.tts.url || !config.tts.key) {
    throw new Error('请先填写 TTS API 地址和密钥');
  }

  return await textToSpeech('测试语音合成');
}