import contextlib
import dataclasses
import inspect
import os.path
from collections.abc import Mapping, Sequence, Iterator, KeysView, Callable
from importlib.resources.abc import Traversable
from io import BytesIO
from pathlib import Path
from typing import (
    cast,
    TYPE_CHECKING,
)

from debian.deb822 import Deb822
from debian.debian_support import DpkgArchTable
from debian.substvars import Substvars

from debputy.architecture_support import DpkgArchitectureBuildProcessValuesTable
from debputy.filesystem_scan import OSFSROOverlay, InMemoryVirtualRootDir
from debputy.packages import BinaryPackage, SourcePackage
from debputy.plugin.api import (
    PluginInitializationEntryPoint,
    VirtualPath,
    PackageProcessingContext,
    DpkgTriggerType,
    Maintscript,
)
from debputy.plugin.api.example_processing import process_discard_rule_example
from debputy.plugin.api.feature_set import PluginProvidedFeatureSet
from debputy.plugin.api.impl import (
    plugin_metadata_for_debputys_own_plugin,
    DebputyPluginInitializerProvider,
    parse_json_plugin_desc,
    MaintscriptAccessorProviderBase,
    BinaryCtrlAccessorProviderBase,
    PLUGIN_TEST_SUFFIX,
    find_json_plugin,
    ServiceDefinitionImpl,
)
from debputy.plugin.api.impl_types import (
    PackagerProvidedFileClassSpec,
    DebputyPluginMetadata,
    PluginProvidedTrigger,
    ServiceManagerDetails,
)
from debputy.plugin.api.spec import (
    MaintscriptAccessor,
    FlushableSubstvars,
    ServiceRegistry,
    DSD,
    ServiceUpgradeRule,
)
from debputy.plugin.api.test_api.test_spec import (
    InitializedPluginUnderTest,
    RegisteredPackagerProvidedFile,
    RegisteredTrigger,
    RegisteredMaintscript,
    DEBPUTY_TEST_AGAINST_INSTALLED_PLUGINS,
    ADRExampleIssue,
    DetectedService,
    RegisteredMetadata,
)
from debputy.plugins.debputy.debputy_plugin import initialize_debputy_features
from debputy.substitution import SubstitutionImpl, VariableContext, Substitution
from debputy.util import package_cross_check_precheck
from debputy.version import DEBPUTY_PLUGIN_ROOT_DIR

RegisteredPackagerProvidedFile.register(PackagerProvidedFileClassSpec)


type ManifestConfigurationImplementation[T] = Callable[
    [SourcePackage | BinaryPackage, type[T]], T
]


@dataclasses.dataclass(frozen=True, slots=True)
class PackageProcessingContextTestProvider(PackageProcessingContext):
    source_package: SourcePackage
    binary_package: BinaryPackage
    binary_package_version: str
    related_udeb_package: BinaryPackage | None
    related_udeb_package_version: str | None
    accessible_package_roots: Callable[[], Sequence[tuple[BinaryPackage, VirtualPath]]]
    manifest_configuration: ManifestConfigurationImplementation

    # TODO: implement (when needed)
    # dpkg_arch_query_table
    # deb_options_and_profiles (pull from binary ?)
    # source_condition_context
    # condition_context


def _initialize_plugin_under_test(
    plugin_metadata: DebputyPluginMetadata,
    load_debputy_plugin: bool = True,
) -> "InitializedPluginUnderTest":
    feature_set = PluginProvidedFeatureSet()
    substitution = SubstitutionImpl(
        unresolvable_substitutions=frozenset(["SOURCE_DATE_EPOCH", "PACKAGE"]),
        variable_context=VariableContext(
            OSFSROOverlay.create_root_dir("debian", "debian"),
        ),
        plugin_feature_set=feature_set,
    )

    if load_debputy_plugin:
        debputy_plugin_metadata = plugin_metadata_for_debputys_own_plugin(
            initialize_debputy_features
        )
        # Load debputy's own plugin first, so conflicts with debputy's plugin are detected early
        debputy_provider = DebputyPluginInitializerProvider(
            debputy_plugin_metadata,
            feature_set,
            substitution,
        )
        debputy_provider.load_plugin()

    plugin_under_test_provider = DebputyPluginInitializerProvider(
        plugin_metadata,
        feature_set,
        substitution,
    )
    plugin_under_test_provider.load_plugin()

    return InitializedPluginUnderTestImpl(
        plugin_metadata.plugin_name,
        feature_set,
        substitution,
    )


