"""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 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

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 == "git":

            override = args.git_bin

        elif name == "oak_installed":

            override = args.oak_installed_bin

        elif name == "oak_local":

            override = args.oak_local_bin

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

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

    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"

    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]]:

    return {

        subject.name: {

            "kind": subject.kind,

            "label": subject.label,

            "bin": str(subject.bin),

            "binary_sha256": binary_sha256(subject.bin),

            "version": subject_version(subject),

            "role": subject_role(subject),

        }

        for subject in subjects

    }

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),

    }