//! WASM-specific cryptographic tests

#[cfg(test)]
mod tests {
    use crate::domain::entities::*;
    use crate::domain::traits::{MnemonicGenerator, KeyDeriver, FileEncryptor};
    use crate::infrastructure::crypto::{Bip39MnemonicGenerator, Ed25519KeyDeriver, XChaCha20FileEncryptor};

    #[test]
    fn test_wasm_bip39_generator_creates_valid_mnemonic() {
        let generator = Bip39MnemonicGenerator;
        let phrase = generator.generate().unwrap();

        // Should have 24 words
        assert_eq!(phrase.words().len(), 24);

        // Should be valid BIP-39
        generator.validate(phrase.words()).unwrap();
    }

    #[test]
    fn test_wasm_key_deriver_creates_consistent_keys() {
        let deriver = Ed25519KeyDeriver;

        // Create a test seed
        let test_seed = Seed::new(vec![1; 32]);

        let (public_key, private_key) = deriver.derive_from_seed(&test_seed).unwrap();

        // Public key should be 32 bytes
        assert_eq!(public_key.0.len(), 32);

        // Private key should be 32 bytes
        assert_eq!(private_key.0.len(), 32);
    }

    #[test]
    fn test_wasm_file_encryptor_round_trip() {
        let encryptor = XChaCha20FileEncryptor;
        let key_deriver = Ed25519KeyDeriver;

        let seed = Seed::new(vec![1; 32]);
        let (public_key, _) = key_deriver.derive_from_seed(&seed).unwrap();
        let did = Did::new(&public_key);
        let password = "test-password";

        // Encrypt
        let encrypted_file = encryptor.encrypt(&seed, password, &public_key, &did, "u:Test Universe:12345678-1234-1234-1234-123456789012", &[], &None, &None).unwrap();

        // Verify file structure
        assert_eq!(encrypted_file.kdf, "HKDF-SHA256");
        assert_eq!(encrypted_file.cipher, "XChaCha20-Poly1305");
        assert_eq!(encrypted_file.salt.len(), 32);
        assert_eq!(encrypted_file.nonce.len(), 24);
        assert_eq!(encrypted_file.public_key, public_key.0);
        assert_eq!(encrypted_file.did, did.0);

        // Decrypt
        let (decrypted_seed, decrypted_public_key, _, _, _, _) = encryptor.decrypt(&encrypted_file, password).unwrap();

        // Verify decryption
        assert_eq!(decrypted_seed.as_bytes(), seed.as_bytes());
        assert_eq!(decrypted_public_key.0, public_key.0);
    }

    #[test]
    fn test_wasm_file_encryptor_wrong_password_fails() {
        let encryptor = XChaCha20FileEncryptor;

        let seed = Seed::new(vec![1, 2, 3, 4, 5]);
        let public_key = PublicKey(vec![1; 32]);
        let did = Did::new(&public_key);

        // Encrypt with one password
        let encrypted_file = encryptor.encrypt(&seed, "correct-password", &public_key, &did, "u:Test Universe:12345678-1234-1234-1234-123456789012", &[], &None, &None).unwrap();

        // Try to decrypt with wrong password
        let result = encryptor.decrypt(&encrypted_file, "wrong-password");

        // Should fail
        assert!(result.is_err());
    }
}