"""Stdlib GitHub REST client for the platform lane's harness-api driver.

Every call goes through one ``_request`` path that updates ``api_metrics``

with exact, observed values: request/response byte counts, the last-seen

``X-RateLimit-Remaining`` header, and GitHub request ids (capped at 50).

Token fields for this driver stay null in rows — API JSON is not an agent

transcript, so token costs would be fiction (ADR-0002: null means

unmeasured, never invented).

The transport is injectable: a callable taking a request dict

(``{"method", "url", "headers", "body"}``, body bytes or None) and returning

a response dict (``{"status", "headers", "body"}``, body bytes). Tests use

fake transports; the default transport uses urllib and never retries.

"""

from __future__ import annotations

import base64

import json

import time

import urllib.error

import urllib.request

from typing import Any, Callable, Optional

DEFAULT_BASE_URL = "https://api.github.com"

USER_AGENT = "oakbench-platform-lane"

API_VERSION = "2022-11-28"

REQUEST_ID_CAP = 50

DEFAULT_TIMEOUT_S = 30.0

Transport = Callable[[dict[str, Any]], dict[str, Any]]

class GitHubApiError(Exception):

    """An API response with status >= 400; carries the observed status."""

    def __init__(self, status: int, method: str, url: str, body_text: str) -> None:

        self.status = status

        self.method = method

        self.url = url

        self.body_text = body_text

        super().__init__(f"{method} {url} -> {status}: {body_text[:200]}")

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

    req = urllib.request.Request(

        request["url"],

        data=request["body"],

        method=request["method"],

        headers=request["headers"],

    )

    try:

        with urllib.request.urlopen(req, timeout=DEFAULT_TIMEOUT_S) as response:

            return {

                "status": response.status,

                "headers": dict(response.headers.items()),

                "body": response.read(),

            }

    except urllib.error.HTTPError as exc:

        return {

            "status": exc.code,

            "headers": dict(exc.headers.items()) if exc.headers else {},

            "body": exc.read(),

        }

def _header(headers: dict[str, Any], name: str) -> Optional[str]:

    wanted = name.lower()

    for key, value in headers.items():

        if str(key).lower() == wanted:

            return str(value)

    return None

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

    return {

        "request_count": 0,

        "request_bytes": 0,

        "response_bytes": 0,

        "rate_limit_remaining": None,

        "request_ids": [],

    }

