use anyhow::Result;
use at_crypto::did_key::verifying_key_to_multibase;
use at_crypto::ecdsa::K256Keypair;
use k256::ecdsa::SigningKey;
use rand::rngs::OsRng;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreatedUser {
    pub did: String,
    pub handle: String,
    pub signing_pubkey_multibase: String,
    pub rotation_pubkey_multibase: String,
    pub k256_signing: K256Keypair,
    pub k256_rotation: K256Keypair,
}

pub fn generate_user_keys() -> Result<CreatedUser> {
    let signing = K256Keypair::generate()?;
    let rotation = K256Keypair::generate()?;
    Ok(CreatedUser {
        did: String::new(),
        handle: String::new(),
        signing_pubkey_multibase: signing.public_multibase.clone(),
        rotation_pubkey_multibase: rotation.public_multibase.clone(),
        k256_signing: signing,
        k256_rotation: rotation,
    })
}

pub fn derive_did_from_signing(k256_signing: &K256Keypair) -> String {
    use at_crypto::did_key::pubkey_to_multibase;
    use k256::PublicKey;
    let sk = k256_signing.secret_key().unwrap();
    let pk: PublicKey = sk.verifying_key().into();
    let mb = pubkey_to_multibase(&pk).unwrap();
    format!("did:key:{}", mb)
}

pub fn random_signing_key() -> SigningKey {
    SigningKey::random(&mut OsRng)
}

pub fn verifying_key_mb(signing: &SigningKey) -> Result<String> {
    Ok(verifying_key_to_multibase(signing.verifying_key())?)
}