from dataclasses import dataclass, field
from typing import Dict, Optional

from providers.target import ProviderTarget

from providers.provision.base import ProvisionProvider
from providers.runtime.base import RuntimeProvider
from providers.workspace.base import WorkspaceProvider


@dataclass
class ProviderRegistry:
    runtime: Dict[str, RuntimeProvider] = field(default_factory=dict)
    workspace: Dict[str, WorkspaceProvider] = field(default_factory=dict)
    provision: Dict[str, ProvisionProvider] = field(default_factory=dict)

    def register_bundle(
        self,
        *,
        key: str,
        runtime_provider: RuntimeProvider,
        workspace_provider: WorkspaceProvider,
        provision_provider: ProvisionProvider,
    ) -> None:
        self.runtime[key] = runtime_provider
        self.workspace[key] = workspace_provider
        self.provision[key] = provision_provider

    def resolve_bundle_key(self, target: ProviderTarget) -> Optional[str]:
        exact = target.key
        if exact in self.runtime and exact in self.workspace and exact in self.provision:
            return exact

        for key in self.runtime.keys():
            if key not in self.workspace or key not in self.provision:
                continue
            parts = str(key or "").split(":")
            if len(parts) < 4:
                continue
            _, transport_kind, runtime_kind, core_adapter = parts[0], parts[1], parts[2], ":".join(parts[3:])
            if (
                str(transport_kind or "").strip().lower() == str(target.transport_kind or "").strip().lower()
                and str(runtime_kind or "").strip().lower() == str(target.runtime_kind or "").strip().lower()
                and str(core_adapter or "").strip().lower() == str(target.core_adapter or "").strip().lower()
            ):
                return key
        return None