from openai import OpenAI
from pathlib import Path

client = OpenAI()

def transcribe_file(file_path: str, language: str = None) -> str:
    """将音频文件转录为文字"""
    with open(file_path, "rb") as audio_file:
        kwargs = {
            "model": "whisper-1",
            "file": audio_file,
            "response_format": "text",
        }
        if language:
            kwargs["language"] = language

        response = client.audio.transcriptions.create(**kwargs)

    return response if isinstance(response, str) else response.text

# 使用
text = transcribe_file("meeting.mp3", language="zh")
print(text)

curl https://api.openai.com/v1/audio/transcriptions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F file="@audio.mp3" \
  -F model="whisper-1" \
  -F language="zh" \
  -F response_format="text"

response = client.audio.transcriptions.create(
    model="whisper-1",
    file=open("speech.mp3", "rb"),
    response_format="verbose_json",
    timestamp_granularities=["segment", "word"],
)

# 段落信息
for segment in response.segments:
    print(f"[{segment['start']:.1f}s → {segment['end']:.1f}s] {segment['text']}")

# 词级时间戳
for word in response.words:
    print(f"  {word['word']} [{word['start']:.2f}s - {word['end']:.2f}s]")

def generate_srt(file_path: str, output_path: str):
    """生成 SRT 字幕文件"""
    response = client.audio.transcriptions.create(
        model="whisper-1",
        file=open(file_path, "rb"),
        response_format="verbose_json",
        timestamp_granularities=["segment"],
    )

    srt_lines = []
    for i, segment in enumerate(response.segments, 1):
        start = format_srt_time(segment['start'])
        end = format_srt_time(segment['end'])
        srt_lines.append(f"{i}")
        srt_lines.append(f"{start} --> {end}")
        srt_lines.append(segment['text'])
        srt_lines.append("")

    with open(output_path, "w", encoding="utf-8") as f:
        f.write("\n".join(srt_lines))

def format_srt_time(seconds: float) -> str:
    """格式化 SRT 时间戳"""
    h = int(seconds // 3600)
    m = int((seconds % 3600) // 60)
    s = int(seconds % 60)
    ms = int((seconds % 1) * 1000)
    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

def translate_to_english(file_path: str) -> str:
    """将音频翻译为英文文本"""
    with open(file_path, "rb") as audio_file:
        response = client.audio.translations.create(
            model="whisper-1",
            file=audio_file,
            response_format="text",
        )
    return response if isinstance(response, str) else response.text

# 中文音频 → 英文文本
english_text = translate_to_english("chinese_speech.mp3")
print(english_text)

from pydub import AudioSegment
import tempfile
import os

def transcribe_large_file(file_path: str, chunk_minutes: int = 10) -> str:
    """分片转录大文件"""
    audio = AudioSegment.from_file(file_path)
    chunk_ms = chunk_minutes * 60 * 1000
    total_ms = len(audio)

    full_text = []
    for start in range(0, total_ms, chunk_ms):
        end = min(start + chunk_ms, total_ms)
        chunk = audio[start:end]

        # 导出临时文件
        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as tmp:
            chunk.export(tmp.name, format="mp3")
            tmp_path = tmp.name

        try:
            with open(tmp_path, "rb") as f:
                response = client.audio.transcriptions.create(
                    model="whisper-1",
                    file=f,
                    response_format="text",
                    language="zh",
                )
            full_text.append(response if isinstance(response, str) else response.text)
            print(f"已完成 {start//60000}-{end//60000} 分钟")
        finally:
            os.unlink(tmp_path)

    return "\n".join(full_text)

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

const client = new OpenAI();

async function transcribeFile(filePath, language = 'zh') {
  const response = await client.audio.transcriptions.create({
    model: 'whisper-1',
    file: fs.createReadStream(filePath),
    language: language,
    response_format: 'verbose_json',
  });

  console.log(`文本: ${response.text}`);
  console.log(`时长: ${response.duration}s`);
  console.log(`语言: ${response.language}`);

  return response;
}

transcribeFile('meeting.mp3');

def voice_chat(audio_path: str) -> tuple[str, str]:
    """语音对话：听 → 想 → 说"""
    # 1. 语音转文字
    with open(audio_path, "rb") as f:
        transcript = client.audio.transcriptions.create(
            model="whisper-1", file=f, language="zh",
        )
    user_text = transcript if isinstance(transcript, str) else transcript.text
    print(f"用户说: {user_text}")

    # 2. 生成回复
    chat_response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "你是一个友好的语音助手，简洁回答。"},
            {"role": "user", "content": user_text},
        ],
        max_tokens=300,
    )
    reply_text = chat_response.choices[0].message.content
    print(f"AI说: {reply_text}")

    # 3. 文字转语音
    speech_response = client.audio.speech.create(
        model="tts-1", voice="nova", input=reply_text,
    )
    speech_response.stream_to_file("reply.mp3")

    return user_text, reply_text

from fastapi import FastAPI, UploadFile, File

app = FastAPI()

@app.post("/api/transcribe")
async def transcribe_audio(file: UploadFile = File(...)):
    """接收音频片段并转录"""
    response = client.audio.transcriptions.create(
        model="whisper-1",
        file=file.file,
        language="zh",
        response_format="verbose_json",
    )
    return {
        "text": response.text,
        "duration": response.duration,
        "language": response.language,
    }

async function startLiveTranscription() {
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  const mediaRecorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });
  const chunks = [];

  // 每 5 秒发送一段
  mediaRecorder.ondataavailable = async (e) => {
    if (e.data.size > 0) {
      chunks.push(e.data);
      const blob = new Blob(chunks, { type: 'audio/webm' });
      chunks.length = 0;

      const formData = new FormData();
      formData.append('file', blob, 'chunk.webm');

      const res = await fetch('/api/transcribe', {
        method: 'POST',
        body: formData,
      });
      const data = await res.json();
      document.getElementById('output').textContent += data.text + ' ';
    }
  };

  mediaRecorder.start(5000); // 每 5 秒触发一次
}