pub const ED25519_2020: &str;

pub const VC_JOSE: &str;

pub const SD_JWT_VC: &str;

pub const DATA_INTEGRITY_2025: &str;

use oas_attestation::proof_formats::{ProofFormatId, ED25519_2020};

let id = ProofFormatId::Ed25519Signature2020;
assert_eq!(id.url(), ED25519_2020);
assert!(id.is_baseline());
assert!(!id.supports_selective_disclosure());

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ProofFormatId {
    /// `Ed25519Signature2020` — the OAS baseline. JSON-LD, no SD, no holder
    /// key binding. Identifier: [`ED25519_2020`].
    Ed25519Signature2020,
    /// `vc-jose` — JWT-VC compact JWS encoding. Holder key binding via `cnf`.
    /// Identifier: [`VC_JOSE`].
    VcJose,
    /// `sd-jwt-vc` — SD-JWT VC with salted-hash selective disclosure.
    /// Identifier: [`SD_JWT_VC`].
    SdJwtVc,
    /// `data-integrity-2025` — JSON-LD `DataIntegrityProof` with optional BBS+
    /// selective disclosure. Identifier: [`DATA_INTEGRITY_2025`].
    DataIntegrity2025,
}

use oas_attestation::proof_formats::ProofFormatId;

assert_eq!(
    ProofFormatId::Ed25519Signature2020.url(),
    "https://openagent.id/proof/ed25519-2020"
);

pub const fn url(self) -> &'static str;

use oas_attestation::proof_formats::{ProofFormatId, SD_JWT_VC};

let parsed = ProofFormatId::from_url(SD_JWT_VC).unwrap();
assert_eq!(parsed, ProofFormatId::SdJwtVc);

let unknown = ProofFormatId::from_url("https://example.com/unknown");
assert!(unknown.is_err());

pub fn from_url(url: &str) -> Result<Self, AttestationError>;

use oas_attestation::proof_formats::ProofFormatId;

assert!(ProofFormatId::Ed25519Signature2020.is_baseline());
assert!(!ProofFormatId::SdJwtVc.is_baseline());

pub const fn is_baseline(self) -> bool;

use oas_attestation::proof_formats::ProofFormatId;

assert!(!ProofFormatId::Ed25519Signature2020.supports_selective_disclosure());
assert!(!ProofFormatId::VcJose.supports_selective_disclosure());
assert!(ProofFormatId::SdJwtVc.supports_selective_disclosure());
// data-integrity-2025 supports SD only when the BBS+ suite is used;
// the registry flag indicates capability, not unconditional support.
assert!(ProofFormatId::DataIntegrity2025.supports_selective_disclosure());

pub const fn supports_selective_disclosure(self) -> bool;

use oas_attestation::proof_formats::ProofFormatId;

assert!(!ProofFormatId::Ed25519Signature2020.supports_holder_key_binding());
assert!(ProofFormatId::VcJose.supports_holder_key_binding());
assert!(ProofFormatId::SdJwtVc.supports_holder_key_binding());
assert!(ProofFormatId::DataIntegrity2025.supports_holder_key_binding());

pub const fn supports_holder_key_binding(self) -> bool;

use oas_attestation::proof_formats::ProofFormatId;

assert_eq!(
    ProofFormatId::Ed25519Signature2020.legacy_proof_type(),
    Some("Ed25519Signature2020")
);
assert_eq!(
    ProofFormatId::DataIntegrity2025.legacy_proof_type(),
    Some("DataIntegrityProof")
);
assert_eq!(ProofFormatId::SdJwtVc.legacy_proof_type(), None);
assert_eq!(ProofFormatId::VcJose.legacy_proof_type(), None);

pub const fn legacy_proof_type(self) -> Option<&'static str>;

use oas_attestation::credential::OasCredential;
use oas_attestation::proof_formats::{Ed25519Signature2020Format, ProofFormat};
use oas_attestation::types::AttestationType;
use oas_crypto::keypair::OasKeyPair;

let format = Ed25519Signature2020Format;
let keypair = OasKeyPair::generate();
let cred = OasCredential::builder()
    .issuer("did:oas:test:hmr:auditor")
    .subject_id("did:oas:test:agent:target")
    .attestation_type(AttestationType::SecurityAudit)
    .issuance_date("2026-01-15T00:00:00Z")
    .subject_claim("auditType", serde_json::json!("codeAudit"))
    .subject_claim("result", serde_json::json!("pass"))
    .subject_claim("severityFindings", serde_json::json!({"critical": 0}))
    .subject_claim("toolOrMethodology", serde_json::json!("OWASP"))
    .subject_claim("auditDate", serde_json::json!("2026-01-15T00:00:00Z"))
    .build()
    .unwrap();

