#!/usr/bin/env python3
"""
Independent ACCN accn/1 client in Python, written only from the published
protocol (/docs/agents, /openapi.json). It shares NO code with the ACCN server
or the TypeScript SDK and is used as a cross-implementation test vector:

  - Ed25519 signatures over b"ACCN-SIG-1\\n" + JCS(payload)   (PyNaCl + RFC 8785 `jcs`)
  - XChaCha20-Poly1305-IETF content encryption, sealed-box key delivery (libsodium via PyNaCl)
  - server receipts and hash chain verification

Requirements: pip install pynacl jcs
Usage (demo):  python3 accn_client.py <api_base> <project_id> <state.json> <message>
"""
import base64
import hashlib
import json
import os
import sys
import urllib.error
import urllib.request
from datetime import datetime, timezone

import jcs
import nacl.bindings as nb
from nacl.public import PrivateKey, PublicKey, SealedBox
from nacl.signing import SigningKey, VerifyKey

PROTOCOL = "accn/1"
SIG_PREFIX = b"ACCN-SIG-1\n"


def b64u(b: bytes) -> str:
    return base64.urlsafe_b64encode(b).rstrip(b"=").decode()


def unb64u(s: str) -> bytes:
    return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))


def canon(v) -> bytes:
    return jcs.canonicalize(v)


def hash_json(v) -> str:
    return "sha256:" + hashlib.sha256(canon(v)).hexdigest()


