# sovereign_validation_seal.py
from __future__ import annotations

import json
from datetime import datetime, timezone
from typing import Any, Dict, Optional

from sovereign_crypto_seal import SovereignCryptoSeal, build_manifest
from sovereign_false_positive_report import generate_false_positive_report


def _utc_now() -> str:
    return datetime.now(timezone.utc).isoformat()


class SovereignValidationSeal:
    """
    Seals and verifies Sovereign validation artifacts.

    Primary use:
    - false positive / false negative validation report
    - validation manifest
    """

    def __init__(self, sealer: Optional[SovereignCryptoSeal] = None) -> None:
        self.sealer = sealer or SovereignCryptoSeal()

    # ---------------------------------------------------------
    # Validation report sealing
    # ---------------------------------------------------------
    def seal_validation_report(
        self,
        report: Dict[str, Any],
        metadata: Optional[Dict[str, Any]] = None,
    ) -> Dict[str, Any]:
        sealed = self.sealer.seal_object(
            report,
            object_type="validation_report",
            metadata=metadata or {
                "domain": "banking",
                "artifact_class": "validation_report",
            },
        )
        return {
            "ok": True,
            "sealed": True,
            "report": report,
            "crypto_seal": sealed["seal"],
        }

    def verify_validation_report(
        self,
        report: Dict[str, Any],
        seal: Dict[str, Any],
    ) -> Dict[str, Any]:
        verified = self.sealer.verify_object(report, seal)
        return {
            "ok": bool(verified.get("ok")),
            "verified": bool(verified.get("verified")),
            "artifact_type": "validation_report",
            "verification": verified,
        }

    # ---------------------------------------------------------
    # Generate + seal convenience
    # ---------------------------------------------------------
    def generate_and_seal_validation_report(
        self,
        output_dir: str = "sovereign_validation_outputs",
        base_name: Optional[str] = None,
        metadata: Optional[Dict[str, Any]] = None,
    ) -> Dict[str, Any]:
        generated = generate_false_positive_report(
            output_dir=output_dir,
            base_name=base_name,
        )

        report = generated.get("report", {}) if isinstance(generated, dict) else {}
        sealed_bundle = self.seal_validation_report(
            report=report,
            metadata=metadata or {
                "domain": "banking",
                "artifact_class": "validation_report",
                "generated_at": _utc_now(),
            },
        )

        return {
            "ok": True,
            "generated_at": _utc_now(),
            "report": report,
            "files": generated.get("files", {}) if isinstance(generated, dict) else {},
            "crypto_seal": sealed_bundle["crypto_seal"],
            "sealed": True,
        }

    # ---------------------------------------------------------
    # Validation manifest
    # ---------------------------------------------------------
    def build_validation_manifest(
        self,
        *,
        subject_name: str,
        subject_version: str,
        validation_report: Dict[str, Any],
        metadata: Optional[Dict[str, Any]] = None,
    ) -> Dict[str, Any]:
        manifest_bundle = build_manifest(
            manifest_type="sovereign_validation_bundle",
            subject_name=subject_name,
            subject_version=subject_version,
            artifacts={
                "validation_report": validation_report,
            },
            metadata=metadata or {
                "domain": "banking",
                "artifact_class": "validation_bundle",
            },
        )
        return {
            "ok": True,
            "manifest_bundle": manifest_bundle,
            "artifacts_included": ["validation_report"],
            "artifact_count": 1,
        }


SEALER = SovereignValidationSeal()


def seal_validation_report(
    report: Dict[str, Any],
    metadata: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    return SEALER.seal_validation_report(report, metadata)


def verify_validation_report(
    report: Dict[str, Any],
    seal: Dict[str, Any],
) -> Dict[str, Any]:
    return SEALER.verify_validation_report(report, seal)


def generate_and_seal_validation_report(
    output_dir: str = "sovereign_validation_outputs",
    base_name: Optional[str] = None,
    metadata: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    return SEALER.generate_and_seal_validation_report(
        output_dir=output_dir,
        base_name=base_name,
        metadata=metadata,
    )


def build_validation_manifest(
    *,
    subject_name: str,
    subject_version: str,
    validation_report: Dict[str, Any],
    metadata: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    return SEALER.build_validation_manifest(
        subject_name=subject_name,
        subject_version=subject_version,
        validation_report=validation_report,
        metadata=metadata,
    )


if __name__ == "__main__":
    out = generate_and_seal_validation_report()
    print(json.dumps(out, indent=2, ensure_ascii=False))

    manifest = build_validation_manifest(
        subject_name="Sovereign Bank Runtime",
        subject_version="v1",
        validation_report=out.get("report", {}),
        metadata={"pack_type": "validation_identity_seed"},
    )
    print(json.dumps(manifest, indent=2, ensure_ascii=False))