brlapi 0.4.1

// SPDX-License-Identifier: LGPL-2.1

//! liblouis Table Discovery Demonstration
//!
//! This example demonstrates the liblouis table discovery and resolution
//! functionality that allows applications to find appropriate braille
//! contraction tables dynamically instead of hardcoding table names.

use liblouis::TableResolver;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("liblouis Table Discovery Demonstration");
    println!("=====================================");
    println!();

    // Initialize table discovery system
    println!("Initializing liblouis table discovery...");
    match TableResolver::index_tables() {
        Ok(()) => println!("[SUCCESS] Table indexing completed"),
        Err(e) => {
            println!("[WARNING] Table indexing failed: {}", e);
            println!("This may be due to missing liblouis tables or incompatible liblouis version");
            println!("Continuing with locale resolution demonstration...");
        }
    }
    println!();

    // Demonstrate query-based table discovery
    println!("Query-based Table Discovery:");
    println!("----------------------------");

    let queries = [
        // Language-based queries
        ("English tables", "language:en"),
        ("French tables", "language:fr"),
        ("German tables", "language:de"),

        // Grade-based queries
        ("Grade 2 tables", "grade:2"),
        ("Grade 1 tables", "grade:1"),

        // Combined queries
        ("English Grade 2", "language:en grade:2"),
        ("US English Grade 2", "language:en region:US grade:2"),
        ("UK English Grade 2", "language:en region:GB grade:2"),
        ("French Grade 2", "language:fr grade:2"),
        ("German Grade 2", "language:de grade:2"),

        // Type-based queries
        ("Computer braille", "type:computer"),
        ("Literary braille", "type:literary"),

        // Dots-based queries
        ("6-dot tables", "dots:6"),
        ("8-dot tables", "dots:8"),
    ];

    for (description, query) in &queries {
        print!("  {:<20} ('{}')  => ", description, query);
        match TableResolver::find_table(query) {
            Ok(Some(table)) => println!("{}", table),
            Ok(None) => println!("(no matches)"),
            Err(e) => println!("ERROR: {} (query may not be supported)", e),
        }
    }
    println!();

    // Demonstrate locale resolution (BRLTTY parameter mapping)
    println!("Locale Resolution (BRLTTY parameter mapping):");
    println!("---------------------------------------------");

    let locales = [
        // Standard locale codes
        "en_US",
        "en_GB",
        "en_CA",
        "fr_FR",
        "fr_CA",
        "de_DE",
        "es_ES",
        "it_IT",
        "pt_BR",
        "nl_NL",
        "sv_SE",
        "da_DK",
        "no_NO",

        // Alternative formats
        "en-US",
        "en-GB",

        // Language only
        "en",
        "fr",
        "de",

        // Table names (should pass through)
        "en-us-g2.ctb",
        "en-gb-g2.ctb",

        // Unknown locale
        "xx_XX",
    ];

    for locale in &locales {
        print!("  {:<10} => ", locale);
        match TableResolver::resolve_locale(locale) {
            Ok(table) => println!("{}", table),
            Err(e) => println!("ERROR: {}", e),
        }
    }
    println!();

    // Demonstrate practical usage patterns
    println!("Practical Usage Examples:");
    println!("------------------------");

    // Example 1: Find best Grade 2 table
    println!("Finding best Grade 2 table for the system:");
    match TableResolver::find_table("grade:2") {
        Ok(Some(table)) => {
            println!("  Found Grade 2 table: {}", table);

            // Test it works
            let translator = liblouis::Translator::new();
            match translator.translate_string(&table, "Hello world") {
                Ok(contracted) => println!("  Test translation: 'Hello world' -> '{}'", contracted),
                Err(e) => println!("  Test translation failed: {}", e),
            }
        }
        Ok(None) => println!("  No Grade 2 table found"),
        Err(e) => println!("  Query failed: {}", e),
    }
    println!();

    // Example 2: User preference simulation
    println!("Simulating user preference resolution:");
    let user_preferences = ["en_US", "en_GB", "fr_FR", "unknown_locale"];

    for pref in &user_preferences {
        println!("  User configured '{}' =>", pref);
        match TableResolver::resolve_locale(pref) {
            Ok(table) => {
                println!("    Resolved to: {}", table);

                // Verify it works
                let translator = liblouis::Translator::new();
                match translator.translate_string(&table, "and the for") {
                    Ok(contracted) => println!("    Test: 'and the for' -> '{}'", contracted),
                    Err(_) => println!("    Test failed (table may not be installed)"),
                }
            }
            Err(e) => println!("    Resolution failed: {}", e),
        }
        println!();
    }

    println!("Table discovery demonstration complete!");
    println!();
    println!("Key benefits:");
    println!("• Dynamic table discovery based on metadata");
    println!("• Automatic locale resolution for user preferences");
    println!("• Fallback mechanisms ensure applications keep working");
    println!("• Integration with BRLTTY parameter system");
    println!("• No more hardcoded table names in application code");

    Ok(())
}