skey_engine/

engine.rs

//! Vietnamese IME engine — Letter-based accumulator model.
//! Each keystroke produces a `Letter` struct. Modifier keys (w, tone, z)
//! mutate the last matching vowel in place. UTF-8 output via precomputed tables.

use crate::tables;

#[derive(Clone, Copy, Default)]
pub(crate) struct Letter {
    pub(crate) c: char,
    pub(crate) is_vowel: bool,
    pub(crate) variant: u8,
    pub(crate) tone: u8,
    pub(crate) is_dstroke: bool,
    pub(crate) upper: bool,
    pub(crate) from_w: bool,
    pub(crate) horn_propagated: bool, // horn set by propagation (not explicit w)
    pub(crate) circ_toggled: bool,    // circumflex was toggled off — don't reapply
    pub(crate) d_toggled: bool,       // đ was toggled off — don't recreate
    pub(crate) horn_toggled: bool,    // horn was toggled off — don't reapply
}

impl Letter {
    pub(crate) fn new(c: char, upper: bool) -> Self {
        let lc = c.to_ascii_lowercase();
        Letter {
            c: lc,
            is_vowel: tables::is_vowel(lc),
            variant: 0,
            tone: 0,
            is_dstroke: false,
            upper,
            from_w: false,
            horn_propagated: false,
            circ_toggled: false,
            d_toggled: false,
            horn_toggled: false,
        }
    }
}

fn emit(ls: &[Letter]) -> String {
    let mut out = String::with_capacity(ls.len() * 3);
    for lt in ls {
        if lt.is_dstroke {
            out.push_str(if lt.upper {
                tables::D_STROKE_UP
            } else {
                tables::D_STROKE_LO
            });
        } else if lt.is_vowel {
            out.push_str(tables::vowel_utf8(lt.c, lt.variant, lt.tone, lt.upper));
        } else {
            out.push(if lt.upper {
                lt.c.to_ascii_uppercase()
            } else {
                lt.c
            });
        }
    }
    out
}

fn last_vowel_index(ls: &[Letter]) -> Option<usize> {
    ls.iter().rposition(|lt| lt.is_vowel)
}
fn last_d_index(ls: &[Letter]) -> Option<usize> {
    ls.iter()
        .rposition(|lt| lt.c == 'd' && !lt.is_vowel && !lt.is_dstroke)
}
fn last_dstroke_index(ls: &[Letter]) -> Option<usize> {
    ls.iter().rposition(|lt| lt.is_dstroke)
}

/// Find the last vowel that can be modified by `w`: a→ă, o→ơ, u→ư.
/// `w` does NOT apply circumflex to `e` — that is done via double-vowel `ee`.
///
/// Special rule (matches x-unikey VSeqList): in a "u"+"a" diphthong, horn
/// goes on `u` (→ ưa), not breve on `a` (→ uă).  For all other combinations
fn tone_vowel_index(ls: &[Letter], modern: bool) -> Option<usize> {
    let end = last_vowel_index(ls)?;
    let mut start = end;
    while start > 0 && ls[start - 1].is_vowel {
        start -= 1;
    }
    if start < end {
        if ls[start].c == 'u' && start > 0 && ls[start - 1].c == 'q' {
            start += 1;
        } else if ls[start].c == 'i' && start > 0 && ls[start - 1].c == 'g' {
            start += 1;
        }
    }
    if start > end {
        start = end;
    }
    let count = end - start + 1;
    // For triphthongs (3+ vowels), tone placement follows position rules —
    // typically the middle vowel.  Don't let a variant (e.g. ô from oo in
    // "oeo") steal the tone; the triphthong structure takes priority.
    if count < 3 {
        for i in (start..=end).rev() {
            if ls[i].variant != 0 {
                return Some(i);
            }
        }
    }
    if count == 1 {
        return Some(start);
    }
    if count >= 3 {
        if ls[start].c == 'u'
            && start + 2 <= end
            && ls[start + 1].c == 'y'
            && ls[start + 2].c == 'e'
        {
            return Some(start + 2);
        }
        return Some(start + 1);
    }
    if end + 1 < ls.len() {
        return Some(end);
    }
    let (c1, c2) = (ls[start].c, ls[end].c);
    if (c1 == 'o' && c2 == 'a') || (c1 == 'o' && c2 == 'e') || (c1 == 'u' && c2 == 'y') {
        // Open oa/oe/uy: modern→2nd vowel, traditional→1st vowel
        // (closed oa/oe/uy always tone on last vowel — handled above)
        return if modern { Some(end) } else { Some(start) };
    }
    Some(start) // default open diphthong: tone on first vowel
}

/// After a hook change (w key), recalculate the correct tone position and
/// move the tone if it's on the wrong vowel. Ported from fcitx5-unikey's
/// tone re-positioning in processHook / processHookWithUO.
fn reposition_tone_after_hook(ls: &mut [Letter], modern: bool) {
    let end = match last_vowel_index(ls) {
        Some(e) => e,
        None => return,
    };
    let mut start = end;
    while start > 0 && ls[start - 1].is_vowel {
        start -= 1;
    }
    // Skip gi/qu digraph vowels
    if start < end {
        if ls[start].c == 'u' && start > 0 && ls[start - 1].c == 'q' {
            start += 1;
        } else if ls[start].c == 'i' && start > 0 && ls[start - 1].c == 'g' {
            start += 1;
        }
    }
    if start > end {
        return;
    }

    // Find which vowel in the cluster currently has tone
    let cur_tone_idx = (start..=end).find(|&i| ls[i].tone != 0);
    let tone_val = match cur_tone_idx {
        Some(i) => ls[i].tone,
        None => return, // no tone → nothing to reposition
    };

    // Find where tone SHOULD be after the hook change
    let new_tone_idx = match tone_vowel_index(ls, modern) {
        Some(i) => i,
        None => return,
    };

    // Move tone if position changed
    if Some(new_tone_idx) != cur_tone_idx {
        if let Some(old) = cur_tone_idx {
            ls[old].tone = 0;
        }
        ls[new_tone_idx].tone = tone_val;
    }
}

fn telex_tone(c: char) -> Option<u8> {
    match c.to_ascii_lowercase() {
        's' => Some(2),
        'f' => Some(1),
        'r' => Some(3),
        'x' => Some(4),
        'j' => Some(5),
        _ => None,
    }
}
fn vni_tone(c: char) -> Option<u8> {
    match c {
        '1' => Some(2),
        '2' => Some(1),
        '3' => Some(3),
        '4' => Some(4),
        '5' => Some(5),
        _ => None,
    }
}

pub fn convert_telex(input: &str, modern: bool, short_w: bool) -> String {
    convert_telex_impl(input, modern, short_w)
}

/// Telex conversion with auto-restore: if the composed output is not valid
/// Vietnamese and differs from the raw input, return the raw input instead.
/// Skips auto-restore when the input has Vietnamese composition markers
/// (dd, vowel+w, double vowels) — those signal intentional IME transforms.
pub fn convert_telex_auto_restore(input: &str, modern: bool, short_w: bool) -> String {
    let composed = convert_telex_impl(input, modern, short_w);
    let all_ascii = composed.chars().all(|c| c.is_ascii());
    if composed != input
        && !all_ascii
        && !crate::spelling::is_valid_cvc(&composed)
        && !crate::has_vn_markers(input)
    {
        input.to_string()
    } else {
        composed
    }
}

