#!/usr/bin/env python3
"""PAA 语音对话服务（/v1/realtime）最小请求样例：播开场白 → 按实时节奏送客户语音 → 收 AI 文本与语音 → 取会后结果。

依赖：Python 3.10+，websockets>=14（pip install "websockets>=14"）。
调用格式见 https://jiandutech.com/docs/realtime （源文件 api-service/deploy/site/docs/realtime.html）。
鉴权：语音对话（service=realtime）的 API key 从环境变量 PAA_API_KEY 读取，不要写进命令行或代码；
只识别的 key 连 /v1/realtime 握手会被拒（HTTP 403）。

用法：
    export PAA_API_KEY=sk_live_...
    python3 realtime_api_sample.py user.wav --out agent.wav

user.wav 是"客户说的话"，要求单声道、16 bit；采样率不是 16 kHz 时脚本会线性插值重采样。
AI 的语音按 16 kHz 下发，全部回复依次写进 --out。

协议：
    -> session.start（话术 prompt_content、音频格式）
    <- session.ready
    -> response.create（mode=speak_text，播开场白，不经过模型）
    -> input_audio.append（16 kHz PCM16 单声道 base64，sequence 从 1 连续；AI 说话期间也不停）
    <- asr.partial / asr.final（客户说的话）
    <- response.started / response.text.delta / response.text.final（AI 回复文本）
    <- response.audio.start / response.audio.delta / response.audio.done（AI 回复语音）/ response.done
    <- response.interrupted（客户抢话，旧回复作废）
    -> session.close
    <- session.result{status:"processing"}，再 session.result{status:"completed", summary, turns, billing}
    -> session.result.ack（result_event_id 填 completed 那条的 event_id）
    <- session.closed
"""

from __future__ import annotations

import argparse
import array
import asyncio
import base64
import json
import os
import sys
import time
import uuid
import wave

import websockets

RATE = 16000
BYTES_PER_MS = RATE * 2 // 1000   # 16 kHz s16 单声道：32 字节 = 1 ms
RESULT_TIMEOUT = 120.0            # 会后总结最多约 90 秒


def load_wav_16k(path: str) -> bytes:
    """读单声道 16 bit wav，必要时线性插值到 16 kHz，返回 PCM16LE 字节。"""
    with wave.open(path, "rb") as w:
        if w.getnchannels() != 1 or w.getsampwidth() != 2:
            raise SystemExit(f"{path}: 需要单声道 16 bit wav")
        src_rate = w.getframerate()
        samples = array.array("h", w.readframes(w.getnframes()))
    if sys.byteorder != "little":
        samples.byteswap()
    if src_rate == RATE or not samples:
        return samples.tobytes()
    n_out = int(len(samples) * RATE / src_rate)
    out = array.array("h", bytes(2 * n_out))
    last = len(samples) - 1
    for i in range(n_out):
        pos = i * src_rate / RATE
        j = min(int(pos), last)
        k = min(j + 1, last)
        out[i] = int(samples[j] + (samples[k] - samples[j]) * (pos - j))
    return out.tobytes()


async def send_audio(ws, session_id: str, pcm: bytes, frame_ms: int, lead_s: float, tail_s: float) -> None:
    """按实时节奏上行：先送 lead_s 秒静音（听开场白），再送客户语音，再送 tail_s 秒静音（等 AI 回复），然后挂机。"""
    pcm = bytes(int(BYTES_PER_MS * 1000 * lead_s)) + pcm + bytes(int(BYTES_PER_MS * 1000 * tail_s))
    step = BYTES_PER_MS * frame_ms
    start = time.monotonic()
    for seq, offset in enumerate(range(0, len(pcm), step), start=1):
        await ws.send(json.dumps({
            "type": "input_audio.append",
            "session_id": session_id,
            "sequence": seq,
            "audio": base64.b64encode(pcm[offset:offset + step]).decode(),
        }))
        # 对齐墙钟，模拟电话的实时上行；一次性灌完会让断句与抢话判断失真
        await asyncio.sleep(max(0.0, start + seq * frame_ms / 1000 - time.monotonic()))
    await ws.send(json.dumps({"type": "session.close", "session_id": session_id, "reason": "hangup"}))


def write_wav(path: str, pcm: bytes, rate: int) -> None:
    with wave.open(path, "wb") as w:
        w.setnchannels(1)
        w.setsampwidth(2)
        w.setframerate(rate)
        w.writeframes(pcm)


