from PySide6 import QtWidgets
#import gui_helper
import util

app = QtWidgets.QApplication([])

class Window(QtWidgets.QMainWindow):
    def __init__(self, size=(640, 480), title="Concorde"):
        super().__init__()
        self.setWindowTitle(title)
        self.resize(size[0], size[1])
        self.show()

    def __del__(self):
        #TODO: whatever needs to be done here
        pass

    def set_title(self, title):
        self.setWindowTitle(title)

    def get_size(self):
        #TODO: implement
        util.warn("Not implemented!")
        return None

    def set_size(self, size_x, size_y):
        self.resize(size_x, size_y)

    def update_menus(self, menu_dict):
        menu = self.menuBar()
        #Looping through entire menu_dict
        for topmenu, submenu in menu_dict.items():
            #making top level menu
            menu_item = menu.addMenu(topmenu)

            #adding menu items (populating menu)
            for inner, data in submenu.items():
                #Adding submenu and populating it
                if type(data) == dict:
                    sub = menu_item.addMenu(inner)
                    for label, func in data.items():
                        sub.addAction(label)

                        if func == None:
                            sub.triggered.connect(lambda x: None)
                        else:
                            sub.triggered.connect(func)
                #Adding separators
                elif inner == None:
                    menu_item.addSeparator()
                else:    
                    item = menu_item.addAction(inner)
                    item.triggered.connect(data)
    

#TODO: This needs to run in a thread but Qt really doesn't want it to. There are two ways around this:
#   - create the QtWidgets.QApplication inside a thread and run all QT stuff inside that thread
#   - make a generic wrapper for window mainloop that will always run in the main thread while the actual main control flow of the program gets moved to another thread
# There are some issues with these workarounds though; mainly that QT isn't thread safe.
# I really want to keep QT running in its own thread because I want to retain the ability to arbitrarily spawn and manipulate windows while other windows are running.
# Another issue that is probably easily worked around / fixed is that app.exec() will return once all running windows are closed.
# Idea for a workaround for both:
#   Maybe Qt has scheduled events in which case a scheduled polling event could run a function inside the Qt thread that fetches commands and executes them.
#   This could work by passing (lambda) functions through a Communication object.
def fixme_window_mainloop_workaround_to_just_get_a_window_started_really_should_not_be_implemented_this_way_for_reasons_stated_in_the_comment_above_the_definition_of_this_function():
    app.exec()