//! Ed25519 keypair utilities and type aliases for node identity and signing.
//!
//! Provides the [`AuthorId`] and [`SignedDigest`] type aliases, a SHA-256 helper,
//! and convenience wrappers around the `ed25519-dalek` Ed25519 primitives used
//! throughout the CRDT codebase.

use ed25519_dalek::Signer as _;
use ed25519_dalek::Verifier as _;
use sha2::{Digest, Sha256};

/// Ed25519 signing key (private + public pair).
pub type Ed25519KeyPair = ed25519_dalek::SigningKey;
/// Ed25519 verifying (public) key.
pub type Ed25519PublicKey = ed25519_dalek::VerifyingKey;
/// Ed25519 signature.
pub type Ed25519Signature = ed25519_dalek::Signature;

/// Length of an Ed25519 public key in bytes.
pub const ED25519_PUBLIC_KEY_LENGTH: usize = 32;
/// Length of an Ed25519 signature in bytes.
pub const ED25519_SIGNATURE_LENGTH: usize = 64;

/// Represents the ID of a unique node. An Ed25519 public key
pub type AuthorId = [u8; ED25519_PUBLIC_KEY_LENGTH];

/// A signed message
pub type SignedDigest = [u8; ED25519_SIGNATURE_LENGTH];

/// Create a fake public key from a u8
pub fn make_author(n: u8) -> AuthorId {
    let mut id = [0u8; ED25519_PUBLIC_KEY_LENGTH];
    id[0] = n;
    id
}

/// Get the least significant 32 bits of a public key
pub fn lsb_32(pubkey: AuthorId) -> u32 {
    ((pubkey[0] as u32) << 24)
        + ((pubkey[1] as u32) << 16)
        + ((pubkey[2] as u32) << 8)
        + (pubkey[3] as u32)
}

/// SHA256 hash of a string
pub fn sha256(input: String) -> [u8; 32] {
    let mut hasher = Sha256::new();
    hasher.update(input.as_bytes());
    let result = hasher.finalize();
    let mut bytes = [0u8; 32];
    bytes.copy_from_slice(&result[..]);
    bytes
}

/// Generate a random Ed25519 keypair from OS rng
pub fn make_keypair() -> Ed25519KeyPair {
    use rand::RngCore as _;
    let mut seed = [0u8; 32];
    rand::rng().fill_bytes(&mut seed);
    Ed25519KeyPair::from_bytes(&seed)
}

/// Sign a byte array
pub fn sign(keypair: &Ed25519KeyPair, message: &[u8]) -> Ed25519Signature {
    keypair.sign(message)
}

/// Verify a byte array was signed by the given pubkey
pub fn verify(pubkey: Ed25519PublicKey, message: &[u8], signature: Ed25519Signature) -> bool {
    pubkey.verify(message, &signature).is_ok()
}