import sys
import signal
from enum import Enum

from maneuver_scheduler import ManeuverScheduler

from maneuvers.rendezvous import RendezvousManeuver
from maneuvers.approach import ApproachManeuver
from maneuvers.docking import DockingManeuver

from connector import get_connexion
from lib import get_contract, get_vessel, get_rescuee_vessel


class MissionStatus(Enum):
    Backlog = 1
    Assigned = 2
    InProgress = 3
    Done = 4


class MissionReport:
    mission_status = None
    new_vessel_id = None
    new_missions = []

    def __int__(self):
        pass


class Mission:
    pass


class TransportMission(Mission):
    def __init__(self, kerbal_name, destination):
        self.kerbal_name = kerbal_name
        self.destination = destination


class RescueMission(Mission):
    def __init__(self, contract_title):
        self.contract_title = contract_title
        self.contract = get_contract(contract_title)
        rescuee_first_name = contract_title.split()[1]
        self.rescuee_vessel = get_rescuee_vessel(rescuee_first_name)
        self.rescuee_vessel_name = self.rescuee_vessel.name
        self.rescuee_name = self.rescuee_vessel.crew[0].name

    def execute(self, vessel):
        conn = get_connexion()
        sc = conn.space_center

        if sc.active_vessel.name != vessel.name:
            sc.active_vessel = vessel

        if sc.target_vessel is None or sc.target_vessel.name != self.rescuee_vessel.name:
            sc.target_vessel = self.rescuee_vessel

        rendezvous_done = RendezvousManeuver(conn, vessel).execute()
        if rendezvous_done:
            reference_frame = sc.ReferenceFrame.create_relative(
                self.rescuee_vessel.reference_frame,
                rotation=(1., 0., 0., 0.)
            )
            approach_done = ApproachManeuver(conn, vessel, reference_frame).start()
            if approach_done:
                docking_part = vessel.parts.root.children[0].children[10].children[0].children[0].children[0].children[
                    0]
                docking_done = DockingManeuver(conn, vessel, docking_part, reference_frame).start()
                # Find new creat member name
                # sc.transfer_crew(self.rescuee_name, target_part)
                # Release Grapple
                # Destroy Capsule
                MissionReport.mission_status = MissionStatus.Done
                MissionReport.new_missions.append(
                    TransportMission(self.rescuee_name, 'kerbin_orbit')
                )


class ShuttleKerbin:

    def __init__(self, vessel_name):
        self.vessel_name = vessel_name
        self.vessel = get_vessel(vessel_name)

        self.current_orbit_missions = []
        self.current_mission = None

    def plan_mission(self, mission):
        self.current_mission = mission
        planning_duration = (5*60)
        ut = ManeuverScheduler.next_free_timeslot(duration=planning_duration)
        ManeuverScheduler.book_timeslot(ut, self.vessel)

    def pick_missions(self, backlog):
        for i, mission in enumerate(backlog.kerbin_orbit_rescue):
            if self.current_mission is None:
                self.plan_mission(mission)
            else:
                self.current_orbit_missions.append(mission)
            del(backlog.kerbin_orbit_rescue[i])

    def execute_mission(self, alarm):
        if self.current_mission is None:
            if self.current_orbit_missions:
                self.current_mission = self.current_orbit_missions.pop(0)
            else:
                return
        self.current_mission.execute(self.vessel)


class Backlog:
    kerbin_orbit_rescue = []
    kerbin_to_orbit = []
    kerbin_to_ground = []


def signal_handler(signal, frame):
    print("\nBye!")
    sys.exit(0)


if __name__ == '__main__':
    signal.signal(signal.SIGINT, signal_handler)
    ships = []

    m = RescueMission('Rescue Rossby from orbit of Kerbin.')
    Backlog.kerbin_orbit_rescue.append(m)

    ships.append(ShuttleKerbin('KKS Gagarin'))

    conn = get_connexion()
    # conn.space_center.GameMode
    space_center = conn.space_center

    for s in ships:
        s.pick_missions(Backlog)

    while True:
        for s in ships:
            s.pick_missions(Backlog)

        space_center.rails_warp_factor = 7
        with conn.stream(getattr, space_center, 'rails_warp_factor') as rails_warp_factor:
            with rails_warp_factor.condition:
                while rails_warp_factor() > 0:
                    rails_warp_factor.wait()

        alarm = ManeuverScheduler.get_last_alarm()
        vessel = alarm.vessel

        current_ship = None
        for s in ships:
            if s.vessel.name == vessel.name:
                current_ship = s
                break

        if current_ship is None:
            raise LookupError("Current ship {} not found".format(vessel.name))
        current_ship.execute_mission(alarm)
        alarm.remove()
        print("turn")