class RegistryManager:
    """
    A class to manage multiple named registries.
    NOTE: Ensure that the register decorator is the outermost decorator!
    """

    _registries: dict[str, dict[str, Callable]] = {}
    _registers: dict[str, Callable] = {}

    @staticmethod
    def create_registry(name: str) -> tuple[Callable, dict[str, Callable]]:
        """
        Create a new named registry.
        NOTE: The register decorator returned must be the outermost decorator as it might not work correctly.

        Args:
            name (str): A unique name for the registry.

        Returns:
            tuple: A tuple containing the decorator function and the registry dictionary

        Raises:
            ValueError: If a registry with the given name already exists.
        """
        if name in RegistryManager._registries:
            raise ValueError(f"Registry '{name}' already exists")

        registry = {}

        # TODO (@legendof-selda): Find a way to check if the decorator used is the outermost decorator
        def register(node: Callable, rename: str | None = None) -> Callable:
            """
            Decorator function to register functions in the registry.

            Args:
                node (Callable): Node function to be registered.
                rename (str | None): Rename the given node. Defaults to None.

            Returns:
                Callable: The original function

            Raises:
                KeyError: If a function with the same name already exists in the registry.
            """
            key = rename or node.__name__

            if key in registry:
                raise KeyError(f"Key '{key}' already exists in registry '{name}'")

            if not is_outermost_decorator(node):
                logger.warning(f"@register is not the outermost decorator for func `{key}`. This can lead to issues.")

            registry[key] = node

            return node

        register.registry = registry
        RegistryManager._registries[name] = registry
        RegistryManager._registers[name] = register

        return register, registry

    @staticmethod
    def get_registry(name: str) -> dict[str, Callable]:
        """
        Retrieve a specific registry by name.

        Args:
            name (str): The name of the registry to retrieve.

        Returns:
            dict: The registry dictionary.

        Raises:
            KeyError: If the registry does not exist.
        """
        return RegistryManager._registries[name]

    @staticmethod
    def get_registrar(name: str) -> Callable:
        """
        Retrieve a specific register decorator by name.

        Args:
            name (str): The name of the register decorator to retrieve.

        Returns:
            dict: The register decorator.

        Raises:
            KeyError: If the register decorator does not exist.
        """
        return RegistryManager._registers[name]

    @staticmethod
    def list_registries() -> list[str]:
        """
        List all existing registry names.

        Returns:
            list: Names of all created registries.
        """
        return list(RegistryManager._registries.keys())