from __future__ import annotations

from collections.abc import Callable, Iterable, Sequence

from govoplan_core.access.manifest import get_manifest as get_access_manifest
from govoplan_core.core.discovery import discover_module_manifests
from govoplan_core.core.modules import ModuleManifest
from govoplan_core.core.registry import PlatformRegistry, RegistryError

ManifestFactory = Callable[[], ModuleManifest]


def parse_enabled_modules(value: str | Iterable[str]) -> list[str]:
    if isinstance(value, str):
        items = [item.strip() for item in value.split(",")]
    else:
        items = [str(item).strip() for item in value]
    return [item for item in items if item]


def available_module_manifests(manifest_factories: Sequence[ManifestFactory] = (), *, enabled_modules: Iterable[str] | None = None) -> dict[str, ModuleManifest]:
    manifests = {manifest.id: manifest for manifest in discover_module_manifests(enabled_modules=enabled_modules)}
    manifests.setdefault("access", get_access_manifest())
    for factory in manifest_factories:
        manifest = factory()
        manifests[manifest.id] = manifest
    return manifests


def build_platform_registry(enabled_modules: str | Iterable[str], *, manifest_factories: Sequence[ManifestFactory] = ()) -> PlatformRegistry:
    requested = parse_enabled_modules(enabled_modules)
    if "access" not in requested:
        requested.insert(0, "access")

    available = available_module_manifests(manifest_factories, enabled_modules=requested)
    registry = PlatformRegistry()
    for module_id in requested:
        manifest = available.get(module_id)
        if manifest is None:
            raise RegistryError(f"Enabled module is not available: {module_id}")
        registry.register(manifest)
    registry.validate()
    return registry