"""Environment boundary sampling for measured runs.

Sample the host before and after a measurement window, then ask

``environment_suspect`` whether the window looks clean.  All fields are

nullable: a signal the host cannot provide is None, never a guess (ADR-0002).

Suspect rows are flagged, never deleted.

"""

from __future__ import annotations

import os

import platform

import re

import subprocess

from pathlib import Path

from typing import Any

from oakbench.runner import _command_text, _text_file, cpu_governor

LINUX_MEMINFO = Path("/proc/meminfo")

LINUX_THERMAL = Path("/sys/class/thermal")

def _loadavg() -> list[float] | None:

    try:

        return [float(value) for value in os.getloadavg()]

    except OSError:

        return None

def parse_meminfo_available_bytes(text: str) -> int | None:

    for line in text.splitlines():

        if line.startswith("MemAvailable:"):

            parts = line.split()

            if len(parts) >= 2 and parts[1].isdigit():

                return int(parts[1]) * 1024

    return None

def parse_vm_stat_free_bytes(text: str) -> int | None:

    page_size_match = re.search(r"page size of (\d+) bytes", text)

    free_match = re.search(r"Pages free:\s+(\d+)", text)

    if not page_size_match or not free_match:

        return None

    return int(free_match.group(1)) * int(page_size_match.group(1))

def parse_pmset_cpu_speed_limit(text: str) -> int | None:

    match = re.search(r"CPU_Speed_Limit\s*=\s*(\d+)", text)

    return int(match.group(1)) if match else None

def _mem_available_bytes(system: str) -> int | None:

    if system == "Linux":

        text = _text_file(LINUX_MEMINFO)

        return parse_meminfo_available_bytes(text) if text else None

    if system == "Darwin":

        text = _command_text(["/usr/bin/vm_stat"])

        return parse_vm_stat_free_bytes(text) if text else None

    return None

def _cpu_speed_limit_pct(system: str) -> int | None:

    if system != "Darwin":

        return None

    text = _command_text(["pmset", "-g", "therm"])

    return parse_pmset_cpu_speed_limit(text) if text else None

def _thermal_zone_max_c(system: str) -> float | None:

    if system != "Linux":

        return None

    readings = [

        int(value) for path in LINUX_THERMAL.glob("thermal_zone*/temp") if (value := _text_file(path)) and value.lstrip("-").isdigit()

    ]

    return max(readings) / 1000.0 if readings else None

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

    """One boundary sample.  Timestamp is the caller's job."""

    system = platform.system()

    return {

        "loadavg": _loadavg(),

        "mem_available_bytes": _mem_available_bytes(system),

        "cpu_speed_limit_pct": _cpu_speed_limit_pct(system),

        "thermal_zone_max_c": _thermal_zone_max_c(system),

        "cpu_governor": cpu_governor(),

        "system": system,

    }

def _load_per_core(sample: dict[str, Any], cores: int) -> float | None:

    loadavg = sample.get("loadavg")

    if not loadavg or cores <= 0:

        return None

    return float(loadavg[0]) / cores

def environment_suspect(

    before: dict[str, Any],

    after: dict[str, Any],

    *,

    load_per_core_threshold: float = 1.5,

    cpu_count: int | None = None,

) -> list[str]:

    """Human-readable suspicion reasons for a measurement window (empty = clean)."""

    cores = cpu_count if cpu_count is not None else (os.cpu_count() or 1)

    reasons: list[str] = []

    for label, sample in (("before", before), ("after", after)):

        per_core = _load_per_core(sample, cores)

        if per_core is not None and per_core > load_per_core_threshold:

            reasons.append(

                f"load_per_core {per_core:.2f} above threshold {load_per_core_threshold:g} at {label} boundary"

            )

    for label, sample in (("before", before), ("after", after)):

        limit = sample.get("cpu_speed_limit_pct")

        if limit is not None and limit < 100:

            reasons.append(f"thermal throttling at {label} boundary: CPU_Speed_Limit={limit}")

    governors = {

        str(sample.get("cpu_governor"))

        for sample in (before, after)

        if sample.get("cpu_governor") is not None and sample.get("cpu_governor") != "performance"

    }

    for governor in sorted(governors):

        reasons.append(f"cpu_governor is '{governor}', not 'performance' (informational)")

    return reasons