"""The terminal's PATH: the user's own tools first, Hermes's after them.

Hermes's process puts its store's tool dirs first (``pm.install.activate``), so Hermes's own
code resolves the pinned binaries. Terminal commands belong to the user and the agent, so they
run the tools the user installed, and Hermes's tools are the fallback for a machine without
them. Hermes's own operations must not depend on this PATH: they resolve pinned tools
through PM (``pm.env_for``, ``pm.installed_package``).

A sealed Windows payload's store sits under ``WindowsApps``. In the process tree that the
app's execution alias starts, a program whose own executable is outside the package cannot
start one inside it: cmd.exe running npm's ``npx.cmd`` gets "Access is denied" from the
packaged ``node.exe``, and a venv's ``Scripts\\python.exe`` redirector exits 101 when it
starts the packaged Python. A copy of the same files outside the package starts without
error, so there :func:`copies` swaps those dirs for PM's verified copies.
"""
from __future__ import annotations

import logging
import os
from pathlib import Path

LOG = logging.getLogger(__name__)

# Packages whose packaged dirs a sealed Windows payload swaps for writable copies.
COPIED = ("npm", "node", "python")


def applies() -> bool:
    """True for a sealed payload on Windows, the only layout with the restriction above."""
    from pm.install import sealed
    from pm.store import current_target

    return current_target().startswith("win32") and sealed()


def writable_copy(name: str, *, realize: bool = True, explicit: bool = False,
                  why: str = "a copy outside the package is required"):
    """``(facts, store)`` of PM's verified copy of the installed *name* in the writable store.

    The first call copies the installed entry and checks its digest. It downloads nothing.
    If the install already lives in the writable store, that install is the answer. Returns
    ``None`` when *name* is not installed, or when no copy exists and *realize* is false.
    Raises the lazy-install refusal, naming *why*, when a copy is needed and lazy installs
    are off.
    """
    from pm import paths
    from pm.filesystem import long_root
    from pm.install import _install, _installed_location, _lockfile, _refuse_lazy, lazy_installs_allowed
    from pm.lock import Facts
    from pm.registry import get_package
    from pm.store import Store, current_target

    package, lockfile, target = get_package(name), _lockfile(), current_target()
    location = _installed_location(package, lockfile, target)
    if location is None:
        return None
    # Spelled like Store spells its root, so the comparison and the copy's file calls agree.
    writable = long_root(paths.writable_store_root())
    if location[1].root == writable:
        return location
    copied = _installed_location(package, lockfile, target, verify=explicit, roots=(writable,))
    if copied is not None or not realize:
        return copied
    if not explicit and not lazy_installs_allowed():
        raise _refuse_lazy(name, why)
    copy_store, copy_facts = Store(writable), Facts(writable / "facts.json")
    _install(package, lockfile, copy_facts, copy_store, target, copy_from=location)
    return copy_facts, copy_store


def _dirs(facts, store, name: str) -> list[str]:
    """The PATH dirs that *store*'s install of *name* contributes, natively spelled."""
    from pm.filesystem import native

    dirs = facts.env_for(name, store.root).get("PATH") or []
    return [native(d) for d in ([dirs] if isinstance(dirs, str) else dirs) if d]


def _sealed_dirs(name: str) -> list[str]:
    from pm.install import _facts, _store

    facts, store = _facts(), _store()
    return _dirs(facts, store, name) if facts.installed(name, None, store.root) else []


def _copy_dirs(name: str) -> list[str]:
    """The PATH dirs of *name*'s writable copy, made on first use, or ``[]`` when PM may not make one."""
    from pm.package import InstallError

    try:
        location = writable_copy(name)
    except (InstallError, OSError) as exc:
        LOG.debug("user-facing %s stays the packaged copy: %s", name, exc)
        return []
    return _dirs(*location, name) if location is not None else []


def copies(dirs: list[str]) -> list[str]:
    """*dirs* with each packaged npm, node and python dir swapped for its writable copy on a
    sealed Windows payload. A packaged dir stays when PM may not copy it (lazy installs off)."""
    if not applies():
        return list(dirs)
    swap: dict[str, list[str]] = {}
    for name in COPIED:
        sealed = _sealed_dirs(name)
        copied = _copy_dirs(name) if sealed else []
        if copied:
            swap.update((os.path.normcase(d), copied) for d in sealed)
    return list(dict.fromkeys(c for d in dirs for c in swap.get(os.path.normcase(d), [d])))


def _python_stub_dir(directory: str) -> bool:
    """True for the Windows app-alias dir when its ``python.exe`` is only the Store stub.

    The stub opens the Microsoft Store instead of running Python. A real Store Python puts its
    aliases in the same dir, and it also ships a ``python3.N.exe``, which the stub does not.
    """
    parts = [os.path.normcase(part) for part in Path(directory).parts[-2:]]
    if parts != [os.path.normcase("Microsoft"), os.path.normcase("WindowsApps")]:
        return False
    try:
        return not any(Path(directory).glob("python3.*.exe"))
    except OSError:
        return True


def _python_dirs() -> list[str]:
    from pm.install import env_for

    return [d for d in env_for("python", base_env={"PATH": ""}).get("PATH", "").split(os.pathsep) if d]


def user_facing_path(path: str) -> str:
    """*path* with Hermes's store tool dirs (their writable copies, see :func:`copies`) moved
    behind the user's own entries.

    Hermes's Python stops just before the app-alias dir that holds the Store stub, so a
    machine without Python still runs a real one.
    """
    from pm.install import _store_path_dirs

    store = _store_path_dirs()
    if not store:
        return path
    ours = copies(store)
    keys = {os.path.normcase(d) for d in (*store, *ours)}
    kept = [p for p in path.split(os.pathsep) if p and os.path.normcase(p) not in keys]
    python = {os.path.normcase(d) for d in copies(_python_dirs())}
    cut = next((i for i, p in enumerate(kept) if _python_stub_dir(p)), len(kept))
    early = [d for d in ours if os.path.normcase(d) in python]
    late = [d for d in ours if os.path.normcase(d) not in python]
    return os.pathsep.join(dict.fromkeys([*kept[:cut], *early, *kept[cut:], *late]))