from openai import OpenAI
from pathlib import Path

client = OpenAI()

def text_to_speech(text: str, output_path: str = "speech.mp3",
                   model: str = "tts-1", voice: str = "alloy"):
    """文本转语音"""
    response = client.audio.speech.create(
        model=model,
        voice=voice,
        input=text,
    )

    response.stream_to_file(output_path)
    print(f"音频已保存: {output_path}")

# 使用
text_to_speech("你好，欢迎使用 OpenAI 语音合成服务。", "welcome.mp3")

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI();

async function textToSpeech(text, outputPath = 'speech.mp3') {
  const response = await client.audio.speech.create({
    model: 'tts-1',
    voice: 'alloy',
    input: text,
  });

  const buffer = Buffer.from(await response.arrayBuffer());
  fs.writeFileSync(outputPath, buffer);
  console.log(`音频已保存: ${outputPath}`);
}

await textToSpeech('你好，欢迎使用语音合成服务。');

def expressive_tts(text: str, instructions: str, output_path: str = "speech.mp3"):
    """可控语气的语音合成"""
    response = client.audio.speech.create(
        model="gpt-4o-mini-tts",
        voice="coral",
        input=text,
        instructions=instructions,
    )
    response.stream_to_file(output_path)

# 欢快语气
expressive_tts(
    "恭喜你获得了大奖！",
    instructions="用非常兴奋和欢快的语气说话，像一个热情的主持人。"
)

# 专业播报
expressive_tts(
    "今天的新闻主要内容如下...",
    instructions="用专业新闻主播的语气，语速适中，吐字清晰。"
)

# 温柔安慰
expressive_tts(
    "不要担心，一切都会好起来的。",
    instructions="用温柔安慰的语气，声音柔和，语速稍慢。"
)

# 有声读物
expressive_tts(
    "很久很久以前，在一个遥远的王国里...",
    instructions="像讲故事一样，语气生动有趣，有起伏变化。"
)

voices = ["alloy", "echo", "fable", "onyx", "nova", "shimmer", "coral"]
sample_text = "人工智能正在改变我们的生活方式。"

for voice in voices:
    response = client.audio.speech.create(
        model="tts-1",
        voice=voice,
        input=sample_text,
    )
    response.stream_to_file(f"voice_{voice}.mp3")
    print(f"已生成: voice_{voice}.mp3")

def stream_tts(text: str, output_path: str = "stream.mp3"):
    """流式生成音频"""
    with client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice="alloy",
        input=text,
        response_format="opus",  # opus 格式更适合流式
    ) as response:
        response.stream_to_file(output_path)

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
from pydantic import BaseModel
import io

app = FastAPI()
client = OpenAI()

class TTSRequest(BaseModel):
    text: str
    voice: str = "alloy"
    model: str = "tts-1"

@app.post("/api/tts")
async def text_to_speech(request: TTSRequest):
    """流式返回音频"""
    response = client.audio.speech.create(
        model=request.model,
        voice=request.voice,
        input=request.text,
        response_format="opus",
    )

    audio_bytes = response.read()

    return StreamingResponse(
        io.BytesIO(audio_bytes),
        media_type="audio/ogg",
        headers={"Content-Disposition": "attachment; filename=speech.opus"},
    )

async function playTTS(text) {
  const response = await fetch('/api/tts', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text, voice: 'nova' }),
  });

  const blob = await response.blob();
  const url = URL.createObjectURL(blob);
  const audio = new Audio(url);
  audio.play();
}

async function streamingTTS(text) {
  const response = await fetch('https://api.openai.com/v1/audio/speech', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'tts-1',
      voice: 'alloy',
      input: text,
      response_format: 'opus',
    }),
  });

  // 使用 MediaSource 流式播放
  const mediaSource = new MediaSource();
  const audio = new Audio();
  audio.src = URL.createObjectURL(mediaSource);

  mediaSource.addEventListener('sourceopen', async () => {
    const sourceBuffer = mediaSource.addSourceBuffer('audio/ogg; codecs="opus"');
    const reader = response.body.getReader();

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      sourceBuffer.appendBuffer(value);
    }
  });

  audio.play();
}

def long_text_to_speech(text: str, output_path: str = "long_speech.mp3",
                        max_chars: int = 4000):
    """长文本分段合成后合并"""
    from pydub import AudioSegment
    import tempfile

    # 按句子分割
    sentences = []
    current = ""
    for char in text:
        current += char
        if char in "。！？.!?\n" and len(current) > 10:
            sentences.append(current.strip())
            current = ""
    if current.strip():
        sentences.append(current.strip())

    # 分组合并
    chunks = []
    current_chunk = ""
    for sentence in sentences:
        if len(current_chunk) + len(sentence) > max_chars:
            chunks.append(current_chunk)
            current_chunk = sentence
        else:
            current_chunk += sentence
    if current_chunk:
        chunks.append(current_chunk)

    # 生成每段音频
    combined = AudioSegment.empty()
    for i, chunk in enumerate(chunks):
        print(f"生成第 {i+1}/{len(chunks)} 段...")
        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as tmp:
            response = client.audio.speech.create(
                model="tts-1-hd",
                voice="nova",
                input=chunk,
            )
            response.stream_to_file(tmp.name)
            segment = AudioSegment.from_mp3(tmp.name)
            combined += segment

    combined.export(output_path, format="mp3")
    print(f"已保存: {output_path}")

def multilingual_tts(text: str, lang: str, output_path: str):
    """多语言语音合成"""
    # 选择适合该语言的音色
    voice_map = {
        "zh": "nova",      # 中文
        "en": "alloy",     # 英文
        "ja": "shimmer",   # 日文
        "ko": "coral",     # 韩文
        "fr": "fable",     # 法文
        "de": "onyx",      # 德文
    }

    response = client.audio.speech.create(
        model="tts-1-hd",
        voice=voice_map.get(lang, "alloy"),
        input=text,
    )
    response.stream_to_file(output_path)

# 不同语言
multilingual_tts("你好，世界！", "zh", "hello_zh.mp3")
multilingual_tts("Hello, World!", "en", "hello_en.mp3")
multilingual_tts("こんにちは世界！", "ja", "hello_ja.mp3")

def ai_voice_reply(user_text: str) -> str:
    """AI 回复并转为语音"""
    # 获取文本回复
    chat_response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "用简短友好的方式回复，不超过100字。"},
            {"role": "user", "content": user_text},
        ],
    )
    reply_text = chat_response.choices[0].message.content
    print(f"AI回复: {reply_text}")

    # 转为语音
    tts_response = client.audio.speech.create(
        model="tts-1",
        voice="nova",
        input=reply_text,
        response_format="mp3",
    )
    tts_response.stream_to_file("reply.mp3")
    return reply_text