use oxirs_did::{Did, DidResolver};
use oxirs_did::proof::ed25519::Ed25519Signer;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate Ed25519 keypair
    let signer = Ed25519Signer::generate();
    let public_key = signer.public_key_bytes();

    // Create did:key from public key
    let did = Did::new_key_ed25519(&public_key)?;
    println!("DID: {}", did);
    // Output: did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK

    // Resolve DID to DID Document
    let resolver = DidResolver::new();
    let doc = resolver.resolve(&did).await?;

    println!("DID Document: {}", serde_json::to_string_pretty(&doc)?);

    Ok(())
}

use oxirs_did::{CredentialIssuer, CredentialSubject, DidResolver, Keystore};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Issuer identity — the keystore generates and holds the signing key
    let keystore = Arc::new(Keystore::new());
    let issuer_did = keystore.generate_ed25519().await?;

    // Create credential subject
    let subject = CredentialSubject::new(Some("did:key:z6Mk..."))
        .with_claim("email", "alice@example.com")
        .with_claim("role", "Researcher");

    // Issue (sign) the credential
    let resolver = Arc::new(DidResolver::new());
    let issuer = CredentialIssuer::new(keystore, resolver);
    let vc = issuer
        .issue(&issuer_did, subject, vec!["EmailCredential".to_string()])
        .await?;

    println!("{}", serde_json::to_string_pretty(&vc)?);

    Ok(())
}

use oxirs_did::{CredentialVerifier, DidResolver, VerifiableCredential};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resolver = Arc::new(DidResolver::new());
    let verifier = CredentialVerifier::new(resolver);

    // Parse a VC received as JSON (e.g. from an API or file)
    let vc: VerifiableCredential = serde_json::from_str(vc_json)?;

    // Verify
    let result = verifier.verify(&vc).await?;

    if result.valid {
        println!("✓ Credential is VALID");
        println!("  Issued by: {}", result.issuer.unwrap_or_default());
    } else {
        println!("✗ Credential is INVALID: {}", result.error.unwrap_or_default());
    }

    for check in &result.checks {
        println!("  [{}] {}", if check.passed { "✓" } else { "✗" }, check.name);
    }

    Ok(())
}

use oxirs_did::signed_graph::{SignedGraph, RdfTriple};
use oxirs_did::proof::ed25519::Ed25519Signer;
use oxirs_did::{Did, DidResolver};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create signer
    let signer = Ed25519Signer::generate();
    let did = Did::new_key_ed25519(&signer.public_key_bytes())?;

    // Create RDF graph
    let triples = vec![
        RdfTriple::iri(
            "http://data.example/entity-1",
            "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
            "http://schema.org/Dataset"
        ),
    ];

    // Sign graph
    let graph = SignedGraph::new(
        "http://data.example/research-2025",
        triples,
        did.clone()
    );
    let signed = graph.sign(&signer)?;

    println!("Graph hash: {}", signed.hash()?);

    // Verify later
    let resolver = DidResolver::new();
    let valid = signed.verify(&resolver).await?;
    println!("Verification: {}", if valid.valid { "✓" } else { "✗" });

    Ok(())
}