plugin

class MaxCacheCreator(Creator, MaxTyFlowDataCreatorBase):
    skip_discovery = True
    settings_category = "max"

    def create(self, product_name, instance_data, pre_create_data):
        tyflow_op_nodes = get_tyflow_export_operators()
        if not tyflow_op_nodes:
            raise CreatorError("No Export Particle Operators"
                               " found in tyCache Editor.")
        instance_node = self.create_instance_node(product_name)
        instance_data["instance_node"] = instance_node.name
        product_type = instance_data.get("productType")
        if not product_type:
            product_type = self.product_base_type
        instance = CreatedInstance(
            product_type=product_type,
            product_base_type=self.product_base_type,
            product_name=product_name,
            data=instance_data,
            creator=self,
        )
        # Setting the property
        node_list = [sub_anim.name for sub_anim in tyflow_op_nodes]
        rt.setProperty(
            instance_node.modifiers[0].AYONTyCacheData,
            "tyc_handles", node_list)
        self._add_instance_to_context(instance)
        imprint(instance_node.name, instance.data_to_store())

        return instance

    def collect_instances(self):
        self.cache_instance_data(self.collection_shared_data)
        for instance in self.collection_shared_data["max_cached_instances"].get(self.identifier, []):  # noqa
            created_instance = CreatedInstance.from_existing(
                read(rt.GetNodeByName(instance)), self
            )
            self._add_instance_to_context(created_instance)

    def update_instances(self, update_list):
        for created_inst, changes in update_list:
            instance_node = created_inst.get("instance_node")
            new_values = {
                key: changes[key].new_value
                for key in changes.changed_keys
            }
            product_name = new_values.get("productName", "")
            if product_name and instance_node != product_name:
                node = rt.getNodeByName(instance_node)
                new_product_name = new_values["productName"]
                if rt.getNodeByName(new_product_name):
                    raise CreatorError(
                        "The product '{}' already exists.".format(
                            new_product_name))
                instance_node = new_product_name
                created_inst["instance_node"] = instance_node
                node.name = instance_node

            imprint(
                instance_node,
                created_inst.data_to_store(),
            )

    def remove_instances(self, instances):
        """Remove specified instance from the scene.

        This is only removing AYON-related parameters based on the modifier
        so instance is no longer instance, because it might contain
        valuable data for artist.

        """
        for instance in instances:
            instance_node = rt.GetNodeByName(
                instance.data.get("instance_node"))
            if instance_node:
                count = rt.custAttributes.count(instance_node.modifiers[0])
                rt.custAttributes.delete(instance_node.modifiers[0], count)
                rt.Delete(instance_node)

            self._remove_instance_from_context(instance)

