api

class CommunicationWrapper:
    # TODO add logs and exceptions
    communicator = None

    log = logging.getLogger("CommunicationWrapper")

    @classmethod
    def create_qt_communicator(cls, *args, **kwargs):
        """Create communicator for Artist usage."""
        communicator = QtCommunicator(*args, **kwargs)
        cls.set_communicator(communicator)
        return communicator

    @classmethod
    def set_communicator(cls, communicator):
        if not cls.communicator:
            cls.communicator = communicator
        else:
            cls.log.warning("Communicator was set multiple times.")

    @classmethod
    def client(cls):
        if not cls.communicator:
            return None
        return cls.communicator.client()

    @classmethod
    def replace_process(cls, launch_args):
        """Load spm file."""
        if not cls.communicator:
            return
        return cls.communicator.replace_process(launch_args)

class SpeedtreeHost(HostBase, IWorkfileHost, ILoadHost, IPublishHost):
    name = "speedtree"

    @staticmethod
    def show_tools_dialog():
        """Show tools dialog with actions leading to show other tools."""
        show_tools_dialog()

    def install(self):

        plugins_dir = os.path.join(SPTREE_ADDON_ROOT, "plugins")
        publish_dir = os.path.join(plugins_dir, "publish")
        load_dir = os.path.join(plugins_dir, "load")
        create_dir = os.path.join(plugins_dir, "create")

        pyblish.api.register_host("speedtree")
        pyblish.api.register_plugin_path(publish_dir)
        register_loader_plugin_path(load_dir)
        register_creator_plugin_path(create_dir)

        register_event_callback(
            "application.launched", self.initial_app_launch
        )
        register_event_callback("application.exit", self.application_exit)

    def get_current_project_name(self):
        """
        Returns:
            Union[str, None]: Current project name.
        """

        return self.get_current_context().get("project_name")

    def get_current_folder_path(self):
        """
        Returns:
            Union[str, None]: Current folder path.
        """

        return self.get_current_context().get("folder_path")

    def get_current_task_name(self):
        """
        Returns:
            Union[str, None]: Current task name.
        """

        return self.get_current_context().get("task_name")

    def get_current_context(self):
        context = get_current_workfile_context()
        if not context:
            return get_global_context()

        return context

    def get_current_workfile(self):
        return os.environ["CURRENT_SPM"]

    def workfile_has_unsaved_changes(self):
        # Pop-up dialog would be located to ask if users
        # save scene if it has unsaved changes
        return True

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

    def open_workfile(self, filepath):
        os.environ["CURRENT_SPM"] = filepath
        load_spm_file(filepath)
        return filepath

    def save_workfile(self, filepath=None):
        with save_scene("Work Files"):
            context = open_workfile()
            filepath = save_workfile(filepath, context)
        print(f"Saving Spm file: {filepath}")
        copy_ayon_data(filepath)
        load_spm_file(filepath)
        return filepath

    def list_instances(self):
        """Get all AYON instances."""
        # Figure out how to deal with this
        return get_instance_workfile_metadata()

    def write_instances(self, data):
        """Write all AYON instances"""
        return write_workfile_metadata(SPTREE_SECTION_NAME_INSTANCES, data)

    def get_containers(self):
        """Get the data of the containers

        Returns:
            list: the list which stores the data of the containers
        """
        return get_containers()

    def initial_app_launch(self):
        """Triggers on launch of the communication server for Speedtree.

        Usually this aligns roughly with the start of Speedtree.
        """
        context = get_global_context()
        save_current_workfile_context(context)
        # Initialize the SpeedTree system
        SpeedTree.StpInit()

    def application_exit(self):
        """Event action when the application exit
        """
        remove_tmp_data()
        SpeedTree.StpShutDown()

    def update_context_data(self, data, changes):
        return write_workfile_metadata(SPTREE_METADATA_CREATE_CONTEXT, data)

    def get_context_data(self):
        get_load_workfile_metadata(SPTREE_METADATA_CREATE_CONTEXT)