ops

class BuildWorkfileFromTemplate(LaunchQtApp):
    """Build Workfile from ayon template settings."""

    bl_idname = "wm.ayon_build_workfile_from_template"
    bl_label = "Build Workfile from Template"
    def execute(self, context):
        from .workfile_template_builder import build_workfile_template
        build_workfile_template()
        return {"FINISHED"}

class CreateFirstWorkfileFromTemplate(LaunchQtApp):
    """Build Workfile from ayon template settings."""

    bl_idname = "wm.ayon_create_first_workfile_from_template"
    bl_label = "Create First Workfile from Template"
    def execute(self, context):
        from .workfile_template_builder import create_first_workfile_from_template
        create_first_workfile_from_template()
        return {"FINISHED"}

class CreatePlaceholder(LaunchQtApp):
    """Create Placeholder from ayon template settings."""

    bl_idname = "wm.ayon_create_placeholder"
    bl_label = "Create Placeholder"
    def execute(self, context):
        from .workfile_template_builder import create_placeholder
        window = create_placeholder()
        BlenderApplication.store_window(self.bl_idname, window)
        self._window = window
        return super().execute(context)

class LaunchCreator(LaunchQtApp):
    """Launch AYON Creator."""

    bl_idname = "wm.ayon_creator"
    bl_label = "Create..."
    _tool_name = "creator"

    def before_window_show(self):
        self._window.refresh()

    def execute(self, context):
        host_tools.show_publisher(tab="create")
        return {"FINISHED"}

class LaunchLibrary(LaunchQtApp):
    """Launch Library Loader."""

    bl_idname = "wm.library_loader"
    bl_label = "Library..."
    _tool_name = "libraryloader"

class LaunchLoader(LaunchQtApp):
    """Launch AYON Loader."""

    bl_idname = "wm.ayon_loader"
    bl_label = "Load..."
    _tool_name = "loader"

class LaunchManager(LaunchQtApp):
    """Launch AYON Manager."""

    bl_idname = "wm.ayon_manager"
    bl_label = "Manage..."
    _tool_name = "sceneinventory"

class LaunchPublisher(LaunchQtApp):
    """Launch AYON Publisher."""

    bl_idname = "wm.ayon_publisher"
    bl_label = "Publish..."

    def execute(self, context):
        host_tools.show_publisher(tab="publish")
        return {"FINISHED"}

class LaunchQtApp(bpy.types.Operator):
    """A Base class for operators to launch a Qt app."""

    _window = Union[QtWidgets.QDialog, ModuleType]
    _tool_name: str = None
    _init_args: Optional[List] = list()
    _init_kwargs: Optional[Dict] = dict()
    bl_idname: str = None

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        if self.bl_idname is None:
            raise NotImplementedError("Attribute `bl_idname` must be set!")
        print(f"Initialising {self.bl_idname}...")
        GlobalClass.app = BlenderApplication.get_app()

        if not bpy.app.timers.is_registered(_process_app_events):
            bpy.app.timers.register(
                _process_app_events,
                persistent=True
            )

    def execute(self, context):
        """Execute the operator.

        The child class must implement `execute()` where it only has to set
        `self._window` to the desired Qt window and then simply run
        `return super().execute(context)`.
        `self._window` is expected to have a `show` method.
        If the `show` method requires arguments, you can set `self._show_args`
        and `self._show_kwargs`. `args` should be a list, `kwargs` a
        dictionary.
        """

        if self._tool_name is None:
            if self._window is None:
                raise AttributeError("`self._window` is not set.")

        else:
            window = BlenderApplication.get_window(self.bl_idname)
            if window is None:
                window = host_tools.get_tool_by_name(self._tool_name)
                BlenderApplication.store_window(self.bl_idname, window)
            self._window = window

        if not isinstance(self._window, (QtWidgets.QWidget, ModuleType)):
            raise AttributeError(
                "`window` should be a `QWidget or module`. Got: {}".format(
                    str(type(self._window))
                )
            )

        self.before_window_show()

        def pull_to_front(window):
            """Pull window forward to screen.

            If Window is minimized this will un-minimize, then it can be raised
            and activated to the front.
            """
            window.setWindowState(
                (window.windowState() & ~QtCore.Qt.WindowMinimized) |
                QtCore.Qt.WindowActive
            )
            window.raise_()
            window.activateWindow()

        if isinstance(self._window, ModuleType):
            self._window.show()
            pull_to_front(self._window)

            # Pull window to the front
            window = None
            if hasattr(self._window, "window"):
                window = self._window.window
            elif hasattr(self._window, "_window"):
                window = self._window.window

            if window:
                BlenderApplication.store_window(self.bl_idname, window)

        else:
            origin_flags = self._window.windowFlags()
            on_top_flags = origin_flags | QtCore.Qt.WindowStaysOnTopHint
            self._window.setWindowFlags(on_top_flags)
            self._window.show()
            pull_to_front(self._window)

            # if on_top_flags != origin_flags:
            #     self._window.setWindowFlags(origin_flags)
            #     self._window.show()

        return {'FINISHED'}

    def before_window_show(self):
        return

class LaunchWorkFiles(LaunchQtApp):
    """Launch AYON Work Files."""

    bl_idname = "wm.ayon_workfiles"
    bl_label = "Work Files..."
    _tool_name = "workfiles"

    def execute(self, context):
        return super().execute(context)

