from __future__ import annotations

from pathlib import Path
from typing import Any

from .config import repo_root
from .installer import apply_plan
from .models import load_lockfile, load_registry
from .planner import create_plan
from .state import load_installed_state


def enable_disabled_plugin(
    *,
    instance: str,
    instance_path: Path,
    state_root: Path,
    plugin_id: str,
    registry: str = "registry/plugins.toml",
    lockfile: str | None = None,
    repo: Path | None = None,
) -> dict[str, Any]:
    installed_state = load_installed_state(state_root, instance)
    if plugin_id not in installed_state.get("disabledPlugins", {}):
        raise KeyError(f"plugin is not recorded as disabled: {plugin_id}")

    root = repo or repo_root()
    registry_path = (root / registry).resolve() if not Path(registry).is_absolute() else Path(registry)
    lock_path = Path(lockfile) if lockfile else root / "locks" / f"{instance}.lock.toml"
    if not lock_path.is_absolute():
        lock_path = (root / lock_path).resolve()
    loaded_lockfile = load_lockfile(lock_path)
    if not any(plugin.id == plugin_id for plugin in loaded_lockfile.plugins):
        raise KeyError(f"plugin is disabled but not locked for this instance: {plugin_id}")

    plan, path = create_plan(
        instance=instance,
        instance_path=instance_path,
        beat_saber_version=loaded_lockfile.beat_saber_version,
        registry=load_registry(registry_path),
        lockfile=loaded_lockfile,
        state_root=state_root,
        repo_root=root,
        selected={plugin_id},
    )
    result = apply_plan(plan, state_root)
    return {"planPath": str(path), **result}