"""Process environment policy for measured commands.

All measured subprocesses run through these environments so that author

identity, color suppression, and locale-ish noise are controlled in one place.

"""

from __future__ import annotations

import atexit

import os

import shutil

import tempfile

from pathlib import Path, PurePath

from typing import Any, Mapping

ENV_ISOLATION_VERSION = "3"

GIT_IDENTITY_KEYS = frozenset({"GIT_AUTHOR_NAME", "GIT_AUTHOR_EMAIL", "GIT_COMMITTER_NAME", "GIT_COMMITTER_EMAIL"})

def sanitize_git_environment(values: Mapping[str, str]) -> dict[str, str]:

    """Prevent host plumbing/configuration from redirecting measured commands.

    Explicit per-command scenario overrides may be applied after this boundary.

    Agent credential filtering is a separate, stricter policy.

    """

    env = {key: value for key, value in values.items()

           if not key.startswith("GIT_") or key in GIT_IDENTITY_KEYS}

    env.update(GIT_CONFIG_GLOBAL=os.devnull, GIT_CONFIG_NOSYSTEM="1", GIT_NO_REPLACE_OBJECTS="1")

    return env

def benchmark_process_environment(values: Mapping[str, str]) -> dict[str, str]:

    """Deterministic engine measurement policy, also enforced after agent filtering.

    Oak's documented updater otherwise performs a network request after the

    first successful command in a fresh HOME, biasing randomized subject order.

    Natural first-use updater UX requires a separate measurement contract.

    """

    env = sanitize_git_environment(values)

    env["OAK_NO_UPDATE_CHECK"] = "1"

    return env

_AUTO_BENCH_HOME: Path | None = None

_CLEANUP_REGISTERED = False

def _cleanup_auto_bench_home() -> None:

    if _AUTO_BENCH_HOME is not None:

        shutil.rmtree(_AUTO_BENCH_HOME, ignore_errors=True)

def _bench_home(home: Path | None = None) -> str:

    global _AUTO_BENCH_HOME, _CLEANUP_REGISTERED

    if home is None:

        path = Path(tempfile.gettempdir()) / f"oak-bench-home-{os.getpid()}"

        _AUTO_BENCH_HOME = path

        if not _CLEANUP_REGISTERED:

            atexit.register(_cleanup_auto_bench_home)

            _CLEANUP_REGISTERED = True

    else:

        path = home

    path.mkdir(mode=0o700, parents=True, exist_ok=True)

    (path / ".config").mkdir(exist_ok=True)

    (path / ".cache").mkdir(exist_ok=True)

    return str(path)

def base_env(

    author_name: str = "Oak Bench",

    author_email: str = "[email protected]",

    oak_author: str = "oakbench",

    home: Path | None = None,

) -> dict[str, str]:

    env = benchmark_process_environment(os.environ)

    bench_home = _bench_home(home)

    env.update(

        {

            "GIT_AUTHOR_NAME": author_name,

            "GIT_AUTHOR_EMAIL": author_email,

            "GIT_COMMITTER_NAME": author_name,

            "GIT_COMMITTER_EMAIL": author_email,

            "OAK_AUTHOR": oak_author,

            "NO_COLOR": "1",

            "CLICOLOR": "0",

            "HOME": bench_home,

            "XDG_CONFIG_HOME": str(Path(bench_home) / ".config"),

            "XDG_CACHE_HOME": str(Path(bench_home) / ".cache"),

            "ZDOTDIR": bench_home,

            "BASH_ENV": os.devnull,

            "ENV": os.devnull,

            "GIT_CONFIG_GLOBAL": os.devnull,

            "GIT_CONFIG_NOSYSTEM": "1",

            "LC_ALL": "C",

            "LANG": "C",

            "TZ": "UTC",

            "OAK_BENCH_ENV_ISOLATION_VERSION": ENV_ISOLATION_VERSION,

        }

    )

    return env

def probe_env(**kwargs: str) -> dict[str, str]:

    # The determinism probe intentionally does NOT suppress color: it measures

    # the tool's own non-TTY behavior. ANSI bytes in piped output are token

    # waste and break provider prompt caching.

    env = base_env(**kwargs)

    env.pop("NO_COLOR", None)

    env.pop("CLICOLOR", None)

    return env

def command_display(command: Any) -> str:

    """Human/token-countable form of a command or command sequence."""

    if (

        isinstance(command, list)

        and len(command) >= 3

        and command[0] in {"/bin/zsh", "zsh", "/bin/bash", "bash", "sh"}

        and command[1] in {"-c", "-lc"}

    ):

        return command[2]

    if isinstance(command, list) and command and all(isinstance(item, str) for item in command):

        executable = PurePath(command[0]).name if os.sep in command[0] else command[0]

        return " ".join([executable, *command[1:]])

    if isinstance(command, list):

        return " && ".join(command_display(item) for item in command)

    return str(command)