from __future__ import annotations

import re
from pathlib import Path
from typing import Any


TEXT_SUFFIXES = {".md", ".py", ".json", ".jsonl", ".toml", ".yaml", ".yml", ".txt"}
FORBIDDEN = {
    "Hugging Face access token": re.compile("h" + r"f_[A-Za-z0-9]{20,}"),
    "macOS user path": re.compile("/" + r"Users/[^/\s]+/"),
    "Linux user path": re.compile("/" + r"home/[^/\s]+/"),
    "private key": re.compile(r"-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----"),
    "loopback URL in public result": re.compile(r"https?://(?:127\.0\.0\.1|localhost):\d+"),
}

PUBLIC_METADATA_KEYS = {
    "target_prompt_tokens",
    "requested_position",
    "actual_position",
    "query_placement",
    "family",
    "matrix",
    "agentic_control_profile",
    "agentic_set",
    "agentic_family",
    "real_repo",
    "max_turns",
    "max_tool_calls",
}
PUBLIC_TELEMETRY_KEYS = {
    "wall_s",
    "ttft_s",
    "prompt_tokens",
    "completion_tokens",
    "cached_tokens",
    "end_to_end_tokens_per_second",
    "prefill_tokens_per_second",
    "decode_tokens_per_second",
    "active_memory_bytes",
    "peak_memory_bytes",
    "tool_call_count",
    "dispatched_tool_call_count",
    "blocked_duplicate_count",
    "blocked_stall_count",
    "terminal_correction_count",
    "format_normalization_count",
    "receipt_projection_count",
}
PUBLIC_REQUEST_OVERRIDE_KEYS = {
    "temperature",
    "top_p",
    "top_k",
    "max_tokens",
    "reasoning_effort",
    "thinking",
    "mtp_depth",
    "speculative_depth",
}


def scan_public_tree(root: Path) -> dict[str, Any]:
    failures = []
    for path in sorted(root.rglob("*")):
        if not path.is_file() or path.suffix.lower() not in TEXT_SUFFIXES:
            continue
        relative = path.relative_to(root).as_posix()
        if any(part in {".git", ".pytest_cache", "__pycache__"} for part in path.parts):
            continue
        text = path.read_text(encoding="utf-8", errors="replace")
        for label, pattern in FORBIDDEN.items():
            if pattern.search(text):
                failures.append({"file": relative, "issue": label})
    return {"ok": not failures, "failures": failures, "files_scanned": sum(1 for p in root.rglob("*") if p.is_file())}


def _public_scalar(value: Any) -> bool:
    return value is None or isinstance(value, (bool, int, float, str))


def _error_category(error: Any) -> str | None:
    if error in (None, ""):
        return None
    text = str(error).lower()
    if "timeout" in text or "timed out" in text:
        return "timeout"
    if "budget" in text:
        return "budget_exceeded"
    if "missing required calls" in text:
        return "missing_required_calls"
    if "forbidden calls" in text:
        return "forbidden_calls"
    if "prompt token" in text or "token count" in text:
        return "token_count_mismatch"
    if "http" in text or "api" in text or "request" in text:
        return "request_error"
    return "evaluation_error"


def sanitize_result_row(row: dict[str, Any]) -> dict[str, Any]:
    metadata = {
        key: value
        for key, value in (row.get("metadata") or {}).items()
        if key in PUBLIC_METADATA_KEYS and _public_scalar(value)
    }
    telemetry = {
        key: value
        for key, value in (row.get("telemetry") or {}).items()
        if key in PUBLIC_TELEMETRY_KEYS and _public_scalar(value)
    }
    return {
        "schema_version": "1.0-public",
        "suite_id": str(row.get("suite_id") or ""),
        "case_id": str(row.get("case_id") or ""),
        "lane": str(row.get("lane") or ""),
        "variant": str(row.get("variant") or ""),
        "passed": bool(row.get("passed")),
        "score": float(row.get("score") or 0),
        "score_max": float(row.get("score_max") or 0),
        "error_category": _error_category(row.get("error")),
        "telemetry": telemetry,
        "metadata": metadata,
    }


def _sanitize_request_overrides(value: Any) -> dict[str, Any]:
    if not isinstance(value, dict):
        return {}
    clean: dict[str, Any] = {}
    for key, item in value.items():
        if key not in PUBLIC_REQUEST_OVERRIDE_KEYS:
            continue
        if key == "thinking" and isinstance(item, dict):
            clean[key] = {"enabled": bool(item.get("enabled"))}
        elif _public_scalar(item):
            clean[key] = item
    return clean


def sanitize_manifest(manifest: dict[str, Any]) -> dict[str, Any]:
    variants = []
    for variant in manifest.get("variants") or []:
        if not isinstance(variant, dict):
            continue
        variants.append(
            {
                "label": str(variant.get("label") or ""),
                "request_overrides": _sanitize_request_overrides(
                    variant.get("request_overrides")
                ),
            }
        )
    clean: dict[str, Any] = {
        "schema_version": "1.0-public",
        "suite_id": str(manifest.get("suite_id") or ""),
        "benchmark_version": str(manifest.get("benchmark_version") or ""),
        "config_sha256": manifest.get("config_sha256"),
        "tokenizer_fingerprint": manifest.get("tokenizer_fingerprint"),
        "planned_cases": manifest.get("planned_cases"),
        "requested_prompt_tokens": manifest.get("requested_prompt_tokens"),
        "variants": variants,
        "claim_policy": {
            "raw_model_outputs_included": False,
            "quality_and_performance_separate": True,
            "single_aggregate_intelligence_score": False,
        },
    }
    for key in (
        "evaluated_artifact",
        "benchmark_source",
        "agentic_control_profile",
        "agentic_set",
    ):
        value = manifest.get(key)
        if key in {"evaluated_artifact", "benchmark_source"} and isinstance(value, dict):
            clean[key] = {
                "repo_id": str(value.get("repo_id") or ""),
                "revision": str(value.get("revision") or ""),
            }
        elif _public_scalar(value) and value is not None:
            clean[key] = value
    return {key: value for key, value in clean.items() if value is not None}