import math

from enum import Enum

from maneuver_scheduler import ManeuverScheduler


class ManeuverAlarmType(Enum):
    ManeuverNode = 1,
    SOI = 2


class Maneuver:
    def __init__(self, conn, mission_control):
        self.mission_control = mission_control
        self.vessel = mission_control.vessel
        self.conn = conn

    def plan_next_maneuver(self):
        pass


class NodeManeuver(Maneuver):
    alarm_type = ManeuverAlarmType.ManeuverNode

    def __init__(self, conn, mission_control):
        super().__init__(conn, mission_control)
        self.mech_jeb = conn.mech_jeb
        self.node_executor = self.mech_jeb.node_executor

    def execute(self) -> bool:
        sc = self.conn.space_center
        if sc.active_vessel.name != self.vessel.name:
            sc.active_vessel = self.vessel

        while self.vessel.control.nodes:
            self._execute_node()

        return self.plan_next_maneuver()

    def _execute_node(self):
        self.node_executor.execute_all_nodes()

        with self.conn.stream(getattr, self.node_executor, "enabled") as enabled:
            enabled.rate = 1
            with enabled.condition:
                while enabled():
                    enabled.wait()

    def book_timeslot_for_node(self, node, maneuver, duration=None):
        if node.time_to < 0:
            node.remove()
            planning_duration = 60
            ut = ManeuverScheduler.next_free_timeslot(self.conn.space_center.ut + planning_duration, planning_duration)
            ManeuverScheduler.book_timeslot(ut, self.vessel, duration=planning_duration)

        time_required = (node.delta_v * self.vessel.mass) / self.vessel.available_thrust
        duration = math.floor(2 * ManeuverScheduler.node_offsets + time_required)
        alarm_start = node.ut - (duration / 2 + ManeuverScheduler.node_offsets)

        if ManeuverScheduler.timeslot_is_free(alarm_start, duration):
            ManeuverScheduler.book_timeslot_for_node(self.vessel, node, self, alarm_start=alarm_start, duration=duration)
        else:
            node.remove()
            planning_duration = 60
            ut = ManeuverScheduler.next_free_timeslot(alarm_start, planning_duration)
            ManeuverScheduler.book_timeslot(ut, self.vessel, duration=planning_duration)


class MechJebManeuver(NodeManeuver):
    def __init__(self, conn, mission_control):
        super().__init__(conn, mission_control)
        self.maneuver_planner = self.mech_jeb.maneuver_planner