qssh 0.0.2-alpha

use qssh::handshake::{ClientHandshake, ServerHandshake};
use qssh::PqAlgorithm;
use tokio::net::{TcpListener, TcpStream};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();
    
    // Start server in background
    tokio::spawn(async {
        let listener = TcpListener::bind("127.0.0.1:9999").await.unwrap();
        println!("Test server listening on 127.0.0.1:9999");
        
        let (stream, addr) = listener.accept().await.unwrap();
        println!("Server: Accepted connection from {}", addr);
        
        let mut server_handshake = ServerHandshake::new(stream);
        match server_handshake.perform_handshake().await {
            Ok((transport, username, session_id)) => {
                println!("Server: Handshake successful! Username: {}", username);
            }
            Err(e) => {
                eprintln!("Server handshake error: {:?}", e);
            }
        }
    });
    
    // Give server time to start
    tokio::time::sleep(Duration::from_millis(100)).await;
    
    // Client connects
    println!("Client: Connecting to server...");
    let stream = TcpStream::connect("127.0.0.1:9999").await?;
    println!("Client: Connected!");
    
    let mut client_handshake = ClientHandshake::new(
        stream,
        "testuser".to_string(),
        PqAlgorithm::Falcon512,
        false,  // QKD disabled
        None,
    );
    
    println!("Client: Starting handshake...");
    match client_handshake.perform_handshake().await {
        Ok((transport, session_id)) => {
            println!("Client: Handshake successful!");
        }
        Err(e) => {
            eprintln!("Client handshake error: {:?}", e);
        }
    }
    
    Ok(())
}