brlapi 0.4.1

// SPDX-License-Identifier: LGPL-2.1

#![cfg(feature = "dangerous-raw-mode")]

//! Integration tests for BrlAPI raw mode functionality
//!
//! These tests verify raw mode behavior in various scenarios:
//! - Driver support detection
//! - Raw mode entry/exit lifecycle
//! - Error handling and edge cases
//! - RAII cleanup behavior
//!
//! Note: Most tests will pass without hardware by testing error paths
//! and validation logic. Tests that require actual raw mode will be
//! skipped gracefully if no compatible hardware is available.

use brlapi::raw::RawMode;

mod common;

#[test]
fn test_driver_support_detection() {
    println!("Testing driver support detection...");

    // Known supported drivers (should return true)
    let supported_drivers = [
        "alva",
        "baum",
        "braillepen",
        "braillelite",
        "braillememo",
        "braillenote",
        "canbraille",
        "cebra",
        "ec",
        "eureka",
        "freedomscientific",
        "handy",
        "hedo",
        "hims",
        "ht",
        "humanware",
        "iris",
        "logtext",
        "md",
        "mn",
        "mt",
        "pegasus",
        "pm",
        "seika",
        "voyager",
        "vr",
        "vs",
    ];

    for driver in &supported_drivers {
        assert!(
            RawMode::is_driver_supported(driver),
            "Driver '{}' should be supported",
            driver
        );
    }

    // Case insensitive support
    assert!(RawMode::is_driver_supported("ALVA"));
    assert!(RawMode::is_driver_supported("Baum"));
    assert!(RawMode::is_driver_supported("HIMS"));

    // Known unsupported drivers (should return false)
    let unsupported_drivers = ["noblraille", "fake", "dummy", "test"];

    for driver in &unsupported_drivers {
        assert!(
            !RawMode::is_driver_supported(driver),
            "Driver '{}' should not be supported",
            driver
        );
    }

    // Empty driver name
    assert!(!RawMode::is_driver_supported(""));

    // Unknown drivers (should assume supported to avoid false negatives)
    assert!(RawMode::is_driver_supported("unknown_driver_xyz"));

    println!("[SUCCESS] Driver support detection works correctly");
}

#[test]
fn test_raw_mode_entry_validation() {
    println!("Testing raw mode entry validation...");

    let connection = match common::try_connect() {
        Ok(conn) => conn,
        Err(_) => {
            println!("WARNING: No BrlAPI connection available - skipping hardware tests");
            return;
        }
    };

    // Test empty driver name rejection
    match RawMode::enter(&connection, "") {
        Err(brlapi::BrlApiError::Custom { message }) => {
            assert!(message.contains("empty"));
            println!("[SUCCESS] Empty driver name properly rejected");
        }
        Err(e) => {
            println!("WARNING: Unexpected error for empty driver: {}", e);
        }
        Ok(_) => {
            panic!("Empty driver name should be rejected");
        }
    }

    // Test null byte in driver name
    match RawMode::enter(&connection, "driver\0with\0nulls") {
        Err(brlapi::BrlApiError::NullByteInString(_)) => {
            println!("[SUCCESS] Null bytes in driver name properly rejected");
        }
        Err(e) => {
            println!("WARNING: Unexpected error for null bytes: {}", e);
        }
        Ok(_) => {
            panic!("Null bytes in driver name should be rejected");
        }
    }

    println!("[SUCCESS] Raw mode entry validation works correctly");
}

#[test]
fn test_raw_mode_lifecycle_with_dummy_driver() {
    println!("Testing raw mode lifecycle with dummy driver...");

    let connection = match common::try_connect() {
        Ok(conn) => conn,
        Err(_) => {
            println!("WARNING: No BrlAPI connection available - skipping test");
            return;
        }
    };

    // Try with dummy driver (should fail but in a controlled way)
    match RawMode::enter(&connection, "dummy") {
        Ok(_raw_mode) => {
            println!("WARNING: Dummy driver unexpectedly supported raw mode");
            // If it works, that's fine - just means the test environment is different
        }
        Err(e) => {
            println!("[SUCCESS] Dummy driver raw mode failed as expected: {}", e);
            // This is the expected case for most test environments
        }
    }

    println!("[SUCCESS] Raw mode lifecycle test completed");
}

#[test]
fn test_raw_mode_with_actual_driver() {
    println!("Testing raw mode with actual device driver...");

    let connection = match common::try_connect() {
        Ok(conn) => conn,
        Err(_) => {
            println!("WARNING: No BrlAPI connection available - skipping test");
            return;
        }
    };

    // Get the actual driver
    let driver = match connection.display_driver() {
        Ok(driver) => driver,
        Err(e) => {
            println!("WARNING: Cannot get driver info: {} - skipping test", e);
            return;
        }
    };

    println!("Actual driver: {}", driver);

    // Check if driver supports raw mode
    if !RawMode::is_driver_supported(&driver) {
        println!(
            "[SUCCESS] Driver '{}' correctly identified as not supporting raw mode",
            driver
        );
        return;
    }

    println!("Driver '{}' supports raw mode, attempting entry...", driver);

    // Try to enter raw mode
    match RawMode::enter(&connection, &driver) {
        Ok(raw_mode) => {
            println!(
                "[SUCCESS] Successfully entered raw mode with driver '{}'",
                driver
            );

            // Test basic operations
            test_raw_mode_operations(&raw_mode);

            // Raw mode will be automatically exited when dropped
            println!("[SUCCESS] Raw mode will be automatically exited");
        }
        Err(e) => {
            println!("WARNING: Failed to enter raw mode: {}", e);
            println!("  This is normal for virtual/testing drivers");
        }
    }

    println!("[SUCCESS] Raw mode with actual driver test completed");
}