def _auto_load_plugin_from_filename(
    py_test_filename: str,
) -> "InitializedPluginUnderTest":
    dirname, basename = os.path.split(py_test_filename)
    plugin_name = PLUGIN_TEST_SUFFIX.sub("", basename).replace("_", "-")

    test_location = os.environ.get("DEBPUTY_TEST_PLUGIN_LOCATION", "uninstalled")
    if test_location == "uninstalled":
        json_basename = f"{plugin_name}.json"
        json_desc_file = os.path.join(dirname, json_basename)
        if "/" not in json_desc_file:
            json_desc_file = f"./{json_desc_file}"

        if os.path.isfile(json_desc_file):
            return _initialize_plugin_from_desc(json_desc_file)

        json_desc_file_in = f"{json_desc_file}.in"
        if os.path.isfile(json_desc_file_in):
            return _initialize_plugin_from_desc(json_desc_file)
        raise FileNotFoundError(
            f"Cannot determine the plugin JSON metadata descriptor: Expected it to be"
            f" {json_desc_file} or {json_desc_file_in}"
        )

    if test_location == "installed":
        plugin_metadata = find_json_plugin([str(DEBPUTY_PLUGIN_ROOT_DIR)], plugin_name)
        return _initialize_plugin_under_test(plugin_metadata, load_debputy_plugin=True)

    raise ValueError(
        'Invalid or unsupported "DEBPUTY_TEST_PLUGIN_LOCATION" environment variable. It must be either'
        ' unset OR one of "installed", "uninstalled".'
    )


def initialize_plugin_under_test(
    *,
    plugin_desc_file: str | None = None,
) -> "InitializedPluginUnderTest":
    """Load and initialize a plugin for testing it

    This method will load the plugin via plugin description, which is the method that `debputy` does at
     run-time (in contrast to `initialize_plugin_under_test_preloaded`, which bypasses this concrete part
     of the flow).

    :param plugin_desc_file: The plugin description file (`.json`) that describes how to load the plugin.
      If omitted, `debputy` will attempt to attempt the plugin description file based on the test itself.
      This works for "single-file" plugins, where the description file and the test are right next to
      each other.
    :return: The loaded plugin for testing
    """
    if plugin_desc_file is None:
        caller_file = inspect.stack()[1].filename
        return _auto_load_plugin_from_filename(caller_file)
    if DEBPUTY_TEST_AGAINST_INSTALLED_PLUGINS:
        raise RuntimeError(
            "Running the test against an installed plugin does not work when"
            " plugin_desc_file is provided. Please skip this test. You can "
            " import DEBPUTY_TEST_AGAINST_INSTALLED_PLUGINS and use that as"
            " conditional for this purpose."
        )
    return _initialize_plugin_from_desc(plugin_desc_file)


def _initialize_plugin_from_desc(
    desc_file: str,
) -> "InitializedPluginUnderTest":
    if not desc_file.endswith((".json", ".json.in")):
        raise ValueError("The plugin file must end with .json or .json.in")

    plugin_metadata = parse_json_plugin_desc(desc_file)

    return _initialize_plugin_under_test(plugin_metadata, load_debputy_plugin=True)


def initialize_plugin_under_test_from_inline_json(
    plugin_name: str,
    json_content: str,
) -> "InitializedPluginUnderTest":
    with BytesIO(json_content.encode("utf-8")) as fd:
        plugin_metadata = parse_json_plugin_desc(plugin_name, fd=fd)

    return _initialize_plugin_under_test(plugin_metadata, load_debputy_plugin=True)


