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"online => {agent_id}, wakeup={agent_meta.get_wakeup_word()}")

    def on_robot_offline(self, agent_id: str) -> None:
        print(f"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:
            init_asr_session(agent_id, event_id)
        elif flag == 1:
            feed_asr(agent_id, event_id, buf)
        elif flag == 2:
            asr_text = finalize_asr(agent_id, event_id)
            response.on_asr_final(event_id, asr_text)
            response.on_interrupt(event_id, "chat", None)
            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_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)


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

on_request(flag=0) → initialise
on_request(flag=1) → accumulate audio → streaming ASR
                                       → on_asr_middle()  (optional)
on_request(flag=2) → ASR done → on_asr_final()
                              → 语义理解 classification
                                ├─ rejected → return (no response.on_*)
                                └─ valid intent
                                     1. on_interrupt(...)  (REQUIRED first)
                                     2. on_skill / on_llm_* / on_vlm_* / on_tts_*

on_request(text="walk forward 10 meters")
      │
      ▼
语义理解 classification
      ├─ rejected → return — no response.on_* calls
      │
      └─ valid intent
           1. response.on_interrupt(event_id, type, tips)
              (type ∈ risk_control / action / chat / realtime)
           2. fill in skill / LLM / VLM / TTS

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

    # 1) rejected → return
    if nlu.is_rejected():
        return

    item_id = IdGenerator.generate_item_id()

    # 2) MUST interrupt first
    if nlu.is_risk_control():
        response.on_interrupt(
            event_id, "risk_control",
            "You mentioned a sensitive topic; let's talk about something else",
        )
        return  # typically no further LLM / skill output after risk control
    elif nlu.is_skill():
        response.on_interrupt(event_id, "action", None)
    else:
        response.on_interrupt(event_id, "chat", None)

    # 3) Skill (optional)
    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)

    # 4) LLM reply
    response.on_llm_item_delta(event_id, item_id, "Sure, walking forward.")
    response.on_llm_item_done(event_id, item_id)
    response.on_llm_done(event_id)

# Plain chat reply
response.on_interrupt(event_id, "chat", None)
response.on_llm_item_delta(event_id, item_id, "Sure, here is the answer.")

# Action / skill
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)

# Realtime dialog
response.on_interrupt(event_id, "realtime", None)
response.on_llm_item_delta(event_id, item_id, "Mhm, I hear you...")

# Risk-control (tips is mandatory — used as the spoken reply)
response.on_interrupt(event_id, "risk_control",
    "You mentioned a sensitive topic; let's talk about something else")

def on_greet_signal(self, agent_id, event_id, param, response):
    # Mode 1: streamed VLM text
    response.on_greet_vlm_delta(event_id, "Hello")
    response.on_greet_vlm_delta(event_id, ", nice to see you")
    response.on_greet_vlm_done(event_id)

    # Mode 2: streamed TTS audio — argument is a base64-encoded chunk of synthesised audio bytes
    import base64
    audio_chunk1 = synthesize_tts("Hello")               # PCM / Opus / ... bytes
    audio_chunk2 = synthesize_tts(", welcome home")
    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)