"""
MoonBase Python SDK — v0.1

Minimal requests wrapper around the public REST + GraphQL API.

    pip install requests
    from moonbase import MoonBase
    mb = MoonBase(api_key="mb_live_...")
    report = mb.reports.get("acme-protocol")
    results = mb.search(industry="Web3", limit=10)
    gql = mb.graphql("{ me { sandbox } }")
"""
from __future__ import annotations
import hmac, hashlib
from typing import Any, Dict, Optional
import requests


class _Reports:
    def __init__(self, parent: "MoonBase"): self._p = parent
    def get(self, slug: str) -> Dict[str, Any]:
        return self._p._req("GET", f"/reports/{slug}")


class MoonBase:
    def __init__(self, api_key: str, base_url: str = "https://base.moonrig.io/api/public/v1"):
        if not api_key: raise ValueError("api_key required")
        self.api_key = api_key
        self.base_url = base_url.rstrip("/")
        self.reports = _Reports(self)

    def _req(self, method: str, path: str, **kwargs) -> Dict[str, Any]:
        headers = kwargs.pop("headers", {})
        headers.setdefault("Authorization", f"Bearer {self.api_key}")
        headers.setdefault("Content-Type", "application/json")
        r = requests.request(method, f"{self.base_url}{path}", headers=headers, **kwargs)
        r.raise_for_status()
        return r.json()

    def search(self, *, q: Optional[str] = None, industry: Optional[str] = None,
               stage: Optional[str] = None, min_score: Optional[int] = None,
               limit: Optional[int] = None) -> Dict[str, Any]:
        params = {k: v for k, v in {
            "q": q, "industry": industry, "stage": stage,
            "min_score": min_score, "limit": limit,
        }.items() if v is not None}
        return self._req("GET", "/search", params=params)

    def graphql(self, query: str, variables: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        return self._req("POST", "/graphql", json={"query": query, "variables": variables or {}})

    @staticmethod
    def verify_webhook(raw_body: bytes, signature_header: str, signing_secret: str) -> bool:
        """Verify HMAC-SHA256 signature on an incoming webhook delivery."""
        expected = "sha256=" + hmac.new(
            signing_secret.encode(), raw_body, hashlib.sha256
        ).hexdigest()
        return hmac.compare_digest(expected, signature_header or "")