#!/usr/bin/env python3
"""Vidimus voor uw eigen systeem (TMS, ERP, WMS, sensorplatform) — zonder dat Vidimus iets kan lezen of in uw naam kan tekenen.

Wat dit bestand doet, op uw eigen server:
  1. een eigen tekensleutel (Ed25519) maken en bewaren; Vidimus krijgt alleen de publieke helft;
  2. de inhoud versleutelen met de publieke bedrijfssleutel van uw organisatie (vertrouwelijke stroom): Vidimus ziet alleen de
     envelop (type, ref) en de vingerafdrukken;
  3. registreren en de vingerafdruk zelf tekenen. Daarna verankert Vidimus: extern tijdstempel, Merkle-wortel, Bitcoin.

Nodig: Python 3.9+, `pip install cryptography requests`.

De stroom ("str_…") bestaat al: een beheerder maakt hem in de app (Nieuwe stroom). Zonder eID-mandaat van de organisatie geeft
POST /streams 428 mandaat_vereist: eerst het eID-mandaat van de organisatie (een bestuurder tekent één keer, golf 4).

Eenmalig (beheerder, in de app of met de organisatiesleutel):
    python3 vidimus_sdk.py sleutel --uit tms.key                      # maakt tms.key en toont de publieke helft
    → in de app: Verbruik › Bronnen › Software toevoegen met die publieke sleutel (of POST /sources {"naam","soort":"systeem","public_pem"})
    → maak voor die bron een sleutel per systeem (vks_…) onder Ontwikkelaars › Sleutels

Daarna, per registratie:
    from vidimus_sdk import Vidimus
    v = Vidimus("https://app.vidimus.be", api_sleutel="vks_…", tekensleutel="tms.key")
    r = v.registreer("str_…", {"cmr": "CMR-2026-0917", "colli": 26}, bestanden=["cmr.pdf"], ref="CMR-2026-0917")
    print(r["id"], r["status"])   # pending-anchor: getekend, binnen vijf minuten verankerd

Op een vertrouwelijke stroom versleutelt registreer() automatisch; op een gewone stroom gaat de inhoud leesbaar mee (laag A).
Formaat van de versleuteling: identiek aan de app (laagb.js): per bestand AES-256-GCM, bestandssleutel vergrendeld met RSA-OAEP-SHA-256.
"""
import base64
import hashlib
import json
import os
import re
import sys
from pathlib import Path

ALG = "RSA-OAEP-256+A256GCM"
ENVELOP = ("type", "ref", "bron", "kanaal", "document_sha256")


def _b64(b: bytes) -> str:
    return base64.b64encode(b).decode()