def initialize_plugin_under_test_preloaded(
    api_compat_version: int,
    plugin_initializer: PluginInitializationEntryPoint,
    /,
    plugin_name: str = "plugin-under-test",
    load_debputy_plugin: bool = True,
    plugin_doc_path_resolver: Callable[[], Traversable | Path | None] = lambda: None,
) -> "InitializedPluginUnderTest":
    """Internal API: Initialize a plugin for testing without loading it from a file

    This method by-passes the standard loading mechanism, meaning you will not test that your plugin
    description file is correct. Notably, any feature provided via the JSON description file will
    **NOT** be visible for the test.

    This API is mostly useful for testing parts of debputy itself.

    :param api_compat_version: The API version the plugin was written for. Use the same version as the
      version from the entry point (The `v1` part of `debputy.plugins.v1.initialize` translate into `1`).
    :param plugin_initializer: The entry point of the plugin
    :param plugin_name: Normally, debputy would derive this from the entry point. In the test, it will
      use a test name and version. However, you can explicitly set if you want the real name/version.
    :param load_debputy_plugin: Whether to load debputy's own plugin first. Doing so provides a more
      realistic test and enables the test to detect conflicts with debputy's own plugins (de facto making
      the plugin unloadable in practice if such a conflict is present).  This option is mostly provided
      to enable debputy to use this method for self testing.
    :param plugin_doc_path_resolver: How to resolve the documentation (if relevant for the test). The
      default is to not load the documentation.
    :return: The loaded plugin for testing
    """

    if DEBPUTY_TEST_AGAINST_INSTALLED_PLUGINS:
        raise RuntimeError(
            "Running the test against an installed plugin does not work when"
            " the plugin is preload. Please skip this test. You can "
            " import DEBPUTY_TEST_AGAINST_INSTALLED_PLUGINS and use that as"
            " conditional for this purpose."
        )

    plugin_metadata = DebputyPluginMetadata(
        plugin_name=plugin_name,
        api_compat_version=api_compat_version,
        plugin_initializer=plugin_initializer,
        plugin_loader=None,
        plugin_path="<loaded-via-test>",
        plugin_doc_path_resolver=plugin_doc_path_resolver,
    )

    return _initialize_plugin_under_test(
        plugin_metadata,
        load_debputy_plugin=load_debputy_plugin,
    )


class _MockArchTable:
    @staticmethod
    def matches_architecture(_a: str, _b: str) -> bool:
        return True


FAKE_DPKG_QUERY_TABLE = cast(DpkgArchTable, _MockArchTable())
del _MockArchTable