class GitHubClient:

    """Minimal GitHub REST client with exact per-call accounting."""

    def __init__(

        self,

        base_url: str = DEFAULT_BASE_URL,

        token: Optional[str] = None,

        transport: Optional[Transport] = None,

    ) -> None:

        self.base_url = base_url.rstrip("/")

        self.token = token

        self.transport = transport or _urllib_transport

        self.api_metrics = new_api_metrics()

    # -- request plumbing ---------------------------------------------------

    def _headers(self, has_body: bool) -> dict[str, str]:

        headers = {

            "Accept": "application/vnd.github+json",

            "User-Agent": USER_AGENT,

            "X-GitHub-Api-Version": API_VERSION,

        }

        if self.token:

            headers["Authorization"] = f"Bearer {self.token}"

        if has_body:

            headers["Content-Type"] = "application/json"

        return headers

    def _request(self, method: str, path: str, payload: Optional[dict[str, Any]] = None) -> dict[str, Any]:

        url = self.base_url + path

        body = None if payload is None else json.dumps(payload, sort_keys=True).encode("utf-8")

        headers = self._headers(body is not None)

        response = self.transport({"method": method, "url": url, "headers": headers, "body": body})

        metrics = self.api_metrics

        metrics["request_count"] += 1

        header_bytes = sum(len(str(k)) + len(str(v)) for k, v in headers.items())

        metrics["request_bytes"] += len(method) + len(url) + header_bytes + len(body or b"")

        response_body = response.get("body") or b""

        metrics["response_bytes"] += len(response_body)

        response_headers = response.get("headers") or {}

        remaining = _header(response_headers, "X-RateLimit-Remaining")

        if remaining is not None:

            try:

                metrics["rate_limit_remaining"] = int(remaining)

            except ValueError:

                pass

        request_id = _header(response_headers, "X-GitHub-Request-Id")

        if request_id is not None:

            metrics["request_ids"].append(request_id)

            if len(metrics["request_ids"]) > REQUEST_ID_CAP:

                # Keep the most recent ids: late requests are the ones a

                # support escalation about a stuck merge actually needs.

                del metrics["request_ids"][: len(metrics["request_ids"]) - REQUEST_ID_CAP]

        status = int(response["status"])

        if status >= 400:

            raise GitHubApiError(status, method, url, response_body.decode("utf-8", "replace"))

        if not response_body:

            return {}

        return json.loads(response_body.decode("utf-8"))

    # -- pr_single_anatomy primitives ---------------------------------------

    def get_repo(self, owner_repo: str) -> dict[str, Any]:

        return self._request("GET", f"/repos/{owner_repo}")

    def get_main_sha(self, owner_repo: str, branch: str = "main") -> str:

        data = self._request("GET", f"/repos/{owner_repo}/git/ref/heads/{branch}")

        return str(data["object"]["sha"])

    def create_ref(self, owner_repo: str, ref: str, sha: str) -> dict[str, Any]:

        full_ref = ref if ref.startswith("refs/") else f"refs/heads/{ref}"

        return self._request("POST", f"/repos/{owner_repo}/git/refs", {"ref": full_ref, "sha": sha})

    def put_file(

        self,

        owner_repo: str,

        path: str,

        message: str,

        content: bytes,

        branch: str,

        sha: Optional[str] = None,

    ) -> dict[str, Any]:

        payload: dict[str, Any] = {

            "message": message,

            "content": base64.b64encode(content).decode("ascii"),

            "branch": branch,

        }

        if sha is not None:

            payload["sha"] = sha

        return self._request("PUT", f"/repos/{owner_repo}/contents/{path}", payload)

    def create_pr(

        self,

        owner_repo: str,

        title: str,

        head: str,

        base: str = "main",

        body: str = "",

    ) -> dict[str, Any]:

        return self._request(

            "POST",

            f"/repos/{owner_repo}/pulls",

            {"title": title, "head": head, "base": base, "body": body},

        )

    def get_pr(self, owner_repo: str, number: int) -> dict[str, Any]:

        return self._request("GET", f"/repos/{owner_repo}/pulls/{number}")

    def merge_pr(self, owner_repo: str, number: int, merge_method: str = "merge") -> dict[str, Any]:

        return self._request(

            "PUT", f"/repos/{owner_repo}/pulls/{number}/merge", {"merge_method": merge_method}

        )

    # -- check-instant protection variant primitives -------------------------

    # The harness itself posts the required status (deterministic, free, no

    # Actions); the race runner then settles on the combined status going

    # green. Accounting is identical to every other method: one _request.

    def post_status(

        self,

        owner_repo: str,

        sha: str,

        state: str,

        context: str,

        description: str = "",

        target_url: str = "",

    ) -> dict[str, Any]:

        payload: dict[str, Any] = {"state": state, "context": context}

        if description:

            payload["description"] = description

        if target_url:

            payload["target_url"] = target_url

        return self._request("POST", f"/repos/{owner_repo}/statuses/{sha}", payload)

    def get_combined_status(self, owner_repo: str, sha: str) -> dict[str, Any]:

        return self._request("GET", f"/repos/{owner_repo}/commits/{sha}/status")

    def delete_ref(self, owner_repo: str, ref: str) -> dict[str, Any]:

        short = ref[len("refs/"):] if ref.startswith("refs/") else f"heads/{ref}" if not ref.startswith("heads/") else ref

        return self._request("DELETE", f"/repos/{owner_repo}/git/refs/{short}")

class RateLimitBudgeter:

    """Pure pacing math to stay under an ops-per-hour budget.

    ``pace()`` returns the wait (seconds) the caller must inject before its

    next request. The budgeter records injected waits and never subtracts

    them from anything — the caller adds the value to its pacing accounting

    (race.pacing.injected) so paced waits stay visible in the data instead of

    silently inflating operation durations.

    """

    def __init__(self, ops_per_hour: int, clock: Optional[Callable[[], float]] = None) -> None:

        if ops_per_hour <= 0:

            raise ValueError(f"ops_per_hour must be positive, got {ops_per_hour!r}")

        self.ops_per_hour = ops_per_hour

        self.min_spacing_s = 3600.0 / float(ops_per_hour)

        self.clock = clock or time.monotonic

        self.injected_wait_s_total = 0.0

        self._next_slot: Optional[float] = None

    def pace(self) -> float:

        now = self.clock()

        if self._next_slot is None:

            self._next_slot = now + self.min_spacing_s

            return 0.0

        wait = max(0.0, self._next_slot - now)

        self._next_slot = max(now, self._next_slot) + self.min_spacing_s

        self.injected_wait_s_total += wait

        return wait