//! Tests for the enhanced request management functionality

use sigsocket_client::prelude::*;

#[test]
fn test_client_request_management() {
    let public_key = hex::decode("02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9").unwrap();
    let mut client = SigSocketClient::new("ws://localhost:8080/ws", public_key).unwrap();
    
    // Initially no requests
    assert_eq!(client.pending_request_count(), 0);
    assert!(client.get_pending_requests().is_empty());
    
    // Add a request
    let request = SignRequest::new("test-1", "dGVzdCBtZXNzYWdl");
    let public_key_hex = "02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9";
    client.add_pending_request(request.clone(), public_key_hex.to_string());
    
    // Check request was added
    assert_eq!(client.pending_request_count(), 1);
    assert!(client.get_pending_request("test-1").is_some());
    
    // Check filtering by public key
    let filtered = client.get_requests_for_public_key(public_key_hex);
    assert_eq!(filtered.len(), 1);
    assert_eq!(filtered[0].id(), "test-1");
    
    // Add another request for different public key
    let request2 = SignRequest::new("test-2", "dGVzdCBtZXNzYWdlMg==");
    let other_public_key = "03f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9";
    client.add_pending_request(request2, other_public_key.to_string());
    
    // Check total count
    assert_eq!(client.pending_request_count(), 2);
    
    // Check filtering still works
    let filtered = client.get_requests_for_public_key(public_key_hex);
    assert_eq!(filtered.len(), 1);
    
    let filtered_other = client.get_requests_for_public_key(other_public_key);
    assert_eq!(filtered_other.len(), 1);
    
    // Remove a request
    let removed = client.remove_pending_request("test-1");
    assert!(removed.is_some());
    assert_eq!(removed.unwrap().id(), "test-1");
    assert_eq!(client.pending_request_count(), 1);
    
    // Clear all requests
    client.clear_pending_requests();
    assert_eq!(client.pending_request_count(), 0);
}

#[test]
fn test_client_request_validation() {
    let public_key = hex::decode("02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9").unwrap();
    let client = SigSocketClient::new("ws://localhost:8080/ws", public_key).unwrap();
    
    // Valid request
    let valid_request = SignRequest::new("test-1", "dGVzdCBtZXNzYWdl");
    assert!(client.can_handle_request_for_key(&valid_request, "some-public-key"));
    
    // Invalid request - empty ID
    let invalid_request = SignRequest::new("", "dGVzdCBtZXNzYWdl");
    assert!(!client.can_handle_request_for_key(&invalid_request, "some-public-key"));
    
    // Invalid request - empty message
    let invalid_request2 = SignRequest::new("test-1", "");
    assert!(!client.can_handle_request_for_key(&invalid_request2, "some-public-key"));
    
    // Invalid request - invalid base64
    let invalid_request3 = SignRequest::new("test-1", "invalid-base64!");
    assert!(!client.can_handle_request_for_key(&invalid_request3, "some-public-key"));
    
    // Invalid public key
    assert!(!client.can_handle_request_for_key(&valid_request, ""));
}

#[test]
fn test_client_connection_state() {
    let public_key = hex::decode("02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9").unwrap();
    let client = SigSocketClient::new("ws://localhost:8080/ws", public_key).unwrap();
    
    // Initially disconnected
    assert_eq!(client.state(), ConnectionState::Disconnected);
    assert!(!client.is_connected());
    assert!(client.connected_public_key().is_none());
    
    // Public key should be available
    assert_eq!(client.public_key_hex(), "02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9");
    assert_eq!(client.url(), "ws://localhost:8080/ws");
}