import dearpygui.core as dpg
import dearpygui.simple as sdpg
import uuid
import logging
from concurrent.futures import ProcessPoolExecutor


def setup_logging(loglevel="INFO"):
    import coloredlogs
    from datetime import timedelta

    coloredlogs.DEFAULT_FIELD_STYLES["delta"] = {"color": "green"}
    coloredlogs.DEFAULT_FIELD_STYLES["levelname"] = {"color": "yellow"}

    class DeltaTimeFormatter(coloredlogs.ColoredFormatter):
        def format(self, record):
            seconds = record.relativeCreated / 1000
            duration = timedelta(seconds=seconds)
            record.delta = str(duration)
            return super().format(record)

    coloredlogs.ColoredFormatter = DeltaTimeFormatter
    logfmt = " | ".join(
        ["[%(delta)s] %(levelname)s", "%(name)s:%(pathname)s:%(lineno)s", "%(message)s"]
    )
    numeric_level = getattr(logging, loglevel.upper(), None)
    if not isinstance(numeric_level, int):
        raise ValueError("Invalid log level: %s" % loglevel)
    coloredlogs.install(level=numeric_level, fmt=logfmt)


setup_logging()

def resolve_systems(stars, *args):
    import _ed_lrr

    r = _ed_lrr.PyRouter(None)
    r.load(stars)
    return r.resolve_systems(*args)


class EdLrrGui:
    def __init__(self):
        self.pool = ProcessPoolExecutor(1)
        self.systems = []
        self.__resolve_job = None
        self.logger = logging.getLogger("GUI")

    def __set_state(self, state):
        print(state)
        dpg.set_value("ed_lrr_state", state)

    def __resolve_done(self, fut):
        data = fut.result()
        self.logger.info(f"Gor resolver data back: {data}")
        self.__resolve_job = None
        for n, system in enumerate(self.systems):
            if system["name"] in data:
                self.systems[n] = data[system["name"]]
                self.systems[n]["resolved"] = True

    def __resolve_systems(self, sender, data):
        names = []
        for system in self.systems:
            if not system.get("resolver", False):
                names.append(system["name"])
        if self.__resolve_job is None:
            job = self.pool.submit(resolve_systems, "../stars.csv", *names)
            self.logger.info(f"Resolving {len(names)} systems...")
            self.__resolve_job = job
            self.__resolve_job.add_done_callback(self.__resolve_done)

    def __render(self, sender, data):
        dpg.clear_table("Systems")
        for system in self.systems:
            row = [
                system.get("id", ""),
                system["name"],
                ", ".join(map(str, system.get("pos", []))),
            ]
            dpg.add_row("Systems", row)

    def __add_system(self, sender, data):
        system_name = dpg.get_value("sys-name")
        self.systems.append({"name": system_name})
        dpg.set_value("sys-name", "")

    def __select_system(self, sender, data):
        system_row = dpg.get_table_selections("Systems")
        idx = system_row[0][0]
        dpg.add_data("selected-system-index", idx)

    def __remove_system(self, sender, data):
        if self.systems:
            system_index = dpg.get_data("selected-system-index")
            self.systems.pop(system_index)

    def __clear_systems(self, sender, data):
        self.systems = []

    def show(self):
        with sdpg.window("Main Window"):
            dpg.set_main_window_size(550, 550)
            dpg.set_main_window_resizable(False)
            dpg.set_main_window_title("Elite: Dangerous Long Range Router")

            dpg.add_text("ED_LRR")
            dpg.add_separator()

            dpg.add_input_text("System name", source="sys-name")
            dpg.add_button("Add", callback=self.__add_system)
            dpg.add_separator()

            dpg.add_table(
                "Systems",
                ["ID", "Name", "Position"],
                height=200,
                callback=self.__select_system,
            )
            dpg.add_separator()
            dpg.add_button("Remove", callback=self.__remove_system)
            dpg.add_button("Clear", callback=self.__clear_systems)
            dpg.add_button("Resolve", callback=self.__resolve_systems)

            # Render Callback and Start gui
        dpg.set_render_callback(self.__render)
        dpg.start_dearpygui(primary_window="Main Window")


if __name__ == "__main__":
    edlrr_gui = EdLrrGui()
    edlrr_gui.show()