# ── tekensleutel ────────────────────────────────────────────────────────────────────────────────────────────────────────────────
def maak_tekensleutel(pad: str, wachtzin: bytes = None) -> str:
    """Nieuwe Ed25519-sleutel in `pad` (alleen leesbaar voor deze gebruiker). Geeft de publieke helft (PEM) terug."""
    from cryptography.hazmat.primitives import serialization as S
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
    p = Path(pad)
    if p.exists(): raise FileExistsError(f"{pad} bestaat al: overschrijven zou de oude sleutel vernietigen")
    k = Ed25519PrivateKey.generate()
    enc = S.BestAvailableEncryption(wachtzin) if wachtzin else S.NoEncryption()
    fd = os.open(p, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
    with os.fdopen(fd, "wb") as f: f.write(k.private_bytes(S.Encoding.PEM, S.PrivateFormat.PKCS8, enc))
    return k.public_key().public_bytes(S.Encoding.PEM, S.PublicFormat.SubjectPublicKeyInfo).decode()


def laad_tekensleutel(pad: str, wachtzin: bytes = None):
    from cryptography.hazmat.primitives import serialization as S
    return S.load_pem_private_key(Path(pad).read_bytes(), password=wachtzin)


# ── versleutelen (zelfde formaat als de app) ────────────────────────────────────────────────────────────────────────────────────
def versleutel(public_pem: str, data: bytes) -> tuple:
    """(cijfertekst_b64, meta) — meta = {enc, sha256 van het origineel, iv, sleutel (vergrendeld), alg}."""
    from cryptography.hazmat.primitives import hashes, serialization as S
    from cryptography.hazmat.primitives.asymmetric import padding
    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
    pub = S.load_pem_public_key(public_pem.encode())
    dek, iv = os.urandom(32), os.urandom(12)
    ct = AESGCM(dek).encrypt(iv, data, None)
    wrapped = pub.encrypt(dek, padding.OAEP(mgf=padding.MGF1(hashes.SHA256()), algorithm=hashes.SHA256(), label=None))
    return _b64(ct), {"enc": True, "sha256": hashlib.sha256(data).hexdigest(), "iv": _b64(iv), "sleutel": _b64(wrapped), "alg": ALG}


def pak_in(public_pem: str, envelop: dict, inhoud: dict, bestanden: list) -> dict:
    """bestanden = [(naam, bytes)]. Geeft {payload (alleen envelop), attachments, att_meta}; de echte bestandsnamen zitten in inhoud.json."""
    attachments, att_meta, namen = {}, {}, {}
    for i, (naam, data) in enumerate(bestanden or [], 1):
        m = re.search(r"\.[A-Za-z0-9]{1,5}$", naam); ext = m.group(0).lower() if m else ""
        nm = f"bijlage-{i:02d}{ext}"
        attachments[nm], att_meta[nm] = versleutel(public_pem, data); namen[nm] = naam
    # willekeurig zout: de vingerafdruk van een korte inhoud is publiek en anders te raden door alle mogelijkheden te proberen
    js = json.dumps({**(inhoud or {}), "bijlagen": namen, "_zout": _b64(os.urandom(16))}, ensure_ascii=False, separators=(",", ":")).encode()
    attachments["inhoud.json"], att_meta["inhoud.json"] = versleutel(public_pem, js)
    return {"payload": envelop or {}, "attachments": attachments, "att_meta": att_meta}


# ── de client ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────
class Vidimus:
    def __init__(self, url: str, api_sleutel: str, tekensleutel: str, wachtzin: bytes = None, timeout: int = 60):
        import requests
        self.url = url.rstrip("/"); self.timeout = timeout
        self.s = requests.Session(); self.s.headers.update({"x-api-key": api_sleutel})
        self.sleutel = laad_tekensleutel(tekensleutel, wachtzin)
        self._stromen = {}; self._bedrijf = None

    def _get(self, pad):
        r = self.s.get(self.url + pad, timeout=self.timeout); r.raise_for_status(); return r.json()

    def _post(self, pad, body):
        r = self.s.post(self.url + pad, json=body, timeout=self.timeout)
        if r.status_code >= 400: raise RuntimeError(f"{pad}: {r.status_code} {r.text[:300]}")
        return r.json()

    def vertrouwelijk(self, stroom: str) -> bool:
        if stroom not in self._stromen:
            st = next((x for x in self._get("/streams") if x["id"] == stroom), None)
            if st is None: raise KeyError(f"onbekende stroom {stroom} (of deze sleutel mag er niet in)")
            self._stromen[stroom] = bool(st.get("vertrouwelijk"))
        return self._stromen[stroom]

    def bedrijfssleutel(self) -> str:
        if self._bedrijf is None:
            b = self._get("/org/bedrijfssleutel")
            if b.get("status") != "actief": raise RuntimeError("de bedrijfssleutel van uw organisatie is niet actief (Instellingen › Vertrouwelijke logboeken)")
            self._bedrijf = b["public_pem"]
        return self._bedrijf

    def registreer(self, stroom: str, velden: dict, bestanden: list = None, ref: str = None, type_: str = None, idempotentie: str = None) -> dict:
        """velden = de inhoud; bestanden = paden of (naam, bytes). Tekent zelf; geeft de registratie terug (status pending-anchor)."""
        bestanden = [(Path(b).name, Path(b).read_bytes()) if isinstance(b, (str, Path)) else b for b in (bestanden or [])]
        if self.vertrouwelijk(stroom):
            envelop = {k: v for k, v in {"ref": ref, "type": type_}.items() if v}
            body = {"stream_id": stroom, **pak_in(self.bedrijfssleutel(), envelop, velden, bestanden)}
        else:
            body = {"stream_id": stroom, "payload": {**velden, **({"ref": ref} if ref else {})},
                    "attachments": {n: _b64(d) for n, d in bestanden}}
        if ref: body["ref"] = ref
        if idempotentie: body["idempotency_key"] = idempotentie
        reg = self._post("/registrations", body)
        if reg.get("status") == "unsigned":   # eigen sleutel: wij tekenen de vingerafdruk, Vidimus kan dat niet
            reg = {**reg, **self._post(f"/registrations/{reg['id']}/sign", {"signature_b64": _b64(self.sleutel.sign(bytes.fromhex(reg["hash"])))})}
        return reg


if __name__ == "__main__":
    if len(sys.argv) >= 2 and sys.argv[1] == "sleutel":
        uit = sys.argv[sys.argv.index("--uit") + 1] if "--uit" in sys.argv else "vidimus-systeem.key"
        print(maak_tekensleutel(uit))
        print(f"# privésleutel bewaard in {uit} (alleen voor deze gebruiker leesbaar). Geef Vidimus alleen de publieke helft hierboven.", file=sys.stderr)
    else:
        print(__doc__)
