"""
CSP API — Python istemcisi (yalnızca standart kütüphane, Python 3.8+)

    from csp_client import CspClient
    client = CspClient("https://csp.siteniz.com", "csp_live_...")
    r = client.analyze_file("dekont.pdf")
    if r["verdict_code"] == "forged": ...
"""
import base64
import json
import os
import urllib.error
import urllib.request


class CspError(Exception):
    def __init__(self, message, status=None, retry_after=None):
        super().__init__(message)
        self.status = status
        self.retry_after = retry_after


class CspClient:
    def __init__(self, base_url: str, api_key: str, timeout: int = 60):
        self.base_url = base_url.rstrip("/")
        self.api_key = api_key
        self.timeout = timeout

    def analyze_file(self, path: str, filename: str | None = None) -> dict:
        with open(path, "rb") as f:
            return self.analyze_bytes(f.read(), filename or os.path.basename(path))

    def analyze_bytes(self, data: bytes, filename: str = "dekont.pdf") -> dict:
        return self._request("POST", "/api/v1/analyze/base64",
                             {"file_base64": base64.b64encode(data).decode(), "filename": filename})

    def get_analysis(self, analysis_id: str) -> dict:
        return self._request("GET", f"/api/v1/analyses/{analysis_id}")

    def list_analyses(self, page: int = 1, size: int = 25, verdict: str = "") -> dict:
        q = f"?page={page}&size={size}" + (f"&verdict={verdict}" if verdict else "")
        return self._request("GET", "/api/v1/analyses" + q)

    def me(self) -> dict:
        return self._request("GET", "/api/v1/me")

    @staticmethod
    def verify_webhook(body: bytes, signature: str, secret: str) -> bool:
        import hashlib
        import hmac
        calc = "sha256=" + hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
        return hmac.compare_digest(calc, signature or "")

    def banks(self) -> list:
        return self._request("GET", "/api/v1/banks")

    @staticmethod
    def is_original(result: dict) -> bool:
        return result.get("verdict_code") == "original"

    @staticmethod
    def is_forged(result: dict) -> bool:
        return result.get("verdict_code") == "forged"

    def _request(self, method, path, payload=None):
        headers = {"X-API-Key": self.api_key, "Accept": "application/json"}
        body = None
        if payload is not None:
            body = json.dumps(payload).encode()
            headers["Content-Type"] = "application/json"
        req = urllib.request.Request(self.base_url + path, data=body, headers=headers, method=method)
        try:
            with urllib.request.urlopen(req, timeout=self.timeout) as res:
                return json.loads(res.read())
        except urllib.error.HTTPError as e:
            try:
                detail = json.loads(e.read()).get("detail")
            except Exception:
                detail = None
            msg = detail if isinstance(detail, str) else (json.dumps(detail, ensure_ascii=False) if detail else f"HTTP {e.code}")
            ra = e.headers.get("Retry-After")
            raise CspError(msg, e.code, int(ra) if ra else None) from None
        except urllib.error.URLError as e:
            raise CspError(f"Bağlantı hatası: {e.reason}") from None


if __name__ == "__main__":
    import sys
    c = CspClient(os.environ.get("CSP_URL", "http://localhost:8000"), os.environ.get("CSP_KEY", ""))
    r = c.analyze_file(sys.argv[1] if len(sys.argv) > 1 else "dekont.pdf")
    f = r["fields"]
    print(f"{r['verdict']} (risk {r['risk_score']}/100)" + (f" - {r['bank']}" if r.get("bank") else ""))
    print(f"  {f.get('sender')} -> {f.get('receiver')} · {(f.get('amount') or {}).get('text')}")
    for f in r["findings"]:
        print(f"  [{f['severity']}] {f['message']}")
