api

class BlenderCreator(Creator):
    """Base class for Blender Creator plug-ins."""
    skip_instances = False
    settings_category = "blender"
    create_as_asset_group = False

    @staticmethod
    def cache_instance_data(shared_data):
        """Cache instances for Creators shared data.

        Create `blender_cached_instances` key when needed in shared data and
        fill it with all collected instances from the scene under its
        respective creator identifiers.

        If legacy instances are detected in the scene, create
        `blender_cached_legacy_instances` key and fill it with
        all legacy products from this family as a value.  # key or value?

        Args:
            shared_data(Dict[str, Any]): Shared data.

        """
        if "blender_cached_instances" not in shared_data:
            cache = {}
            cache_legacy = {}
            convert_avalon_instances()
            ayon_instances = bpy.data.collections.get(AYON_INSTANCES)
            ayon_instance_objs = (
                ayon_instances.objects if ayon_instances else []
            )

            # Consider any node tree objects as well
            node_tree_objects = []
            node_tree = get_scene_node_tree()
            if node_tree:
                node_tree_objects = node_tree.nodes

            for obj_or_col in itertools.chain(
                    ayon_instance_objs,
                    bpy.data.collections,
                    node_tree_objects
            ):
                ayon_prop = get_ayon_property(obj_or_col)
                if not ayon_prop:
                    continue

                if ayon_prop.get('id') not in {
                    AYON_INSTANCE_ID, AVALON_INSTANCE_ID
                }:
                    continue

                creator_id = ayon_prop.get("creator_identifier")
                if creator_id and "openpype" in creator_id:
                    creator_id = creator_id.replace("openpype", "ayon")
                    ayon_prop["creator_identifier"] = creator_id

                if creator_id:
                    # Creator instance
                    cache.setdefault(creator_id, []).append(obj_or_col)
                else:
                    # Legacy creator instance
                    family = ayon_prop.get('family')
                    cache_legacy.setdefault(family, []).append(obj_or_col)

            shared_data["blender_cached_instances"] = cache
            shared_data["blender_cached_legacy_instances"] = cache_legacy
        return shared_data

    def create(
        self, product_name: str, instance_data: dict, pre_create_data: dict
    ):
        """Override abstract method from Creator.
        Create new instance and store it.

        Args:
            product_name (str): Product name of created instance.
            instance_data (dict): Instance base data.
            pre_create_data (dict): Data based on pre creation attributes.
                Those may affect how creator works.
        """
        # Get Instance Container or create it if it does not exist
        ayon_instances = self._ensure_ayon_instances_collection()

        # Create asset group
        folder_name = instance_data["folderPath"].split("/")[-1]

        name = prepare_scene_name(folder_name, product_name)
        if self.create_as_asset_group:
            # Create instance as empty
            instance_node = bpy.data.objects.new(name=name, object_data=None)
            instance_node.empty_display_type = 'SINGLE_ARROW'
            ayon_instances.objects.link(instance_node)
        else:
            # Create instance collection
            instance_node = bpy.data.collections.new(name=name)
            ayon_instances.children.link(instance_node)

        self.set_instance_data(product_name, instance_data)

        # Mimic families override like `self.read` does
        instance_data["families"] = self.get_publish_families()
        product_type = instance_data.get("productType")
        if not product_type:
            product_type = self.product_base_type
        instance = CreatedInstance(
            product_base_type=self.product_base_type,
            product_type=product_type,
            product_name=product_name,
            data=instance_data,
            creator=self,
            transient_data={"instance_node": instance_node}
        )
        self._add_instance_to_context(instance)

        self.imprint(instance_node, instance_data)

        return instance_node

    def collect_instances(self):
        """Override abstract method from BlenderCreator.
        Collect existing instances related to this creator plugin."""

        # Cache instances in shared data
        self.cache_instance_data(self.collection_shared_data)

        # Get cached instances
        cached_instances = self.collection_shared_data.get(
            "blender_cached_instances"
        )
        if not cached_instances:
            return

        # Process only instances that were created by this creator
        for instance_node in cached_instances.get(self.identifier, []):
            instance_data = self.read(instance_node)

            # Create instance object from existing data
            instance = CreatedInstance.from_existing(
                instance_data=instance_data,
                creator=self,
                transient_data={"instance_node": instance_node}
            )

            # Add instance to create context
            self._add_instance_to_context(instance)

    def update_instances(self, update_list):
        """Override abstract method from BlenderCreator.
        Store changes of existing instances so they can be recollected.

        Args:
            update_list(List[UpdateData]): Changed instances
                and their changes, as a list of tuples.
        """

        for created_instance, changes in update_list:
            data = created_instance.data_to_store()
            node = created_instance.transient_data["instance_node"]
            if not node:
                # We can't update if we don't know the node
                self.log.error(
                    f"Unable to update instance {created_instance} "
                    f"without instance node."
                )
                continue

            # Rename the instance node in the scene if product
            #   or folder changed.
            # Do not rename the instance if the family is workfile, as the
            # workfile instance is included in the AYON_CONTAINER collection.
            if (
                "productName" in changes.changed_keys
                or "folderPath" in changes.changed_keys
            ) and created_instance.product_base_type != "workfile":
                folder_name = data["folderPath"].split("/")[-1]
                name = prepare_scene_name(
                    folder_name, data["productName"]
                )
                node.name = name

            self.imprint(node, data)

    def remove_instances(self, instances: List[CreatedInstance]):
        for instance in instances:
            node = instance.transient_data["instance_node"]

            # Remove collection node and its children
            if isinstance(node, bpy.types.Collection):
                # Keep child collections in the scene if only used by the
                # instance collection
                scene_collection = bpy.context.scene.collection
                for child in node.children:
                    if child.users - int(child.use_fake_user) == 1:
                        scene_collection.children.link(child)
                # Keep directly linked objects in the scene
                for obj in node.objects:
                    if len(obj.users_collection) == 1:
                        if obj.name not in bpy.context.scene.collection.objects:
                            bpy.context.scene.collection.objects.link(obj)

                bpy.data.collections.remove(node)

            # Remove object node
            elif isinstance(node, bpy.types.Object):
                bpy.data.objects.remove(node)

            # Remove compositor node
            elif isinstance(node, bpy.types.CompositorNode):
                node_tree = get_scene_node_tree()
                node_tree.nodes.remove(node)

            self._remove_instance_from_context(instance)

    def set_instance_data(
        self,
        product_name: str,
        instance_data: dict
    ):
        """Fill instance data with required items.

        Args:
            product_name (str): Product name of created instance.
            instance_data (dict): Instance base data.
            instance_node (bpy.types.ID): Instance node in blender scene.
        """
        if not instance_data:
            instance_data = {}

        instance_data.update(
            {
                "id": AYON_INSTANCE_ID,
                "creator_identifier": self.identifier,
                "productName": product_name,
            }
        )

    def _ensure_ayon_instances_collection(self) -> bpy.types.Collection:
        """Create AYON Instances collections that contains created instances.

        Returns:
            bpy.types.Collection: AYON Instances collection
        """
        node = bpy.data.collections.get(AYON_INSTANCES)
        if node:
            # Already exists, return it
            return node

        node = bpy.data.collections.new(AYON_INSTANCES)
        node.color_tag = "COLOR_04"
        node.use_fake_user = True
        bpy.context.scene.collection.children.link(node)
        return node

    def get_pre_create_attr_defs(self):
        return [
            BoolDef("use_selection",
                    label="Use selection",
                    default=True)
        ]

    def imprint(self, node, data: dict):
        """Imprint data to the instance node.

        This can be overridden by a sub-class to store certain data of the
        instance in a different way, e.g. in a custom property or the 'mute'
        state of a node.
        """
        data.pop("families", None)
        imprint(node, data)

    def read(self, node) -> dict:
        """Read data from the instance node.

        The `data` dictionary is the readily stored
        """
        ayon_property = node.get(AYON_PROPERTY)
        if not ayon_property:
            return {}

        data = ayon_property.to_dict()
        data["families"] = self.get_publish_families()
        return data

    def get_publish_families(self) -> list[str]:
        return [self.product_base_type]