def package_metadata_context(
    *,
    host_arch: str = "amd64",
    package_fields: dict[str, str] | None = None,
    related_udeb_package_fields: dict[str, str] | None = None,
    binary_package_version: str = "1.0-1",
    related_udeb_package_version: str | None = None,
    should_be_acted_on: bool = True,
    related_udeb_fs_root: VirtualPath | None = None,
    accessible_package_roots: Sequence[tuple[Mapping[str, str], VirtualPath]] = tuple(),
    source_package_fields: dict[str, str] | None = None,
    manifest_configuration: ManifestConfigurationImplementation = lambda x, y: None,
) -> PackageProcessingContext:
    process_table = DpkgArchitectureBuildProcessValuesTable(fake_host=host_arch)
    f = {
        "Package": "foo",
        "Architecture": "any",
    }
    if package_fields is not None:
        f.update(package_fields)

    bin_package = BinaryPackage(
        Deb822(f),
        process_table,
        FAKE_DPKG_QUERY_TABLE,
        is_main_package=True,
        should_be_acted_on=should_be_acted_on,
    )
    udeb_package = None
    s = {
        "Source": bin_package.name,
    }
    if source_package_fields is not None:
        s.update(source_package_fields)
    source_package = SourcePackage(Deb822(s))
    if related_udeb_package_fields is not None:
        uf = dict(related_udeb_package_fields)
        uf.setdefault("Package", f'{f["Package"]}-udeb')
        uf.setdefault("Architecture", f["Architecture"])
        uf.setdefault("Package-Type", "udeb")
        udeb_package = BinaryPackage(
            Deb822(uf),
            process_table,
            FAKE_DPKG_QUERY_TABLE,
            is_main_package=False,
            should_be_acted_on=True,
        )
        if related_udeb_package_version is None:
            related_udeb_package_version = binary_package_version
    if accessible_package_roots:
        apr = []
        for fields, apr_fs_root in accessible_package_roots:
            apr_fields = Deb822(dict(fields))
            if "Package" not in apr_fields:
                raise ValueError(
                    "Missing mandatory Package field in member of accessible_package_roots"
                )
            if "Architecture" not in apr_fields:
                raise ValueError(
                    "Missing mandatory Architecture field in member of accessible_package_roots"
                )
            apr_package = BinaryPackage(
                apr_fields,
                process_table,
                FAKE_DPKG_QUERY_TABLE,
                is_main_package=False,
                should_be_acted_on=True,
            )
            r = package_cross_check_precheck(bin_package, apr_package)
            if not r[0]:
                raise ValueError(
                    f"{apr_package.name} would not be accessible for {bin_package.name}"
                )
            apr.append((apr_package, apr_fs_root))

        if related_udeb_fs_root is not None:
            if udeb_package is None:
                raise ValueError(
                    "related_udeb_package_fields must be given when related_udeb_fs_root is given"
                )
            r = package_cross_check_precheck(bin_package, udeb_package)
            if not r[0]:
                raise ValueError(
                    f"{udeb_package.name} would not be accessible for {bin_package.name}, so providing"
                    " related_udeb_fs_root is irrelevant"
                )
            apr.append((udeb_package, related_udeb_fs_root))
        final_apr = tuple(apr)
    else:
        final_apr = tuple()

    return PackageProcessingContextTestProvider(
        source_package=source_package,
        binary_package=bin_package,
        related_udeb_package=udeb_package,
        binary_package_version=binary_package_version,
        related_udeb_package_version=related_udeb_package_version,
        accessible_package_roots=lambda: final_apr,
        manifest_configuration=manifest_configuration,
    )


def manifest_variable_resolution_context(
    *,
    debian_dir: VirtualPath | None = None,
) -> VariableContext:
    if debian_dir is None:
        debian_dir = InMemoryVirtualRootDir()

    return VariableContext(debian_dir)


class MaintscriptAccessorTestProvider(MaintscriptAccessorProviderBase):
    __slots__ = ("_plugin_metadata", "_plugin_source_id", "_maintscript_container")

    def __init__(
        self,
        plugin_metadata: DebputyPluginMetadata,
        plugin_source_id: str,
        maintscript_container: dict[str, list[RegisteredMaintscript]],
    ):
        self._plugin_metadata = plugin_metadata
        self._plugin_source_id = plugin_source_id
        self._maintscript_container = maintscript_container

    @classmethod
    def _apply_condition_to_script(
        cls, condition: str, run_snippet: str, /, indent: bool | None = None
    ) -> str:
        return run_snippet

    def _append_script(
        self,
        caller_name: str,
        maintscript: Maintscript,
        full_script: str,
        /,
        perform_substitution: bool = True,
    ) -> None:
        if self._plugin_source_id not in self._maintscript_container:
            self._maintscript_container[self._plugin_source_id] = []
        self._maintscript_container[self._plugin_source_id].append(
            RegisteredMaintscript(
                maintscript,
                caller_name,
                full_script,
                perform_substitution,
            )
        )


