"""Prevent aggregation of observably incompatible measurement populations.

Legacy rows with uniformly absent metadata remain usable for diagnostics.

Missing and present metadata are distinct: absence never establishes equality

with a known environment. This check is not a public-provenance attestation.

"""

from __future__ import annotations

import json

from typing import Any

DIMENSIONS = (

    "lane", "benchmark_lane", "measurement_lane", "profile", "benchmark_track", "command_semantics_version",

    "fixture_version", "scenario_version", "oracle_version", "runner_class", "runner_id", "cache_state",

    "remote_transport", "remote_server", "netshape_profile", "env_isolation_version",

    "calibration_version", "platform_semantics_version", "binary_sha256", "load_tier",

    "instruction_level", "agent.name", "agent.model", "agent.adapter",

    "agent.provider", "agent.version", "agent.temperature", "agent.max_output_tokens",

    "agent.environment", "agent.instruction_level", "fixture.version", "fixture.fixture_version",

    "oracle.version", "task_prompt_id", "output_oracle_version", "patch_oracle_version",

)

def population_conflicts(rows: list[dict[str, Any]]) -> list[str]:

    """Return differing identity fields within ONE subject/scenario/op cell."""

    fields = {name: set() for name in DIMENSIONS}

    fields.update({"subject_details.version": set(), "subject_details.binary_sha256": set()})

    for row in rows:

        for name in DIMENSIONS:

            value: Any = row

            for part in name.split("."):

                value = value.get(part) if isinstance(value, dict) else None

            fields[name].add(json.dumps(value, sort_keys=True))

        details = row.get("subject_details") or {}

        if isinstance(details, dict):

            details = details.get(str(row.get("subject")), details)

        for name in ("version", "binary_sha256"):

            value = details.get(name) if isinstance(details, dict) else None

            fields[f"subject_details.{name}"].add(json.dumps(value, sort_keys=True))

    return sorted(name for name, values in fields.items() if len(values) > 1)

# Unlike within-subject identity, comparator identity deliberately excludes

# subject binary/version, names and subject-specific prompt IDs.

COMPARISON_FIELDS = (

    "benchmark_track", "command_semantics_version", "fixture_version", "scenario_version",

    "oracle_version", "runner_class", "cache_state", "remote_transport", "remote_server",

    "netshape_profile", "env_isolation_version", "calibration_version",

    "platform_semantics_version", "agent.model", "agent.adapter", "agent.provider",

    "agent.version", "agent.temperature", "agent.max_output_tokens", "agent.environment",

    "agent.instruction_level", "output_oracle_version", "patch_oracle_version", "load_tier",

)

COMPARISON_IDENTITY_VERSION = 1

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

    identity = {"schema_version": COMPARISON_IDENTITY_VERSION}

    for name in COMPARISON_FIELDS:

        value: Any = row

        for part in name.split("."):

            value = value.get(part) if isinstance(value, dict) else None

        identity[name] = value

    fixture = row.get("fixture")

    if identity["fixture_version"] is None and isinstance(fixture, dict):

        identity["fixture_version"] = fixture.get("fixture_version", fixture.get("version"))

    if identity["agent.instruction_level"] is None:

        identity["agent.instruction_level"] = row.get("instruction_level")

    oracle = row.get("oracle")

    if identity["oracle_version"] is None and isinstance(oracle, dict):

        identity["oracle_version"] = oracle.get("version")

    return identity

def comparison_conflicts(baseline: dict[str, Any], candidate: dict[str, Any]) -> list[str]:

    return sorted(name for name in ("schema_version", *COMPARISON_FIELDS)

                  if baseline.get(name) != candidate.get(name))

def missing_claim_identity(identity: dict[str, Any], lane: str, metric: str, operation: str) -> list[str]:

    required = {"benchmark_track", "command_semantics_version", "fixture_version", "env_isolation_version"}

    if metric.endswith("_ms") or metric == "elapsed_ms":

        required.update(("runner_class", "cache_state"))

        if lane in {"core", "workflow"}:

            required.add("load_tier")

    if lane == "agent":

        required.update(("scenario_version", "oracle_version", "agent.model", "agent.adapter",

                         "agent.provider", "agent.version", "agent.environment", "agent.instruction_level"))

    if "remote" in operation or identity.get("remote_transport") is not None:

        required.update(("remote_transport", "remote_server"))

    if identity.get("remote_transport") == "network_shaped":

        required.add("netshape_profile")

    if metric == "tokens" or "token" in metric:

        required.add("calibration_version")

    unknown = {"", "unknown", "unmeasured", "unavailable", "unspecified", "not_measured"}

    missing = [name for name in required if identity.get(name) is None or

               (isinstance(identity.get(name), str) and identity[name].lower() in unknown)]

    if identity.get("schema_version") != COMPARISON_IDENTITY_VERSION:

        missing.append("schema_version")

    return sorted(missing)

def independent_run_count(rows: list[dict[str, Any]]) -> int | None:

    """Distinct recorded trial IDs, not proof of independence across sessions."""

    identifiers = set()

    for row in rows:

        if (not isinstance(row.get("bench_id"), str) or not row["bench_id"] or

                type(row.get("run")) is not int or row["run"] < 0):

            return None

        identifiers.add(json.dumps([row["bench_id"], row["run"]], sort_keys=True))

    return len(identifiers)