//! Tests for keypair functionality.

#[cfg(test)]
mod tests {
    use crate::core::keypair;

    // Helper to ensure keypair is initialized for tests that need it.
    fn ensure_keypair_initialized() {
        // Create a space and keypair for testing
        let _ = keypair::create_space("test_space");
        let _ = keypair::create_keypair("test_keypair");
        let _ = keypair::select_keypair("test_keypair");
    }

    #[test]
    fn test_keypair_generation_and_retrieval() {
        ensure_keypair_initialized();
        let pub_key = keypair::pub_key().expect("Should be able to get pub key after init");
        assert!(!pub_key.is_empty(), "Public key should not be empty");
        // Basic check for SEC1 format (0x02, 0x03, or 0x04 prefix)
        assert!(pub_key.len() == 33 || pub_key.len() == 65, "Public key length is incorrect");
        assert!(pub_key[0] == 0x02 || pub_key[0] == 0x03 || pub_key[0] == 0x04, "Invalid SEC1 format start byte");
    }

    #[test]
    fn test_sign_verify_valid() {
        ensure_keypair_initialized();
        let message = b"this is a test message";
        let signature = keypair::sign(message).expect("Signing failed");
        assert!(!signature.is_empty(), "Signature should not be empty");

        let is_valid = keypair::verify(message, &signature).expect("Verification failed");
        assert!(is_valid, "Signature should be valid");
    }

    #[test]
    fn test_verify_invalid_signature() {
        ensure_keypair_initialized();
        let message = b"another test message";
        let mut invalid_signature = keypair::sign(message).expect("Signing failed");
        // Tamper with the signature
        invalid_signature[0] = invalid_signature[0].wrapping_add(1);

        let is_valid = keypair::verify(message, &invalid_signature).expect("Verification process failed");
        assert!(!is_valid, "Tampered signature should be invalid");
    }
    
    #[test]
    fn test_verify_wrong_message() {
        ensure_keypair_initialized();
        let message = b"original message";
        let wrong_message = b"different message";
        let signature = keypair::sign(message).expect("Signing failed");

        let is_valid = keypair::verify(wrong_message, &signature).expect("Verification process failed");
        assert!(!is_valid, "Signature should be invalid for a different message");
    }
    
    // Clean up after tests
    fn cleanup() {
        keypair::logout();
    }
}