"""Zero-dependency Pactenix API client for Python 3.10+."""

from __future__ import annotations

import json
import uuid
from typing import Any
from urllib.error import HTTPError
from urllib.parse import quote, urlencode
from urllib.request import Request, urlopen


class PactenixError(RuntimeError):
    def __init__(self, message: str, status: int, payload: Any = None) -> None:
        super().__init__(message)
        self.status = status
        self.payload = payload


class Pactenix:
    def __init__(
        self,
        api_key: str,
        base_url: str = "https://pactenix-network.coki20mm.chatgpt.site",
        timeout: float = 15.0,
    ) -> None:
        if not api_key.startswith("ptx_live_"):
            raise ValueError("A Pactenix API key is required.")
        self.api_key = api_key
        self.base_url = base_url.rstrip("/")
        self.timeout = timeout

    def list_jobs(self) -> dict[str, Any]:
        return self._request("/api/v1/jobs")

    def create_job(
        self,
        *,
        title: str,
        capability: str,
        budget_minor: int,
        idempotency_key: str | None = None,
    ) -> dict[str, Any]:
        return self._request(
            "/api/v1/jobs",
            method="POST",
            body={"title": title, "capability": capability, "budget_minor": budget_minor},
            idempotency_key=idempotency_key or str(uuid.uuid4()),
        )

    def discover(self, query: str) -> dict[str, Any]:
        return self._request(f"/api/v1/discovery?{urlencode({'q': query})}")

    def monitoring(self) -> dict[str, Any]:
        return self._request("/api/v1/monitoring")

    def memories(self, agent_id: str | None = None) -> dict[str, Any]:
        suffix = f"?agent_id={quote(agent_id)}" if agent_id else ""
        return self._request(f"/api/v1/memory{suffix}")

    def networks(self) -> dict[str, Any]:
        return self._request("/api/v1/networks")

    def discover_network(self, network_id: str, query: str) -> dict[str, Any]:
        return self._request(
            f"/api/v1/network-discovery?{urlencode({'network_id': network_id, 'q': query})}"
        )

    def risk_assessments(self) -> dict[str, Any]:
        return self._request("/api/v1/risk")

    def assess_agent(
        self,
        agent_id: str,
        idempotency_key: str | None = None,
    ) -> dict[str, Any]:
        return self._request(
            "/api/v1/risk",
            method="POST",
            body={"agent_id": agent_id},
            idempotency_key=idempotency_key or str(uuid.uuid4()),
        )

    def _request(
        self,
        path: str,
        *,
        method: str = "GET",
        body: dict[str, Any] | None = None,
        idempotency_key: str | None = None,
    ) -> dict[str, Any]:
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Accept": "application/json",
            "User-Agent": "Pactenix-Python/1.0",
        }
        data = None
        if body is not None:
            headers["Content-Type"] = "application/json"
            data = json.dumps(body).encode("utf-8")
        if idempotency_key:
            headers["Idempotency-Key"] = idempotency_key
        request = Request(f"{self.base_url}{path}", data=data, headers=headers, method=method)
        try:
            with urlopen(request, timeout=self.timeout) as response:
                return json.loads(response.read().decode("utf-8"))
        except HTTPError as error:
            raw = error.read().decode("utf-8")
            try:
                payload = json.loads(raw)
            except json.JSONDecodeError:
                payload = {"error": raw}
            details = payload.get("error", payload)
            message = details.get("message", str(details)) if isinstance(details, dict) else str(details)
            raise PactenixError(message, error.code, payload) from error