class RegisteredMetadataImpl(RegisteredMetadata):
    __slots__ = (
        "_substvars",
        "_triggers",
        "_maintscripts",
    )

    def __init__(
        self,
        substvars: Substvars,
        triggers: list[RegisteredTrigger],
        maintscripts: list[RegisteredMaintscript],
    ) -> None:
        self._substvars = substvars
        self._triggers = triggers
        self._maintscripts = maintscripts

    @property
    def substvars(self) -> Substvars:
        return self._substvars

    @property
    def triggers(self) -> list[RegisteredTrigger]:
        return self._triggers

    def maintscripts(
        self,
        *,
        maintscript: Maintscript | None = None,
    ) -> list[RegisteredMaintscript]:
        if maintscript is None:
            return self._maintscripts
        return [m for m in self._maintscripts if m.maintscript == maintscript]


class BinaryCtrlAccessorTestProvider(BinaryCtrlAccessorProviderBase):
    __slots__ = ("_maintscript_container",)

    def __init__(
        self,
        plugin_metadata: DebputyPluginMetadata,
        plugin_source_id: str,
        context: PackageProcessingContext,
    ) -> None:
        super().__init__(
            plugin_metadata,
            plugin_source_id,
            context,
            {},
            FlushableSubstvars(),
            (None, None),
        )
        self._maintscript_container: dict[str, list[RegisteredMaintscript]] = {}

    def _create_maintscript_accessor(self) -> MaintscriptAccessor:
        return MaintscriptAccessorTestProvider(
            self._plugin_metadata,
            self._plugin_source_id,
            self._maintscript_container,
        )

    def registered_metadata(self) -> RegisteredMetadata:
        return RegisteredMetadataImpl(
            self._substvars,
            [
                RegisteredTrigger.from_plugin_provided_trigger(t)
                for t in self._triggers.values()
                if t.provider_source_id == self._plugin_source_id
            ],
            self._maintscript_container.get(self._plugin_source_id, []),
        )


class ServiceRegistryTestImpl(ServiceRegistry[DSD]):
    __slots__ = ("_service_manager_details", "_service_definitions")

    def __init__(
        self,
        service_manager_details: ServiceManagerDetails,
        detected_services: list[DetectedService[DSD]],
    ) -> None:
        self._service_manager_details = service_manager_details
        self._service_definitions = detected_services

    def register_service(
        self,
        path: VirtualPath,
        name: str | list[str],
        *,
        type_of_service: str = "service",  # "timer", etc.
        service_scope: str = "system",
        enable_by_default: bool = True,
        start_by_default: bool = True,
        default_upgrade_rule: ServiceUpgradeRule = "restart",
        service_context: DSD | None = None,
    ) -> None:
        names = name if isinstance(name, list) else [name]
        if len(names) < 1:
            raise ValueError(
                f"The service must have at least one name - {path.absolute} did not have any"
            )
        self._service_definitions.append(
            DetectedService(
                path,
                names,
                type_of_service,
                service_scope,
                enable_by_default,
                start_by_default,
                default_upgrade_rule,
                service_context,
            )
        )


@contextlib.contextmanager
def _read_only_fs_root(fs_root: VirtualPath) -> Iterator[VirtualPath]:
    if fs_root.is_read_write:
        assert isinstance(fs_root, InMemoryVirtualRootDir)
        fs_root.is_read_write = False
        yield fs_root
        fs_root.is_read_write = True
    else:
        yield fs_root


