use sigsocket::crypto::SignatureVerifier;
use sigsocket::error::SigSocketError;
use secp256k1::{Secp256k1, Message, PublicKey};
use sha2::{Sha256, Digest};
use hex;
use rand::{rngs::OsRng, Rng};

#[test]
fn test_encode_decode_base64() {
    let test_data = b"Hello, World!";
    
    // Test encoding
    let encoded = SignatureVerifier::encode_base64(test_data);
    
    // Test decoding
    let decoded = SignatureVerifier::decode_base64(&encoded).unwrap();
    
    assert_eq!(test_data.to_vec(), decoded);
}

#[test]
fn test_encode_decode_hex() {
    let test_data = b"Hello, World!";
    
    // Test encoding
    let encoded = SignatureVerifier::encode_hex(test_data);
    
    // Test decoding
    let decoded = SignatureVerifier::decode_hex(&encoded).unwrap();
    
    assert_eq!(test_data.to_vec(), decoded);
}

#[test]
fn test_parse_format_response() {
    let message = b"Test message";
    let signature = b"Test signature";
    
    // Format response
    let formatted = SignatureVerifier::format_response(message, signature);
    
    // Parse response
    let (parsed_message, parsed_signature) = SignatureVerifier::parse_response(&formatted).unwrap();
    
    assert_eq!(message.to_vec(), parsed_message);
    assert_eq!(signature.to_vec(), parsed_signature);
}

#[test]
fn test_invalid_response_format() {
    // Invalid format (no separator)
    let invalid = "invalid_format_no_separator";
    let result = SignatureVerifier::parse_response(invalid);
    
    assert!(result.is_err());
    if let Err(e) = result {
        assert!(matches!(e, SigSocketError::InvalidResponseFormat));
    }
}

#[test]
fn test_verify_signature_valid() {
    // Create a secp256k1 context
    let secp = Secp256k1::new();
    
    // Generate a random private key
    let mut rng = OsRng::default();
    let mut secret_key_bytes = [0u8; 32];
    rng.fill(&mut secret_key_bytes);
    
    // Create a secret key from random bytes
    let secret_key = secp256k1::SecretKey::from_slice(&secret_key_bytes).unwrap();
    
    // Derive the public key
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);
    
    // Convert to hex for our API
    let public_key_hex = hex::encode(public_key.serialize());
    
    // Message to sign
    let message = b"Test message for signing";
    
    // Hash the message (required for secp256k1)
    let mut hasher = Sha256::new();
    hasher.update(message);
    let message_hash = hasher.finalize();
    
    // Create a signature
    let msg = Message::from_digest_slice(&message_hash).unwrap();
    let signature = secp.sign_ecdsa(&msg, &secret_key);
    
    // Convert signature to hex
    let signature_hex = hex::encode(signature.serialize_compact());
    
    // Verify the signature using our API
    let result = SignatureVerifier::verify_signature(
        &public_key_hex,
        message,
        &signature_hex
    ).unwrap();
    
    assert!(result);
}

#[test]
fn test_verify_signature_invalid() {
    // Create a secp256k1 context
    let secp = Secp256k1::new();
    
    // Generate two different private keys
    let mut rng = OsRng::default();
    let mut secret_key_bytes1 = [0u8; 32];
    let mut secret_key_bytes2 = [0u8; 32];
    rng.fill(&mut secret_key_bytes1);
    rng.fill(&mut secret_key_bytes2);
    
    // Create secret keys from random bytes
    let secret_key = secp256k1::SecretKey::from_slice(&secret_key_bytes1).unwrap();
    let wrong_secret_key = secp256k1::SecretKey::from_slice(&secret_key_bytes2).unwrap();
    
    // Derive the public key from the first private key
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);
    
    // Convert to hex for our API
    let public_key_hex = hex::encode(public_key.serialize());
    
    // Message to sign
    let message = b"Test message for signing";
    
    // Hash the message (required for secp256k1)
    let mut hasher = Sha256::new();
    hasher.update(message);
    let message_hash = hasher.finalize();
    
    // Create a signature with the WRONG key
    let msg = Message::from_digest_slice(&message_hash).unwrap();
    let wrong_signature = secp.sign_ecdsa(&msg, &wrong_secret_key);
    
    // Convert signature to hex
    let signature_hex = hex::encode(wrong_signature.serialize_compact());
    
    // Verify the signature using our API (should fail)
    let result = SignatureVerifier::verify_signature(
        &public_key_hex,
        message,
        &signature_hex
    ).unwrap();
    
    assert!(!result);
}