#!/usr/bin/env python3
"""PAA 只识别服务（/v1/asr）最小请求样例：读 wav → 实时节奏推流 → 打印识别结果。

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

用法：
    export PAA_API_KEY=sk_live_...
    python3 asr_api_sample.py a.wav [b.wav ...]

wav 要求单声道、16 bit；采样率不是 16 kHz 时脚本会线性插值重采样（电话 8 kHz 录音可直接用）。
多个文件按顺序拼接，中间插 0.8 秒静音，便于 ASR 断句。

协议（详见 gateway/README.md「只识别」一节）：
    -> session.start
    <- session.ready
    -> input_audio.append（16 kHz PCM16 单声道 base64，sequence 从 1 连续）
    <- speech.started / asr.partial（本段累计文本）/ asr.final（一段话定稿）
    -> session.close
    <- session.result{status:"processing"}，再 session.result{status:"completed", 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


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) -> None:
    """按实时节奏发送音频，发完补 1 秒静音再 session.close。"""
    pcm += bytes(BYTES_PER_MS * 1000)
    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(),
        }))
        # 对齐墙钟，模拟实时推流；一次性灌完会让 ASR 的分段时间失真
        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}))


async def run(url: str, key: str, pcm: bytes, frame_ms: int) -> int:
    session_id = f"asr-sample-{uuid.uuid4().hex[:12]}"
    headers = {"Authorization": f"Bearer {key}"}
    async with websockets.connect(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": frame_ms}},
            "features": {"max_call_seconds": 600},
        }))
        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}  audio={len(pcm) / BYTES_PER_MS / 1000:.1f}s")

        sender = asyncio.create_task(send_audio(ws, session_id, pcm, frame_ms))
        try:
            async for raw in ws:
                ev = json.loads(raw)
                kind = ev.get("type")
                if kind == "asr.partial":
                    print(f"  partial [{ev.get('turn_id')}] {ev.get('text')}")
                elif kind == "asr.final":
                    print(f"  FINAL   [{ev.get('turn_id')}] {ev.get('text')}"
                          f"  ({ev.get('audio_start_ms')}–{ev.get('audio_end_ms')} ms)")
                elif kind == "session.result" and ev.get("status") == "completed":
                    print("session.result completed：")
                    for turn in ev.get("turns", []):
                        print(f"  {turn.get('turn_id')}: {turn.get('text')}")
                    print(f"  audio_ms={ev.get('audio_ms')}  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["event_id"]}))
                elif kind == "session.closed":
                    print(f"session.closed reason={ev.get('reason')}")
                    return 0
                elif kind == "error":
                    print("error：", json.dumps(ev, ensure_ascii=False))
                else:
                    print(f"  {kind}")
        finally:
            sender.cancel()
    print("连接在 session.closed 之前断开")
    return 1


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("wav", nargs="+", help="单声道 16 bit wav，可多个")
    parser.add_argument("--url", default="wss://api.jftxyun.com:31080/v1/asr")
    parser.add_argument("--frame-ms", type=int, default=100, help="每包音频时长，10–200")
    args = parser.parse_args()
    key = os.environ.get("PAA_API_KEY", "")
    if not key:
        raise SystemExit("请先设置环境变量 PAA_API_KEY")
    gap = bytes(BYTES_PER_MS * 800)
    pcm = gap.join(load_wav_16k(p) for p in args.wav)
    return asyncio.run(run(args.url, key, pcm, args.frame_ms))


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