fn test_raw_mode_operations(raw_mode: &RawMode) {
    println!("Testing raw mode operations...");

    // Test driver name access
    let driver_name = raw_mode.driver_name();
    assert!(!driver_name.is_empty());
    println!("[SUCCESS] Driver name: {}", driver_name);

    // Test connection access
    let _connection = raw_mode.connection();
    println!("[SUCCESS] Connection access works");

    // Test send with empty data
    match raw_mode.send_data(&[]) {
        Ok(bytes_sent) => {
            assert_eq!(bytes_sent, 0);
            println!("[SUCCESS] Empty data send returns 0 bytes");
        }
        Err(e) => {
            println!("WARNING: Empty data send failed: {}", e);
        }
    }

    // Test send with safe test data
    let test_data = b"\x00\x01\x02"; // Safe test pattern
    match raw_mode.send_data(test_data) {
        Ok(bytes_sent) => {
            println!("[SUCCESS] Test data sent: {} bytes", bytes_sent);
        }
        Err(e) => {
            println!("WARNING: Test data send failed (this is normal): {}", e);
        }
    }

    // Test receive with empty buffer
    let mut empty_buffer = [];
    match raw_mode.receive_data(&mut empty_buffer) {
        Ok(bytes_received) => {
            assert_eq!(bytes_received, 0);
            println!("[SUCCESS] Empty buffer receive returns 0 bytes");
        }
        Err(e) => {
            println!("WARNING: Empty buffer receive failed: {}", e);
        }
    }

    // Note: Skipping receive test as it would block indefinitely
    println!("[SUCCESS] Skipping receive test - would block indefinitely without data");

    println!("[SUCCESS] Raw mode operations test completed");
}

#[test]
fn test_raw_mode_raii_cleanup() {
    println!("Testing RAII cleanup behavior...");

    let connection = match common::try_connect() {
        Ok(conn) => conn,
        Err(_) => {
            println!("WARNING: No BrlAPI connection available - skipping test");
            return;
        }
    };

    let driver = match connection.display_driver() {
        Ok(driver) => driver,
        Err(_) => {
            println!("WARNING: Cannot get driver info - using dummy driver");
            "dummy".to_string()
        }
    };

    // Create and immediately drop raw mode to test cleanup
    let result = RawMode::enter(&connection, &driver);
    match result {
        Ok(raw_mode) => {
            println!("[SUCCESS] Raw mode entered, testing automatic cleanup...");
            drop(raw_mode);
            println!("[SUCCESS] Raw mode dropped - cleanup should have occurred");

            // Try to enter again to verify cleanup worked
            match RawMode::enter(&connection, &driver) {
                Ok(_raw_mode2) => {
                    println!("[SUCCESS] Second raw mode entry successful - cleanup worked");
                }
                Err(e) => {
                    println!(
                        "WARNING: Second entry failed: {} (may be driver limitation)",
                        e
                    );
                }
            }
        }
        Err(e) => {
            println!(
                "WARNING: Raw mode entry failed: {} (testing cleanup anyway)",
                e
            );
        }
    }

    println!("[SUCCESS] RAII cleanup test completed");
}

#[test]
fn test_raw_mode_error_scenarios() {
    println!("Testing error scenarios...");

    let connection = match common::try_connect() {
        Ok(conn) => conn,
        Err(_) => {
            println!("WARNING: No BrlAPI connection available - skipping test");
            return;
        }
    };

    // Test with known unsupported driver
    match RawMode::enter(&connection, "noblraille") {
        Ok(_) => {
            println!("WARNING: NoBraille driver unexpectedly supported raw mode");
        }
        Err(e) => {
            println!("[SUCCESS] NoBraille driver correctly rejected: {}", e);
        }
    }

    // Test with very long driver name
    let long_driver = "a".repeat(1000);
    match RawMode::enter(&connection, &long_driver) {
        Ok(_) => {
            println!("WARNING: Very long driver name unexpectedly accepted");
        }
        Err(e) => {
            println!("[SUCCESS] Very long driver name rejected: {}", e);
        }
    }

    println!("[SUCCESS] Error scenarios test completed");
}

#[test]
fn test_raw_mode_concurrent_access() {
    println!("Testing concurrent access restrictions...");

    let connection = match common::try_connect() {
        Ok(conn) => conn,
        Err(_) => {
            println!("WARNING: No BrlAPI connection available - skipping test");
            return;
        }
    };

    let driver = match connection.display_driver() {
        Ok(driver) => driver,
        Err(_) => "dummy".to_string(),
    };

    // Try to enter raw mode
    let raw_mode1 = match RawMode::enter(&connection, &driver) {
        Ok(raw_mode) => {
            println!("[SUCCESS] First raw mode entry successful");
            raw_mode
        }
        Err(e) => {
            println!(
                "WARNING: First raw mode entry failed: {} - skipping concurrent test",
                e
            );
            return;
        }
    };

    // Try to enter raw mode again (should fail)
    match RawMode::enter(&connection, &driver) {
        Ok(_raw_mode2) => {
            println!("WARNING: Second raw mode entry should have failed (device limitation?)");
        }
        Err(e) => {
            println!("[SUCCESS] Second raw mode entry correctly failed: {}", e);
        }
    }

    // Clean up first raw mode
    drop(raw_mode1);
    println!("[SUCCESS] First raw mode cleaned up");

    // Now second entry might work
    match RawMode::enter(&connection, &driver) {
        Ok(_raw_mode2) => {
            println!("[SUCCESS] Raw mode entry after cleanup successful");
        }
        Err(e) => {
            println!("WARNING: Raw mode entry after cleanup failed: {}", e);
        }
    }

    println!("[SUCCESS] Concurrent access test completed");
}