"""

oversight_core.manifest

======================

The manifest is the signed metadata that binds a sealed file to its recipient,

its watermarks, its beacons, and its policy. It's the artifact a registry stores

and a verifier checks.

Wire format (v1): canonical JSON (sorted keys, no whitespace), UTF-8, Ed25519-signed.

Post-quantum: ML-DSA signature slot reserved in the envelope.

"""

from __future__ import annotations

import json

import time

import uuid

from dataclasses import dataclass, field, asdict, fields

from typing import Optional

from .crypto import sign_manifest, verify_manifest, SUITE_CLASSIC_V1

from .jcs import jcs_dumps

@dataclass

class Recipient:

    recipient_id: str

    x25519_pub: str

    ed25519_pub: Optional[str] = None

    p256_pub: Optional[str] = None

@dataclass

class WatermarkRef:

    layer: str

    mark_id: str

@dataclass

class Manifest:

    file_id: str

    issued_at: int

    version: str = "OVERSIGHT-v1"

    suite: str = SUITE_CLASSIC_V1

    original_filename: str = ""

    content_hash: str = ""

    canonical_content_hash: str = ""

    content_type: str = "application/octet-stream"

    size_bytes: int = 0

    issuer_id: str = ""

    issuer_ed25519_pub: str = ""

    recipient: Optional[Recipient] = None

    watermarks: list[WatermarkRef] = field(default_factory=list)

    beacons: list[dict] = field(default_factory=list)

    policy: dict = field(default_factory=dict)

    l3_policy: dict = field(default_factory=dict)

    signature_ed25519: str = ""

    signature_ml_dsa: str = ""

    @classmethod

    def new(

        cls,

        original_filename: str,

        content_hash: str,

        size_bytes: int,

        issuer_id: str,

        issuer_ed25519_pub_hex: str,

        recipient: Recipient,

        registry_url: str,

        content_type: str = "application/octet-stream",

        not_after: Optional[int] = None,

        max_opens: Optional[int] = None,

        jurisdiction: str = "GLOBAL",

    ) -> "Manifest":

        policy = {

            "registry_url": registry_url,

            "jurisdiction": jurisdiction,

        }

        if not_after:

            policy["not_after"] = not_after

        if max_opens:

            policy["max_opens"] = max_opens

        return cls(

            file_id=str(uuid.uuid4()),

            issued_at=int(time.time()),

            original_filename=original_filename,

            content_hash=content_hash,

            canonical_content_hash=content_hash,

            content_type=content_type,

            size_bytes=size_bytes,

            issuer_id=issuer_id,

            issuer_ed25519_pub=issuer_ed25519_pub_hex,

            recipient=recipient,

            policy=policy,

        )

    def to_dict(self, include_signatures: bool = True) -> dict:

        d = asdict(self)

        if not include_signatures:

            d["signature_ed25519"] = ""

            d["signature_ml_dsa"] = ""

        return d

    @staticmethod

    def _strip_none(obj):

        """Recursively drop None values from dicts.

        Canonical JSON for Oversight: omit null-valued fields rather than

        emit `"field": null`. Matches the Rust reference's `serde(skip_serializing_if)`

        and the broader industry convention (Sigstore et al.).

        """

        if isinstance(obj, dict):

            return {k: Manifest._strip_none(v) for k, v in obj.items() if v is not None}

        if isinstance(obj, list):

            return [Manifest._strip_none(x) for x in obj]

        return obj

    def canonical_bytes(self) -> bytes:

        """Canonical serialization excluding signatures (what we actually sign).

        Rules:

          - Exclude the two signature fields (replace with empty string sentinel).

          - Drop None-valued fields recursively.

          - RFC 8785 JCS: keys sorted by UTF-16 code unit, no whitespace,

            non-ASCII output as raw UTF-8. Byte-exact match with the Rust

            reference's ``serde_jcs::to_vec``.

        """

        d = self.to_dict(include_signatures=False)

        d = self._strip_none(d)

        return jcs_dumps(d)

    def to_json(self) -> bytes:

        d = self._strip_none(self.to_dict())

        return jcs_dumps(d)

    @classmethod

    def from_json(cls, data: bytes) -> "Manifest":

        try:

            d = json.loads(data.decode("utf-8"))

        except (UnicodeDecodeError, json.JSONDecodeError) as exc:

            raise ValueError("Malformed manifest JSON") from exc

        if not isinstance(d, dict):

            raise ValueError("Malformed manifest: expected JSON object")

        rec = d.pop("recipient", None)

        wms = d.pop("watermarks", [])

        allowed = {f.name for f in fields(cls)}

        unknown = sorted(set(d) - allowed)

        if unknown:

            raise ValueError(f"Unknown manifest field: {unknown[0]}")

        try:

            m = cls(**d)

            if rec:

                if not isinstance(rec, dict):

                    raise ValueError("Malformed manifest recipient")

                rec_allowed = {f.name for f in fields(Recipient)}

                rec_unknown = sorted(set(rec) - rec_allowed)

                if rec_unknown:

                    raise ValueError(f"Unknown recipient field: {rec_unknown[0]}")

                m.recipient = Recipient(**rec)

            if not isinstance(wms, list):

                raise ValueError("Malformed manifest watermarks")

            wm_allowed = {f.name for f in fields(WatermarkRef)}

            watermarks = []

            for w in wms:

                if not isinstance(w, dict):

                    raise ValueError("Malformed manifest watermark")

                wm_unknown = sorted(set(w) - wm_allowed)

                if wm_unknown:

                    raise ValueError(f"Unknown watermark field: {wm_unknown[0]}")

                watermarks.append(WatermarkRef(**w))

            m.watermarks = watermarks

        except TypeError as exc:

            raise ValueError("Malformed manifest fields") from exc

        return m

    def sign(self, issuer_ed25519_priv: bytes) -> None:

        sig = sign_manifest(self.canonical_bytes(), issuer_ed25519_priv)

        self.signature_ed25519 = sig.hex()

    def verify(self) -> bool:

        if not self.signature_ed25519 or not self.issuer_ed25519_pub:

            return False

        return verify_manifest(

            self.canonical_bytes(),

            bytes.fromhex(self.signature_ed25519),

            bytes.fromhex(self.issuer_ed25519_pub),

        )