class MainThreadItem:
    """Structure to store information about callback in main thread.

    Item should be used to execute callback in main thread which may be needed
    for execution of Qt objects.

    Item store callback (callable variable), arguments and keyword arguments
    for the callback. Item hold information about it's process.
    """
    not_set = object()
    sleep_time = 0.1

    def __init__(self, callback, *args, **kwargs):
        self.done = False
        self.exception = self.not_set
        self.result = self.not_set
        self.callback = callback
        self.args = args
        self.kwargs = kwargs

    def execute(self):
        """Execute callback and store its result.

        Method must be called from main thread. Item is marked as `done`
        when callback execution finished. Store output of callback of exception
        information when callback raises one.
        """
        print("Executing process in main thread")
        if self.done:
            print("- item is already processed")
            return

        callback = self.callback
        args = self.args
        kwargs = self.kwargs
        print("Running callback: {}".format(str(callback)))
        try:
            result = callback(*args, **kwargs)
            self.result = result

        except Exception:
            self.exception = sys.exc_info()

        finally:
            print("Done")
            self.done = True

    def wait(self):
        """Wait for result from main thread.

        This method stops current thread until callback is executed.

        Returns:
            object: Output of callback. May be any type or object.

        Raises:
            Exception: Reraise any exception that happened during callback
                execution.
        """
        while not self.done:
            print(self.done)
            time.sleep(self.sleep_time)

        if self.exception is self.not_set:
            return self.result
        raise self.exception

class OpenTemplate(LaunchQtApp):
    """Build Workfile from ayon template settings."""

    bl_idname = "wm.ayon_open_template"
    bl_label = "Open Template"
    def execute(self, context):
        from .workfile_template_builder import open_template
        window = open_template()
        BlenderApplication.store_window(self.bl_idname, window)
        self._window = window
        return super().execute(context)

class TOPBAR_MT_ayon(bpy.types.Menu):
    """AYON menu."""

    bl_idname = "TOPBAR_MT_AYON"
    bl_label = os.environ.get("AYON_MENU_LABEL")

    def draw(self, context):
        """Draw the menu in the UI."""

        layout = self.layout

        pcoll = PREVIEW_COLLECTIONS.get("ayon")
        if pcoll:
            pyblish_menu_icon = pcoll["pyblish_menu_icon"]
            pyblish_menu_icon_id = pyblish_menu_icon.icon_id
        else:
            pyblish_menu_icon_id = 0

        folder_path = get_current_folder_path()
        task_name = get_current_task_name()
        context_label = f"{folder_path}, {task_name}"
        context_label_item = layout.row()
        context_label_item.operator(
            LaunchWorkFiles.bl_idname, text=context_label
        )
        context_label_item.enabled = False
        project_name = get_current_project_name()
        project_settings = get_project_settings(project_name)
        if project_settings["core"]["tools"]["ayon_menu"].get(
            "version_up_current_workfile"):
                layout.separator()
                layout.operator(
                    VersionUpWorkfile.bl_idname,
                    text="Version Up Workfile"
                )
                wm = bpy.context.window_manager
                keyconfigs = wm.keyconfigs
                keymap = keyconfigs.addon.keymaps.new(name='Window', space_type='EMPTY')
                keymap.keymap_items.new(
                    VersionUpWorkfile.bl_idname, 'S',
                    'PRESS', ctrl=True, alt=True
                )
                bpy.context.window_manager.keyconfigs.addon.keymaps.update()

        layout.separator()
        layout.operator(LaunchWorkFiles.bl_idname, text="Work Files...")

        layout.separator()
        layout.operator(LaunchCreator.bl_idname, text="Create...")
        layout.operator(LaunchLoader.bl_idname, text="Load...")
        layout.operator(
            LaunchPublisher.bl_idname,
            text="Publish...",
            icon_value=pyblish_menu_icon_id,
        )
        layout.operator(LaunchManager.bl_idname, text="Manage...")
        layout.operator(LaunchLibrary.bl_idname, text="Library...")
        layout.separator()
        layout.operator(SetFrameRange.bl_idname, text="Set Frame Range")
        layout.operator(SetResolution.bl_idname, text="Set Resolution")
        layout.operator(SetUnitScale.bl_idname, text="Set Unit Scale")
        layout.operator(CreateRenderSetup.bl_idname,
                        text="Create Render Setup")

        layout.separator()
        layout.menu(
            TOPBAR_MT_ayon_Templated_Workfile.bl_idname,
            text="Templated Workfile"
        )

class TOPBAR_MT_ayon_Templated_Workfile(bpy.types.Menu):
    """AYON submenu example."""

    bl_idname = "TOPBAR_MT_AYON_TEMPLATED_WORKFILE"
    bl_label = "Templated Workfile"

    def draw(self, context):
        layout = self.layout
        layout.operator(
            CreateFirstWorkfileFromTemplate.bl_idname,
            text="Create First Workfile from Template"
        )
        layout.operator(
            BuildWorkfileFromTemplate.bl_idname,
            text="Build Workfile from Template"
        )
        # layout.operator(
        #     UpdateWorkfileFromTemplate.bl_idname,
        #     text="Update Workfile from Template"
        # )
        layout.separator()
        layout.operator(
            OpenTemplate.bl_idname,
            text="Open Template"
        )
        layout.operator(
            CreatePlaceholder.bl_idname,
            text="Create Placeholder"
        )
        layout.operator(
            UpdatePlaceholder.bl_idname,
            text="Update Placeholder"
        )

class UpdatePlaceholder(LaunchQtApp):
    """Update Placeholder from ayon template settings."""

    bl_idname = "wm.ayon_update_placeholder"
    bl_label = "Update Placeholder"
    def execute(self, context):
        from .workfile_template_builder import update_placeholder
        window = update_placeholder()
        BlenderApplication.store_window(self.bl_idname, window)
        self._window = window
        return super().execute(context)

class VersionUpWorkfile(LaunchQtApp):
    """Perform Incremental Save Workfile."""

    bl_idname = "wm.ayon_version_up_workfile"
    bl_label = "Version Up Workfile"

    def execute(self, context):
        version_up_current_workfile()
        return {"FINISHED"}