class InitializedPluginUnderTestImpl(InitializedPluginUnderTest):
    def __init__(
        self,
        plugin_name: str,
        feature_set: PluginProvidedFeatureSet,
        substitution: SubstitutionImpl,
    ) -> None:
        self._feature_set = feature_set
        self._plugin_name = plugin_name
        self._packager_provided_files: None | (
            dict[str, RegisteredPackagerProvidedFile]
        ) = None
        self._triggers: dict[tuple[DpkgTriggerType, str], PluginProvidedTrigger] = {}
        self._maintscript_container: dict[str, list[RegisteredMaintscript]] = {}
        self._substitution = substitution
        assert plugin_name in self._feature_set.plugin_data

    @property
    def _plugin_metadata(self) -> DebputyPluginMetadata:
        return self._feature_set.plugin_data[self._plugin_name]

    def packager_provided_files_by_stem(
        self,
    ) -> Mapping[str, RegisteredPackagerProvidedFile]:
        ppf = self._packager_provided_files
        if ppf is None:
            result: dict[str, RegisteredPackagerProvidedFile] = {}
            for spec in self._feature_set.packager_provided_files.values():
                if spec.debputy_plugin_metadata.plugin_name != self._plugin_name:
                    continue
                # Registered as a virtual subclass, so this should always be True
                assert isinstance(spec, RegisteredPackagerProvidedFile)
                result[spec.stem] = spec
            self._packager_provided_files = result
            ppf = result
        return ppf

    def run_metadata_detector(
        self,
        metadata_detector_id: str,
        fs_root: VirtualPath,
        context: PackageProcessingContext | None = None,
    ) -> RegisteredMetadata:
        if not fs_root.is_root_dir():
            raise ValueError("Provided path must be the file system root.")
        detectors = self._feature_set.metadata_maintscript_detectors[self._plugin_name]
        matching_detectors = [
            d for d in detectors if d.detector_id == metadata_detector_id
        ]
        if len(matching_detectors) != 1:
            assert not matching_detectors
            raise ValueError(
                f"The plugin {self._plugin_name} did not provide a metadata detector with ID"
                f' "{metadata_detector_id}"'
            )
        if context is None:
            context = package_metadata_context()
        detector = matching_detectors[0]
        if not detector.applies_to(context.binary_package):
            raise ValueError(
                f'The detector "{metadata_detector_id}" from {self._plugin_name} does not apply to the'
                " given package. Consider using `package_metadata_context()` to emulate a binary package"
                " with the correct specification. As an example: "
                '`package_metadata_context(package_fields={"Package-Type": "udeb"})` would emulate a udeb'
                " package."
            )

        ctrl = BinaryCtrlAccessorTestProvider(
            self._plugin_metadata,
            metadata_detector_id,
            context,
        )
        with _read_only_fs_root(fs_root) as ro_root:
            detector.run_detector(
                ro_root,
                ctrl,
                context,
            )
        return ctrl.registered_metadata()

    def run_package_processor(
        self,
        package_processor_id: str,
        fs_root: VirtualPath,
        context: PackageProcessingContext | None = None,
    ) -> None:
        if not fs_root.is_root_dir():
            raise ValueError("Provided path must be the file system root.")
        pp_key = (self._plugin_name, package_processor_id)
        package_processor = self._feature_set.all_package_processors.get(pp_key)
        if package_processor is None:
            raise ValueError(
                f"The plugin {self._plugin_name} did not provide a package processor with ID"
                f' "{package_processor_id}"'
            )
        if context is None:
            context = package_metadata_context()
        if not fs_root.is_read_write:
            raise ValueError(
                "The provided fs_root is read-only and it must be read-write for package processor"
            )
        if not package_processor.applies_to(context.binary_package):
            raise ValueError(
                f'The package processor "{package_processor_id}" from {self._plugin_name} does not apply'
                " to the given package. Consider using `package_metadata_context()` to emulate a binary"
                " package with the correct specification. As an example: "
                '`package_metadata_context(package_fields={"Package-Type": "udeb"})` would emulate a udeb'
                " package."
            )
        package_processor.run_package_processor(
            fs_root,
            None,
            context,
        )

    @property
    def declared_manifest_variables(self) -> frozenset[str]:
        return frozenset(
            {
                k
                for k, v in self._feature_set.manifest_variables.items()
                if v.plugin_metadata.plugin_name == self._plugin_name
            }
        )

    def automatic_discard_rules_examples_with_issues(self) -> Sequence[ADRExampleIssue]:
        issues = []
        for adr in self._feature_set.auto_discard_rules.values():
            if adr.plugin_metadata.plugin_name != self._plugin_name:
                continue
            for idx, example in enumerate(adr.examples):
                result = process_discard_rule_example(
                    adr,
                    example,
                )
                if result.inconsistent_paths:
                    issues.append(
                        ADRExampleIssue(
                            adr.name,
                            idx,
                            [
                                x.absolute + ("/" if x.is_dir else "")
                                for x in result.inconsistent_paths
                            ],
                        )
                    )
        return issues

    def run_service_detection_and_integrations(
        self,
        service_manager: str,
        fs_root: VirtualPath,
        context: PackageProcessingContext | None = None,
        *,
        service_context_type_hint: type[DSD] | None = None,
    ) -> tuple[list[DetectedService[DSD]], RegisteredMetadata]:
        if not fs_root.is_root_dir():
            raise ValueError("Provided path must be the file system root.")
        try:
            service_manager_details = self._feature_set.service_managers[
                service_manager
            ]
            if service_manager_details.plugin_metadata.plugin_name != self._plugin_name:
                raise KeyError(service_manager)
        except KeyError:
            raise ValueError(
                f"The plugin {self._plugin_name} does not provide a"
                f" service manager called {service_manager}"
            ) from None

        if context is None:
            context = package_metadata_context()
        detected_services: list[DetectedService[DSD]] = []
        registry = ServiceRegistryTestImpl(service_manager_details, detected_services)
        service_manager_details.service_detector(
            fs_root,
            registry,
            context,
        )
        ctrl = BinaryCtrlAccessorTestProvider(
            self._plugin_metadata,
            service_manager_details.service_manager,
            context,
        )
        if detected_services:
            service_definitions = [
                ServiceDefinitionImpl(
                    ds.names[0],
                    ds.names,
                    ds.path,
                    ds.type_of_service,
                    ds.service_scope,
                    ds.enable_by_default,
                    ds.start_by_default,
                    ds.default_upgrade_rule,
                    self._plugin_name,
                    True,
                    ds.service_context,
                )
                for ds in detected_services
            ]
            service_manager_details.service_integrator(
                service_definitions,
                ctrl,
                context,
            )
        return detected_services, ctrl.registered_metadata()

    def manifest_variables(
        self,
        *,
        resolution_context: VariableContext | None = None,
        mocked_variables: Mapping[str, str] | None = None,
    ) -> Mapping[str, str]:
        valid_manifest_variables = frozenset(
            {
                n
                for n, v in self._feature_set.manifest_variables.items()
                if v.plugin_metadata.plugin_name == self._plugin_name
            }
        )
        if resolution_context is None:
            resolution_context = manifest_variable_resolution_context()
        substitution = self._substitution.copy_for_subst_test(
            self._feature_set,
            resolution_context,
            extra_substitutions=mocked_variables,
        )
        return SubstitutionTable(
            valid_manifest_variables,
            substitution,
        )


class SubstitutionTable(Mapping[str, str]):
    def __init__(
        self, valid_manifest_variables: frozenset[str], substitution: Substitution
    ) -> None:
        self._valid_manifest_variables = valid_manifest_variables
        self._resolved: set[str] = set()
        self._substitution = substitution

    def __contains__(self, item: object) -> bool:
        return item in self._valid_manifest_variables

    def __getitem__(self, key: str) -> str:
        if key not in self._valid_manifest_variables:
            raise KeyError(key)
        v = self._substitution.substitute(
            "{{" + key + "}}", f"test of manifest variable `{key}`"
        )
        self._resolved.add(key)
        return v

    def __len__(self) -> int:
        return len(self._valid_manifest_variables)

    def __iter__(self) -> Iterator[str]:
        return iter(self._valid_manifest_variables)

    def keys(self) -> KeysView[str]:
        return cast("KeysView[str]", self._valid_manifest_variables)
