"""Runner identity and machine-profile capture.

Latency rows are only comparable inside a runner class (ADR-0007).  This

module keeps that policy behind a small interface: capture the local profile,

classify it with ``config/runner_classes.json``, and stamp rows additively.

"""

from __future__ import annotations

import hashlib

import json

import os

import platform

import shutil

import subprocess

from pathlib import Path

from typing import Any

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

DEFAULT_RUNNER_CLASSES = ROOT / "config" / "runner_classes.json"

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

    try:

        text = path.read_text(errors="replace").strip()

    except OSError:

        return None

    return text or None

def _command_text(command: list[str]) -> str | None:

    try:

        return subprocess.check_output(command, text=True, stderr=subprocess.DEVNULL, timeout=2).strip() or None

    except Exception:

        return None

def cpu_model() -> str | None:

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

        return _command_text(["sysctl", "-n", "machdep.cpu.brand_string"])

    linux = _text_file(Path("/proc/cpuinfo"))

    if linux:

        for line in linux.splitlines():

            if line.lower().startswith("model name"):

                return line.split(":", 1)[1].strip()

            if line.lower().startswith("hardware"):

                return line.split(":", 1)[1].strip()

    return platform.processor() or None

def cpu_governor() -> str | None:

    governors = sorted(

        {

            value

            for path in Path("/sys/devices/system/cpu").glob("cpu*/cpufreq/scaling_governor")

            if (value := _text_file(path))

        }

    )

    return ",".join(governors) if governors else None

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

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

        output = _command_text(["/usr/sbin/diskutil", "info", str(mount_point(path))])

        return parse_diskutil_filesystem_type(output or "")

    if shutil.which("stat"):

        return _command_text(["stat", "-f", "-c", "%T", str(path)])

    return None

def mount_point(path: Path) -> Path:

    candidate = path.resolve()

    if not candidate.exists():

        candidate = candidate.parent

    if candidate.is_file():

        candidate = candidate.parent

    while not os.path.ismount(candidate):

        parent = candidate.parent

        if parent == candidate:

            break

        candidate = parent

    return candidate

def parse_diskutil_filesystem_type(output: str) -> str | None:

    preferred = ("File System Personality", "Type (Bundle)")

    values: dict[str, str] = {}

    for line in output.splitlines():

        if ":" not in line:

            continue

        key, value = line.split(":", 1)

        key = key.strip()

        value = value.strip()

        if key in preferred and value:

            values[key] = value

    for key in preferred:

        if key in values:

            return values[key]

    return None

def machine_profile(path: Path | None = None) -> dict[str, Any]:

    probe_path = (path or Path.cwd()).resolve()

    return {

        "schema_version": 1,

        "system": platform.system(),

        "release": platform.release(),

        "machine": platform.machine(),

        "processor": platform.processor() or None,

        "cpu_model": cpu_model(),

        "cpu_count_logical": os.cpu_count(),

        "cpu_governor": cpu_governor(),

        "python_version": platform.python_version(),

        "filesystem_type": filesystem_type(probe_path),

        "probe_path": str(probe_path),

    }

def stable_runner_fields(profile: dict[str, Any]) -> dict[str, Any]:

    return {

        key: profile.get(key)

        for key in (

            "system",

            "release",

            "machine",

            "processor",

            "cpu_model",

            "cpu_count_logical",

            "filesystem_type",

        )

    }

def runner_id(profile: dict[str, Any]) -> str:

    payload = json.dumps(stable_runner_fields(profile), sort_keys=True, separators=(",", ":")).encode("utf-8")

    return hashlib.sha256(payload).hexdigest()[:16]

def load_runner_classes(path: Path = DEFAULT_RUNNER_CLASSES) -> dict[str, Any]:

    return json.loads(path.read_text())

def _matches(profile: dict[str, Any], match: dict[str, Any]) -> bool:

    for key, expected in match.items():

        if key.endswith("_prefix"):

            field = key[: -len("_prefix")]

            if not str(profile.get(field) or "").startswith(str(expected)):

                return False

        elif profile.get(key) != expected:

            return False

    return True

def runner_class(profile: dict[str, Any], config: dict[str, Any] | None = None) -> str:

    data = config or load_runner_classes()

    default = "unknown"

    for item in data.get("classes", []):

        if item.get("default"):

            default = str(item["id"])

            continue

        if _matches(profile, item.get("match", {})):

            return str(item["id"])

    return default

def runner_fields(profile: dict[str, Any] | None = None, config: dict[str, Any] | None = None) -> dict[str, Any]:

    prof = profile or machine_profile()

    return {

        "runner_id": runner_id(prof),

        "runner_class": runner_class(prof, config),

        "runner_profile": prof,

    }

def stamp_row(row: dict[str, Any], fields: dict[str, Any]) -> dict[str, Any]:

    stamped = dict(row)

    stamped.update(fields)

    return stamped