let connect = "ARAeUAECAQJRBAEBURgBAg8wRExWEAT/7sdvWj8/v1kDYXE+XfS/ULf8x31NITI+Sdjf66qhzlTBAAARBARBEAL/JVPBhu0kDCADmZ0m5USL70BUlzXIyWMvlkwvYhSUwwWHEQQDMQ3yAf9w0MAGY9qk4gnK1d4qtaaKLcFTETRXD7N27+N4ZB46mcJ9csfX/uxApBr5BiDV/J0IU3u/CS1+k5MjmdMaiMvWdNqRh8RvBLE/3E60qWAAZMQ/JkdnKkeM";
    let blob: Vec<u8> = data_encoding::BASE64.decode(connect.as_bytes())?l;
    let _ = open_route(blob, config, String::from("yelllooow")).await;

pub async fn create_route(
    mut done_recv: tokio::sync::mpsc::Receiver<()>,
    mut config: VeilidConfig,
) -> Result<(), Box<dyn std::error::Error>> {
    // Use a namespace for the receiving side of the private route
    config.namespace = "recv".to_owned();

// Run veilid node
veilid_api_scope(update_callback, config, |veilid_api| async move {
        // Create a new private route endpoint
        let (route_id, route_blob) =
            try_again_loop(|| async { veilid_api.new_private_route().await }).await?;

        // Print the blob
println!("Route id created: {route_id}\nConnect with this private route blob:\ncargo run --example private-route-example -- --connect {}",
            data_encoding::BASE64.encode(&route_blob)
);

use std::path::PathBuf;                                      
use tempfile::tempdir;                                       
                                                             
fn get_temp_dir() -> Result<PathBuf, MyErrorClass> {              
    let temp_dir = tempdir()?;     
    let dir_path: PathBuf = temp_dir.into_path();            
    Ok(dir_path)                                             
}           

# Halloy config.
#
# For a complete list of available options,
# please visit https://Halloy.chat/configuration.html

[servers.liberachat]
nickname = "__NICKNAME__"
server = "irc.libera.chat"
channels = ["#halloy"]
protocol = "irc"  # Optional: "irc" (default) or "veilid"

# Example veilid server configuration:
# [servers.veilid-example]
# protocol = "veilid"
# nickname = "__NICKNAME__"
# # For Veilid, you need to provide the route blob (base64 encoded) instead of server/port
# # Get this from the person you want to connect to (they need to spawn a veilid node first)
# veilid_route_blob = "ARAeUAECAQJRBAEBURgBAg8wRExWEAT/7sdvWj8/v1kDYXE+XfS/ULf8x31NITI+Sdjf66qhzlTBAAARBARBEAL/JVPBhu0kDCADmZ0m5USL70BUlzXIyWMvlkwvYhSUwwWHEQQDMQ3yAf9w0MAGY9qk4gnK1d4qtaaKLcFTETRXD7N27+N4ZB46mcJ9csfX/uxApBr5BiDV/J0IU3u/CS1+k5MjmdMaiMvWdNqRh8RvBLE/3E60qWAAZMQ/JkdnKkeM"

[servers.veilid-example]
protocol = "veilid"
nickname = "VeilidTest"
# # For Veilid, you need to provide the route blob (base64 encoded) instead of server/port
# # Get this from the person you want to connect to (they need to spawn a veilid node first)
veilid_route_blob = "ARAeUAECAQJRBAEBURgBAg8wRExWEAT/7sdvWj8/v1kDYXE+XfS/ULf8x31NITI+Sdjf66qhzlTBAAARBARBEAL/JVPBhu0kDCADmZ0m5USL70BUlzXIyWMvlkwvYhSUwwWHEQQDMQ3yAf9w0MAGY9qk4gnK1d4qtaaKLcFTETRXD7N27+N4ZB46mcJ9csfX/uxApBr5BiDV/J0IU3u/CS1+k5MjmdMaiMvWdNqRh8RvBLE/3E60qWAAZMQ/JkdnKkeM"

use pqc_kyber::{keypair, encapsulate, KYBER_CIPHERTEXT_BYTES, PUBLICKEYBYTES};
use aes_gcm::{Aes256Gcm, KeyInit, aead::{Aead, OsRng, generic_array::GenericArray}};
use rand_core::RngCore;

pub async fn send_message(
    message: &str,
    recipient: &UserIdentity,
    sender_identity: &UserIdentity,
    route_id: veilid_core::routing_table::RouteId,
    network_context: &Arc<veilid_core::NetworkContext>,
) -> Result<[u8; 16], CryptoError> {
    log::info!("Sending message to {} (fingerprint: {:02x?})", 
        recipient.name, &recipient.key_fingerprint[..8]);

    // 1. Generate unique message ID
    let mut rng = rand::thread_rng();
    let message_id = {
        let mut id = [0u8; 16];
        rng.fill_bytes(&mut id);
        id
    };

    // 2. Prepare recipient's public key
    let recipient_pk = pqc_kyber::PublicKey::from_bytes(&recipient.public_key)
        .map_err(|e| CryptoError::KeyError(format!("Invalid public key format: {:?}", e)))?;

    // 3. Generate ephemeral keypair for forward secrecy
    let (ephemeral_pk, ephemeral_sk) = keypair(&mut rng)
        .map_err(|e| CryptoError::KeyError(format!("Failed to generate ephemeral key: {:?}", e)))?;

    // 4. Encapsulate shared secret
    let (kyber_ciphertext, mut shared_secret) = encapsulate(&recipient_pk, &mut rng)
        .map_err(|e| CryptoError::EncryptionError(format!("Kyber encapsulation failed: {:?}", e)))?;

    // 5. Derive encryption keys using HKDF
    let aes_key = derive_keys(&shared_secret, &message_id, b"aes_key");
    let hmac_key = derive_keys(&shared_secret, &message_id, b"hmac_key");
    
    // Zeroize shared secret immediately after use
    shared_secret.zeroize();

    // 6. Prepare payload
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|_| CryptoError::InvalidInput("System time error".to_string()))?
        .as_secs();

    let payload = MessagePayload {
        text: message.to_string(),
        timestamp,
        sender_name: sender_identity.name.clone(),
        ephemeral_public_key: ephemeral_pk.to_vec(),
    };

    // 7. Encrypt payload
    let nonce = {
        let mut nonce = [0u8; 12];
        rng.fill_bytes(&mut nonce);
        nonce
    };

    let encrypted_payload = encrypt_payload(&payload, &aes_key, &nonce)
        .map_err(|e| CryptoError::EncryptionError(format!("Payload encryption failed: {}", e)))?;

    // 8. Create packet
    let mut packet = EncryptedPacket {
        version: PROTOCOL_VERSION,
        kyber_ciphertext: kyber_ciphertext.to_vec(),
        encrypted_payload,
        nonce,
        hmac: [0u8; 32],
        timestamp,
        message_id,
        sender_fingerprint: sender_identity.key_fingerprint,
    };

    // 9. Calculate HMAC
    packet.hmac = calculate_hmac(&packet, &hmac_key)
        .map_err(|e| CryptoError::EncryptionError(format!("HMAC calculation failed: {}", e)))?;

    // 10. Serialize and send
    let serialized = bincode::serialize(&packet)
        .map_err(CryptoError::SerializationError)?;

    // 11. Send via Veilid with retry logic
    send_with_retry(network_context, route_id, &serialized).await
        .map_err(|e| CryptoError::NetworkError(format!("Failed to send message: {}", e)))?;

    log::info!("Message {} sent successfully", hex::encode(&message_id[..8]));
    
    // 12. Clean up ephemeral key
    ephemeral_sk.zeroize();

    Ok(message_id)
}