from robomaster import robot
from typing import Callable, Optional, Union
from enum import Enum
from dora import DoraStatus

import pyarrow as pa


CONN = "ap"


class Command(Enum):
    NOD_YES = [
        {"action": "gimbal", "value": [20.0, 0.0]},
        {"action": "gimbal", "value": [-5.0, 0.0]},
    ]
    NOD_NO = [
        {"action": "gimbal", "value": [-5, -55.0]},
        {"action": "gimbal", "value": [-5, 55.0]},
        {"action": "gimbal", "value": [-5.0, 0.0]},
    ]
    FORWARD = [
        {
            "action": "control",
            "value": [0.5, 0.0, 0.0, 0.6, 0],
        }
    ]
    BACKWARD = [
        {
            "action": "control",
            "value": [-0.5, 0, 180.0, 0.6, 30],
        },
    ]
    LEFT = [
        {"action": "gimbal", "value": [-5, -30.0]},
        {
            "action": "control",
            "value": [0.2, -0.2, 30.0, 0.6, 30],
        },
    ]
    SLIGHT_LEFT = [
        {"action": "gimbal", "value": [-0.0, -15.0]},
        {
            "action": "control",
            "value": [0.3, -0.1, 15.0, 0.6, 50],
        },
    ]
    RIGHT = [
        {"action": "gimbal", "value": [-5, 30.0]},
        {
            "value": [0.2, 0.2, -30.0, 0.6, 30],
            "action": "control",
        },
    ]
    SLIGHT_RIGHT = [
        {"action": "gimbal", "value": [-20.0, 15.0]},
        {
            "value": [0.3, 0.1, -15.0, 0.6, 50],
            "action": "control",
        },
    ]
    UNKNOWN = []
    # STOP = [0, 0, 0, 0]
    # COMPLETED = [0, 0, 0, 0]

    @classmethod
    def parse(cls, value):
        for k, v in cls.__members__.items():
            if k == value:
                return v
        return cls.UNKNOWN


class Operator:
    def __init__(self):
        self.ep_robot = robot.Robot()
        print("Initializing robot...")
        assert self.ep_robot.initialize(conn_type=CONN), "Could not initialize ep_robot"
        assert self.ep_robot.camera.start_video_stream(
            display=False
        ), "Could not start video stream"

        self.ep_robot.gimbal.recenter().wait_for_completed()
        self.event = self.ep_robot.gimbal.moveto(
            pitch=-5, yaw=0, pitch_speed=50.0, yaw_speed=50.0
        )
        self.backlog = []
        self.last_control = ""

    def execute_backlog(self):
        if len(self.backlog) > 0:
            command = self.backlog.pop(0)
            if command["action"] == "control":
                [x, y, z, xy_speed, z_speed] = command["value"]
                print(command, flush=True)
                self.event = self.ep_robot.chassis.move(
                    x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
                )
            elif command["action"] == "gimbal":
                [pitch, yaw] = command["value"]
                print(command, flush=True)
                self.event = self.ep_robot.gimbal.moveto(
                    pitch=pitch, yaw=yaw, pitch_speed=50.0, yaw_speed=50.0
                )

    def on_event(
        self,
        dora_event: str,
        send_output: Callable[[str, pa.Array, Optional[dict]], None],
    ) -> DoraStatus:
        event_type = dora_event["type"]
        if event_type == "INPUT":
            if dora_event["id"] == "tick":
                if not (
                    self.event is not None
                    and not (self.event._event.isSet() and self.event.is_completed)
                ):
                    if len(self.backlog) > 0:
                        self.execute_backlog()
                    else:
                        print(f"sending control reply: {self.last_control}", flush=True)
                        send_output("control_reply", pa.array([self.last_control]))
            elif dora_event["id"] == "control":
                raw_command = dora_event["value"][0].as_py()
                print(raw_command, flush=True)
                self.last_control = raw_command
                if "but" in raw_command:
                    cmd = Command.NOD_NO
                elif "right" in raw_command:
                    cmd = Command.RIGHT
                elif "left" in raw_command:
                    cmd = Command.LEFT
                elif "forward" in raw_command:
                    cmd = Command.FORWARD
                elif "behind" in raw_command:
                    cmd = Command.BACKWARD
                else:
                    cmd = Command.UNKNOWN
                if len(self.backlog) == 0:
                    self.backlog += cmd.value
                    self.execute_backlog()

        return DoraStatus.CONTINUE