use vietc_engine::{Engine, InputMethod, EngineEvent};

fn trace(input: &str, method: InputMethod) {
    let mut e = Engine::new(method);
    eprintln!("\n=== {:?}: {} ===", method, input);
    eprintln!("Ch | prev_buf  → new_buf   | expected_screen     | Event");
    eprintln!("---+-----------+-----------+---------------------+------");
    for ch in input.chars() {
        let prev = e.buffer().to_string();
        let event = e.process_key(ch);
        let curr = e.buffer().to_string();
        let expected = format!("{}{}", prev, ch);
        let event_str = match &event {
            Some(EngineEvent::Replace { backspaces, insert }) =>
                format!("Replace({}, {:?})", backspaces, insert),
            Some(EngineEvent::Insert(t)) => format!("Insert({:?})", t),
            Some(EngineEvent::Flush(t)) => format!("Flush({:?})", t),
            Some(EngineEvent::AutoRestore(w)) => format!("AutoRestore({:?})", w),
            Some(EngineEvent::UndoTones { backspaces, restored }) =>
                format!("UndoTones({}, {:?})", backspaces, restored),
            None => "None".to_string(),
        };
        let backspaces = match &event {
            Some(EngineEvent::Replace { backspaces, .. }) => format!("bs={}", backspaces),
            _ => "     ".to_string(),
        };
        eprintln!("'{}' | {:<9} → {:<9} | {:<19} | {}",
            ch, prev, curr, expected, event_str);
        if let Some(EngineEvent::Replace { backspaces, insert }) = &event {
            // In grab mode, backspace - 1 (key consumed)
            let grab_bs = backspaces.saturating_sub(1);
            // In non-grab mode, full backspace
            eprintln!("    |           |           | grab_bs={} non_grab_bs={} insert={:?}",
                grab_bs, backspaces, insert);
        }
    }
    // Flush
    if let Some(event) = e.flush() {
        eprintln!("FL  |           |           |                     | {:?}", event);
    }
}

fn main() {
    // Category 1: Basic A group
    trace("traan", InputMethod::Telex);       // trâ
    trace("traanw", InputMethod::Telex);      // trân → w → trăn
    trace("tranwa", InputMethod::Telex);      // trăn → a → trân

    // Category 2: Basic O group
    trace("coon", InputMethod::Telex);        // côn
    trace("coonw", InputMethod::Telex);       // côn → w → cơn
    trace("conwo", InputMethod::Telex);       // cơn → o → côn

    // Category 3: Smart cluster
    trace("chuoonw", InputMethod::Telex);     // chuôn → w → chươn
    trace("chuonwo", InputMethod::Telex);     // chươn → o → chuôn

    // Category 4: With tones
    trace("traansw", InputMethod::Telex);     // trấn → w → trắn

    // Basic typing
    trace("chaof ", InputMethod::Telex);      // chào + space

    // VNI tests
    trace("tran6", InputMethod::Vni);
    trace("tran61", InputMethod::Vni);
    trace("tran618", InputMethod::Vni);
    trace("con67", InputMethod::Vni);
    trace("con627", InputMethod::Vni);

    // Smart cluster VNI
    trace("chuon67", InputMethod::Vni);
    trace("chuon76", InputMethod::Vni);
}