let signed = format.sign(
    &cred, &keypair,
    "did:oas:test:hmr:auditor#key-1",
    "2026-01-15T00:00:00Z",
).unwrap();

assert!(format.verify(&signed, &keypair.verifying_key_bytes()).is_ok());

pub trait ProofFormat: Send + Sync {
    /// Returns the registered format identifier per Spec §14.4.
    fn format_id(&self) -> ProofFormatId;

    /// Returns `true` if this format supports selective disclosure of claims
    /// per Spec §14.6. Default delegates to the format identifier's
    /// capability flag.
    fn supports_selective_disclosure(&self) -> bool ;

    /// Returns `true` if this format supports holder key binding at
    /// presentation time per Spec §14.5. Default delegates to the format
    /// identifier's capability flag.
    fn supports_holder_key_binding(&self) -> bool ;

    /// Signs an OAS credential with this proof format and returns a new
    /// credential with the proof field populated.
    ///
    /// # Arguments
    ///
    /// * `credential` - The unsigned credential to sign.
    /// * `keypair` - The issuer's signing keypair.
    /// * `verification_method_id` - Full ID of the verification method
    ///   (e.g., `"did:oas:test:hmr:auditor#key-1"`).
    /// * `created` - ISO 8601 timestamp for the proof.
    ///
    /// # Returns
    ///
    /// A new [`OasCredential`] with the `proof` field populated.
    ///
    /// # Errors
    ///
    /// Returns [`AttestationError`] if validation, canonicalization, or
    /// signing fails.
    fn sign(
        &self,
        credential: &OasCredential,
        keypair: &OasKeyPair,
        verification_method_id: &str,
        created: &str,
    ) -> Result<OasCredential, AttestationError>;

    /// Verifies a signed credential against a known issuer public key.
    ///
    /// # Arguments
    ///
    /// * `credential` - The signed credential to verify.
    /// * `issuer_public_key` - The 32-byte Ed25519 public key of the issuer.
    ///
    /// # Returns
    ///
    /// `Ok(())` if the credential is valid and the proof verifies.
    ///
    /// # Errors
    ///
    /// Returns [`AttestationError`] on any validation or signature failure.
    /// Per Spec §14.4, verifiers encountering an unrecognized format MUST
    /// reject the credential.
    fn verify(
        &self,
        credential: &OasCredential,
        issuer_public_key: &[u8],
    ) -> Result<(), AttestationError>;
}

use oas_attestation::credential::OasCredential;
use oas_attestation::proof_formats::{Ed25519Signature2020Format, ProofFormat, ProofFormatId};
use oas_attestation::types::AttestationType;
use oas_crypto::keypair::OasKeyPair;

let format = Ed25519Signature2020Format;
assert_eq!(format.format_id(), ProofFormatId::Ed25519Signature2020);
assert!(format.format_id().is_baseline());
assert!(!format.supports_selective_disclosure());
assert!(!format.supports_holder_key_binding());

let keypair = OasKeyPair::generate();
let cred = OasCredential::builder()
    .issuer("did:oas:test:hmr:auditor")
    .subject_id("did:oas:test:agent:target")
    .attestation_type(AttestationType::SecurityAudit)
    .issuance_date("2026-01-15T00:00:00Z")
    .subject_claim("auditType", serde_json::json!("codeAudit"))
    .subject_claim("result", serde_json::json!("pass"))
    .subject_claim("severityFindings", serde_json::json!({"critical": 0}))
    .subject_claim("toolOrMethodology", serde_json::json!("OWASP"))
    .subject_claim("auditDate", serde_json::json!("2026-01-15T00:00:00Z"))
    .build()
    .unwrap();

let signed = format.sign(
    &cred, &keypair,
    "did:oas:test:hmr:auditor#key-1",
    "2026-01-15T00:00:00Z",
).unwrap();

assert!(format.verify(&signed, &keypair.verifying_key_bytes()).is_ok());

#[derive(Debug, Default, Clone, Copy)]
pub struct Ed25519Signature2020Format;