brlapi 0.4.1

// SPDX-License-Identifier: LGPL-2.1

//! Integration tests for BrlAPI parameter management system

use brlapi::{
    BrlApiError, Connection,
    parameters::{Parameter, ParameterFlags, ParameterValue, constants},
};

#[test]
fn test_parameter_system() {
    match Connection::open() {
        Ok(connection) => {
            println!("Connection established, testing parameter system");

            // Test getting server version parameter
            match connection.get_parameter::<u32>(
                Parameter::ServerVersion,
                0,
                ParameterFlags::LOCAL,
            ) {
                Ok(version) => {
                    println!("[SUCCESS] Server version parameter: {}", version);
                    assert!(version > 0, "Server version should be positive");
                }
                Err(e) => {
                    println!("Server version parameter failed: {} (may be expected)", e);
                }
            }

            // Test getting display size parameter
            match connection.get_parameter::<(u32, u32)>(
                Parameter::DisplaySize,
                0,
                ParameterFlags::LOCAL,
            ) {
                Ok((width, height)) => {
                    println!("[SUCCESS] Display size parameter: {}x{}", width, height);
                    // Display size can be 0x0 for some drivers like NoBraille
                }
                Err(e) => {
                    println!("Display size parameter failed: {} (may be expected)", e);
                }
            }

            // Test getting driver name parameter
            match connection.get_parameter::<String>(
                Parameter::DriverName,
                0,
                ParameterFlags::LOCAL,
            ) {
                Ok(driver_name) => {
                    println!("[SUCCESS] Driver name parameter: '{}'", driver_name);
                    assert!(!driver_name.is_empty(), "Driver name should not be empty");
                }
                Err(e) => {
                    println!("Driver name parameter failed: {} (may be expected)", e);
                }
            }

            // Test setting and getting client priority parameter
            match connection.set_parameter(
                Parameter::ClientPriority,
                0,
                ParameterFlags::LOCAL,
                &constants::CLIENT_PRIORITY_DEFAULT,
            ) {
                Ok(()) => {
                    println!("[SUCCESS] Client priority parameter set successfully");

                    // Try to read it back
                    match connection.get_parameter::<u32>(
                        Parameter::ClientPriority,
                        0,
                        ParameterFlags::LOCAL,
                    ) {
                        Ok(priority) => {
                            println!("[SUCCESS] Client priority readback: {}", priority);
                            assert_eq!(priority, constants::CLIENT_PRIORITY_DEFAULT);
                        }
                        Err(e) => {
                            println!("Client priority readback failed: {}", e);
                        }
                    }
                }
                Err(e) => {
                    println!("Setting client priority failed: {} (may be expected)", e);
                }
            }

            // Test using get_parameter_alloc for string parameter
            match connection.get_parameter_alloc::<String>(
                Parameter::DriverName,
                0,
                ParameterFlags::LOCAL,
            ) {
                Ok(driver_name) => {
                    println!("[SUCCESS] Driver name (alloc): '{}'", driver_name);
                    assert!(!driver_name.is_empty(), "Driver name should not be empty");
                }
                Err(e) => {
                    println!("Driver name (alloc) failed: {} (may be expected)", e);
                }
            }

            // Test boolean parameter if available
            match connection.get_parameter::<bool>(
                Parameter::DeviceOnline,
                0,
                ParameterFlags::LOCAL,
            ) {
                Ok(online) => {
                    println!("[SUCCESS] Device online parameter: {}", online);
                }
                Err(e) => {
                    println!("Device online parameter failed: {} (may be expected)", e);
                }
            }

            println!("[SUCCESS] Parameter system tests completed");
        }
        Err(BrlApiError::ConnectionTimeout) => {
            println!("BRLTTY not running - parameter tests skipped (timeout)");
            println!("  Start BRLTTY to run parameter tests: sudo systemctl start brltty");
        }
        Err(BrlApiError::ConnectionRefused) => {
            println!("BRLTTY not running - parameter tests skipped (refused)");
            println!("  Start BRLTTY to run parameter tests: sudo systemctl start brltty");
        }
        Err(BrlApiError::LibCError) => {
            println!("BRLTTY not running - parameter tests skipped (system error)");
            println!("  Start BRLTTY to run parameter tests: sudo systemctl start brltty");
        }
        Err(e) => {
            panic!("Unexpected connection error: {e}");
        }
    }
}

#[test]
fn test_parameter_flags_operations() {
    let local = ParameterFlags::LOCAL;
    let global = ParameterFlags::GLOBAL;
    let self_flag = ParameterFlags::SELF;

    // Test flag combinations
    let combined = local.with(self_flag);
    assert_eq!(combined.raw(), 0x02);

    let global_self = global.with(self_flag);
    assert_eq!(global_self.raw(), 0x03);

    // Test from_raw
    let from_raw = ParameterFlags::from_raw(0x01);
    assert_eq!(from_raw, global);

    println!("[SUCCESS] Parameter flags operations work correctly");
}

#[test]
fn test_parameter_value_conversions() {
    // Test u32 conversion
    let value = 0x12345678u32;
    let data = value
        .to_parameter_data()
        .expect("u32 to parameter data conversion should succeed");
    let converted =
        u32::from_parameter_data(&data).expect("Parameter data to u32 conversion should succeed");
    assert_eq!(value, converted);

    // Test string conversion
    let text = "Hello, BrlAPI!";
    let data = text
        .to_string()
        .to_parameter_data()
        .expect("String to parameter data conversion should succeed");
    let converted = String::from_parameter_data(&data)
        .expect("Parameter data to String conversion should succeed");
    assert_eq!(text, converted);

    // Test boolean conversion
    let bool_val = true;
    let data = bool_val
        .to_parameter_data()
        .expect("bool to parameter data conversion should succeed");
    let converted =
        bool::from_parameter_data(&data).expect("Parameter data to bool conversion should succeed");
    assert_eq!(bool_val, converted);

    // Test display size conversion
    let size = (80u32, 25u32);
    let data = size
        .to_parameter_data()
        .expect("Display size to parameter data conversion should succeed");
    let converted = <(u32, u32)>::from_parameter_data(&data)
        .expect("Parameter data to display size conversion should succeed");
    assert_eq!(size, converted);

    println!("[SUCCESS] Parameter value conversions work correctly");
}

#[test]
fn test_parameter_constants() {
    // Test that our constants match expected values
    assert_eq!(constants::CLIENT_PRIORITY_DEFAULT, 50);
    assert_eq!(constants::CLIENT_PRIORITY_DISABLE, 0);

    println!("[SUCCESS] Parameter constants are correct");
}