class MaxCreator(Creator, MaxCreatorBase):
    skip_discovery = True
    settings_category = "max"
    selected_nodes = []

    def create(self, product_name, instance_data, pre_create_data):
        if pre_create_data.get("use_selection"):
            self.selected_nodes = rt.GetCurrentSelection()
        if rt.getNodeByName(product_name):
            raise CreatorError(f"'{product_name}' is already created..")

        instance_node = self.create_instance_node(product_name)
        instance_data["instance_node"] = instance_node.name
        product_type = instance_data.get("productType")
        if not product_type:
            product_type = self.product_base_type
        instance = CreatedInstance(
            product_type=product_type,
            product_base_type=self.product_base_type,
            product_name=product_name,
            data=instance_data,
            creator=self,
        )
        if pre_create_data.get("use_selection"):

            node_list = []
            sel_list = []
            for i in self.selected_nodes:
                node_ref = rt.NodeTransformMonitor(node=i)
                node_list.append(node_ref)
                sel_list.append(str(i))

            # Setting the property
            rt.setProperty(
                instance_node.modifiers[0].AYONData,
                "all_handles", node_list)
            rt.setProperty(
                instance_node.modifiers[0].AYONData,
                "sel_list", sel_list)

        self._add_instance_to_context(instance)
        imprint(instance_node.name, instance.data_to_store())

        return instance

    def collect_instances(self):
        self.cache_instance_data(self.collection_shared_data)
        for instance in self.collection_shared_data["max_cached_instances"].get(self.identifier, []):  # noqa
            created_instance = CreatedInstance.from_existing(
                read(rt.GetNodeByName(instance)), self
            )
            self._add_instance_to_context(created_instance)

    def update_instances(self, update_list):
        for created_inst, changes in update_list:
            instance_node = created_inst.get("instance_node")
            new_values = {
                key: changes[key].new_value
                for key in changes.changed_keys
            }
            product_name = new_values.get("productName", "")
            if product_name and instance_node != product_name:
                node = rt.getNodeByName(instance_node)
                new_product_name = new_values["productName"]
                if rt.getNodeByName(new_product_name):
                    raise CreatorError(
                        "The product '{}' already exists.".format(
                            new_product_name))
                instance_node = new_product_name
                created_inst["instance_node"] = instance_node
                node.name = instance_node

            imprint(
                instance_node,
                created_inst.data_to_store(),
            )

    def remove_instances(self, instances):
        """Remove specified instance from the scene.

        This is only removing `id` parameter so instance is no longer
        instance, because it might contain valuable data for artist.

        """
        for instance in instances:
            instance_node = rt.GetNodeByName(
                instance.data.get("instance_node"))
            if instance_node:
                count = rt.custAttributes.count(instance_node.modifiers[0])
                rt.custAttributes.delete(instance_node.modifiers[0], count)
                rt.Delete(instance_node)

            self._remove_instance_from_context(instance)

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

class MaxCreatorBase(object):

    @staticmethod
    def cache_instance_data(shared_data):
        if shared_data.get("max_cached_instances") is not None:
            return shared_data

        shared_data["max_cached_instances"] = {}
        shared_data["max_cached_legacy_instances"] = {}

        cached_instances = []
        for id_type in [AYON_INSTANCE_ID, AVALON_INSTANCE_ID]:
            cached_instances.extend(lsattr("id", id_type))

        for i in cached_instances:
            creator_id = rt.GetUserProp(i, "creator_identifier")
            if "openpype" in creator_id:
                # Legacy creator instance
                shared_data["max_cached_legacy_instances"].setdefault(
                    creator_id, []).append(i.name)
            else:
                shared_data["max_cached_instances"].setdefault(
                    creator_id, []).append(i.name)

        return shared_data

    @staticmethod
    def create_instance_node(node):
        """Create instance node.

        If the supplied node is existing node, it will be used to hold the
        instance, otherwise new node of type Dummy will be created.

        Args:
            node (rt.MXSWrapperBase, str): Node or node name to use.

        Returns:
            instance
        """
        if not isinstance(node, str):
            raise CreatorError("Instance node is not at the string value.")

        node = rt.Container(name=node)
        attrs = rt.Execute(MS_CUSTOM_ATTRIB)
        modifier = rt.EmptyModifier()
        rt.addModifier(node, modifier)
        node.modifiers[0].name = "AYON Data"
        rt.custAttributes.add(node.modifiers[0], attrs)

        return node

class MaxTyFlowDataCreatorBase(MaxCreatorBase):
    @staticmethod
    def create_instance_node(node):
        """Create instance node.

        If the supplied node is existing node, it will be used to hold the
        instance, otherwise new node of type Dummy will be created.

        Args:
            node (rt.MXSWrapperBase, str): Node or node name to use.

        Returns:
            instance
        """
        if not isinstance(node, str):
            raise CreatorError("Instance node is not at the string value.")
        node = rt.Container(name=node)
        attrs = rt.Execute(MS_TYCACHE_ATTRIB)
        modifier = rt.EmptyModifier()
        rt.addModifier(node, modifier)
        node.modifiers[0].name = "AYON TyCache Data"
        rt.custAttributes.add(node.modifiers[0], attrs)

        return node