async def run(args, key: str, pcm: bytes) -> int:
    session_id = f"realtime-sample-{uuid.uuid4().hex[:12]}"
    headers = {"Authorization": f"Bearer {key}"}
    agent_pcm = bytearray()
    out_rate = RATE
    async with websockets.connect(args.url, additional_headers=headers, max_size=None) as ws:
        await ws.send(json.dumps({
            "type": "session.start",
            "session_id": session_id,
            "audio": {"input": {"encoding": "pcm_s16le", "sample_rate": RATE, "channels": 1,
                                "frame_ms": args.frame_ms},
                      "requested_output": {"encoding": "pcm_s16le", "sample_rate": RATE}},
            "conversation": {"prompt_content": args.prompt, "customer": {}},
            "features": {"max_call_seconds": 300},
        }))
        ready = json.loads(await ws.recv())
        if ready.get("type") != "session.ready":
            print("准入失败：", json.dumps(ready, ensure_ascii=False))
            return 1
        print(f"session.ready  session_id={session_id}  客户语音 {len(pcm) / BYTES_PER_MS / 1000:.1f}s")
        for warning in ready.get("warnings") or []:
            print("  warning:", warning)

        if args.greeting:
            await ws.send(json.dumps({"type": "response.create", "session_id": session_id,
                                      "input": {"mode": "speak_text", "text": args.greeting}}))
        sender = asyncio.create_task(send_audio(ws, session_id, pcm, args.frame_ms, args.lead, args.tail))
        try:
            while True:
                ev = json.loads(await asyncio.wait_for(ws.recv(), RESULT_TIMEOUT))
                kind = ev.get("type")
                if kind == "asr.final":
                    print(f"  客户：{ev.get('text')}")
                elif kind == "response.text.final":
                    print(f"  AI：  {ev.get('text')}")
                elif kind == "response.audio.start":
                    out_rate = int(ev.get("sample_rate") or RATE)
                elif kind == "response.audio.delta":
                    agent_pcm += base64.b64decode(ev.get("audio", ""))
                elif kind == "response.interrupted":
                    print(f"  （客户抢话，回复 {ev.get('response_id')} 中断）")
                elif kind == "session.result" and ev.get("status") in ("completed", "failed"):
                    print(f"session.result {ev.get('status')}：")
                    print(f"  summary={ev.get('summary')}")
                    print(f"  intention_grade={ev.get('intention_grade')}  turn_count={ev.get('turn_count')}"
                          f"  duration_seconds={ev.get('duration_seconds')}")
                    print(f"  billing={json.dumps(ev.get('billing'), ensure_ascii=False)}")
                    await ws.send(json.dumps({"type": "session.result.ack", "session_id": session_id,
                                              "result_event_id": ev.get("event_id", "")}))
                elif kind == "session.closed":
                    print(f"session.closed reason={ev.get('reason')}")
                    break
                elif kind == "error":
                    print("error：", json.dumps(ev, ensure_ascii=False))
                    if ev.get("fatal"):
                        return 1
        finally:
            sender.cancel()
    if agent_pcm:
        write_wav(args.out, bytes(agent_pcm), out_rate)
        print(f"AI 语音 {len(agent_pcm) / (out_rate * 2):.1f}s 已写入 {args.out}")
    return 0


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("wav", help="客户说的话：单声道 16 bit wav")
    parser.add_argument("--url", default="wss://api.jftxyun.com:31080/v1/realtime")
    parser.add_argument("--prompt", default="你是物业公司的客服，给业主回访最近一次报修的处理情况。说话简短。",
                        help="话术（conversation.prompt_content）")
    parser.add_argument("--greeting", default="您好，这里是物业客服中心，想跟您回访一下最近的报修。",
                        help="开场白，经 response.create 播报；传空串则不播")
    parser.add_argument("--out", default="agent.wav", help="AI 语音写到这个 wav")
    parser.add_argument("--frame-ms", type=int, default=20, help="每包音频时长，10–200")
    parser.add_argument("--lead", type=float, default=6.0, help="客户开口前先听开场白的秒数")
    parser.add_argument("--tail", type=float, default=10.0, help="客户说完后等 AI 回复的秒数，然后挂机")
    args = parser.parse_args()
    key = os.environ.get("PAA_API_KEY", "")
    if not key:
        raise SystemExit("请先设置环境变量 PAA_API_KEY")
    return asyncio.run(run(args, key, load_wav_16k(args.wav)))


if __name__ == "__main__":
    sys.exit(main())
