"""Subject identity: which VCS binaries are under measurement.

Subjects have two identity layers (CONTEXT.md): the logical name used for

trend grouping, and binary+version+source-hash provenance recorded per run.

"""

from __future__ import annotations

import argparse

import hashlib

import os

import platform

import shutil

import subprocess

from dataclasses import dataclass

from pathlib import Path

from typing import Any

from oakbench.configio import load_subject_config

ROOT = Path(__file__).resolve().parents[2]

DEFAULT_OAK_REPO = Path(os.environ.get("OAK_REPO", ROOT.parent / "oak"))

@dataclass(frozen=True)

class Subject:

    name: str

    kind: str

    label: str

    bin: Path

    git_mode: str | None = None

    # Provenance of shim resolution: the configured path when it was the

    # macOS xcrun trampoline and was resolved to the real binary (or kept,

    # explicitly allowed, in which case git_shim is True).

    requested_bin: Path | None = None

    git_shim: bool = False

# macOS ships /usr/bin/git as an xcrun trampoline: every call re-resolves the

# developer directory before exec'ing the real binary (~3 ms per call on the

# benchmark workstation), and hashing it identifies the stub, not the Git

# that ran. Only the canonical stub location is treated as a shim.

XCRUN_SHIM_PATHS = frozenset({"/usr/bin/git"})

ALLOW_GIT_SHIM_ENV = "OAK_BENCH_ALLOW_GIT_SHIM"

def is_xcrun_git_shim(path: Path | str, system: str | None = None) -> bool:

    if (system or platform.system()) != "Darwin":

        return False

    try:

        resolved = str(Path(path).resolve())

    except OSError:

        resolved = str(path)

    return resolved in XCRUN_SHIM_PATHS or str(path) in XCRUN_SHIM_PATHS

def resolve_real_git(runner=subprocess.run) -> Path | None:

    """The real Git behind the xcrun shim, or None when it cannot be found.

    Order: ``xcrun --find git`` (honours DEVELOPER_DIR / xcode-select), then

    the selected developer directory, then Command Line Tools.

    """

    candidates: list[str] = []

    for command in (["/usr/bin/xcrun", "--find", "git"], ["/usr/bin/xcode-select", "-p"]):

        try:

            result = runner(command, capture_output=True, text=True, timeout=10, check=False)

        except (OSError, subprocess.TimeoutExpired):

            continue

        text = (result.stdout or "").strip()

        if result.returncode == 0 and text:

            candidates.append(text if command[-1] == "git" else str(Path(text) / "usr" / "bin" / "git"))

    candidates.append("/Library/Developer/CommandLineTools/usr/bin/git")

    for candidate in candidates:

        path = Path(candidate)

        if path.is_file() and os.access(path, os.X_OK) and not is_xcrun_git_shim(path, "Darwin"):

            return path.resolve()

    return None

def which_measured_git() -> str | None:

    """``shutil.which("git")`` with the xcrun shim resolved to the real Git.

    For auxiliary resolution sites; timed subjects go through load_subjects,

    which refuses an unresolvable shim instead of silently measuring it.

    """

    found = shutil.which("git")

    if found and is_xcrun_git_shim(found) and not allow_git_shim():

        real = resolve_real_git()

        return str(real) if real else found

    return found

def allow_git_shim(args: argparse.Namespace | None = None) -> bool:

    return bool(getattr(args, "allow_git_shim", False)) or os.environ.get(ALLOW_GIT_SHIM_ENV) == "1"

def resolve_git_subject_bin(path: Path, *, allow_shim: bool, system: str | None = None,

                            resolver=resolve_real_git) -> tuple[Path, Path | None, bool]:

    """Return (bin to execute, requested bin if resolved/kept, shim_measured).

    Refuses (SystemExit) to measure the shim unless explicitly allowed.

    """

    if not is_xcrun_git_shim(path, system):

        return path, None, False

    if allow_shim:

        return path, path, True

    real = resolver()

    if real is None:

        raise SystemExit(

            f"{path} is the macOS xcrun git shim and the real Git could not be resolved "

            "(xcrun --find git failed). Pass --git-bin <real git>, or set "

            f"{ALLOW_GIT_SHIM_ENV}=1 / --allow-git-shim to measure the shim deliberately.")

    return real, path, False

def resolve_subject_bin(raw: str | Path, override: Path | None = None) -> Path:

    if override is not None:

        path = override.expanduser()

        return path if path.is_absolute() else (ROOT / path).resolve()

    raw_text = str(raw)

    path = Path(raw_text).expanduser()

    if path.is_absolute():

        return path

    if "/" in raw_text or "\\" in raw_text:

        return (ROOT / path).resolve()

    found = shutil.which(raw_text)

    return Path(found) if found else path

