#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
odata_scel — client Python officiel pour 0DATA Scel (SPINA API v3).

Preuve-as-a-Service : scellez une donnée (SHA-256 + horodatage + ancrage
Hedera HCS) en une requête HTTP. Clé API, quota, crédits, fichier-clé,
verticales réglementaires (C2PA, consentement RGPD, agent IA, incident NIS2).

Zéro dépendance (stdlib uniquement) — Python 3.7+.

Usage minimal
-------------
    from odata_scel import SpinaClient

    spina = SpinaClient(api_key="scel_live_...")   # ou SpinaClient() = invité

    proof = spina.seal("contrat signé v1")
    print(proof["proof"]["digest"])               # SHA-256 de la donnée
    print(spina.verify("contrat signé v1", proof["proof"]))  # {"valid": True}

    # Sceller un fichier SANS l'envoyer (zéro donnée) :
    r = spina.seal_file("contrat.pdf")
    # r["proof"]["digest"] == SHA-256 du hash SHA-256 du fichier (voir doc).

Clé API : obtenue sur https://scel.0data.fr/docs.html (création self-service),
ou via spina.create_key("vous@exemple.fr").
"""
from __future__ import annotations

import json
import hashlib
import urllib.request
import urllib.error
import urllib.parse
import os

__version__ = "1.0.0"
__all__ = ["SpinaClient", "SpinaError"]

DEFAULT_BASE = "https://scel.0data.fr"
DEFAULT_PREFIX = "/api"


class SpinaError(Exception):
    """Erreur API (statut HTTP + message serveur)."""

    def __init__(self, status: int, message: str, body=None):
        self.status = status
        self.message = message
        self.body = body or {}
        super().__init__(f"[{status}] {message}")


class SpinaClient:
    """Client HTTP pour l'API 0DATA Scel (SPINA)."""

    def __init__(
        self,
        base_url: str = DEFAULT_BASE,
        api_prefix: str = DEFAULT_PREFIX,
        api_key: str | None = None,
        keyfile_id: str | None = None,
        keyfile_hash: str | None = None,
        timeout: float = 30.0,
    ):
        """
        base_url     : racine du serveur (défaut https://scel.0data.fr).
                       Pour un accès direct local : SpinaClient(base_url="http://127.0.0.1:5099", api_prefix="")
        api_prefix   : préfixe des endpoints (défaut /api — nginx le strippe en prod).
        api_key      : clé API `scel_live_...` (ou lire env O_DATA_SCEL_KEY).
        keyfile_id / keyfile_hash : login par fichier-clé (Bearer keyfile_id:file_hash).
        """
        self.base_url = base_url.rstrip("/")
        self.api_prefix = api_prefix
        self.api_key = api_key or os.environ.get("O_DATA_SCEL_KEY", "").strip() or None
        self.keyfile_id = keyfile_id
        self.keyfile_hash = keyfile_hash
        self.timeout = timeout

    # ── auth ──────────────────────────────────────────────
    def _credential(self):
        """Renvoie le Bearer à utiliser, ou None (invité)."""
        if self.keyfile_id and self.keyfile_hash:
            return f"{self.keyfile_id}:{self.keyfile_hash}"
        return self.api_key

    def _headers(self):
        h = {"Content-Type": "application/json", "Accept": "application/json"}
        cred = self._credential()
        if cred:
            h["Authorization"] = f"Bearer {cred}"
        return h

    # ── transport ────────────────────────────────────────
    def _request(self, method: str, path: str, body=None, params=None) -> dict:
        url = f"{self.base_url}{self.api_prefix}{path}"
        if params:
            url += "?" + urllib.parse.urlencode(params)
        data = None
        if body is not None:
            data = json.dumps(body).encode("utf-8")
        req = urllib.request.Request(url, data=data, method=method, headers=self._headers())
        try:
            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
                raw = resp.read()
                if not raw:
                    return {}
                return json.loads(raw.decode("utf-8"))
        except urllib.error.HTTPError as e:
            raw = e.read()
            try:
                parsed = json.loads(raw.decode("utf-8")) if raw else {}
            except Exception:
                parsed = {"error": raw.decode("utf-8", "replace")}
            msg = parsed.get("error") or parsed.get("detail") or f"HTTP {e.code}"
            raise SpinaError(e.code, msg, parsed) from None
        except urllib.error.URLError as e:
            raise SpinaError(0, f"Réseau : {e.reason}") from None

    def _get(self, path, params=None):
        return self._request("GET", path, params=params)

    def _post(self, path, body=None):
        return self._request("POST", path, body=body)

    # ── scellement ───────────────────────────────────────
    def seal(self, data, mode: str = "local", tsa: str | None = None) -> dict:
        """
        Scelle une donnée.

        data : str (UTF-8) ou dict (canonicalisé : clés triées). Le serveur
               calcule `digest = SHA-256(data)`. Pour sceller un fichier sans
               l'envoyer, calculez son SHA-256 côté client et passez le hash
               hex en `data` (voir seal_file).
        mode : "local" (Ed25519, auto-vérifiable) | "eidas" (RFC 3161).
        tsa  : pour mode=eidas — "freetsa" | "certigna" | "universign".
        """
        body = {"data": data, "mode": mode}
        if tsa:
            body["tsa"] = tsa
        return self._post("/seal", body)

    def seal_file(self, path: str, mode: str = "local", tsa: str | None = None) -> dict:
        """
        Scelle un fichier SANS l'envoyer : calcule SHA-256(file) localement et
        scelle le hash hex. La donnée brute ne quitte jamais la machine.
        Le `proof["digest"]` renvoyé est donc SHA-256 du hash hex du fichier.
        """
        h = hashlib.sha256()
        with open(path, "rb") as f:
            for chunk in iter(lambda: f.read(65536), b""):
                h.update(chunk)
        file_sha256 = h.hexdigest()
        resp = self.seal(file_sha256, mode=mode, tsa=tsa)
        resp["file_sha256"] = file_sha256
        return resp

    def verify(self, data, proof: dict) -> dict:
        """Vérifie qu'une donnée correspond à sa preuve (gratuit, sans quota)."""
        return self._post("/verify", {"data": data, "proof": proof})

    # ── compte & clés ────────────────────────────────────
    def create_key(self, email: str, file_hash: str | None = None) -> dict:
        """Inscription : crée compte + clé API + fichier-clé (clé affichée une seule fois)."""
        body = {"email": email}
        if file_hash:
            body["file_hash"] = file_hash
        return self._post("/keys", body)

    def keyfile_login(self, keyfile_id: str, file_hash: str) -> dict:
        """Login par fichier-clé (renvoie plan, quota, account_id)."""
        return self._post("/auth/keyfile", {"keyfile_id": keyfile_id, "file_hash": file_hash})

    def usage(self) -> dict:
        """État de consommation de la clé (plan, quota, crédits)."""
        return self._get("/usage")

    def account(self) -> dict:
        """Vue complète du compte (plan, quota, crédits, abo, liste des clés)."""
        return self._get("/account")

    def account_seals(self) -> dict:
        """Historique des scels du compte (50 derniers)."""
        return self._get("/account/seals")

    def add_key(self) -> dict:
        """Ajoute une clé API au compte (réservé au login fichier-clé)."""
        return self._post("/account/keys")

    def revoke_key(self, key_id: int) -> dict:
        """Révoque une clé API (pas la clé maître)."""
        return self._post("/account/keys/revoke", {"key_id": key_id})

    def rotate_keyfile(self) -> dict:
        """Rotation de la clé maître (nouveau fichier .key, ancienne désactivée)."""
        return self._post("/account/keyfile/rotate")

    def create_webhook(self, url: str, events: str = "seal") -> dict:
        """Abonne un webhook sortant (déclenché à chaque scel ancré). Réservé au login fichier-clé."""
        return self._post("/webhooks", {"url": url, "events": events})

    def list_webhooks(self) -> dict:
        """Liste les webhooks du compte."""
        return self._get("/webhooks")

    def delete_webhook(self, webhook_id: int) -> dict:
        """Supprime un webhook."""
        return self._post("/webhooks/delete", {"id": webhook_id})

    # ── facturation ──────────────────────────────────────
    def checkout(self, product: str, email: str, account_id: int | None = None,
                 key_id: int | None = None) -> dict:
        """Session Stripe Checkout (product = standard | pro | pack100 | pack500)."""
        body = {"product": product, "email": email}
        if account_id:
            body["account_id"] = account_id
        if key_id:
            body["key_id"] = key_id
        return self._post("/checkout", body)

    def checkout_verticale(self, verticale: str, email: str) -> dict:
        """Checkout Stripe pour une verticale réglementaire (prospect froid)."""
        return self._post("/checkout/verticale", {"verticale": verticale, "email": email})

    def delivery(self, session_id: str) -> dict:
        """Remise de la config après paiement (show-once)."""
        return self._get("/delivery", {"session_id": session_id})

    # ── verticales ───────────────────────────────────────
    def contrefacon(self, url: str, digest: str | None = None, proof: dict | None = None) -> dict:
        """Contrefaçon inversée : fetch sécurisé + hash + comparaison optionnelle."""
        body = {"url": url}
        if digest:
            body["digest"] = digest
        if proof:
            body["proof"] = proof
        return self._post("/contrefacon", body)

    def c2pa(self, manifest, mode: str = "local", tsa: str | None = None,
             content_hash: str | None = None, origin: str | None = None) -> dict:
        """Preuve d'origine de contenu (C2PA / Content Credentials)."""
        body = {"manifest": manifest, "mode": mode}
        if tsa:
            body["tsa"] = tsa
        if content_hash:
            body["content_hash"] = content_hash
        if origin:
            body["origin"] = origin
        return self._post("/c2pa", body)

    def consent(self, purpose: str, consent: str, email: str | None = None,
                identity: dict | None = None, consent_mode: str = "text",
                lang: str = "fr", granted: bool = True,
                seal_mode: str = "local", tsa: str | None = None) -> dict:
        """Preuve de consentement scellée + ancrée (RGPD art.7)."""
        body = {"purpose": purpose, "consent": consent, "consent_mode": consent_mode,
                "lang": lang, "granted": granted, "seal_mode": seal_mode}
        if email:
            body["email"] = email
        if identity:
            body["identity"] = identity
        if tsa:
            body["tsa"] = tsa
        return self._post("/consent", body)

    def agent(self, agent_id: str, action: str, decision: str | None = None,
              input_digest: str | None = None, context: dict | None = None,
              seal_mode: str = "local", tsa: str | None = None) -> dict:
        """Preuve d'exécution d'un agent IA (AI Act art.12)."""
        body = {"agent_id": agent_id, "action": action, "seal_mode": seal_mode}
        if decision is not None:
            body["decision"] = decision
        if input_digest:
            body["input_digest"] = input_digest
        if context:
            body["context"] = context
        if tsa:
            body["tsa"] = tsa
        return self._post("/agent", body)

    def incident(self, incident_id: str, phase: str, description: str | None = None,
                 severity: str | None = None, seal_mode: str = "local",
                 tsa: str | None = None) -> dict:
        """Timeline d'incident NIS2 (phase = detection/qualification/notification/remediation)."""
        body = {"incident_id": incident_id, "phase": phase, "seal_mode": seal_mode}
        if description:
            body["description"] = description
        if severity:
            body["severity"] = severity
        if tsa:
            body["tsa"] = tsa
        return self._post("/incident", body)

    # ── méta ─────────────────────────────────────────────
    def chain(self) -> dict:
        """État de la chaîne d'audit immuable + ancrage Hedera."""
        return self._get("/chain")

    def pubkey(self) -> dict:
        """Clé publique Ed25519 du mode local (vérification sans serveur)."""
        return self._get("/pubkey")

    def proof(self, digest: str) -> dict:
        """Récupère une preuve stockée (consentement/agent/incident) par digest."""
        return self._get(f"/proof/{digest}")

    def modes(self) -> list:
        """Modes de scellement disponibles."""
        return self._get("/modes")

    def plans(self) -> dict:
        """Plans, packs de crédits et prix unitaires."""
        return self._get("/plans")

    def health(self) -> dict:
        """État du service."""
        return self._get("/health")


# ── autotest (sans clé = mode invité) ───────────────────
if __name__ == "__main__":
    import sys
    spina = SpinaClient()
    print("── 0DATA Scel · autotest ──")
    h = spina.health()
    print("health :", h)
    print("modes  :", [m["id"] for m in spina.modes()])
    r = spina.seal("autotest-" + str(h.get("service", "")).replace(" ", "-"))
    ok = r.get("ok")
    print("seal   : ok=%s digest=%s" % (ok, r.get("proof", {}).get("digest", "?")[:16]))
    if ok:
        v = spina.verify("autotest-" + str(h.get("service", "")).replace(" ", "-"), r["proof"])
        print("verify :", v)
    sys.exit(0 if ok else 1)