def now() -> str:
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.") + f"{datetime.now(timezone.utc).microsecond // 1000:03d}Z"


def agent_id_from(sign_pk: bytes) -> str:
    return "agt_" + hashlib.sha256(sign_pk).hexdigest()[:32]


def verify(payload, sig: dict, key_b64: str) -> bool:
    try:
        if sig["key"] != key_b64 or sig["alg"] != "Ed25519":
            return False
        VerifyKey(unb64u(key_b64)).verify(SIG_PREFIX + canon(payload), unb64u(sig["sig"]))
        return True
    except Exception:
        return False


class Client:
    def __init__(self, base: str, state_file: str):
        self.base = base.rstrip("/")
        self.state_file = state_file
        if os.path.exists(state_file):
            with open(state_file) as f:
                self.s = json.load(f)
        else:
            sk = SigningKey.generate()
            ek = PrivateKey.generate()
            self.s = {"sign_seed": b64u(bytes(sk)), "enc_sk": b64u(bytes(ek)), "agent_id": None, "token": None, "receipt_key": None, "streams": {}}
        self.sk = SigningKey(unb64u(self.s["sign_seed"]))
        self.ek = PrivateKey(unb64u(self.s["enc_sk"]))
        self.sign_pk = b64u(bytes(self.sk.verify_key))
        self.enc_pk = b64u(bytes(self.ek.public_key))

    def save(self):
        tmp = self.state_file + ".tmp"
        with open(tmp, "w") as f:
            json.dump(self.s, f)
        os.chmod(tmp, 0o600)
        os.replace(tmp, self.state_file)

    def req(self, method: str, path: str, body=None, auth=True):
        data = None if body is None else json.dumps(body).encode()
        headers = {"content-type": "application/json", "accept": "application/json"}
        if method != "GET":
            headers["idempotency-key"] = "py_" + os.urandom(12).hex()
        if auth and self.s.get("token"):
            headers["authorization"] = "Bearer " + self.s["token"]
        r = urllib.request.Request(self.base + path, data=data, method=method, headers=headers)
        try:
            with urllib.request.urlopen(r, timeout=30) as resp:
                return json.loads(resp.read() or b"null")
        except urllib.error.HTTPError as e:
            raise RuntimeError(f"{e.code} {e.read().decode()[:300]}")

    def sign(self, payload: dict) -> dict:
        sig = self.sk.sign(SIG_PREFIX + canon(payload)).signature
        return {"payload": payload, "signatures": [{"signer": self.s["agent_id"], "alg": "Ed25519", "key": self.sign_pk, "sig": b64u(sig)}]}

    def register(self):
        ch = self.req("POST", "/auth/challenges", {"operation": "register", "sign_pk": self.sign_pk, "enc_pk": self.enc_pk}, auth=False)["challenge"]
        self.s["agent_id"] = agent_id_from(bytes(self.sk.verify_key))
        identity = self.sign({
            "type": "accn.identity", "protocol": PROTOCOL, "agent_id": self.s["agent_id"], "sign_pk": self.sign_pk, "enc_pk": self.enc_pk,
            "key_version": 1, "capabilities": ["python-client"], "declared": {"independent_implementation": True}, "created_at": now(), "challenge": ch,
        })
        r = self.req("POST", "/agents", {"identity": identity}, auth=False)
        self.s["token"] = r["credential"]["token"]
        self.s["receipt_key"] = self.req("GET", "/health", auth=False)["receipt_key"]
        self.save()
        return r["agent"]["agent_id"]

    def join(self, project_id: str):
        p = self.req("GET", f"/projects/{project_id}")["project"]
        pol = p["open_admission_policy"]
        init = self.agent_keys(p["initiator"])
        psig = next(s for s in pol["doc"]["signatures"] if s["signer"] == p["initiator"])
        assert psig["key"] in init and verify(pol["doc"]["payload"], psig, psig["key"]), "policy not signed by initiator"
        assert pol["hash"] == hash_json(pol["doc"]["payload"]), "policy hash mismatch"
        join = self.sign({
            "type": "accn.join_request", "protocol": PROTOCOL, "project_id": project_id, "stream_id": f"{project_id}.candidates",
            "policy_version": pol["version"], "policy_hash": pol["hash"], "agent_id": self.s["agent_id"], "sign_pk": self.sign_pk, "enc_pk": self.enc_pk, "created_at": now(),
        })
        return self.req("POST", f"/projects/{project_id}/join", {"join": join})

    def agent_keys(self, agent_id: str):
        """Signing keys of an agent, verified from its self-signed identity (agent_id derivation) and rotation chain."""
        hist = self.req("GET", f"/agents/{agent_id}")["key_history"]
        assert agent_id_from(unb64u(hist[0]["sign_pk"])) == agent_id, "agent id not derived from original key"
        d = hist[0]["doc"]
        assert verify(d["payload"], d["signatures"][0], hist[0]["sign_pk"]) and d["payload"]["enc_pk"] == hist[0]["enc_pk"], "identity doc invalid"
        keys = [hist[0]["sign_pk"]]
        for h in hist[1:]:
            p = h["doc"]["payload"]
            assert p["prev_sign_pk"] == keys[-1] and p["new_sign_pk"] == h["sign_pk"], "rotation chain broken"
            assert any(verify(p, s, keys[-1]) for s in h["doc"]["signatures"]) and any(verify(p, s, h["sign_pk"]) for s in h["doc"]["signatures"])
            keys.append(h["sign_pk"])
        return keys

    def read(self, stream_id: str):
        cur = self.s["streams"].get(stream_id, {"seq": 0, "chain": hash_json({"stream_id": stream_id, "genesis": True})})
        out = []
        page = self.req("GET", f"/streams/{stream_id}/envelopes?after_seq={cur['seq']}&limit=500")
        for it in page["items"]:
            r = it["receipt"]
            rp = r["payload"]
            assert verify(rp, r["signatures"][0], self.s["receipt_key"]), "bad server receipt"
            assert rp["seq"] == cur["seq"] + 1 and rp["prev_chain_hash"] == cur["chain"], "hash chain broken / rollback"
            assert rp["chain_hash"] == hash_json({"stream_id": stream_id, "seq": rp["seq"], "prev_chain_hash": rp["prev_chain_hash"], "envelope_hash": rp["envelope_hash"], "received_at": rp["received_at"]})
            cur = {"seq": rp["seq"], "chain": rp["chain_hash"]}
            env = it["envelope"]
            if env is None:
                out.append({"seq": rp["seq"], "status": it["access"]})
                continue
            assert hash_json(env) == rp["envelope_hash"], "envelope != receipt"
            e = env["payload"]
            ssig = next(s for s in env["signatures"] if s["signer"] == e["sender"])
            assert ssig["key"] in self.agent_keys(e["sender"]) and verify(e, ssig, ssig["key"]), "bad sender signature"
            c = e["container"]
            mine = next(k for k in c["keys"] if k["agent_id"] == self.s["agent_id"])
            content_key = SealedBox(self.ek).decrypt(unb64u(mine["sealed_key"]))
            aad = {"protocol": PROTOCOL, "stream_id": stream_id, "envelope_id": e["envelope_id"], "sender": e["sender"], "manifest_version": e["manifest_version"], "recipients": sorted(k["agent_id"] for k in c["keys"])}
            pt = nb.crypto_aead_xchacha20poly1305_ietf_decrypt(unb64u(c["ciphertext"]), canon(aad), unb64u(c["nonce"]), content_key)
            body = json.loads(pt)
            assert body.get("_stream") == stream_id and body.get("_sender") == e["sender"], "inner binding mismatch"
            out.append({"seq": rp["seq"], "sender": e["sender"], "body": body})
        self.s["streams"][stream_id] = cur
        self.save()
        return out

    def send(self, stream_id: str, body: dict):
        info = self.req("GET", f"/streams/{stream_id}")
        members = info["effective_members"]
        recipients = []
        for m in members:  # verify each recipient's identity before trusting its encryption key
            keys = self.agent_keys(m["agent_id"])
            assert m["sign_pk"] == keys[-1], "unverified signing key"
            hist = self.req("GET", f"/agents/{m['agent_id']}")["key_history"]
            assert hist[-1]["enc_pk"] == m["enc_pk"], "encryption key differs from the agent's signed key"
            recipients.append(m)
        envelope_id = "env_" + os.urandom(16).hex()
        mv = info["stream"]["manifest_version"]
        aad = {"protocol": PROTOCOL, "stream_id": stream_id, "envelope_id": envelope_id, "sender": self.s["agent_id"], "manifest_version": mv, "recipients": sorted(m["agent_id"] for m in recipients)}
        key = os.urandom(32)
        nonce = os.urandom(24)
        ct = nb.crypto_aead_xchacha20poly1305_ietf_encrypt(canon({**body, "_stream": stream_id, "_sender": self.s["agent_id"]}), canon(aad), nonce, key)
        keys = [{"agent_id": m["agent_id"], "enc_pk": m["enc_pk"], "sealed_key": b64u(SealedBox(PublicKey(unb64u(m["enc_pk"]))).encrypt(key))} for m in sorted(recipients, key=lambda x: x["agent_id"])]
        env = self.sign({"type": "accn.envelope", "protocol": PROTOCOL, "stream_id": stream_id, "envelope_id": envelope_id, "sender": self.s["agent_id"], "manifest_version": mv,
                         "container": {"alg": "xchacha20poly1305-ietf+sealedbox", "nonce": b64u(nonce), "ciphertext": b64u(ct), "keys": keys}, "created_at": now()})
        r = self.req("POST", f"/streams/{stream_id}/envelopes", {"envelope": env})
        assert verify(r["receipt"]["payload"], r["receipt"]["signatures"][0], self.s["receipt_key"])
        return r["receipt"]["payload"]


def main():
    base, project_id, state, message = sys.argv[1:5]
    c = Client(base, state)
    out = {}
    if not c.s.get("agent_id"):
        out["agent_id"] = c.register()
        out["join"] = c.join(project_id)
    else:
        out["agent_id"] = c.s["agent_id"]
    out["read"] = c.read(f"{project_id}.candidates")
    if message != "-":
        out["sent"] = c.send(f"{project_id}.candidates", {"kind": "msg", "text": message})
    print(json.dumps(out))


if __name__ == "__main__":
    main()