fn convert_telex_impl(input: &str, modern: bool, short_w: bool) -> String {
    let mut ls: Vec<Letter> = Vec::with_capacity(input.len());
    for ch in input.chars() {
        let lc = ch.to_ascii_lowercase();
        let upper = ch.is_ascii_uppercase();
        // dd → đ: merge once, unmerge once, then one-shot (like aa).
        // dd→đ, ddd→dd, dddd→ddd (no re-merge after toggle-off).
        if lc == 'd' {
            let any_d_toggled = ls.iter().any(|lt| lt.c == 'd' && lt.d_toggled);
            if !any_d_toggled && last_dstroke_index(&ls).is_none() {
                // No đ yet and never toggled — convert plain d to đ.
                if let Some(di) = last_d_index(&ls) {
                    ls[di].is_dstroke = true;
                    if upper {
                        ls[di].upper = true;
                    }
                    continue;
                }
            } else if last_dstroke_index(&ls).is_some() {
                // đ exists — toggle off once, mark as toggled.
                if let Some(di) = last_dstroke_index(&ls) {
                    ls[di].is_dstroke = false;
                    ls[di].d_toggled = true;
                    // fall through: push literal 'd'
                }
            }
        }
        // Circumflex toggle: a→â, â→a (in-place on matching vowel, like w).
        // the circumflex, searching backwards through the vowel cluster
        // (skipping y/u, so "vay"+a→"vây", "sau"+a→"sâu").
        if matches!(lc, 'a' | 'e' | 'o') {
            // Double-vowel circumflex: aa→â (merge), aaa→aa (unmerge once),
            // then aaaa→aaa (no re-merge — circ_toggled blocks reapply).
            let mut consumed = false;
            if let Some(vi) = last_vowel_index(&ls) {
                // If any matching vowel was already toggled off, don't reapply.
                let any_circ_toggled = ls[..=vi]
                    .iter()
                    .any(|lt| lt.is_vowel && lt.c == lc && lt.circ_toggled);
                if !any_circ_toggled {
                    for i in (0..=vi).rev() {
                        if ls[i].is_vowel {
                            if ls[i].c == lc {
                                if i < vi {
                                    // Roof crossing rules (x-unikey VSeqList
                                    // withRoof): a crosses y/u (ây, âu),
                                    // e crosses u (êu), o crosses i
                                    // (ôi, uôi). Any other intermediate
                                    // vowel blocks the roof.
                                    let blocked = ls[i + 1..=vi]
                                        .iter()
                                        .any(|lt| lt.is_vowel
                                            && !matches!(
                                                (lc, lt.c),
                                                ('a', 'y' | 'u')
                                                    | ('e', 'u')
                                                    | ('o', 'i')
                                            ));
                                    if blocked {
                                        break;
                                    }
                                }
                                if ls[i].variant == 0 {
                                    ls[i].variant = 1;
                                    if upper {
                                        ls[i].upper = true;
                                    }
                                    consumed = true;
                                    break;
                                }
                                if ls[i].variant == 1 {
                                    ls[i].variant = 0;
                                    ls[i].circ_toggled = true;
                                    break;
                                } // unmerge once
                                if ls[i].variant == 2 {
                                    // Swap hook↔circumflex: ă→â, ơ→ô (tone
                                    // stays on the vowel).  For a hooked o
                                    // after a hooked u, unhook the u too
                                    // (ươ→uô) — inverse of the w rule where
                                    // hook replaces circumflex (uô→ươ).
                                    ls[i].variant = 1;
                                    if upper {
                                        ls[i].upper = true;
                                    }
                                    if ls[i].c == 'o'
                                        && i > 0
                                        && ls[i - 1].is_vowel
                                        && ls[i - 1].c == 'u'
                                        && ls[i - 1].variant == 2
                                    {
                                        ls[i - 1].variant = 0;
                                    }
                                    consumed = true;
                                    break;
                                }
                            }
                        } else {
                            break;
                        }
                    }
                }
            }
            if consumed {
                continue;
            }
        }
        if lc == 'w' {
            // Two-phase w handling (from fcitx5-unikey):
            // Phase 1: try to hook/breve the current vowel cluster
            // Phase 2: if not applicable, insert standalone ư (short_w)
            let hook_result = crate::vseq::try_apply_hook(&mut ls);
            match hook_result {
                crate::vseq::HookResult::Applied => {
                    // Hook changed vowel structure — tone may need repositioning
                    reposition_tone_after_hook(&mut ls, modern);
                    continue;
                }
                crate::vseq::HookResult::ToggledOff => {
                    // Hook removed — tone may need repositioning
                    reposition_tone_after_hook(&mut ls, modern);
                    // w falls through as literal below
                }
                crate::vseq::HookResult::NotApplicable => {
                    if crate::vseq::try_insert_horn(&mut ls, short_w, upper) {
                        continue;
                    }
                    // w falls through as literal
                }
            }
        }
        if let Some(t) = telex_tone(lc) {
            if let Some(vi) = tone_vowel_index(&ls, modern) {
                ls[vi].tone = t;
                continue; // replace existing tone
            }
        }
        if lc == 'z' {
            if let Some(vi) = tone_vowel_index(&ls, modern) {
                if ls[vi].tone != 0 {
                    ls[vi].tone = 0;
                    continue;
                }
            }
        }
        ls.push(Letter::new(ch, upper));
        // Horn propagation: ư+o→ươ, ơ+u→ươ within vowel cluster.
        // When a horned vowel is followed by a compatible vowel, share horn.
        if ls.len() >= 2 {
            let last = ls.len() - 1;
            if ls[last].is_vowel && ls[last].variant == 0 {
                let prev = last - 1;
                if ls[prev].is_vowel && ls[prev].variant == 2 {
                    if ls[prev].c == 'u' && ls[last].c == 'o' {
                        ls[last].variant = 2;
                        ls[last].horn_propagated = true;
                    }
                    if ls[prev].c == 'o' && ls[last].c == 'u' {
                        let has_u_horn_before = prev >= 1
                            && ls[prev - 1].is_vowel
                            && ls[prev - 1].c == 'u'
                            && ls[prev - 1].variant == 2;
                        if !has_u_horn_before {
                            ls[last].variant = 2;
                            ls[last].horn_propagated = true;
                        }
                    }
                }
            }
        }
        // Tone reassignment: when a new vowel is pushed, move tone if the
        // vowel structure has changed.
        // e.g. "gis"→"gí" then "a"→"giá" (tone moves from i to a).
        // e.g. "ngoaf"→"ngòa" then "i"→"ngoài" (triphthong, tone to middle).
        if ls.len() >= 2 {
            let last = ls.len() - 1;
            if ls[last].is_vowel {
                // Find first vowel in the cluster
                let first_vowel = (0..last).find(|&j| ls[j].is_vowel);
                if let Some(fv) = first_vowel {
                    let vcount = last - fv + 1;
                    // gi/qu digraph: move tone from digraph vowel to new vowel
                    if vcount >= 2 {
                        for j in (fv..last).rev() {
                            if ls[j].tone != 0 {
                                let move_tone = (ls[j].c == 'i' && j > 0 && ls[j - 1].c == 'g')
                                    || (ls[j].c == 'u' && j > 0 && ls[j - 1].c == 'q');
                                if move_tone {
                                    ls[last].tone = ls[j].tone;
                                    ls[j].tone = 0;
                                }
                                break;
                            }
                        }
                    }
                    // Triphthong: when expanding from 2 to 3+ vowels, move
                    // tone to the correct vowel (middle for most, 3rd for uyê).
                    // Only for a genuine vowel cluster — a consonant in
                    // between ("force" → f,o,c,e) must not count as a third
                    // vowel, or the tone lands on the consonant and is lost.
                    if vcount >= 3 && (fv..=last).all(|j| ls[j].is_vowel) {
                        for j in (fv..last).rev() {
                            if ls[j].tone != 0 {
                                let t = ls[j].tone;
                                ls[j].tone = 0;
                                let target = if ls[fv].c == 'u'
                                    && fv + 2 <= last
                                    && ls[fv + 1].c == 'y'
                                    && ls[fv + 2].c == 'e'
                                {
                                    fv + 2 // uyê → tone on ê
                                } else {
                                    fv + 1 // default → tone on middle vowel
                                };
                                // Guard: move only if target is within bounds
                                // and the current tone is on a non-target vowel
                                if target <= last && target != j {
                                    ls[target].tone = t;
                                } else {
                                    ls[j].tone = t; // restore
                                }
                                break;
                            }
                        }
                    }
                }
            } else if lc != 'w' {
                // Trailing consonant: closed syllable → tone must be on
                // last vowel. e.g. "tof"→"tò" then "a" then "n"→"toàn".
                // Skip for literal 'w' — w is never a Vietnamese final consonant.
                if let Some(end) = last_vowel_index(&ls) {
                    if end + 1 < ls.len() {
                        let fv = (0..end).find(|&j| ls[j].is_vowel);
                        if let Some(fv) = fv {
                            if fv < end {
                                for j in (fv..end).rev() {
                                    if ls[j].tone != 0 {
                                        ls[end].tone = ls[j].tone;
                                        ls[j].tone = 0;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    emit(&ls)
}

/// Combined Telex + VNI mode.
/// Accepts BOTH Telex and VNI keystrokes in one stream:
///   - VNI digits (0-9) apply VNI tone/marks to the last vowel
///   - Telex markers (w, s/f/r/x/j/z, and double-vowel ^/breve) apply Telex
///   - everything else is a normal letter
pub fn convert_teip_vni(input: &str, modern: bool, short_w: bool) -> String {
    let mut ls: Vec<Letter> = Vec::with_capacity(input.len());
    for ch in input.chars() {
        let lc = ch.to_ascii_lowercase();
        let upper = ch.is_ascii_uppercase();

        // ── VNI digit rules ──
        if let Some(t) = vni_tone(lc) {
            if let Some(vi) = tone_vowel_index(&ls, modern) {
                ls[vi].tone = t;
                continue;
            }
        }
        if lc >= '0' && lc <= '9' {
            match lc {
                '6' => {
                    if let Some(vi) = last_vowel_index(&ls) {
                        if matches!(ls[vi].c, 'a' | 'e' | 'o') {
                            ls[vi].variant = 1;
                            continue;
                        }
                    }
                }
                '7' => {
                    if let Some(vi) = last_vowel_index(&ls) {
                        if matches!(ls[vi].c, 'o' | 'u') {
                            ls[vi].variant = 2;
                            if ls[vi].c == 'o' && vi > 0 && ls[vi - 1].c == 'u' {
                                ls[vi - 1].variant = 2;
                            }
                            continue;
                        }
                    }
                }
                '8' => {
                    if let Some(vi) = last_vowel_index(&ls) {
                        if ls[vi].c == 'a' {
                            ls[vi].variant = 2;
                            continue;
                        }
                    }
                }
                '9' => {
                    if let Some(di) = last_d_index(&ls) {
                        ls[di].is_dstroke = true;
                        if upper {
                            ls[di].upper = true;
                        }
                    }
                    continue;
                }
                '0' => {
                    continue;
                }
                _ => {} // digits 1-5 already handled by vni_tone above
            }
        }

        // ── Telex dd → đ: merge once, unmerge once, then one-shot ──
        if lc == 'd' {
            let any_d_toggled = ls.iter().any(|lt| lt.c == 'd' && lt.d_toggled);
            if !any_d_toggled && last_dstroke_index(&ls).is_none() {
                if let Some(di) = last_d_index(&ls) {
                    ls[di].is_dstroke = true;
                    if upper {
                        ls[di].upper = true;
                    }
                    continue;
                }
            } else if last_dstroke_index(&ls).is_some() {
                if let Some(di) = last_dstroke_index(&ls) {
                    ls[di].is_dstroke = false;
                    ls[di].d_toggled = true;
                    // fall through: push literal 'd'
                }
            }
        }

        // ── Circumflex toggle: a→â (in-place, like w) ──
        if matches!(lc, 'a' | 'e' | 'o') {
            // Double-vowel circumflex: aa→â (merge), aaa→aa (unmerge once),
            // then aaaa→aaa (no re-merge — circ_toggled blocks reapply).
            let mut consumed = false;
            if let Some(vi) = last_vowel_index(&ls) {
                // If any matching vowel was already toggled off, don't reapply.
                let any_circ_toggled = ls[..=vi]
                    .iter()
                    .any(|lt| lt.is_vowel && lt.c == lc && lt.circ_toggled);
                if !any_circ_toggled {
                    for i in (0..=vi).rev() {
                        if ls[i].is_vowel {
                            if ls[i].c == lc {
                                if i < vi {
                                    // Roof crossing rules (x-unikey VSeqList
                                    // withRoof): a crosses y/u (ây, âu),
                                    // e crosses u (êu), o crosses i
                                    // (ôi, uôi). Any other intermediate
                                    // vowel blocks the roof.
                                    let blocked = ls[i + 1..=vi]
                                        .iter()
                                        .any(|lt| lt.is_vowel
                                            && !matches!(
                                                (lc, lt.c),
                                                ('a', 'y' | 'u')
                                                    | ('e', 'u')
                                                    | ('o', 'i')
                                            ));
                                    if blocked {
                                        break;
                                    }
                                }
                                if ls[i].variant == 0 {
                                    ls[i].variant = 1;
                                    if upper {
                                        ls[i].upper = true;
                                    }
                                    consumed = true;
                                    break;
                                }
                                if ls[i].variant == 1 {
                                    ls[i].variant = 0;
                                    ls[i].circ_toggled = true;
                                    break;
                                } // unmerge once
                                if ls[i].variant == 2 {
                                    // Swap hook↔circumflex: ă→â, ơ→ô (tone
                                    // stays on the vowel).  For a hooked o
                                    // after a hooked u, unhook the u too
                                    // (ươ→uô) — inverse of the w rule where
                                    // hook replaces circumflex (uô→ươ).
                                    ls[i].variant = 1;
                                    if upper {
                                        ls[i].upper = true;
                                    }
                                    if ls[i].c == 'o'
                                        && i > 0
                                        && ls[i - 1].is_vowel
                                        && ls[i - 1].c == 'u'
                                        && ls[i - 1].variant == 2
                                    {
                                        ls[i - 1].variant = 0;
                                    }
                                    consumed = true;
                                    break;
                                }
                            }
                        } else {
                            break;
                        }
                    }
                }
            }
            if consumed {
                continue;
            }
        }

        // ── Telex w (breve/horn) ──
        if lc == 'w' {
            let hook_result = crate::vseq::try_apply_hook(&mut ls);
            match hook_result {
                crate::vseq::HookResult::Applied => {
                    reposition_tone_after_hook(&mut ls, modern);
                    continue;
                }
                crate::vseq::HookResult::ToggledOff => {
                    reposition_tone_after_hook(&mut ls, modern);
                    // w falls through as literal
                }
                crate::vseq::HookResult::NotApplicable => {
                    if crate::vseq::try_insert_horn(&mut ls, short_w, upper) {
                        continue;
                    }
                }
            }
        }

        // ── Telex tone marks ──
        if let Some(t) = telex_tone(lc) {
            if let Some(vi) = tone_vowel_index(&ls, modern) {
                ls[vi].tone = t;
                continue; // replace existing tone
            }
        }
        if lc == 'z' {
            if let Some(vi) = tone_vowel_index(&ls, modern) {
                if ls[vi].tone != 0 {
                    ls[vi].tone = 0;
                    continue;
                }
            }
        }

        ls.push(Letter::new(ch, upper));
        // Tone reassignment: when a new vowel is pushed, move tone if the
        // vowel structure has changed (gi/qu digraph, triphthong expansion).
        if ls.len() >= 2 {
            let last = ls.len() - 1;
            if ls[last].is_vowel {
                let first_vowel = (0..last).find(|&j| ls[j].is_vowel);
                if let Some(fv) = first_vowel {
                    let vcount = last - fv + 1;
                    // gi/qu digraph: move tone from digraph vowel to new vowel
                    if vcount >= 2 {
                        for j in (fv..last).rev() {
                            if ls[j].tone != 0 {
                                let move_tone = (ls[j].c == 'i' && j > 0 && ls[j - 1].c == 'g')
                                    || (ls[j].c == 'u' && j > 0 && ls[j - 1].c == 'q');
                                if move_tone {
                                    ls[last].tone = ls[j].tone;
                                    ls[j].tone = 0;
                                }
                                break;
                            }
                        }
                    }
                    // Triphthong expansion: 2→3+ vowels, move tone to
                    // correct position (middle vowel, or 3rd for uyê).
                    if vcount >= 3 {
                        for j in (fv..last).rev() {
                            if ls[j].tone != 0 {
                                let t = ls[j].tone;
                                ls[j].tone = 0;
                                let target = if ls[fv].c == 'u'
                                    && fv + 2 <= last
                                    && ls[fv + 1].c == 'y'
                                    && ls[fv + 2].c == 'e'
                                {
                                    fv + 2
                                } else {
                                    fv + 1
                                };
                                if target <= last && target != j {
                                    ls[target].tone = t;
                                } else {
                                    ls[j].tone = t;
                                }
                                break;
                            }
                        }
                    }
                }
            } else {
                // Trailing consonant: closed syllable → tone must be on
                // last vowel.
                if let Some(end) = last_vowel_index(&ls) {
                    if end + 1 < ls.len() {
                        let fv = (0..end).find(|&j| ls[j].is_vowel);
                        if let Some(fv) = fv {
                            if fv < end {
                                for j in (fv..end).rev() {
                                    if ls[j].tone != 0 {
                                        ls[end].tone = ls[j].tone;
                                        ls[j].tone = 0;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    emit(&ls)
}

/// VIQR (Vietnamese Quoted-Readable) conversion.
///
/// Uses ASCII punctuation as diacritic markers:
///   ^ circumflex, ( breve, + horn (modifiers)
///   ' sac, ` huyen, ? hoi, ~ nga, . nang (tones)
///   dd -> đ d-stroke
pub fn convert_viqr(input: &str) -> String {
    let mut ls: Vec<Letter> = Vec::with_capacity(input.len());
    for ch in input.chars() {
        let lc = ch.to_ascii_lowercase();
        let n = ls.len();

        // Modifier characters: apply to last vowel
        match ch {
            '^' | '(' | '+' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    match (ch, ls[vi].c) {
                        ('^', 'a' | 'e' | 'o') => {
                            ls[vi].variant = 1;
                            continue;
                        }
                        ('(', 'a') => {
                            ls[vi].variant = 2;
                            continue;
                        }
                        ('+', 'o' | 'u') => {
                            ls[vi].variant = 2;
                            continue;
                        }
                        _ => {} // illegal combination: fall through to literal
                    }
                }
                // Fall through: treat as literal character
                ls.push(Letter {
                    c: ch,
                    is_vowel: false,
                    variant: 0,
                    tone: 0,
                    is_dstroke: false,
                    upper: false,
                    from_w: false,
                    horn_propagated: false,
                    circ_toggled: false,
                    d_toggled: false,
                    horn_toggled: false,
                });
                continue;
            }
            _ => {}
        }

        // Tone characters
        match ch {
            '\'' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    ls[vi].tone = 2;
                    continue;
                }
            }
            '`' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    ls[vi].tone = 1;
                    continue;
                }
            }
            '?' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    ls[vi].tone = 3;
                    continue;
                }
            }
            '~' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    ls[vi].tone = 4;
                    continue;
                }
            }
            '.' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    ls[vi].tone = 5;
                    continue;
                }
            }
            _ => {}
        }

        // dd → đ
        if lc == 'd' && n > 0 && ls[n - 1].c == 'd' && !ls[n - 1].is_vowel && !ls[n - 1].is_dstroke
        {
            ls[n - 1].is_dstroke = true;
            if ch.is_ascii_uppercase() {
                ls[n - 1].upper = true;
            }
            continue;
        }

        ls.push(Letter::new(ch, ch.is_ascii_uppercase()));
    }
    emit(&ls)
}

pub fn convert_vni(input: &str, modern: bool, _short_w: bool) -> String {
    let mut ls: Vec<Letter> = Vec::with_capacity(input.len());
    for ch in input.chars() {
        let lc = ch.to_ascii_lowercase();
        let upper = ch.is_ascii_uppercase();
        if let Some(t) = vni_tone(lc) {
            if let Some(vi) = tone_vowel_index(&ls, modern) {
                ls[vi].tone = t;
                continue;
            }
        }
        match lc {
            '6' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    if matches!(ls[vi].c, 'a' | 'e' | 'o') {
                        ls[vi].variant = 1;
                        continue;
                    }
                }
            }
            '7' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    if matches!(ls[vi].c, 'o' | 'u') {
                        ls[vi].variant = 2;
                        if ls[vi].c == 'o' && vi > 0 && ls[vi - 1].c == 'u' {
                            ls[vi - 1].variant = 2;
                        }
                        continue;
                    }
                }
            }
            '8' => {
                if let Some(vi) = last_vowel_index(&ls) {
                    if ls[vi].c == 'a' {
                        ls[vi].variant = 2;
                        continue;
                    }
                }
            }
            '9' => {
                if let Some(di) = last_d_index(&ls) {
                    ls[di].is_dstroke = true;
                    if upper {
                        ls[di].upper = true;
                    }
                }
                continue;
            }
            '0' => {
                continue;
            }
            _ => {}
        }
        if lc.is_ascii_alphabetic() || (lc.is_ascii_digit() && !ls.is_empty()) {
            ls.push(Letter::new(ch, upper));
        }
    }
    emit(&ls)
}

#[cfg(test)]
mod tests {
    use super::*;
    // modern=true, short_w=false (current default behavior)
    fn t(s: &str) -> String {
        convert_telex(s, true, false)
    }
    fn tw(s: &str) -> String {
        convert_telex(s, true, true)
    }
    // traditional tone placement (short_w enabled)
    fn tt(s: &str) -> String {
        convert_telex(s, false, true)
    }
    fn vt(s: &str) -> String {
        convert_vni(s, false, true)
    }

    #[test]
    fn telex_basic() {
        assert_eq!(t("as"), "á");
        assert_eq!(t("af"), "à");
        assert_eq!(t("ar"), "ả");
        assert_eq!(t("ax"), "ã");
        assert_eq!(t("aj"), "ạ");
        assert_eq!(t("aw"), "ă");
        assert_eq!(t("aa"), "â");
        assert_eq!(t("ee"), "ê");
        assert_eq!(t("oo"), "ô");
        assert_eq!(t("ow"), "ơ");
        assert_eq!(t("uw"), "ư");
        assert_eq!(t("dd"), "đ");
    }
    #[test]
    fn telex_compound() {
        assert_eq!(t("aws"), "ắ");
        assert_eq!(t("aas"), "ấ");
        assert_eq!(t("ees"), "ế");
        assert_eq!(t("oos"), "ố");
        assert_eq!(t("ows"), "ớ");
        assert_eq!(t("uws"), "ứ");
    }
    #[test]
    fn telex_tone_not_lost_on_consonant_gap() {
        // A consonant between vowels must not be counted as a vowel
        // cluster member — the tone stays on the real vowel.
        assert_eq!(t("for"), "fỏ");
        assert_eq!(t("force"), "fỏce");
        assert_eq!(t("vai"), "vai");
        assert_eq!(t("vaif"), "vài");
    }
    #[test]
    fn telex_words() {
        assert_eq!(t("xin"), "xin");
        assert_eq!(t("tooi"), "tôi");
        assert_eq!(t("laf"), "là");
        assert_eq!(t("cos"), "có");
        assert_eq!(t("khoong"), "không");
        assert_eq!(t("tieengs"), "tiếng");
        assert_eq!(t("Vieetj"), "Việt");
    }
    #[test]
    fn telex_uow() {
        assert_eq!(t("uow"), "ươ");
        assert_eq!(t("cuowcs"), "cước");
        assert_eq!(t("dduwowcj"), "được");
        assert_eq!(t("nguwowif"), "người");
        // Horn propagation: ư+o→ươ (single w serves both vowels)
        assert_eq!(t("uwocs"), "ước");
        assert_eq!(t("truwocs"), "trước");
        assert_eq!(t("luwowcs"), "lước"); // explicit w on both — still works (sắc → ước)
        assert_eq!(t("truwowcs"), "trước"); // "uwo" abbreviated = "uow" long form
                                            // Triphthong: horn does not propagate further
        assert_eq!(t("uowus"), "ướu"); // ươu — horn stays, u unmodified
        assert_eq!(t("ruowus"), "rướu");
        // w replaces circumflex with hook (matches unikey): ô→ơ, â→ă
        assert_eq!(t("luoojcw"), "lược"); // luộc + w → lược
        assert_eq!(t("oow"), "ơ");
        assert_eq!(t("coow"), "cơ");
        assert_eq!(t("aaw"), "ă");
        assert_eq!(t("ooiw"), "ơi"); // ôi + w → ơi
        assert_eq!(t("uooiw"), "ươi");
    }
    #[test]
    fn telex_gi_qu() {
        assert_eq!(t("gif"), "gì");
        assert_eq!(t("giowf"), "giờ");
        assert_eq!(t("gioir"), "giỏi");
        assert_eq!(t("gias"), "giá");
        assert_eq!(t("quas"), "quá");
    }
    #[test]
    fn telex_tone_placement() {
        assert_eq!(t("chafo"), "chào");
        assert_eq!(t("toans"), "toán");
        assert_eq!(t("hoaf"), "hoà");
        assert_eq!(t("thowif"), "thời");
        assert_eq!(t("cuar"), "của");
        assert_eq!(t("thoix"), "thõi");
        // òa/oà both accessible via typing order:
        assert_eq!(t("ofa"), "òa"); // tone between vowels → on first vowel
        assert_eq!(t("oaf"), "oà"); // tone after all vowels → on second vowel
    }
    #[test]
    fn telex_english() {
        assert_eq!(t("hello"), "hello");
        assert_eq!(t("wood"), "wôd");
        assert_eq!(t("reboot"), "rebôt");
    }
    #[test]
    fn telex_z() {
        assert_eq!(t("asz"), "a");
    }
    #[test]
    fn telex_w_standalone() {
        assert_eq!(t("w"), "w"); // without short_w: w stays as w
        assert_eq!(tw("w"), "ư"); // with short_w: standalone w → ư
        assert_eq!(tw("ws"), "ứ");
        assert_eq!(tw("wf"), "ừ");
        assert_eq!(tw("wn"), "ưn");
    }

    // ── traditional tone placement (modern=false, short_w=true) ─────────────

    #[test]
    fn telex_dd_traditional() {
        assert_eq!(tt("dd"), "đ");
        assert_eq!(tt("DD"), "Đ");
        assert_eq!(tt("Dd"), "Đ");
        assert_eq!(tt("dD"), "Đ");
    }

    #[test]
    fn telex_dd_across_chars() {
        // dd → đ works across intervening characters (Unikey-compatible)
        assert_eq!(tt("dad"), "đa");
        assert_eq!(tt("dda"), "đa");
        assert_eq!(tt("dadf"), "đà");
        assert_eq!(tt("dads"), "đá");
        assert_eq!(tt("dadr"), "đả");
        assert_eq!(tt("dadx"), "đã");
        assert_eq!(tt("dadj"), "đạ");
        assert_eq!(tt("dangd"), "đang"); // second d converts first
        assert_eq!(tt("dangdf"), "đàng"); // d...d converts first d
        assert_eq!(tt("DAD"), "ĐA");
        assert_eq!(tt("Dad"), "Đa");
        // Toggle once, then one-shot (like aa): dd→đ, ddd→dd, dddd→ddd
        assert_eq!(tt("dadd"), "dad");
        assert_eq!(tt("ddd"), "dd");     // toggle off once
        assert_eq!(tt("dddd"), "ddd");   // no re-merge, plain d's
        assert_eq!(tt("ddddd"), "dddd"); // plain d's
        assert_eq!(tt("ddda"), "dda");   // plain d's
        assert_eq!(tt("ddddf"), "dddf"); // tone falls through on plain d's
    }
    #[test]
    fn telex_marks_traditional() {
        assert_eq!(tt("aa"), "â");
        assert_eq!(tt("aw"), "ă");
        assert_eq!(tt("ee"), "ê");
        assert_eq!(tt("ew"), "ew"); // ew no longer → ê (use ee)
        assert_eq!(tt("oo"), "ô");
        assert_eq!(tt("ow"), "ơ");
        assert_eq!(tt("uw"), "ư");
        assert_eq!(tt("uow"), "ươ");
    }
    #[test]
    fn telex_w_traditional() {
        assert_eq!(tt("w"), "ư");
        assert_eq!(tt("W"), "Ư");
        assert_eq!(tt("wn"), "ưn");
        assert_eq!(tt("ws"), "ứ");
        assert_eq!(tt("wf"), "ừ");
    }
    #[test]
    fn telex_compound_traditional() {
        assert_eq!(tt("aws"), "ắ");
        assert_eq!(tt("aas"), "ấ");
        assert_eq!(tt("ees"), "ế");
        assert_eq!(tt("oos"), "ố");
        assert_eq!(tt("ows"), "ớ");
        assert_eq!(tt("uws"), "ứ");
    }
    #[test]
    fn telex_words_traditional() {
        assert_eq!(tt("chaof"), "chào");
        assert_eq!(tt("vieejt"), "việt");
        assert_eq!(tt("tieengs"), "tiếng");
        assert_eq!(tt("quas"), "quá");
        assert_eq!(tt("gias"), "giá");
        assert_eq!(tt("xin"), "xin");
        assert_eq!(tt("tooi"), "tôi");
        assert_eq!(tt("laf"), "là");
        assert_eq!(tt("cos"), "có");
        assert_eq!(tt("khoong"), "không");
        assert_eq!(tt("Vieetj"), "Việt");
    }
    #[test]
    fn telex_tone_traditional() {
        // traditional: tone on 2nd vowel for oa/oe/uy open diphthongs
        assert_eq!(tt("toans"), "toán");
        assert_eq!(tt("hoaf"), "hòa");
        assert_eq!(tt("thowif"), "thời");
        assert_eq!(tt("cuar"), "của");
    }
    #[test]
    fn telex_gi_qu_traditional() {
        assert_eq!(tt("gif"), "gì");
        assert_eq!(tt("giowf"), "giờ");
        assert_eq!(tt("gioir"), "giỏi");
    }

    #[test]
    fn telex_gi_qu_tone_reassign() {
        // Incremental typing: tone moves from digraph vowel to new vowel
        assert_eq!(tt("gisa"), "giá"); // gis→gí + a → giá
        assert_eq!(tt("gifa"), "già"); // gif→gì + a → già
        assert_eq!(tt("quisa"), "quía"); // qus→qú + i + a → quía
        assert_eq!(tt("qufa"), "quà"); // quf→qù + a → quà
                                       // Multi-vowel after gi: tone moves to last vowel
        assert_eq!(tt("gias"), "giá"); // already works in one shot
        assert_eq!(tt("giois"), "giói"); // gio + is → giói
    }

    #[test]
    fn telex_trailing_consonant_reassign() {
        // Tone between vowels, then consonant closes syllable
        // → tone moves to last vowel (correct Vietnamese spelling)
        assert_eq!(tt("tofan"), "toàn"); // tof→tò + a + n → toàn
        assert_eq!(tt("toafn"), "toàn"); // toa→toa + f→tòa + n→toàn
        assert_eq!(tt("hoafn"), "hoàn"); // hoaf→hòa + n→hoàn
                                         // One-shot: tone after all vowels already works correctly
        assert_eq!(tt("toanf"), "toàn");
        assert_eq!(tt("hoanf"), "hoàn");
    }
    #[test]
    fn telex_uow_traditional() {
        assert_eq!(tt("cuowcs"), "cước");
        assert_eq!(tt("dduwowcj"), "được");
        assert_eq!(tt("nguwowif"), "người");
    }
    #[test]
    fn telex_z_traditional() {
        assert_eq!(tt("asz"), "a");
    }
    #[test]
    fn telex_english_traditional() {
        assert_eq!(tt("hello"), "hello");
    }
    #[test]
    fn telex_more_traditional() {
        assert_eq!(tt("hoanf"), "hoàn");
        assert_eq!(tt("huyeenf"), "huyền");
        assert_eq!(tt("nguyeexn"), "nguyễn");
        assert_eq!(tt("ngoaif"), "ngoài");
        assert_eq!(tt("thuowngf"), "thường");
    }
    #[test]
    fn vni_marks_traditional() {
        assert_eq!(vt("d9"), "đ");
        assert_eq!(vt("a6"), "â");
        assert_eq!(vt("a8"), "ă");
        assert_eq!(vt("e6"), "ê");
        assert_eq!(vt("o6"), "ô");
        assert_eq!(vt("o7"), "ơ");
        assert_eq!(vt("u7"), "ư");
        assert_eq!(vt("uo7"), "ươ");
    }
    #[test]
    fn vni_words_traditional() {
        assert_eq!(vt("vie65t"), "việt");
        assert_eq!(vt("tie61ng"), "tiếng");
        assert_eq!(vt("qua1"), "quá");
        assert_eq!(vt("gia1"), "giá");
    }

    // ── Tone replacement tests ─────────────────────────────────────
    #[test]
    fn telex_tone_replace() {
        assert_eq!(tt("saosf"), "sào"); // sáo + f → sào (acute→grave)
        assert_eq!(tt("saojs"), "sáo"); // sạ + s → sáo (dot→acute)
        assert_eq!(tt("saojr"), "sảo"); // sạo + r → sảo (dot→hook)
        assert_eq!(tt("hoasf"), "hòa"); // hóa + f → hòa (acute→grave, traditional on o)
        assert_eq!(tt("toansr"), "toản"); // toán + r → toản (acute→hook)
    }
    #[test]
    fn teipvni_tone_replace() {
        assert_eq!(tv("saosf"), "sào"); // Telex acute→grave in combined mode
        assert_eq!(tv("sao1f"), "sào"); // VNI acute + Telex grave
    }

    // ── Double-vowel: merge once, unmerge once, then one-shot ───────
    #[test]
    fn telex_double_vowel_toggle() {
        assert_eq!(tt("aa"), "â");
        assert_eq!(tt("aaa"), "aa");    // unmerge once
        assert_eq!(tt("aaaa"), "aaa");  // no re-merge, plain a's after
        assert_eq!(tt("ee"), "ê");
        assert_eq!(tt("eee"), "ee");
        assert_eq!(tt("eeee"), "eee");  // no re-merge
        assert_eq!(tt("oo"), "ô");
        assert_eq!(tt("ooo"), "oo");
        assert_eq!(tt("oooo"), "ooo");
        assert_eq!(tt("roo"), "rô");
        assert_eq!(tt("rooot"), "root"); // oo→ô, ooo→oo, t
    }

    // ── Double-vowel across y/u (vay+a→vây) ────────────────────────
    #[test]
    fn telex_double_vowel_across_y() {
        assert_eq!(tt("vaya"), "vây");
        assert_eq!(tt("vayaj"), "vậy");
        assert_eq!(tt("vayas"), "vấy");
        assert_eq!(tt("vayaf"), "vầy");
        assert_eq!(tt("mayas"), "mấy");
        assert_eq!(tt("dayaj"), "dậy");
        assert_eq!(tt("quaya"), "quây");
        assert_eq!(tt("quayar"), "quẩy");
        assert_eq!(tt("saua"), "sâu");
        assert_eq!(tt("sauas"), "sấu");
        assert_eq!(tt("dauaf"), "dầu");
        assert_eq!(tt("aay"), "ây");
    }

    // ── Double-vowel on a hooked vowel swaps hook↔circumflex ───────
    #[test]
    fn telex_double_vowel_swap() {
        // ă + a → â (tone preserved): lắm + a → lấm
        assert_eq!(tt("lawsma"), "lấm"); // lắm + a (tone after final consonant)
        assert_eq!(t("lawsma"), "lấm"); // modern tone placement — same result
        assert_eq!(tt("awsa"), "ấ"); // ắ + a → ấ
        assert_eq!(tt("luowjco"), "luộc"); // lược + o → luộc (ươ→uô, inverse of uô+w→ươ)
        assert_eq!(tv("lawsma"), "lấm"); // TeipVni combined mode too
                                         // One-shot after swap: second a unmerges â→a like the aa/aaa pattern.
        assert_eq!(tt("lawsmaa"), "láma"); // lấm + a → lám + literal a
    }

    // ── Roof (circumflex) crossing rules — x-unikey VSeqList parity ──
    // a crosses y/u (ây, âu), e crosses u (êu), o crosses i (ôi/uôi).
    #[test]
    fn telex_roof_crossing() {
        // o crosses i: oi + o → ôi (x-unikey: vs_oi withRoof = vs_ori)
        assert_eq!(tt("oio"), "ôi");
        assert_eq!(t("oio"), "ôi");
        assert_eq!(tt("ddoio"), "đôi");
        assert_eq!(tt("đoio"), "đôi"); // literal đ (surrounding-text rebuild)
        assert_eq!(tt("doio"), "dôi");
        assert_eq!(tt("oiof"), "ồi"); // tone after roof lands on ô
        // uoi + o → uôi (roof at position 1, x-unikey vs_uoi → vs_uori)
        assert_eq!(tt("uoio"), "uôi");
        assert_eq!(tt("uoiof"), "uồi");
        // ơi + o → ôi and ươi + o → uôi (hook↔circumflex swap across i)
        assert_eq!(tt("owio"), "ôi");
        assert_eq!(tt("uowio"), "uôi");
        assert_eq!(tv("oio"), "ôi"); // TeipVni combined mode too
                                     // ai + a stays aia — x-unikey vs_ai has no withRoof (blocks i for a)
        assert_eq!(tt("aia"), "aia");
        assert_eq!(tt("eie"), "eie"); // ei is not a roofable cluster either
        // a still crosses y/u, e crosses u (existing behavior)
        assert_eq!(tt("vaya"), "vây");
        assert_eq!(tt("saua"), "sâu");
        assert_eq!(tt("eue"), "êu");
        // o does NOT cross u/y (x-unikey vs_uou / oy have no withRoof)
        assert_eq!(tt("uouo"), "uouo");
        assert_eq!(tt("oyo"), "oyo");
    }

    // ── w-toggle: pressing w again undoes the mark ──────────────────
    #[test]
    fn telex_w_toggle() {
        // Standalone w → ư, ww → ư→w + literal w → ww
        // Toggle-off now also produces a literal w (ow + w → ow, not o)
        assert_eq!(tt("w"), "ư");
        assert_eq!(tt("ww"), "w"); // ư→w toggle (consumed)
        assert_eq!(tt("www"), "ww"); // w literal + w literal
        assert_eq!(tt("wws"), "ws"); // w→ư, w→w (toggle), s has no vowel → ws
    }
    #[test]
    fn telex_w_toggle_regular() {
        assert_eq!(tt("aw"), "ă"); // a+w → ă
        assert_eq!(tt("aww"), "aw"); // ă+w → a + literal w → aw
        assert_eq!(tt("ow"), "ơ"); // o+w → ơ
        assert_eq!(tt("oww"), "ow"); // ơ+w → o + literal w → ow
        assert_eq!(tt("uw"), "ư"); // u+w → ư
        assert_eq!(tt("uww"), "uw"); // ư+w → u + literal w → uw
                                     // e+w no longer → ê — use ee for circumflex
        assert_eq!(tt("ew"), "ew");
        assert_eq!(tt("uow"), "ươ"); // u+o+w → ươ
        assert_eq!(tt("uoww"), "uow"); // ươ+w → uo + literal w → uow
        // Triple-w: one-shot after toggle (like aa→â, aaa→aa, aaaa→aaa)
        assert_eq!(tt("owww"), "oww"); // ơ→o toggle off once, then literal w's
        assert_eq!(tt("uowww"), "uoww"); // ươ→uo toggle off once, then literal w's
                                       // uu + w → ưu (horn on first u of cluster, matches Unikey Windows)
        assert_eq!(tt("uuw"), "ưu");
        assert_eq!(tt("uuww"), "uuw"); // 2nd w: toggle ưu→uu + literal w → uuw
        assert_eq!(tt("uuws"), "ứu"); // uuw + acute
    }

    // ── w-target tests: w applies to last modifiable vowel ──────────
    #[test]
    fn telex_w_target() {
        // toi+w: w modifies 'o' (last modifiable), not 'i'
        assert_eq!(tt("toiw"), "tơi");
        assert_eq!(tt("toiws"), "tới"); // toi + w + sắc → tới
        assert_eq!(tt("toiwf"), "tời"); // toi + w + huyền → tời
        assert_eq!(tt("toiwr"), "tởi"); // toi + w + hỏi → tởi
        assert_eq!(tt("toiwj"), "tợi"); // toi + w + nặng → tợi
                                        // nguoi + w + f = người (w→ơ on o, uow→ươ, f→huyền on ư)
        assert_eq!(tt("nguoiwf"), "người");
        assert_eq!(tt("nguoiws"), "ngưới");
        // muoi + w + f = mười
        assert_eq!(tt("muoiwf"), "mười");
        // tuoi + w + s = tưới
        assert_eq!(tt("tuoiws"), "tưới");
        // "tuổi" correctly typed as tuooir (oo→ô)
        assert_eq!(tt("tuooir"), "tuổi");
        assert_eq!(tt("tuooif"), "tuồi");
    }
    #[test]
    fn telex_toan() {
        // "toàn" has trailing consonant → tone on 2nd vowel always
        assert_eq!(tt("toanf"), "toàn");
        assert_eq!(t("toanf"), "toàn");
        assert_eq!(tt("hoanf"), "hoàn");
        assert_eq!(t("hoanf"), "hoàn");
        // open diphthong oa/oe/uy: always 2nd vowel
        // òa typed as ofa (tone between vowels), oà typed as oaf (tone after)
        assert_eq!(t("oaf"), "oà"); // tone after all vowels → 2nd
        assert_eq!(t("ofa"), "òa"); // tone between vowels → 1st
        assert_eq!(tt("oaf"), "òa"); // traditional: tone on 1st vowel
        assert_eq!(tt("ofa"), "òa"); // tone between vowels → 1st (typing order)
    }

    // ── TeipVni (combined Telex + VNI) tests ─────────────────────────
    fn tv(s: &str) -> String {
        convert_teip_vni(s, false, true)
    }

    #[test]
    fn teipvni_telex_words() {
        assert_eq!(tv("vieejt"), "việt");
        assert_eq!(tv("dd"), "đ");
        assert_eq!(tv("aa"), "â");
        assert_eq!(tv("aw"), "ă");
        assert_eq!(tv("ee"), "ê");
        assert_eq!(tv("oo"), "ô");
        assert_eq!(tv("ow"), "ơ");
        assert_eq!(tv("uw"), "ư");
        assert_eq!(tv("uow"), "ươ");
        assert_eq!(tv("w"), "ư");
    }
    #[test]
    fn teipvni_vni_marks() {
        assert_eq!(tv("a6"), "â");
        assert_eq!(tv("a8"), "ă");
        assert_eq!(tv("e6"), "ê");
        assert_eq!(tv("o6"), "ô");
        assert_eq!(tv("o7"), "ơ");
        assert_eq!(tv("u7"), "ư");
        assert_eq!(tv("uo7"), "ươ");
        assert_eq!(tv("d9"), "đ");
    }
    #[test]
    fn teipvni_numbers() {
        // VNI tones
        assert_eq!(tv("qua1"), "quá");
        assert_eq!(tv("gia1"), "giá");
        assert_eq!(tv("vie65t"), "việt");
        assert_eq!(tv("tie61ng"), "tiếng");
    }
    #[test]
    fn teipvni_mixed() {
        // Mix Telex and VNI in same stream
        assert_eq!(tv("vie6t"), "viêt"); // VNI circumflex + Telex
        assert_eq!(tv("vie6ts"), "viết"); // VNI circumflex + Telex tone
        assert_eq!(tv("tie6ngs"), "tiếng");
    }

    // ── VIQR tests ──────────────────────────────────────────────────
    fn viqr(s: &str) -> String {
        convert_viqr(s)
    }

    #[test]
    fn viqr_marks() {
        assert_eq!(viqr("a^"), "â");
        assert_eq!(viqr("a("), "ă");
        assert_eq!(viqr("e^"), "ê");
        assert_eq!(viqr("o^"), "ô");
        assert_eq!(viqr("o+"), "ơ");
        assert_eq!(viqr("u+"), "ư");
        assert_eq!(viqr("dd"), "đ");
    }
    #[test]
    fn viqr_tones() {
        assert_eq!(viqr("a'"), "á");
        assert_eq!(viqr("a`"), "à");
        assert_eq!(viqr("a?"), "ả");
        assert_eq!(viqr("a~"), "ã");
        assert_eq!(viqr("a."), "ạ");
    }
    #[test]
    fn viqr_words() {
        assert_eq!(viqr("vie^'t"), "viết");
        assert_eq!(viqr("nu+o+'c"), "nước");
        assert_eq!(viqr("ngu+o+`i"), "người");
    }
    #[test]
    fn viqr_dd() {
        assert_eq!(viqr("dd"), "đ");
        assert_eq!(viqr("DD"), "Đ");
    }
    #[test]
    fn viqr_english() {
        assert_eq!(viqr("hello"), "hello");
    }
}

#[test]
fn full_parity() {
    // This test verifies full parity for all 73 reference cases.
    // traditional settings: modern=false (traditional tone placement), short_w=true

    struct Case {
        input: &'static str,
        expected: &'static str,
        method: u8,
    }
    // method: 1=Telex, 2=VNI, 3=VIQR, 4=TeipVni
    let cases = [
        // ── Telex ──
        Case {
            input: "dd",
            expected: "đ",
            method: 1,
        },
        Case {
            input: "DD",
            expected: "Đ",
            method: 1,
        },
        Case {
            input: "Dd",
            expected: "Đ",
            method: 1,
        },
        Case {
            input: "dD",
            expected: "Đ",
            method: 1,
        },
        Case {
            input: "aa",
            expected: "â",
            method: 1,
        },
        Case {
            input: "aw",
            expected: "ă",
            method: 1,
        },
        Case {
            input: "ee",
            expected: "ê",
            method: 1,
        },
        Case {
            input: "ew",
            expected: "ew", // ew no longer → ê (use ee)
            method: 1,
        },
        Case {
            input: "oo",
            expected: "ô",
            method: 1,
        },
        Case {
            input: "ow",
            expected: "ơ",
            method: 1,
        },
        Case {
            input: "uw",
            expected: "ư",
            method: 1,
        },
        Case {
            input: "uow",
            expected: "ươ",
            method: 1,
        },
        Case {
            input: "w",
            expected: "ư",
            method: 1,
        },
        Case {
            input: "W",
            expected: "Ư",
            method: 1,
        },
        Case {
            input: "wn",
            expected: "ưn",
            method: 1,
        },
        Case {
            input: "ws",
            expected: "ứ",
            method: 1,
        },
        Case {
            input: "wf",
            expected: "ừ",
            method: 1,
        },
        Case {
            input: "aws",
            expected: "ắ",
            method: 1,
        },
        Case {
            input: "aas",
            expected: "ấ",
            method: 1,
        },
        Case {
            input: "ees",
            expected: "ế",
            method: 1,
        },
        Case {
            input: "oos",
            expected: "ố",
            method: 1,
        },
        Case {
            input: "ows",
            expected: "ớ",
            method: 1,
        },
        Case {
            input: "uws",
            expected: "ứ",
            method: 1,
        },
        Case {
            input: "chaof",
            expected: "chào",
            method: 1,
        },
        Case {
            input: "vieejt",
            expected: "việt",
            method: 1,
        },
        Case {
            input: "tieengs",
            expected: "tiếng",
            method: 1,
        },
        Case {
            input: "quas",
            expected: "quá",
            method: 1,
        },
        Case {
            input: "gias",
            expected: "giá",
            method: 1,
        },
        Case {
            input: "xin",
            expected: "xin",
            method: 1,
        },
        Case {
            input: "tooi",
            expected: "tôi",
            method: 1,
        },
        Case {
            input: "laf",
            expected: "là",
            method: 1,
        },
        Case {
            input: "cos",
            expected: "có",
            method: 1,
        },
        Case {
            input: "khoong",
            expected: "không",
            method: 1,
        },
        Case {
            input: "Vieetj",
            expected: "Việt",
            method: 1,
        },
        Case {
            input: "toans",
            expected: "toán",
            method: 1,
        },
        Case {
            input: "hoaf",
            expected: "hòa",
            method: 1,
        },
        Case {
            input: "thowif",
            expected: "thời",
            method: 1,
        },
        Case {
            input: "cuar",
            expected: "của",
            method: 1,
        },
        Case {
            input: "gif",
            expected: "gì",
            method: 1,
        },
        Case {
            input: "giowf",
            expected: "giờ",
            method: 1,
        },
        Case {
            input: "gioir",
            expected: "giỏi",
            method: 1,
        },
        Case {
            input: "cuowcs",
            expected: "cước",
            method: 1,
        },
        Case {
            input: "dduwowcj",
            expected: "được",
            method: 1,
        },
        Case {
            input: "nguwowif",
            expected: "người",
            method: 1,
        },
        Case {
            input: "asz",
            expected: "a",
            method: 1,
        },
        Case {
            input: "hello",
            expected: "hello",
            method: 1,
        },
        Case {
            input: "hoanf",
            expected: "hoàn",
            method: 1,
        },
        Case {
            input: "huyeenf",
            expected: "huyền",
            method: 1,
        },
        Case {
            input: "nguyeexn",
            expected: "nguyễn",
            method: 1,
        },
        Case {
            input: "ngoaif",
            expected: "ngoài",
            method: 1,
        },
        Case {
            input: "thuowngf",
            expected: "thường",
            method: 1,
        },
        // ── VNI ──
        Case {
            input: "d9",
            expected: "đ",
            method: 2,
        },
        Case {
            input: "a6",
            expected: "â",
            method: 2,
        },
        Case {
            input: "a8",
            expected: "ă",
            method: 2,
        },
        Case {
            input: "e6",
            expected: "ê",
            method: 2,
        },
        Case {
            input: "o6",
            expected: "ô",
            method: 2,
        },
        Case {
            input: "o7",
            expected: "ơ",
            method: 2,
        },
        Case {
            input: "u7",
            expected: "ư",
            method: 2,
        },
        Case {
            input: "uo7",
            expected: "ươ",
            method: 2,
        },
        Case {
            input: "vie65t",
            expected: "việt",
            method: 2,
        },
        Case {
            input: "tie61ng",
            expected: "tiếng",
            method: 2,
        },
        Case {
            input: "qua1",
            expected: "quá",
            method: 2,
        },
        Case {
            input: "gia1",
            expected: "giá",
            method: 2,
        },
        // ── TeipVni ──
        Case {
            input: "vie61t",
            expected: "viết",
            method: 4,
        },
        Case {
            input: "vieejt",
            expected: "việt",
            method: 4,
        },
        Case {
            input: "tie61ng",
            expected: "tiếng",
            method: 4,
        },
        Case {
            input: "a6",
            expected: "â",
            method: 4,
        },
        Case {
            input: "dd",
            expected: "đ",
            method: 4,
        },
        // ── VIQR ──
        Case {
            input: "dd",
            expected: "đ",
            method: 3,
        },
        Case {
            input: "DD",
            expected: "Đ",
            method: 3,
        },
        Case {
            input: "vie^'t",
            expected: "viết",
            method: 3,
        },
        Case {
            input: "nu+o+'c",
            expected: "nước",
            method: 3,
        },
        Case {
            input: "ngu+o+`i",
            expected: "người",
            method: 3,
        },
    ];

    let mut failures = Vec::new();
    for c in &cases {
        let result = match c.method {
            1 => convert_telex(c.input, false, true),
            2 => convert_vni(c.input, false, true),
            3 => convert_viqr(c.input),
            4 => convert_teip_vni(c.input, false, true),
            _ => unreachable!(),
        };
        if result != c.expected {
            failures.push(format!(
                "[m{}] '{}' -> '{}' (expected '{}')",
                c.method, c.input, result, c.expected
            ));
        }
    }
    assert!(
        failures.is_empty(),
        "{} full parity failures:\n{}",
        failures.len(),
        failures.join("\n")
    );
}

#[test]
fn comprehensive_vietnamese() {
    // Comprehensive test covering all Vietnamese syllable patterns.
    // Uses traditional settings: modern=false, short_w=true.
    // method: 1=Telex, 2=VNI, 3=VIQR, 4=TeipVni.
    // Method 0 = Telex (traditional) for brevity.

    let cases: &[(&str, &str, u8)] = &[
        // ═══ SINGLE VOWELS — 5 tones each ═══
        ("as", "á", 1),
        ("af", "à", 1),
        ("ar", "ả", 1),
        ("ax", "ã", 1),
        ("aj", "ạ", 1),
        ("es", "é", 1),
        ("ef", "è", 1),
        ("er", "ẻ", 1),
        ("ex", "ẽ", 1),
        ("ej", "ẹ", 1),
        ("is", "í", 1),
        ("if", "ì", 1),
        ("ir", "ỉ", 1),
        ("ix", "ĩ", 1),
        ("ij", "ị", 1),
        ("os", "ó", 1),
        ("of", "ò", 1),
        ("or", "ỏ", 1),
        ("ox", "õ", 1),
        ("oj", "ọ", 1),
        ("us", "ú", 1),
        ("uf", "ù", 1),
        ("ur", "ủ", 1),
        ("ux", "ũ", 1),
        ("uj", "ụ", 1),
        ("ys", "ý", 1),
        ("yf", "ỳ", 1),
        ("yr", "ỷ", 1),
        ("yx", "ỹ", 1),
        ("yj", "ỵ", 1),
        // ═══ MARKED VOWELS (breve/circumflex/horn) + tones ═══
        // ă = aw
        ("aw", "ă", 1),
        ("aws", "ắ", 1),
        ("awf", "ằ", 1),
        ("awr", "ẳ", 1),
        ("awx", "ẵ", 1),
        ("awj", "ặ", 1),
        // â = aa
        ("aa", "â", 1),
        ("aas", "ấ", 1),
        ("aaf", "ầ", 1),
        ("aar", "ẩ", 1),
        ("aax", "ẫ", 1),
        ("aaj", "ậ", 1),
        // ê = ee / ew
        ("ee", "ê", 1),
        ("ees", "ế", 1),
        ("eef", "ề", 1),
        ("eer", "ể", 1),
        ("eex", "ễ", 1),
        ("eej", "ệ", 1),
        // ew no longer → ê (use ee for circumflex)
        // tone keys still apply: e+w+s → éw (tone on e, w literal)
        ("ew", "ew", 1),
        ("ews", "éw", 1),
        ("ewf", "èw", 1),
        ("ewr", "ẻw", 1),
        // ô = oo
        ("oo", "ô", 1),
        ("oos", "ố", 1),
        ("oof", "ồ", 1),
        ("oor", "ổ", 1),
        ("oox", "ỗ", 1),
        ("ooj", "ộ", 1),
        // ơ = ow
        ("ow", "ơ", 1),
        ("ows", "ớ", 1),
        ("owf", "ờ", 1),
        ("owr", "ở", 1),
        ("owx", "ỡ", 1),
        ("owj", "ợ", 1),
        // ư = uw
        ("uw", "ư", 1),
        ("uws", "ứ", 1),
        ("uwf", "ừ", 1),
        ("uwr", "ử", 1),
        ("uwx", "ữ", 1),
        ("uwj", "ự", 1),
        // ═══ dd → đ ═══
        ("dd", "đ", 1),
        // ═══ STANDALONE w → ư ═══
        ("w", "ư", 1),
        ("ws", "ứ", 1),
        ("wf", "ừ", 1),
        ("wr", "ử", 1),
        ("wx", "ữ", 1),
        ("wj", "ự", 1),
        ("wn", "ưn", 1),
        ("wt", "ưt", 1),
        // ═══ DIPHTHONGS — closed (trailing consonant) ═══
        // ai, ao, au
        ("ais", "ái", 1),
        ("aif", "ài", 1),
        ("air", "ải", 1),
        ("aix", "ãi", 1),
        ("aij", "ại", 1),
        ("aos", "áo", 1),
        ("aof", "ào", 1),
        ("aor", "ảo", 1),
        ("aox", "ão", 1),
        ("aoj", "ạo", 1),
        ("aus", "áu", 1),
        ("auf", "àu", 1),
        ("aur", "ảu", 1),
        ("aux", "ãu", 1),
        ("auj", "ạu", 1),
        // ây, ay
        ("aays", "ấy", 1),
        ("aayf", "ầy", 1),
        ("aayr", "ẩy", 1),
        ("aayx", "ẫy", 1),
        ("aayj", "ậy", 1),
        ("ays", "áy", 1),
        ("ayf", "ày", 1),
        ("ayr", "ảy", 1),
        ("ayx", "ãy", 1),
        ("ayj", "ạy", 1),
        // eo, êu
        ("eos", "éo", 1),
        ("eof", "èo", 1),
        ("eor", "ẻo", 1),
        ("eox", "ẽo", 1),
        ("eoj", "ẹo", 1),
        ("eeus", "ếu", 1),
        ("eeuf", "ều", 1),
        ("eeur", "ểu", 1),
        ("eeux", "ễu", 1),
        ("eeuj", "ệu", 1),
        // oi, ôi, ơi, ui, ưi, ưu
        ("ois", "ói", 1),
        ("oif", "òi", 1),
        ("oir", "ỏi", 1),
        ("oix", "õi", 1),
        ("oij", "ọi", 1),
        ("oois", "ối", 1),
        ("ooif", "ồi", 1),
        ("ooir", "ổi", 1),
        ("ooix", "ỗi", 1),
        ("ooij", "ội", 1),
        ("owis", "ới", 1),
        ("owif", "ời", 1),
        ("owir", "ởi", 1),
        ("owix", "ỡi", 1),
        ("owij", "ợi", 1),
        ("uis", "úi", 1),
        ("uif", "ùi", 1),
        ("uir", "ủi", 1),
        ("uix", "ũi", 1),
        ("uij", "ụi", 1),
        ("uwis", "ứi", 1),
        ("uwif", "ừi", 1),
        ("uwir", "ửi", 1),
        ("uwix", "ữi", 1),
        ("uwij", "ựi", 1),
        ("uwus", "ứu", 1),
        ("uwuf", "ừu", 1),
        ("uwur", "ửu", 1),
        ("uwux", "ữu", 1),
        ("uwuj", "ựu", 1),
        // ═══ oa, oe, uy — closed (trailing consonant, tone on 2nd vowel) ═══
        ("oans", "oán", 1),
        ("oanf", "oàn", 1),
        ("oanr", "oản", 1),
        ("oanx", "oãn", 1),
        ("oanj", "oạn", 1),
        ("oats", "oát", 1),
        ("oatf", "oàt", 1),
        ("oatr", "oảt", 1),
        ("oens", "oén", 1),
        ("oenf", "oèn", 1),
        ("uyns", "uýn", 1),
        ("uynf", "uỳn", 1),
        ("uynr", "uỷn", 1),
        // ═══ oa, oe, uy — open (traditional: tone on 1st vowel) ═══
        ("oas", "óa", 1),
        ("oaf", "òa", 1),
        ("oar", "ỏa", 1),
        ("oax", "õa", 1),
        ("oaj", "ọa", 1),
        ("oes", "óe", 1),
        ("oef", "òe", 1),
        ("uys", "úy", 1),
        ("uyf", "ùy", 1),
        ("uyr", "ủy", 1),
        ("uyx", "ũy", 1),
        ("uyj", "ụy", 1),
        // ═══ TRIPHTHONGS ═══
        // oai, oay (tone on middle vowel)
        ("oais", "oái", 1),
        ("oaif", "oài", 1),
        ("oair", "oải", 1),
        ("oaix", "oãi", 1),
        ("oaij", "oại", 1),
        ("oays", "oáy", 1),
        ("oayf", "oày", 1),
        ("oayr", "oảy", 1),
        ("oayx", "oãy", 1),
        ("oayj", "oạy", 1),
        // uây (tone on middle vowel â)
        ("uaays", "uấy", 1),
        ("uaayf", "uầy", 1),
        ("uaayr", "uẩy", 1),
        ("uaayx", "uẫy", 1),
        ("uaayj", "uậy", 1),
        // uyê (tone on ê — 3rd vowel, the one with variant)
        ("uyeef", "uyề", 1),
        ("uyees", "uyế", 1),
        ("uyeer", "uyể", 1),
        ("uyeex", "uyễ", 1),
        ("uyeej", "uyệ", 1),
        // iê, yê
        ("ieef", "iề", 1),
        ("iees", "iế", 1),
        ("ieer", "iể", 1),
        ("ieex", "iễ", 1),
        ("ieej", "iệ", 1),
        ("yeef", "yề", 1),
        ("yees", "yế", 1),
        ("yeer", "yể", 1),
        ("yeex", "yễ", 1),
        ("yeej", "yệ", 1),
        // uôi = u + ô + i (oo→ô, tone on ô which has variant≠0)
        ("uoois", "uối", 1),
        ("uooif", "uồi", 1),
        ("uooir", "uổi", 1),
        ("uooix", "uỗi", 1),
        ("uooij", "uội", 1),
        // ươi = u + ơ + i (w targets o, uow spread → ươ, tone on ơ which has variant≠0)
        ("uoiws", "ưới", 1),
        ("uoiwf", "ười", 1),
        ("uoiwr", "ưởi", 1),
        ("uoiwx", "ưỡi", 1),
        ("uoiwj", "ượi", 1),
        // ═══ GI / QU initial consonant digraphs ═══
        ("gif", "gì", 1),
        ("gis", "gí", 1),
        ("gir", "gỉ", 1),
        ("gix", "gĩ", 1),
        ("gij", "gị", 1),
        ("gias", "giá", 1),
        ("giaf", "già", 1),
        ("giar", "giả", 1),
        ("giax", "giã", 1),
        ("giaj", "giạ", 1),
        ("gioir", "giỏi", 1),
        ("gioif", "giòi", 1),
        ("giois", "giói", 1),
        ("quas", "quá", 1),
        ("quaf", "quà", 1),
        ("quar", "quả", 1),
        ("quax", "quã", 1),
        ("quaj", "quạ", 1),
        ("quys", "quý", 1),
        ("quyf", "quỳ", 1),
        ("quyr", "quỷ", 1),
        ("quyx", "quỹ", 1),
        ("quyj", "quỵ", 1),
        // ═══ REAL WORDS ═══
        ("chaof", "chào", 1),
        ("vieejt", "việt", 1),
        ("tieengs", "tiếng", 1),
        ("khoong", "không", 1),
        ("cuar", "của", 1),
        ("cuowcs", "cước", 1),
        ("dduwowcj", "được", 1),
        ("nguwowif", "người", 1),
        ("thuowngf", "thường", 1),
        ("hoanf", "hoàn", 1),
        ("huyeenf", "huyền", 1),
        ("nguyeexn", "nguyễn", 1),
        ("ngoaif", "ngoài", 1),
        ("ngoafi", "ngoài", 1),
        ("vaya", "vây", 1),
        ("vayaj", "vậy", 1),
        ("vayas", "vấy", 1),
        ("mayas", "mấy", 1),
        // Double-vowel across consonant: nhan+a→nhân, khan+a→khân
        ("nhana", "nhân", 1),
        ("khanas", "khấn", 1),
        ("nhanaa", "nhana", 1),
        ("toans", "toán", 1),
        ("thowif", "thời", 1),
        ("xin", "xin", 1),
        ("tooi", "tôi", 1),
        ("laf", "là", 1),
        ("cos", "có", 1),
        ("banj", "bạn", 1),
        ("minhf", "mình", 1),
        ("nawm", "năm", 1),
        ("thangs", "tháng", 1),
        ("truwowngf", "trường", 1),
        ("luaatj", "luật", 1),
        // ═══ dd ACROSS CHARACTERS (Unikey-compatible) ═══
        ("dad", "đa", 1),
        ("DAD", "ĐA", 1),
        ("Dad", "Đa", 1),
        ("dda", "đa", 1),
        ("dadf", "đà", 1),
        ("dads", "đá", 1),
        ("dadr", "đả", 1),
        ("dadx", "đã", 1),
        ("dadj", "đạ", 1),
        // Toggle only for non-consecutive d's; at most one đ
        ("dadd", "dad", 1),
        // Consecutive d's after first đ: all literal
        ("ddd", "dd", 1),
        ("dddd", "ddd", 1),
        // ═══ CONSONANT CLUSTERS ═══
        ("nhas", "nhá", 1),
        ("nghir", "nghỉ", 1),
        ("gheps", "ghép", 1),
        ("truws", "trứ", 1),
        ("thas", "thá", 1),
        ("phos", "phó", 1),
        ("khas", "khá", 1),
        ("chays", "cháy", 1),
        ("ngays", "ngáy", 1),
        // ═══ FINAL CONSONANT VARIETY ═══
        ("ddejp", "đẹp", 1),
        ("maats", "mất", 1),
        ("bacs", "bác", 1),
        ("ngachs", "ngách", 1),
        ("banhf", "bành", 1),
        ("tins", "tín", 1),
        ("metj", "mẹt", 1),
        // ═══ z (tone removal) ═══
        ("asz", "a", 1),
        ("awsjz", "ă", 1),
        ("aasz", "â", 1),
        // ═══ ENGLISH PASS-THROUGH (words without Telex tone/mark keys s/f/r/x/j/w/z) ═══
        ("hello", "hello", 1),
        ("bacon", "bacon", 1),
        ("thing", "thing", 1),
        ("climb", "climb", 1),
        // ═══ CAPITALIZATION ═══
        ("As", "Á", 1),
        ("Af", "À", 1),
        ("Aas", "Ấ", 1),
        ("Aws", "Ắ", 1),
        ("Dd", "Đ", 1),
        ("DD", "Đ", 1),
        ("W", "Ư", 1),
        ("Ws", "Ứ", 1),
        ("Vieetj", "Việt", 1),
        ("Tooi", "Tôi", 1),
        // ═══ VNI method ═══
        ("d9", "đ", 2),
        ("a6", "â", 2),
        ("a8", "ă", 2),
        ("e6", "ê", 2),
        ("o6", "ô", 2),
        ("o7", "ơ", 2),
        ("u7", "ư", 2),
        ("uo7", "ươ", 2),
        ("vie65t", "việt", 2),
        ("tie61ng", "tiếng", 2),
        ("qua1", "quá", 2),
        ("gia1", "giá", 2),
        // ═══ TeipVni combined ═══
        ("vie61t", "viết", 4),
        ("vieejt", "việt", 4),
        ("tie61ng", "tiếng", 4),
        ("a6", "â", 4),
        ("dd", "đ", 4),
        // ═══ VIQR method ═══
        ("dd", "đ", 3),
        ("DD", "Đ", 3),
        ("vie^'t", "viết", 3),
        ("nu+o+'c", "nước", 3),
        ("ngu+o+`i", "người", 3),
    ];

    let mut failures = Vec::new();
    for &(input, expected, method) in cases {
        let result = match method {
            1 => convert_telex(input, false, true),
            2 => convert_vni(input, false, true),
            3 => convert_viqr(input),
            4 => convert_teip_vni(input, false, true),
            _ => unreachable!(),
        };
        if result != expected {
            failures.push(format!(
                "[m{}] '{}' -> '{}' (expected '{}')",
                method, input, result, expected
            ));
        }
    }
    assert!(
        failures.is_empty(),
        "{} comprehensive failures (traditional mode):\n{}",
        failures.len(),
        failures.join("\n")
    );
}