from linksoul_agentsdk import AgentMeta, AgentParam, AgentSdk
from linksoul_agentsdk.passive import Audio2TtsCallback, Audio2TtsResponse


class MyCallback(Audio2TtsCallback):

    def on_robot_online(self, agent_id: str, agent_meta: AgentMeta) -> None:
        # 机器人上线，初始化该机器人的资源
        print(f"on_robot_online => {agent_id}, wakeup={agent_meta.get_wakeup_word()}")

    def on_robot_offline(self, agent_id: str) -> None:
        # 机器人下线，清理该机器人相关的资源
        print(f"on_robot_offline => {agent_id}")

    def on_request(
        self,
        agent_id: str,
        event_id: str,
        item_id: str,
        flag: int,
        buf: bytes | None,
        param: AgentParam,
        response: Audio2TtsResponse,
    ) -> None:
        if flag == 0:
            # VAD 开始：可以初始化 ASR 会话
            init_asr_session(agent_id, event_id)
        elif flag == 1:
            # 音频帧：发送到 ASR 服务进行流式识别
            feed_asr(agent_id, event_id, buf)
        elif flag == 2:
            # VAD 结束：完成 ASR，调用 LLM，合成 TTS
            asr_text = finalize_asr(agent_id, event_id)
            response.on_asr_final(event_id, asr_text)

            # 有效指令必须先打断
            response.on_interrupt(event_id, "chat", None)

            # 调用 LLM 获取回复
            llm_reply = call_llm(asr_text)
            response.on_llm_item_delta(event_id, item_id, llm_reply)
            response.on_llm_item_done(event_id, item_id)
            response.on_llm_done(event_id)

            # 合成 TTS 音频
            tts_audio = synthesize_tts(llm_reply)
            response.on_tts_item_delta(event_id, item_id, tts_audio)
            response.on_tts_item_done(event_id, item_id)
            response.on_tts_done(event_id)


agent_sdk = AgentSdk.create(url, app_id, app_key, app_secret)
agent_sdk.register_audio2_tts(MyCallback(agent_sdk))
agent_sdk.initialize()

on_request(flag=0) → 初始化
on_request(flag=1) → 累积音频 → ASR 流式识别
                                └→ on_asr_middle()（可选，中间结果）
on_request(flag=2) → ASR 完成 → on_asr_final()
                              → 语义理解分类
                                ├─ 拒识 → return（不调用任何 response.on_*）
                                └─ 有效指令
                                     ① on_interrupt(...)（必须先于 ②）
                                     ② 按需 on_skill / on_llm_* / on_vlm_* / on_tts_*

on_request(text="今天天气怎么样")
      │
      ▼
语义理解分类
      ├─ 拒识（无效查询 / 误唤醒 / 噪音等）
      │    └→ 直接 return，不调用任何 response.on_* 方法
      │
      └─ 有效指令
           ① 必须先 response.on_interrupt(event_id, type, tips)
           │    (type 见下文「打断」小节：风控 / 技能 / 有效闲聊 / realtime)
           │
           ② 再按命中结果回填：
           ├─ 命中技能 → response.on_skill(event_id, item_id, ...)
           ├─ 命中有效闲聊 → response.on_llm_item_delta / on_llm_item_done / on_llm_done
           ├─ 命中多模态 → response.on_vlm_item_delta / on_vlm_item_done / on_vlm_done
           └─ TTS 应答（如适用） → response.on_tts_item_delta / on_tts_item_done / on_tts_done

def on_request(self, agent_id, event_id, text, param, response):
    nlu = classify(text)

    # ① 拒识：直接 return
    if nlu.is_rejected():
        return

    item_id = IdGenerator.generate_item_id()

    # ② 有效指令必须先打断
    if nlu.is_risk_control():
        # 风控：interrupt_tips 必填
        response.on_interrupt(
            event_id, "risk_control",
            "你谈到敏感话题了，咱们换个话题聊吧",
        )
        return  # 风控场景下后续通常不再返回 LLM/技能
    elif nlu.is_skill():
        response.on_interrupt(event_id, "action", None)   # 技能打断
    else:
        response.on_interrupt(event_id, "chat", None)     # 有效闲聊打断
        # 若是 realtime 对话：response.on_interrupt(event_id, "realtime", None)

    # ③ 命中技能：下发 skill_param（key/value 见《语义技能参考》）
    if nlu.is_skill():
        skill_param = (
            AgentParam.create()
            .set_string("movement", "move_forward")
            .set_integer("meter", 10)
        )
        response.on_skill(event_id, item_id, "movement", "move_forward", skill_param)

    # ④ LLM 流式回复
    response.on_llm_item_delta(event_id, item_id, "好的，我开始向前走。")
    response.on_llm_item_done(event_id, item_id)
    response.on_llm_done(event_id)

# 普通对话回复
response.on_interrupt(event_id, "chat", None)
response.on_llm_item_delta(event_id, item_id, "好的，我来回答你的问题。")

# 命中动作技能
response.on_interrupt(event_id, "action", None)
skill_param = AgentParam.create().set_string("action", "wave_hands")
response.on_skill(event_id, item_id, "action", "wave_hands", skill_param)

# 实时对话边听边说
response.on_interrupt(event_id, "realtime", None)
response.on_llm_item_delta(event_id, item_id, "嗯嗯，我听到了……")

# 风控命中（interrupt_tips 必填，作为给用户的话术）
response.on_interrupt(event_id, "risk_control", "你谈到敏感话题了，咱们换个话题聊吧")

def on_greet_signal(self, agent_id, event_id, param, response):
    # 模式一：VLM 文本流式应答
    response.on_greet_vlm_delta(event_id, "你好")
    response.on_greet_vlm_delta(event_id, "，今天天气真不错")
    response.on_greet_vlm_done(event_id)

    # 模式二：TTS 音频流式应答（参数是合成好的音频字节经 base64 编码后的字符串片段）
    import base64
    audio_chunk1 = synthesize_tts("你好")              # PCM / Opus 等 bytes
    audio_chunk2 = synthesize_tts("，欢迎回家")
    response.on_greet_tts_delta(event_id, base64.b64encode(audio_chunk1).decode())
    response.on_greet_tts_delta(event_id, base64.b64encode(audio_chunk2).decode())
    response.on_greet_tts_done(event_id)