use cmz::*;
use curve25519_dalek::ristretto::RistrettoPoint;
use curve25519_dalek::scalar::Scalar;
use group::Group;
use rand::{CryptoRng, RngCore};

CMZ! { Basic<RistrettoPoint> :
    attr1,
    attr2
}

CMZ14Protocol! { basic_issue,
  ,
  A: Basic { attr1: S, attr2: S },
}

CMZ14Protocol! { basic_proto,
A: Basic {
    attr1: H,
    attr2: H,
}, , }

#[test]
fn test_basic() {
    let mut rng = rand::thread_rng();

    let (privkey, pubkey) = Basic::cmz14_gen_keys(&mut rng);

    // Serialize and deserialize
    let privkey_bytes = postcard::to_allocvec(&privkey).unwrap();
    let pubkey_bytes = postcard::to_allocvec(&pubkey).unwrap();

    let privkey_serde = postcard::from_bytes::<CMZPrivkey<RistrettoPoint>>(&privkey_bytes).unwrap();
    let pubkey_serde = postcard::from_bytes::<CMZPubkey<RistrettoPoint>>(&pubkey_bytes).unwrap();

    assert!(privkey == privkey_serde);
    assert!(pubkey == pubkey_serde);

    // A showing proof needs an issued credential. An unissued credential has
    // the identity as its MAC, which is rejected as an invalid instance point.
    let (request, state) =
        basic_issue::prepare(&mut rng, b"issue_basic", Basic::using_pubkey(&pubkey_serde)).unwrap();
    let (reply, _) = basic_issue::handle(
        &mut rng,
        b"issue_basic",
        request,
        |a: &mut Basic| {
            a.set_privkey(&privkey_serde);
            a.attr1 = Some(Scalar::ZERO);
            a.attr2 = Some(Scalar::ONE);
            Ok(())
        },
        |_a: &Basic| Ok(()),
    )
    .unwrap();
    let basic_cred = state.finalize(reply).map_err(|(err, _state)| err).unwrap();

    let basic_cred_bytes = postcard::to_allocvec(&basic_cred).unwrap();

    println!("{:#?}", basic_cred);

    println!("{:#?}", basic_cred_bytes);

    let (req, state) = basic_proto::prepare(&mut rng, b"test_basic", &basic_cred).unwrap();
    println!("{req:#?}");
    println!("{state:#?}");
}