def load_subjects(args: argparse.Namespace) -> list[Subject]:

    """Load subjects from config/subjects.toml with the standard CLI overrides.

    Expects args to carry: config, subjects, git_bin, oak_installed_bin,

    oak_local_bin — the shared flag set every lane defines.

    """

    data = load_subject_config(args.config)

    subjects: list[Subject] = []

    wanted = {item.strip() for item in args.subjects.split(",") if item.strip()} if args.subjects else None

    for name, raw in data["subjects"].items():

        if not raw.get("enabled", False) and (wanted is None or name not in wanted):

            continue

        override = None

        if name in ("git", "git_aa"):

            override = args.git_bin

        elif name == "oak_installed":

            override = args.oak_installed_bin

        elif name == "oak_local":

            override = args.oak_local_bin

        elif name == "oak_installed_aa":

            override = getattr(args, "oak_aa_bin", None)

        path = resolve_subject_bin(raw["bin"], override)

        requested, shim = None, False

        if raw["kind"] == "git":

            path, requested, shim = resolve_git_subject_bin(path, allow_shim=allow_git_shim(args))

        subjects.append(Subject(name=name, kind=raw["kind"], label=raw.get("label", name), bin=path,

                                requested_bin=requested, git_shim=shim))

    if wanted is not None:

        subjects = [subject for subject in subjects if subject.name in wanted]

    missing = [str(subject.bin) for subject in subjects if not subject.bin.exists()]

    if missing:

        raise SystemExit("Missing benchmark binaries:\n  " + "\n  ".join(missing))

    if not subjects:

        raise SystemExit("No enabled benchmark subjects")

    return subjects

def subject_version(subject: Subject) -> str:

    try:

        return subprocess.check_output(

            [str(subject.bin), "--version"], text=True, stderr=subprocess.STDOUT, timeout=5

        ).strip()

    except Exception as exc:  # noqa: BLE001 - metadata only

        return f"unknown ({exc})"

def subject_role(subject: Subject) -> str:

    if subject.name == "oak_installed":

        return "oak_release_latest_installed"

    if subject.name == "oak_local":

        return "oak_current_changeset"

    if subject.name == "oak_main":

        return "oak_main_clean_build"

    if subject.name == "oak_installed_aa":

        return "oak_baseline_aa_control"

    return subject.kind

def binary_sha256(path: Path) -> str | None:

    try:

        digest = hashlib.sha256()

        with path.open("rb") as fh:

            for chunk in iter(lambda: fh.read(1024 * 1024), b""):

                digest.update(chunk)

        return digest.hexdigest()

    except OSError:

        return None

def subject_details(subjects: list[Subject]) -> dict[str, dict[str, Any]]:

    details = {}

    for subject in subjects:

        item = {

            "kind": subject.kind,

            "label": subject.label,

            "bin": str(subject.bin),

            "binary_sha256": binary_sha256(subject.bin),

            "version": subject_version(subject),

            "role": subject_role(subject),

        }

        if subject.kind == "git":

            item.update(requested_bin=str(subject.requested_bin) if subject.requested_bin else None,

                        git_shim_measured=subject.git_shim,

                        git_shim_resolved=subject.requested_bin is not None and not subject.git_shim,

                        git_config_profile=git_config_profile(subject.git_mode))

        details[subject.name] = item

    return details

def git_config_profile(mode: str | None) -> str:

    """Row label that separates stock Git from tuned configurations."""

    return "stock" if not mode else ("scalar_recommended" if mode == "scalar" else f"tuned_{mode}")

def subject_versions(subjects: list[Subject]) -> dict[str, str]:

    return {subject.name: subject_version(subject) for subject in subjects}

def command_text(command: list[str], cwd: Path | None = None) -> str | None:

    try:

        return subprocess.check_output(

            command, cwd=cwd, text=True, stderr=subprocess.STDOUT, timeout=10

        ).strip()

    except Exception:

        return None

def source_metadata(oak_repo: Path) -> dict[str, Any]:

    """Oak-source provenance for tying rows back to a changeset, without using Git."""

    oak_bin = shutil.which("oak")

    if not oak_bin or not oak_repo.exists():

        return {"oak_repo": str(oak_repo), "oak_hash": None, "oak_status": None}

    return {

        "oak_repo": str(oak_repo),

        "oak_hash": command_text([oak_bin, "hash"], cwd=oak_repo),

        "oak_status": command_text([oak_bin, "status"], cwd=oak_repo),

    }