import time

from linksoul_agentsdk import (
    AgentAuthCallback,
    AgentParam,
    AgentSdk,
    IdGenerator,
    TeleopEnterCallback,
    TeleopExitCallback,
    TeleopKeepaliveCallback,
    TeleopRequest,
)

url        = "wss://open.agibot.com/api/V1/open-portal/app/wss/agent-sdk"
app_id     = "<appId from the LinkSoul open platform>"
app_key    = "<appKey from the LinkSoul open platform>"
app_secret = "<appSecret from the LinkSoul open platform>"
agent_id   = "<target robot agentId>"

# 1. Create the SDK instance
agent_sdk = AgentSdk.create(url, app_id, app_key, app_secret)


# 2. Register auth callback
class MyAuthCallback(AgentAuthCallback):
    def on_auth_state(self, app_id: str, code: int, msg: str) -> None:
        print(f"on_auth_state => app_id: {app_id}, code: {code}, msg: {msg}")


agent_sdk.register_auth(MyAuthCallback())

# 3. Open the WebSocket connection
agent_sdk.initialize()
time.sleep(2)

# 4. Register a teleop request
teleop_id = IdGenerator.generate_teleop_id()
teleop_request = TeleopRequest(agent_sdk, agent_id, teleop_id)
agent_sdk.register_teleop(teleop_request)


# 5. Enter the teleop session
class MyEnterCallback(TeleopEnterCallback):
    def on_enter_ack(self, teleop_id: str, event_id: str, code: int, msg: str) -> None:
        print(f"on_enter_ack => teleop_id={teleop_id}, event_id={event_id}, code={code}, msg={msg}")


enter_param = AgentParam.create()
teleop_request.enter(enter_param, MyEnterCallback(), 2000)

# 6. Push one audio segment (fire-and-forget)
start_param = (
    AgentParam.create()
    .set_string("role", "male")       # male / female
    .set_integer("threshold", 0)      # -14 ~ 14
)
event_id = teleop_request.start_audio(start_param)
# real code should call append_audio_delta once per 20-40 ms PCM/Opus chunk (base64-encoded)
teleop_request.append_audio_delta(event_id, "")
teleop_request.done_audio(event_id)


# 7. Probe robot online (in real code drive this on a 10 s timer -- see "Periodic keepalive" below)
class MyKeepaliveCallback(TeleopKeepaliveCallback):
    def on_keepalive_ack(self, teleop_id: str, event_id: str, code: int, msg: str) -> None:
        print(f"on_keepalive_ack => teleop_id={teleop_id}, event_id={event_id}, code={code}, msg={msg}")


teleop_request.keepalive(MyKeepaliveCallback(), 2000)


# 8. Exit the teleop session
class MyExitCallback(TeleopExitCallback):
    def on_exit_ack(self, teleop_id: str, event_id: str, code: int, msg: str) -> None:
        print(f"on_exit_ack => teleop_id={teleop_id}, event_id={event_id}, code={code}, msg={msg}")


teleop_request.exit(MyExitCallback(), 2000)

# 9. Unregister and release (omitted here)
# agent_sdk.unregister_teleop(teleop_id)
# agent_sdk.release()

import threading
from linksoul_agentsdk import TeleopKeepaliveCallback, TeleopExitCallback


def start_keepalive(teleop_request, agent_sdk, interval_sec: int = 10):
    """Call after enter succeeds; probes every interval_sec seconds"""
    state = {"online": True}

    def tick():
        if not state["online"]:
            return

        class _Cb(TeleopKeepaliveCallback):
            def on_keepalive_ack(self, teleop_id, event_id, code, msg):
                if code != 0 and state["online"]:
                    state["online"] = False
                    print(f"robot offline => code={code}, msg={msg}")

                    class _ExitCb(TeleopExitCallback):
                        def on_exit_ack(self, teleop_id, event_id, code, msg):
                            agent_sdk.unregister_teleop(teleop_id)
                    teleop_request.exit(_ExitCb(), 2000)

        teleop_request.keepalive(_Cb(), 2000)
        if state["online"]:
            threading.Timer(interval_sec, tick).start()

    threading.Timer(interval_sec, tick).start()
    return state  # caller may set state["online"] = False to stop probing