_mapper

class WorkflowNodeMapper(taskflow.task.Task):
    """ Add ayon-workflow on the top of taskflow task to validate signatures.
    """

    # The version of the node. Used to determine
    # compatibility with previously saved workflows.
    version: str = ""

    # The name of the node (inherited from class name)
    name: Optional[str] = None

    # The input(s) of the node.
    inputs: list[InputAttribute] = []

    # The output(s) of the node.
    outputs: list[OutputAttribute] = []

    def __init__(
        self,
        name: Optional[str] = None,
        provides: Optional[list[str]] = None,
        inject: Optional[dict[str, Any]] = None,
        rebind: Optional[dict[str, str]] = None,
    ):
        super().__init__(
            name=name,
            provides=provides,
            inject=inject,
            rebind=rebind,
        )
        self.pre_revert_tasks = []

    def revert(self, result, *args, **kwargs) -> list[Any]:
        """https://docs.openstack.org/taskflow/latest/user/atoms.html#taskflow.atom.Atom.revert
        """
        # Pre-revert mechanism, call execute function for
        # nodes connected to the 'revert' output slot.
        revert_results = []
        for pre_revert_task in self.pre_revert_tasks:
            rev_inputs = [
                key for key, value
                in pre_revert_task.rebind.items()
                if value == f"result.{self.name}"
            ]
            pre_kwargs = {
                rev_input: result
                for rev_input in rev_inputs
            }
            revert_results.append(
                pre_revert_task.execute(**pre_kwargs)
            )

            revert_exec = self.revert_execute(*args, **kwargs)
            revert_results.append(revert_exec)

        return revert_results

    @classmethod
    def to_workflow_node(cls) -> WorkflowNode:
        """ Converts the node class to a plugin description dictionary.
        """
        if not cls.version or cls.version.count(".") < 2:
            raise ValueError(
                f"Plugin version '{cls.version}' does not match format "
                "(e.g., '1.0.0')."
            )

        # Validate explicit inputs
        inputs = []
        input_names = []
        execute_insp = inspect.signature(cls.execute)
        for insp_data in cls.inputs:
            inp = insp_data.name
            if inp not in execute_insp.parameters:
                raise ValueError(
                    f"Input {inp} not found in execute signature"
                )

            edited_insp_data = copy.deepcopy(insp_data)
            edited_insp_data.type = execute_insp.parameters[inp].annotation
            edited_insp_data.default = execute_insp.parameters[inp].default

            input_names.append(inp)
            inputs.append(edited_insp_data)

        # Detect missing input
        for inp, inp_data in execute_insp.parameters.items():
            if inp == "self" or inp_data.kind in (
                inspect.Parameter.VAR_POSITIONAL,
                inspect.Parameter.VAR_KEYWORD,
            ):
                continue
            if (
                inp not in input_names
                and inp_data.default is inspect.Parameter.empty
            ):
                raise ValueError(
                    f"{inp} in execute signature with no "
                    "default value but not defined in node inputs"
                )

        # Validate outputs
        out_insp = inspect.signature(cls.execute).return_annotation
        if (
            out_insp is inspect.Signature.empty
            and len(cls.outputs) > 0
        ):
            raise TypeError(
                "Cannot determine output(s) return type "
                "from execute method"
            )

        # Multiple outputs
        out_origin = typing.get_origin(out_insp)
        out_args = typing.get_args(out_insp)

        if (
            not out_args
            and len(cls.outputs) > 1
        ):
            raise TypeError(
                "Multiple output defined, "
                "but only one is return annotation"
            )

        outputs = []
        for idx, out_data in enumerate(cls.outputs):
            edited_out_data = copy.deepcopy(out_data)
            out_type = typing.Any

            if len(cls.outputs) == 1:
                out_type = out_insp
            elif out_origin is tuple and idx < len(out_args):
                out_type = out_args[idx]
            elif out_origin is dict and len(out_args) == 2:
                out_type = out_args[1]

            edited_out_data.type = out_type
            outputs.append(edited_out_data)

        return WorkflowNode(
            name=cls.name or cls.__name__,
            version=cls.version,
            inputs=inputs,
            outputs=outputs,
            description=cls.__doc__ or "",
            implementation=cls,
        )

class WorkflowTaskNode(WorkflowNodeMapper):
    """ Base class for workflow node that executes a task.
    """
    # Put the description of the node as class docstring.

    # The version of the node. Used to determine
    # compatibility with previously saved workflows.
    version: str = ""

    # The name of the node (inherited from class name)
    name: Optional[str] = None

    # The input(s) of the node.
    inputs: list[InputAttribute] = []

    # The output(s) of the node.
    outputs: list[OutputAttribute] = []

    def execute(self, *args, **kwargs) -> Any:
        """ Define the execution logic of the node.
        """
        raise NotImplementedError("Must be implemented by subclass.")

    def revert_execute(self, *args, **kwargs) -> Any:
        """ Define the revert logic of the node.
        """
        pass