class BlenderHost(HostBase, IWorkfileHost, IPublishHost, ILoadHost):
    name = "blender"

    def get_app_information(self):
        from ayon_core.host import ApplicationInformation

        return ApplicationInformation(
            app_name="Blender",
            app_version=bpy.app.version_string,
        )

    def install(self):
        """Override install method from HostBase.
        Install Blender host functionality."""
        install()

    def get_containers(self) -> Iterator:
        """List containers from active Blender scene."""
        return ls()

    def get_workfile_extensions(self) -> List[str]:
        """Override get_workfile_extensions method from IWorkfileHost.
        Get workfile possible extensions.

        Returns:
            List[str]: Workfile extensions.
        """
        return file_extensions()

    def save_workfile(self, dst_path: str = None):
        """Override save_workfile method from IWorkfileHost.
        Save currently opened workfile.

        Args:
            dst_path (str): Where the current scene should be saved. Or use
                current path if `None` is passed.
        """
        save_file(dst_path if dst_path else bpy.data.filepath)

    def open_workfile(self, filepath: str):
        """Override open_workfile method from IWorkfileHost.
        Open workfile at specified filepath in the host.

        Args:
            filepath (str): Path to workfile.
        """
        open_file(filepath)

    def get_current_workfile(self) -> str:
        """Override get_current_workfile method from IWorkfileHost.
        Retrieve currently opened workfile path.

        Returns:
            str: Path to currently opened workfile.
        """
        return current_file()

    def workfile_has_unsaved_changes(self) -> bool:
        """Override wokfile_has_unsaved_changes method from IWorkfileHost.
        Returns True if opened workfile has no unsaved changes.

        Returns:
            bool: True if scene is saved and False if it has unsaved
                modifications.
        """
        return has_unsaved_changes()

    def work_root(self, session) -> str:
        """Override work_root method from IWorkfileHost.
        Modify workdir per host.

        Args:
            session (dict): Session context data.

        Returns:
            str: Path to new workdir.
        """
        return work_root(session)

    def get_context_data(self) -> dict:
        """Override abstract method from IPublishHost.
        Get global data related to creation-publishing from workfile.

        Returns:
            dict: Context data stored using 'update_context_data'.
        """
        property = bpy.context.scene.get(AYON_PROPERTY)
        if property:
            return property.to_dict()
        return {}

    def update_context_data(self, data: dict, changes: dict):
        """Override abstract method from IPublishHost.
        Store global context data to workfile.

        Args:
            data (dict): New data as are.
            changes (dict): Only data that has been changed. Each value has
                tuple with '(<old>, <new>)' value.
        """
        bpy.context.scene[AYON_PROPERTY] = data