ayon_menus

class AYONMenus(MinorMode):
    def __init__(self):
        MinorMode.__init__(self)

        self.review_controller = None

        bindings: list[tuple[str, Callable, str]] = [
            # event name, callback, description
            (
                "ayon_load_container",
                on_ayon_load_container,
                "Loads an AYON representation into the session.",
            ),
            (
                "session-initialized",
                self._open_visible_panels,
                "Open visible panels on session initialization",
            ),
        ]
        if os.getenv("AYON_RV_UNSET_SESSION") == "1":
            bindings.append((
                "after-session-read",
                self._unset_session_filename,
                "Unset session after start",
            ))

        self.init(
            name="py-ayon",
            globalBindings=None,
            overrideBindings=bindings,
            menu=[
                # Menu name
                # NOTE: If it already exists it will merge with existing
                # and add submenus / menuitems to the existing one
                ("AYON", self.menu_item()),
            ],
            # initialization order
            sortKey="source_setup",
            ordering=15,
        )
        self._panel_startup_visibility = []
        self._connected_panels = set()
        self._is_closing = False
        self._session_was_unset = False

    def _unset_session_filename(self, event=None):
        # Only ever run once
        if self._session_was_unset:
            return

        self._session_was_unset = True
        logging.debug("Unsetting session filename...")
        rv.commands.setSessionFileName("")

    def _read_panel_startup_visibility(self):
        return rv.commands.readSettings("ayon", "panel_startup_visibility", [])

    def _write_panel_startup_visibility(self, panel_name: str, visible: bool):
        if self._is_closing:
            return

        if visible:
            if panel_name not in self._panel_startup_visibility:
                self._panel_startup_visibility.append(panel_name)
        else:
            if panel_name in self._panel_startup_visibility:
                self._panel_startup_visibility.remove(panel_name)
        rv.commands.writeSettings(
            "ayon", "panel_startup_visibility", self._panel_startup_visibility
        )

    def _open_visible_panels(self, event):
        """Re-open desktop review panels that were visible last session."""
        event.reject()
        if self.review_controller is None:
            return

        self._panel_startup_visibility: list[str] = (
            self._read_panel_startup_visibility()
        )

        for panel_name in self._panel_startup_visibility:
            QTimer.singleShot(
                0, partial(self.open_desktop_review_panel, panel_name)
            )

    @property
    def _parent(self):
        return rv.qtutils.sessionWindow()

    def load(self, event):
        host_tools.show_loader(parent=self._parent, use_context=True)

    def publish(self, event):
        host_tools.show_publisher(parent=self._parent, tab="publish")

    def workfiles(self, event):
        host_tools.show_workfiles(parent=self._parent)

    def scene_inventory(self, event):
        host_tools.show_scene_inventory(parent=self._parent)

    def library(self, event):
        host_tools.show_library_loader(parent=self._parent)

    def _on_app_closing(self):
        self._is_closing = True

    def open_desktop_review_panel(self, panel_name: str, *_):
        if self.review_controller is None:
            raise RuntimeError(
                "Unable to open desktop review panel because desktop review"
                " has not been initialized."
            )

        panel = self.review_controller.get_panel(panel_name)
        dock_widget = self.review_controller.set_docker_widget(
            self._parent, panel, panel_name
        )
        # get the data
        self.review_controller.set_project(get_current_project_name() or "")
        self.review_controller.load_ayon_data()

        if dock_widget and panel_name not in self._connected_panels:
            filter_ = DockCloseFilter(
                panel_name,
                self._write_panel_startup_visibility,
                parent=dock_widget,
            )
            dock_widget.installEventFilter(filter_)
            self._connected_panels.add(panel_name)

    def add_desktop_review_menu_items(self, menu):
        # Check if addon is enabled
        project_settings = get_project_settings(get_current_project_name())
        review_desktop = project_settings.get("review_desktop", {})
        if not review_desktop.get("enabled", False):
            return

        # import review desktop controller
        try:
            from ayon_review_desktop.session_controller import ReviewController
        except ImportError:
            print("Failed to import 'ayon_review_desktop.session_controller':")
            traceback.print_exc()
            return

        # Instantiate controller and add menu items.
        self.review_controller = ReviewController(host="rv")
        menu.append(("_", None))  # separator
        for k, panel_name in enumerate(
            self.review_controller.get_available_panels()
        ):
            label = panel_name.replace("_", " ").capitalize()
            menu.append(
                (
                    f"{label}...",
                    partial(self.open_desktop_review_panel, panel_name),
                    f"control shift {k + 1}",
                    None,
                )
            )

    def menu_item(self):
        menu = [
            # Menuitem name, actionHook (event), key, stateHook
            ("Load...", self.load, None, None),
            ("Publish...", self.publish, None, None),
            ("Manage...", self.scene_inventory, None, None),
            ("Library...", self.library, None, None),
            ("_", None),  # separator
            ("Work Files...", self.workfiles, None, None),
        ]
        # Add Activity Stream menu item if enabled in project settings
        self.add_desktop_review_menu_items(menu)

        # Add a callback to detect when RV is closing
        QApplication.instance().aboutToQuit.connect(self._on_app_closing)

        return menu