dist_agent_lang 1.0.24

// Performance tests for FFI interfaces
// Compares HTTP vs FFI performance characteristics

use dist_agent_lang::ffi::{FFIConfig, FFIInterface};
use dist_agent_lang::runtime::values::Value;
use std::time::Instant;

#[test]
fn test_ffi_interface_creation_performance() {
    let start = Instant::now();

    for _ in 0..1000 {
        let config = FFIConfig::both();
        let _interface = FFIInterface::new(config);
    }

    let duration = start.elapsed();
    println!("Created 1000 FFI interfaces in {:?}", duration);

    // Should be fast (< 100ms for 1000 creations)
    assert!(duration.as_millis() < 1000);
}

#[test]
fn test_auto_detection_performance() {
    use dist_agent_lang::ffi::InterfaceSelector;

    let selector = InterfaceSelector::new();
    let functions = vec![
        "hash_data",
        "sign_data",
        "chain::get_balance",
        "database::query",
        "batch_process",
        "fetch_data",
    ];

    let start = Instant::now();

    for _ in 0..10000 {
        for func in &functions {
            let _interface = selector.select_interface("Service", func, &[]);
        }
    }

    let duration = start.elapsed();
    println!("Selected interface 60000 times in {:?}", duration);

    // Should be very fast (< 2s for 60k selections)
    // Increased threshold for system variability during mutation testing
    assert!(
        duration.as_millis() < 2000,
        "Performance test: took {:?}, expected < 2000ms",
        duration
    );
}

#[test]
fn test_value_size_estimation_performance() {
    // Test the performance of value size calculations (internal operation)
    // Rather than testing full FFI call overhead which includes error handling

    let small_value = Value::String("small".to_string());
    let medium_value = Value::String("x".repeat(100));
    let large_value = Value::String("x".repeat(10000));

    let start = Instant::now();

    // Test just the value cloning and size estimation overhead
    for _ in 0..10000 {
        let _args1 = vec![small_value.clone()];
        let _args2 = vec![medium_value.clone()];
        let _args3 = vec![large_value.clone()];

        // Measure the value manipulation overhead, not full FFI call
        let _size1 = std::mem::size_of_val(&_args1);
        let _size2 = std::mem::size_of_val(&_args2);
        let _size3 = std::mem::size_of_val(&_args3);
    }

    let duration = start.elapsed();
    println!("Processed 30000 value size estimations in {:?}", duration);

    // Should be reasonably fast (just memory operations)
    assert!(
        duration.as_millis() < 1000,
        "Value size estimation too slow: {:?}",
        duration
    );
}

#[test]
fn test_interface_selector_performance() {
    use dist_agent_lang::ffi::{CallFrequency, InterfaceSelector, ServiceMetadata};

    let mut selector = InterfaceSelector::new();

    // Register multiple services
    for i in 0..100 {
        let metadata = ServiceMetadata {
            name: format!("Service{}", i),
            function_names: vec!["function1".to_string(), "function2".to_string()],
            has_network_operations: i % 2 == 0,
            has_compute_operations: i % 2 == 1,
            estimated_call_frequency: if i % 3 == 0 {
                CallFrequency::High
            } else if i % 3 == 1 {
                CallFrequency::Medium
            } else {
                CallFrequency::Low
            },
        };
        selector.register_service(metadata);
    }

    let start = Instant::now();

    // Test selection performance
    for i in 0..1000 {
        let service_name = format!("Service{}", i % 100);
        let _interface = selector.select_interface(&service_name, "function1", &[]);
    }

    let duration = start.elapsed();
    println!(
        "Selected interface 1000 times with 100 registered services in {:?}",
        duration
    );

    // Should be fast even with many registered services
    assert!(duration.as_millis() < 100);
}

#[test]
fn test_config_creation_performance() {
    let start = Instant::now();

    for _ in 0..10000 {
        let _config1 = FFIConfig::default();
        let _config2 = FFIConfig::http_only();
        let _config3 = FFIConfig::ffi_only();
        let _config4 = FFIConfig::both();
        let _config5 = FFIConfig::auto_detect();
    }

    let duration = start.elapsed();
    println!("Created 50000 configs in {:?}", duration);

    // Should be very fast
    assert!(duration.as_millis() < 100);
}

#[test]
fn test_pattern_matching_performance() {
    use dist_agent_lang::ffi::ServiceMetadata;

    let functions = vec![
        "hash_data",
        "sign_data",
        "verify_signature",
        "chain::get_balance",
        "database::query",
        "fetch_data",
        "batch_process",
        "parallel_compute",
    ];

    let start = Instant::now();

    for _ in 0..10000 {
        for func in &functions {
            let _analysis = ServiceMetadata::analyze_function(func);
        }
    }

    let duration = start.elapsed();
    println!("Analyzed 80000 functions in {:?}", duration);

    // Should be very fast (increased threshold for system variability during mutation testing)
    assert!(
        duration.as_millis() < 2000,
        "Performance test: took {:?}, expected < 2000ms",
        duration
    );
}