pipeline

class FusionEventHandler(QtCore.QObject):
    """Emits AYON events based on Fusion events captured in a QThread.

    This will emit the following AYON events based on Fusion actions:
        save: Comp_Save, Comp_SaveAs
        open: Comp_Opened
        new: Comp_New

    To use this you can attach it to you Qt UI so it runs in the background.
    E.g.
        >>> handler = FusionEventHandler(parent=window)
        >>> handler.start()

    """
    ACTION_IDS = [
        "Comp_Save",
        "Comp_SaveAs",
        "Comp_New",
        "Comp_Opened"
    ]

    def __init__(self, parent=None):
        super(FusionEventHandler, self).__init__(parent=parent)

        # Set up Fusion event callbacks
        fusion = getattr(sys.modules["__main__"], "fusion", None)
        ui = fusion.UIManager

        # Add notifications for the ones we want to listen to
        notifiers = []
        for action_id in self.ACTION_IDS:
            notifier = ui.AddNotify(action_id, None)
            notifiers.append(notifier)

        # TODO: Not entirely sure whether these must be kept to avoid
        #       garbage collection
        self._notifiers = notifiers

        self._event_thread = FusionEventThread(parent=self)
        self._event_thread.on_event.connect(self._on_event)

    def start(self):
        self._event_thread.start()

    def stop(self):
        self._event_thread.stop()

    def _on_event(self, event):
        """Handle Fusion events to emit AYON events"""
        if not event:
            return

        what = event["what"]

        # Comp Save
        if what in {"Comp_Save", "Comp_SaveAs"}:
            if not event["Rets"].get("success"):
                # If the Save action is cancelled it will still emit an
                # event but with "success": False so we ignore those cases
                return
            # Comp was saved
            emit_event("save", data=event)
            return

        # Comp New
        elif what in {"Comp_New"}:
            emit_event("new", data=event)

        # Comp Opened
        elif what in {"Comp_Opened"}:
            emit_event("open", data=event)

class FusionEventThread(QtCore.QThread):
    """QThread which will periodically ping Fusion app for any events.
    The fusion.UIManager must be set up to be notified of events before they'll
    be reported by this thread, for example:
        fusion.UIManager.AddNotify("Comp_Save", None)

    """

    on_event = QtCore.Signal(dict)

    def run(self):

        app = getattr(sys.modules["__main__"], "app", None)
        if app is None:
            # No Fusion app found
            return

        # As optimization store the GetEvent method directly because every
        # getattr of UIManager.GetEvent tries to resolve the Remote Function
        # through the PyRemoteObject
        get_event = app.UIManager.GetEvent
        delay = int(os.environ.get("AYON_FUSION_CALLBACK_INTERVAL", 1000))
        while True:
            if self.isInterruptionRequested():
                return

            # Process all events that have been queued up until now
            while True:
                event = get_event(False)
                if not event:
                    break
                self.on_event.emit(event)

            # Wait some time before processing events again
            # to not keep blocking the UI
            self.msleep(delay)

class FusionHost(HostBase, IWorkfileHost, ILoadHost, IPublishHost):
    name = "fusion"

    def install(self):
        """Install fusion-specific functionality of AYON.

        This is where you install menus and register families, data
        and loaders into fusion.

        It is called automatically when installing via
        `ayon_core.pipeline.install_host(ayon_fusion.api)`

        See the Maya equivalent for inspiration on how to implement this.

        """
        # Remove all handlers associated with the root logger object, because
        # that one always logs as "warnings" incorrectly.
        for handler in logging.root.handlers[:]:
            logging.root.removeHandler(handler)

        # Attach default logging handler that prints to active comp
        logger = logging.getLogger()
        formatter = logging.Formatter(fmt="%(message)s\n")
        handler = FusionLogHandler()
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        logger.setLevel(logging.DEBUG)

        pyblish.api.register_host("fusion")
        pyblish.api.register_plugin_path(PUBLISH_PATH)
        log.info("Registering Fusion plug-ins..")

        register_loader_plugin_path(LOAD_PATH)
        register_creator_plugin_path(CREATE_PATH)
        register_inventory_action_path(INVENTORY_PATH)

        # Register events
        register_event_callback("open", on_after_open)
        register_event_callback("workfile.save.before", before_workfile_save)
        register_event_callback("save", on_save)
        register_event_callback("new", on_new)
        register_event_callback("taskChanged", on_task_changed)

    # region workfile io api
    def has_unsaved_changes(self):
        comp = get_current_comp()
        return comp.GetAttrs()["COMPB_Modified"]

    def get_workfile_extensions(self):
        return [".comp"]

    def save_workfile(self, dst_path=None):
        comp = get_current_comp()
        comp.Save(dst_path)

    def open_workfile(self, filepath):
        # Hack to get fusion, see
        #   ayon_fusion.api.pipeline.get_current_comp()
        fusion = getattr(sys.modules["__main__"], "fusion", None)

        return fusion.LoadComp(filepath)

    def get_current_workfile(self):
        comp = get_current_comp()
        current_filepath = comp.GetAttrs()["COMPS_FileName"]
        if not current_filepath:
            return None

        return current_filepath

    def work_root(self, session):
        work_dir = session["AYON_WORKDIR"]
        scene_dir = session.get("AVALON_SCENEDIR")
        if scene_dir:
            return os.path.join(work_dir, scene_dir)
        else:
            return work_dir
    # endregion

    @contextlib.contextmanager
    def maintained_selection(self):
        from .lib import maintained_selection
        return maintained_selection()

    def get_containers(self):
        return ls()

    def update_context_data(self, data, changes):
        comp = get_current_comp()
        comp.SetData("openpype", data)

    def get_context_data(self):
        comp = get_current_comp()
        return comp.GetData("openpype") or {}