msime_engine/zhuyin/

scheme.rs

//! The Dachen bopomofo editor with libchewing's semantics: keys fill the pending syllable, a tone key completes it against the syllable inventory, and the completed syllables are reconverted after every change. Candidates come from a list the user opens; choosing one pins that span's text and never commits. Text leaves the editor only through Enter, Shift punctuation, auto-shift past `MAX_SYLLABLES` and `take_text`.
//!
//! 九键模式（`set_nine_key`）下不读大千键：数字串按 `nine_key::KEYPAD` 记下符号位置，声调键结束音节，这个位置的读音是数字串加声调对应的全部合法音节；转换在每个位置的读音里一起挑，用户可以经 `choose_spelling` 逐个钉住目标音节的读音。

use std::cmp::Reverse;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;

use super::conversion::{self, Span, MAX_SYLLABLES};
use super::layout::{self, DACHEN_SYMBOLS, IDLE_SYMBOLS, SHIFT_PUNCTUATION};
use super::nine_key::{self, NineKeyIndex};
use super::syllable::PendingSyllable;
use crate::error::Result;
use crate::language_dictionary::{LanguageDictionary, LanguageEntry};
use crate::types::{QueryRequest, SchemeType};

/// The non-letter keys the editor still claims while the list is open: the phonetic keys that are not selection digits. Digits 1–9 and Space go to selection.
pub const LIST_OPEN_SYMBOLS: &str = "0,./;-";
const SMALL_READING_DEDUP: usize = 32;

/// A key as the editor sees it. The session maps host keys and command 16 (`Command::ConvertHanja`, "open the candidate list") onto these.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ZhuyinKey {
    /// A printable ASCII key: a Dachen key, a tone key, or a Shift punctuation key.
    Char(u8),
    /// Open the list, or close it when it is open.
    OpenList,
    Enter,
    Escape,
    Backspace,
}

/// One row of the candidate list: `text` for the syllables from `start` to the end of the composition.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ListCandidate {
    pub text: String,
    pub start: usize,
    /// 这一行在词库里的键（带调音节以空格连接），选中后随 pin 一起保存，说明被覆盖的音节用的是哪个读音。
    pub key: String,
}

/// 一个已完成的音节和打出它的键。
#[derive(Debug, Clone, PartialEq, Eq)]
struct Syllable {
    /// 大千下是大千键加声调键，九键下是数字串加声调键。
    keys: String,
    /// 这个位置合法的带调音节。大千下只有一个；九键下是这串数字和声调对应的全部音节。
    readings: Arc<[String]>,
    /// 九键下用户钉住的读音在 `readings` 里的下标；大千下恒为 `None`。
    locked: Option<usize>,
}

impl Syllable {
    /// 转换时这个位置允许的读音：钉住的那一个，否则全部。
    fn allowed(&self) -> &[String] {
        match self.locked {
            Some(index) => std::slice::from_ref(&self.readings[index]),
            None => &self.readings,
        }
    }
}

#[derive(Default)]
struct BestCache {
    entries: HashMap<String, Option<(String, LanguageEntry)>>,
    description: String,
}

impl BestCache {
    fn clear(&mut self) {
        self.entries.clear();
        self.description.clear();
    }
}

pub struct ZhuyinScheme {
    dictionary: LanguageDictionary,
    syllables: Vec<Syllable>,
    /// Spans whose text the user chose from the list; non-overlapping.
    pins: Vec<Span>,
    pending: PendingSyllable,
    /// The current conversion of `syllables`, recomputed after every change to them or to `pins`.
    conversion: Vec<Span>,
    list_open: bool,
    /// The list rows while `list_open`, empty otherwise.
    list: Vec<ListCandidate>,
    /// Text the last key committed, waiting for the session to hand it to the host.
    committed: String,
    /// 组字过程中每段位置描述（各位置允许的读音以 `|` 连接，位置之间用空格）的最重词条及其键。词库只读，所以条目一直有效；九键下每次钉读音都会产生新的描述，缓存在组字结束和每次 auto-shift 时清空。
    best: BestCache,
    /// 注音九键模式：数字键拼音节，`zxcvb` 和空格是声调键。
    nine_key: bool,
    /// 九键模式第一次处理按键时从音节表建出的索引，之后一直保留。
    nine_key_index: Option<NineKeyIndex>,
    /// 九键下还没按声调键的数字串。
    pending_digits: Vec<u8>,
    /// 九键下供用户钉读音的目标音节的候选读音，当前转换用的排在最前；最近一次转换后算出，列表打开时不对外提供。
    spellings: Vec<String>,
    /// `spellings` 对应的音节下标。
    spelling_target: Option<usize>,
}

impl ZhuyinScheme {
    /// An idle editor reading `dictionary` (`msime-zhuyin.db`).
    pub fn new(dictionary: LanguageDictionary) -> Self {
        Self {
            dictionary,
            syllables: Vec::new(),
            pins: Vec::new(),
            pending: PendingSyllable::default(),
            conversion: Vec::new(),
            list_open: false,
            list: Vec::new(),
            committed: String::new(),
            best: BestCache::default(),
            nine_key: false,
            nine_key_index: None,
            pending_digits: Vec::new(),
            spellings: Vec::new(),
            spelling_target: None,
        }
    }

    /// 切换注音九键模式，丢掉正在进行的组字。`reset` 不改变模式。
    pub fn set_nine_key(&mut self, enabled: bool) {
        self.clear_composition();
        self.nine_key = enabled;
    }

    pub fn nine_key(&self) -> bool {
        self.nine_key
    }

    /// The `msime-zhuyin.db` connection, given back when the editor is replaced so the next one reuses it.
    pub fn into_dictionary(self) -> LanguageDictionary {
        self.dictionary
    }

    /// Drops the composition and any text not yet taken.
    pub fn reset(&mut self) {
        self.clear_composition();
        self.committed.clear();
    }

    pub fn is_composing(&self) -> bool {
        !self.syllables.is_empty() || !self.pending.is_empty() || !self.pending_digits.is_empty()
    }

    /// Handles one key and returns whether the editor claimed it. An unclaimed key is left to the session and host (idle tone digits and Space type themselves; selection digits and Space while the list is open select through the session). Text the key committed is in `take_committed`.
    pub fn handle_key(&mut self, key: ZhuyinKey) -> Result<bool> {
        match key {
            ZhuyinKey::Char(byte) => self.handle_char(byte),
            _ if !self.is_composing() => Ok(false),
            ZhuyinKey::OpenList => {
                if self.list_open {
                    self.close_list();
                } else {
                    self.open_list()?;
                }
                Ok(true)
            }
            ZhuyinKey::Enter => {
                let text = self.take_text();
                self.committed.push_str(&text);
                Ok(true)
            }
            ZhuyinKey::Escape => {
                if self.list_open {
                    self.close_list();
                } else {
                    self.clear_composition();
                }
                Ok(true)
            }
            ZhuyinKey::Backspace => {
                if self.list_open {
                    self.close_list();
                } else if self.pending_digits.pop().is_none() && !self.pending.pop() {
                    let end = self.syllables.len();
                    self.syllables.pop();
                    self.pins.retain(|pin| pin.end != end);
                    self.reconvert()?;
                    if !self.is_composing() {
                        self.clear_composition();
                    }
                }
                Ok(true)
            }
        }
    }

    /// Pins the text of list row `index` over its span and closes the list. Nothing is committed. Returns false when the list is closed or has no such row.
    pub fn select(&mut self, index: usize) -> Result<bool> {
        if !self.list_open {
            return Ok(false);
        }
        if index >= self.list.len() {
            return Ok(false);
        }
        let candidate = self.list.swap_remove(index);
        let pin = Span {
            start: candidate.start,
            end: self.syllables.len(),
            key: candidate.key,
            text: candidate.text,
        };
        self.pins
            .retain(|other| !other.overlaps(pin.start, pin.end));
        self.pins.push(pin);
        self.pins.sort_by_key(|pin| pin.start);
        self.close_list();
        self.reconvert()?;
        Ok(true)
    }

    /// The converted text, ending the composition; the pending syllable is dropped. This is what blur, a scheme switch and Enter commit.
    pub fn take_text(&mut self) -> String {
        let text = self.converted_text();
        self.clear_composition();
        text
    }

    /// The text the last key committed; empty when it committed none.
    pub fn take_committed(&mut self) -> String {
        std::mem::take(&mut self.committed)
    }

    /// 打出组字的键，按顺序，供光标锁定的编辑文本使用；九键下是数字串加声调键，例如 `28c39c4`。
    pub fn editing_text(&self) -> String {
        let mut keys =
            build_editing_keys(&self.syllables, &self.pending, self.pending_digits.len());
        keys.extend(self.pending_digits.iter().map(|digit| char::from(*digit)));
        keys
    }

    fn editing_text_into(&self, keys: &mut String) {
        append_editing_keys(
            &self.syllables,
            &self.pending,
            self.pending_digits.len(),
            keys,
        );
        keys.extend(self.pending_digits.iter().map(|digit| char::from(*digit)));
    }

    /// 转换后的文字加上还在拼的部分：大千是待定的注音符号，例如 `你好ㄇㄚ`；九键是还没按声调的数字，例如 `你好28`。
    pub fn reading(&self) -> String {
        let mut reading = String::new();
        self.reading_into(&mut reading);
        reading
    }

    fn reading_into(&self, reading: &mut String) {
        let pending_capacity = [self.pending.initial, self.pending.medial, self.pending.rime]
            .into_iter()
            .flatten()
            .map(char::len_utf8)
            .sum::<usize>()
            + self.pending_digits.len();
        append_converted_text(&self.conversion, pending_capacity, reading);
        if let Some(symbol) = self.pending.initial {
            reading.push(symbol);
        }
        if let Some(symbol) = self.pending.medial {
            reading.push(symbol);
        }
        if let Some(symbol) = self.pending.rime {
            reading.push(symbol);
        }
        reading.extend(self.pending_digits.iter().map(|digit| char::from(*digit)));
    }

    /// What the session shows and tests for a composition: the reading, which is empty exactly when nothing is composing.
    pub fn preedit(&self) -> String {
        self.reading()
    }

    /// The request the session keeps for the composition. Nothing is queried with it, since the list rows come from the editor itself; `raw_input` is the typed keys the caret-locked editing text shows and `normalized_segmentation` the reading the snapshot draws.
    pub fn build_request(&self) -> QueryRequest {
        let mut request = QueryRequest::default();
        self.build_request_into(&mut request);
        request
    }

    /// 将注音请求写入已有存储，避免刷新时重复复制按键和读音字符串。
    pub fn build_request_into(&self, request: &mut QueryRequest) {
        request.scheme = SchemeType::Zhuyin;
        self.editing_text_into(&mut request.raw_input);
        request.raw_input_with_cases.clone_from(&request.raw_input);
        request.normalized_input.clone_from(&request.raw_input);
        request.raw_segmentation.clone_from(&request.raw_input);
        self.reading_into(&mut request.normalized_segmentation);
        request.segmentation.clear();
        request.korean_hanja = false;
        request.valid = self.is_composing();
    }

    pub fn converted_text(&self) -> String {
        build_converted_text(&self.conversion)
    }

    pub fn list_open(&self) -> bool {
        self.list_open
    }

    /// The list rows; empty unless the list is open.
    pub fn candidates(&self) -> &[ListCandidate] {
        &self.list
    }

    /// 九键下供用户钉读音的候选读音（带调注音，一声不带符号），当前转换用的排在最前；列表打开、没有歧义音节或在大千模式时为空。
    pub fn spellings(&self) -> &[String] {
        if self.list_open {
            return &[];
        }
        &self.spellings
    }

    /// 把 `spellings()[index]` 钉为目标音节的读音并重新转换，不提交任何文字。读音即使与当前转换相同也照样钉住，目标随之移到下一个歧义音节，用户可以逐个确认。列表打开、没有目标或下标越界时返回 false。
    pub fn choose_spelling(&mut self, index: usize) -> Result<bool> {
        if self.list_open {
            return Ok(false);
        }
        let (Some(target), Some(reading)) = (self.spelling_target, self.spellings.get(index))
        else {
            return Ok(false);
        };
        let Some(syllable) = self.syllables.get_mut(target) else {
            return Ok(false);
        };
        let Some(position) = syllable.readings.iter().position(|other| other == reading) else {
            return Ok(false);
        };
        syllable.locked = Some(position);
        self.reconvert()?;
        Ok(true)
    }

    /// The non-letter keys the editor claims in its current state, in `DACHEN_SYMBOLS` order; 九键下见 `nine_key` 的三个常量。
    pub fn spelling_symbols(&self) -> &'static str {
        if self.nine_key {
            return if !self.is_composing() {
                nine_key::IDLE_SYMBOLS
            } else if self.list_open {
                nine_key::LIST_OPEN_SYMBOLS
            } else {
                nine_key::SYMBOLS
            };
        }
        if !self.is_composing() {
            IDLE_SYMBOLS
        } else if self.list_open {
            LIST_OPEN_SYMBOLS
        } else {
            DACHEN_SYMBOLS
        }
    }

    fn handle_char(&mut self, byte: u8) -> Result<bool> {
        if let Some((_, mark)) = SHIFT_PUNCTUATION.iter().find(|(key, _)| *key == byte) {
            let text = self.take_text();
            self.committed.push_str(&text);
            self.committed.push(*mark);
            return Ok(true);
        }
        if self.nine_key {
            return self.handle_nine_key_char(byte);
        }
        if self.list_open {
            if !byte.is_ascii_lowercase() && !LIST_OPEN_SYMBOLS.as_bytes().contains(&byte) {
                return Ok(false);
            }
            self.close_list();
        }
        // Every phonetic key is a lowercase letter or one of IDLE_SYMBOLS, so each starts a composition from idle.
        if let Some((symbol, kind)) = layout::symbol(byte) {
            self.pending.insert(symbol, kind);
            return Ok(true);
        }
        let Some(mark) = layout::tone_mark(byte) else {
            return Ok(false);
        };
        if !self.is_composing() {
            return Ok(false);
        }
        let Some(toned) = self.pending.toned(mark) else {
            // A tone with nothing pending: Space opens the list, the tone digits are swallowed.
            if byte == b' ' {
                self.open_list()?;
            }
            return Ok(true);
        };
        // A syllable the inventory does not know stays pending; libchewing beeps here.
        if !self.dictionary.has_syllable(&toned)? {
            return Ok(true);
        }
        if self.syllables.len() == MAX_SYLLABLES {
            self.shift_leftmost_word();
        }
        let mut keys = self.pending.keys();
        keys.push(char::from(byte));
        self.syllables.push(Syllable {
            keys,
            readings: Arc::from([toned]),
            locked: None,
        });
        self.pending.clear();
        self.reconvert()?;
        Ok(true)
    }

    /// 九键模式的字符键。列表打开时，数字和声调字母关闭列表后照常处理，其余键（包括空格）不认领，交给运行时选行。数字总是认领，只有还能拼成某个音节时才追加，否则吞掉（libchewing 在这里会响铃）。声调键结束一个音节：空闲时声调字母和空格都不认领（实体键盘上的这几个字母照常上屏，软键盘空闲时不发声调键）；有组字但没有数字时空格打开列表、声调字母被吞掉；数字串加这个声调没有合法音节时数字留着。其他键（包括全部字母）不认领，九键模式不读大千键。
    fn handle_nine_key_char(&mut self, byte: u8) -> Result<bool> {
        let mark = nine_key::tone_mark(byte);
        if self.list_open {
            if !byte.is_ascii_digit() && (mark.is_none() || byte == b' ') {
                return Ok(false);
            }
            self.close_list();
        }
        if byte.is_ascii_digit() {
            if self.pending_digits.len() == nine_key::MAX_DIGITS {
                return Ok(true);
            }
            let mut next = std::mem::take(&mut self.pending_digits);
            next.push(byte);
            let accepted = self.nine_key_index().map(|index| index.accepts(&next));
            if !matches!(accepted, Ok(true)) {
                next.pop();
            }
            self.pending_digits = next;
            accepted?;
            return Ok(true);
        }
        let Some(mark) = mark else {
            return Ok(false);
        };
        if !self.is_composing() {
            return Ok(false);
        }
        if self.pending_digits.is_empty() {
            if byte == b' ' {
                self.open_list()?;
            }
            return Ok(true);
        }
        let mut digits = std::mem::take(&mut self.pending_digits);
        let readings = match self.nine_key_index() {
            Ok(index) => index.readings(&digits, mark),
            Err(error) => {
                self.pending_digits = digits;
                return Err(error);
            }
        };
        let Some(readings) = readings else {
            self.pending_digits = digits;
            return Ok(true);
        };
        if self.syllables.len() == MAX_SYLLABLES {
            self.shift_leftmost_word();
        }
        let mut keys: String = digits.iter().map(|digit| char::from(*digit)).collect();
        keys.push(char::from(byte));
        digits.clear();
        self.pending_digits = digits;
        self.syllables.push(Syllable {
            keys,
            readings,
            locked: None,
        });
        self.reconvert()?;
        Ok(true)
    }

    /// 九键索引，第一次用到时从 `msime-zhuyin.db` 的音节表建立，大千用户不付出这份代价。
    fn nine_key_index(&mut self) -> Result<&NineKeyIndex> {
        let index = match self.nine_key_index.take() {
            Some(index) => index,
            None => NineKeyIndex::new(self.dictionary.syllables()?),
        };
        Ok(self.nine_key_index.insert(index))
    }

    /// Commits the first converted word and drops its syllables, making room for one more.
    fn shift_leftmost_word(&mut self) {
        let Some(word) = self.conversion.first() else {
            return;
        };
        let end = word.end;
        self.committed.push_str(&word.text);
        self.syllables.drain(..end);
        self.best.clear();
        self.pins.retain(|pin| pin.start >= end);
        for pin in &mut self.pins {
            pin.start -= end;
            pin.end -= end;
        }
    }

    /// Lists every suffix span of the syllables, longest first, each span's entries by weight. Every entry is listed, since the list is the only way to choose a character; common syllables such as ㄧˋ have over 200. The list stays closed when it would be empty.
    fn open_list(&mut self) -> Result<()> {
        let count = self.syllables.len();
        self.list.clear();
        let positions = list_positions(&self.syllables);
        for start in 0..count {
            let mut entries = self
                .dictionary
                .lookup_readings(&positions[start..count], usize::MAX)?;
            // 九键下同一个字可能在同一位置的两个读音下各有一条，只留较重的那条。
            deduplicate_reading_entries(&mut entries);
            self.list.reserve(entries.len());
            self.list
                .extend(entries.into_iter().map(|(key, entry)| ListCandidate {
                    text: entry.text,
                    start,
                    key,
                }));
        }
        self.list_open = !self.list.is_empty();
        Ok(())
    }

    fn close_list(&mut self) {
        self.list_open = false;
        self.list.clear();
    }

    fn clear_composition(&mut self) {
        self.syllables.clear();
        self.pins.clear();
        self.pending.clear();
        self.pending_digits.clear();
        self.spellings.clear();
        self.spelling_target = None;
        self.conversion.clear();
        self.close_list();
        self.best.clear();
    }

    fn reconvert(&mut self) -> Result<()> {
        let count = self.syllables.len();
        let (positions, ambiguous) = reconversion_buffers(&self.syllables);
        let positions = &positions[..count];
        let ambiguous = &ambiguous[..count];
        // 歧义按打字时的读音算，不按钉住后剩下的：钉住当前用的读音不该放出被下限挡住的冷僻词（是之 → 適之）。
        let dictionary = &self.dictionary;
        let best = &mut self.best;
        // 每个位置单字最重词条的权重，只在九键下有位置打出来不止一个读音时才用得到。
        let mut singles = [0; MAX_SYLLABLES];
        if ambiguous.iter().any(|&ambiguous| ambiguous) {
            for index in 0..positions.len() {
                singles[index] =
                    cached_best_weight(dictionary, best, &positions[index..=index])?.unwrap_or(0);
            }
        }
        let singles = &singles[..count];
        self.conversion = conversion::convert_filtered(
            positions.len(),
            &self.pins,
            |start, end, can_improve| {
                cached_best(
                    dictionary,
                    best,
                    &positions[start..end],
                    |entry| match entry.filter(|(_, entry)| {
                        clears_ambiguous_word_floor(&ambiguous[start..end], singles, start, entry)
                    }) {
                        Some((key, entry)) if can_improve(entry.weight) => {
                            conversion::Lookup::Found(key.clone(), entry.clone())
                        }
                        Some(_) => conversion::Lookup::Rejected,
                        None => conversion::Lookup::Missing,
                    },
                )
            },
            |index| positions[index][0].clone(),
        )?;
        self.refresh_spellings()
    }

    /// 重算钉读音的目标和它的候选读音。目标是第一个不被任何 pin 覆盖、没有钉住、且有不止一个读音的音节；读音按当前转换用的那个、单字最重词条的权重（从重到轻）、字典序排列。没有目标时为空，大千模式下永远为空。
    fn refresh_spellings(&mut self) -> Result<()> {
        let result = self.refresh_spelling_choices();
        if result.is_err() {
            self.spellings.clear();
        }
        result
    }

    fn refresh_spelling_choices(&mut self) -> Result<()> {
        self.spelling_target = None;
        if !self.nine_key {
            self.spellings.clear();
            return Ok(());
        }
        let Some(target) = self
            .syllables
            .iter()
            .enumerate()
            .position(|(index, syllable)| {
                syllable.locked.is_none()
                    && syllable.readings.len() > 1
                    && !self.pins.iter().any(|pin| pin.overlaps(index, index + 1))
            })
        else {
            self.spellings.clear();
            return Ok(());
        };
        let current = current_spelling(&self.conversion, target);
        let readings = Arc::clone(&self.syllables[target].readings);
        if readings.len() <= SMALL_SPELLING_RANK {
            let mut ranked = [(false, Reverse(0), 0usize); SMALL_SPELLING_RANK];
            for (index, reading) in readings.iter().enumerate() {
                let weight = cached_best_weight(
                    &self.dictionary,
                    &mut self.best,
                    &[std::slice::from_ref(reading)],
                )?
                .unwrap_or(i64::MIN);
                ranked[index] = (current != Some(reading.as_str()), Reverse(weight), index);
            }
            ranked[..readings.len()].sort_by(|left, right| {
                left.0
                    .cmp(&right.0)
                    .then_with(|| left.1.cmp(&right.1))
                    .then_with(|| readings[left.2].cmp(&readings[right.2]))
            });
            replace_string_buffer(
                &mut self.spellings,
                ranked[..readings.len()]
                    .iter()
                    .map(|(_, _, index)| readings[*index].as_str()),
            );
        } else {
            let mut ranked = Vec::with_capacity(readings.len());
            for reading in readings.iter() {
                let weight = cached_best_weight(
                    &self.dictionary,
                    &mut self.best,
                    &[std::slice::from_ref(reading)],
                )?
                .unwrap_or(i64::MIN);
                ranked.push((current != Some(reading.as_str()), Reverse(weight), reading));
            }
            ranked.sort();
            replace_string_buffer(
                &mut self.spellings,
                ranked.into_iter().map(|(_, _, reading)| reading.as_str()),
            );
        }
        self.spelling_target = Some(target);
        Ok(())
    }
}

fn replace_string_buffer<'a>(
    destination: &mut Vec<String>,
    mut source: impl Iterator<Item = &'a str>,
) {
    let mut kept = 0;
    loop {
        let Some(value) = source.next() else {
            destination.truncate(kept);
            return;
        };
        if let Some(target) = destination.get_mut(kept) {
            target.clear();
            target.push_str(value);
            kept += 1;
        } else {
            destination.extend(std::iter::once(value).chain(source).map(str::to_owned));
            return;
        }
    }
}

fn deduplicate_reading_entries(entries: &mut Vec<(String, LanguageEntry)>) {
    if entries.len() <= SMALL_READING_DEDUP {
        let mut write = 0;
        for read in 0..entries.len() {
            if entries[..write]
                .iter()
                .any(|(_, entry)| entry.text == entries[read].1.text)
            {
                continue;
            }
            if write != read {
                entries.swap(write, read);
            }
            write += 1;
        }
        entries.truncate(write);
        return;
    }
    let mut seen = HashSet::with_capacity(entries.len());
    let duplicates = entries
        .iter()
        .enumerate()
        .filter_map(|(index, (_, entry))| (!seen.insert(entry.text.as_str())).then_some(index))
        .collect::<Vec<_>>();
    drop(seen);
    let mut duplicates = duplicates.into_iter().peekable();
    let mut write = 0;
    for read in 0..entries.len() {
        if duplicates.peek() == Some(&read) {
            duplicates.next();
            continue;
        }
        if write != read {
            entries.swap(write, read);
        }
        write += 1;
    }
    entries.truncate(write);
}

fn list_positions<'a>(syllables: &'a [Syllable]) -> [&'a [String]; MAX_SYLLABLES] {
    let mut positions: [&'a [String]; MAX_SYLLABLES] = [&[]; MAX_SYLLABLES];
    for (index, syllable) in syllables.iter().enumerate() {
        positions[index] = syllable.allowed();
    }
    positions
}

fn reconversion_buffers<'a>(
    syllables: &'a [Syllable],
) -> ([&'a [String]; MAX_SYLLABLES], [bool; MAX_SYLLABLES]) {
    let mut positions: [&'a [String]; MAX_SYLLABLES] = [&[]; MAX_SYLLABLES];
    let mut ambiguous = [false; MAX_SYLLABLES];
    for (index, syllable) in syllables.iter().enumerate() {
        positions[index] = syllable.allowed();
        ambiguous[index] = syllable.readings.len() > 1;
    }
    (positions, ambiguous)
}

fn current_spelling(conversion: &[Span], target: usize) -> Option<&str> {
    conversion
        .iter()
        .find(|span| span.overlaps(target, target + 1))
        .and_then(|span| span.key.split(' ').nth(target - span.start))
}

/// 多音节词经过一个有多种允许读法的位置时，词频最多可以比它覆盖的最弱单字轻多少倍。
///
/// Conversion ranks paths by word length first (the sum of squared span lengths in `conversion.rs`), which suits Dachen, where each position has exactly one reading. A nine-key position allows 4 to 23 readings, so the combined reading sets of two or three positions match some obscure word almost everywhere, and length-first alone lets 監聽器 (weight 9) beat 今天 (25469) + 去 (28394). Such a word therefore takes part only when its weight times this factor reaches the smallest single-character weight over its positions. 1000 was chosen against a rebuild of the libchewing-derived dictionary: it drops 監聽器, 趕明兒 and 禮教 from 我們今天去學校, 這個東西很便宜 and 請問你叫什麼名字, and of the sampled counted 2 to 4 syllable words that convert to themselves without the floor all but one still do, while a factor of 300 already loses about one in eight of them.
const AMBIGUOUS_WORD_FLOOR: i64 = 1000;

/// 九键一个音节的读音通常很短；短列表用栈上的排序状态，避免为临时排名向量分配堆内存。
const SMALL_SPELLING_RANK: usize = 64;

/// Whether `entry`, the heaviest entry for the span starting at syllable `start` whose positions are flagged in `ambiguous`, may take part in conversion. Single syllables and spans where no position was typed with more than one reading (all of Dachen) always may, so Dachen conversion is unchanged; otherwise see `AMBIGUOUS_WORD_FLOOR`. Ambiguity is how the syllable was typed, not what is left after the user pinned a reading: pinning the reading the conversion already uses must not let a word the floor held back win (是之 turning into 適之). `singles` holds every position's single-character weight over its allowed readings and is empty when no position is ambiguous.
fn clears_ambiguous_word_floor(
    ambiguous: &[bool],
    singles: &[i64],
    start: usize,
    entry: &LanguageEntry,
) -> bool {
    if ambiguous.len() < 2 || !ambiguous.iter().any(|&ambiguous| ambiguous) {
        return true;
    }
    let weakest = singles[start..start + ambiguous.len()]
        .iter()
        .copied()
        .min()
        .unwrap_or(0);
    entry.weight.saturating_mul(AMBIGUOUS_WORD_FLOOR) >= weakest
}

/// 只取词频时，单位置单读音的缓存键直接借用读音；未命中或需要组合缓存键时复用完整词条的查询路径。
fn cached_best_weight(
    dictionary: &LanguageDictionary,
    best: &mut BestCache,
    positions: &[&[String]],
) -> Result<Option<i64>> {
    if let [[reading]] = positions {
        if let Some(entry) = best.entries.get(reading.as_str()) {
            return Ok(entry.as_ref().map(|(_, entry)| entry.weight));
        }
    }
    cached_best(dictionary, best, positions, |entry| {
        entry.map(|(_, entry)| entry.weight)
    })
}

/// 在借用期间消费 `positions` 的缓存词条；只在成功插入新键时复制描述，查询缓冲始终保留。
fn cached_best<T>(
    dictionary: &LanguageDictionary,
    best: &mut BestCache,
    positions: &[&[String]],
    consume: impl FnOnce(Option<&(String, LanguageEntry)>) -> T,
) -> Result<T> {
    describe(positions, &mut best.description);
    if let Some(entry) = best.entries.get(best.description.as_str()) {
        return Ok(consume(entry.as_ref()));
    }
    let candidate = dictionary.lookup_readings(positions, 1)?.into_iter().next();
    let description = best.description.clone();
    Ok(consume(
        best.entries
            .entry(description)
            .or_insert(candidate)
            .as_ref(),
    ))
}

/// `cached_best` 的缓存键：各位置的读音以 `|` 连接，位置之间用空格。
fn describe(positions: &[&[String]], description: &mut String) {
    let capacity = positions
        .iter()
        .enumerate()
        .map(|(position, readings)| {
            readings.iter().map(String::len).sum::<usize>()
                + readings.len().saturating_sub(1)
                + usize::from(position > 0)
        })
        .sum();
    description.clear();
    description.reserve(capacity);
    for (position, readings) in positions.iter().enumerate() {
        if position > 0 {
            description.push(' ');
        }
        for (reading, value) in readings.iter().enumerate() {
            if reading > 0 {
                description.push('|');
            }
            description.push_str(value);
        }
    }
}

fn build_editing_keys(
    syllables: &[Syllable],
    pending: &PendingSyllable,
    extra_capacity: usize,
) -> String {
    let mut keys = String::new();
    append_editing_keys(syllables, pending, extra_capacity, &mut keys);
    keys
}

fn build_converted_text(spans: &[Span]) -> String {
    let mut text = String::new();
    append_converted_text(spans, 0, &mut text);
    text
}

fn append_editing_keys(
    syllables: &[Syllable],
    pending: &PendingSyllable,
    extra_capacity: usize,
    keys: &mut String,
) {
    let pending_capacity = usize::from(pending.initial.is_some())
        + usize::from(pending.medial.is_some())
        + usize::from(pending.rime.is_some());
    let capacity = syllables
        .iter()
        .map(|syllable| syllable.keys.len())
        .sum::<usize>()
        + pending_capacity
        + extra_capacity;
    keys.clear();
    keys.reserve(capacity);
    for syllable in syllables {
        keys.push_str(&syllable.keys);
    }
    pending.append_keys(keys);
}

fn append_converted_text(spans: &[Span], extra_capacity: usize, text: &mut String) {
    let capacity = spans.iter().map(|span| span.text.len()).sum::<usize>() + extra_capacity;
    text.clear();
    text.reserve(capacity);
    for span in spans {
        text.push_str(&span.text);
    }
}

#[cfg(test)]
mod tests {
    use rusqlite::Connection;

    use super::*;
    use crate::language_dictionary::{
        open_read_only, FORMAT_VERSION, METADATA_FORMAT_VERSION, SCHEMA,
    };

    const ENTRIES: [(&str, &str, i64); 15] = [
        ("ㄋㄧˇ", "你", 1000),
        ("ㄋㄧˇ", "妳", 300),
        ("ㄋㄧˇ", "擬", 50),
        ("ㄏㄠˇ", "好", 2000),
        ("ㄏㄠˇ", "郝", 10),
        ("ㄋㄧˇ ㄏㄠˇ", "你好", 500),
        ("ㄊㄞˊ", "台", 900),
        ("ㄊㄞˊ", "臺", 400),
        ("ㄨㄢ", "彎", 500),
        ("ㄨㄢ", "灣", 300),
        ("ㄊㄞˊ ㄨㄢ", "臺灣", 800),
        ("ㄊㄞˊ ㄨㄢ", "台灣", 600),
        ("ㄇㄚ˙", "嗎", 800),
        ("ㄇㄚ", "媽", 700),
        ("ㄢ", "安", 100),
    ];

    fn syllable(keys: &str, readings: &[&str]) -> Syllable {
        Syllable {
            keys: keys.to_owned(),
            readings: readings
                .iter()
                .map(|reading| (*reading).to_owned())
                .collect(),
            locked: None,
        }
    }

    #[test]
    fn editing_keys_append_syllables_and_pending_keys_in_order() {
        let syllables = vec![syllable("su3", &["ㄋㄧˇ"]), syllable("lc3", &["ㄏㄠˇ"])];
        let pending = PendingSyllable {
            initial: Some('ㄇ'),
            medial: Some('ㄚ'),
            rime: None,
        };

        assert_eq!(build_editing_keys(&syllables, &pending, 0), "su3lc3a8");
    }

    #[test]
    fn list_positions_keep_allowed_readings_on_the_stack() {
        let syllables = [
            syllable("su3", &["ㄋㄧˇ"]),
            syllable("28c", &["ㄋㄧˇ", "ㄌㄧˇ"]),
        ];

        let positions = list_positions(&syllables);

        assert_eq!(positions[0], &["ㄋㄧˇ".to_owned()]);
        assert_eq!(positions[1], &["ㄋㄧˇ".to_owned(), "ㄌㄧˇ".to_owned()]);
    }

    #[test]
    fn short_reading_dedup_keeps_first_rows_without_temporary_heap_state() {
        let mut entries = (0..32)
            .map(|index| {
                (
                    format!("key-{index}"),
                    LanguageEntry {
                        text: format!("字{}", index % 18),
                        weight: index as i64,
                    },
                )
            })
            .collect::<Vec<_>>();
        let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
            deduplicate_reading_entries(&mut entries);
        });
        assert_eq!(allocations, 0);
        assert_eq!(entries.len(), 18);
        assert_eq!(entries[0].1.text, "字0");
        assert_eq!(entries[17].1.text, "字17");

        let mut large = (0..=SMALL_READING_DEDUP)
            .map(|index| {
                (
                    format!("key-{index}"),
                    LanguageEntry {
                        text: format!("大字{index}"),
                        weight: index as i64,
                    },
                )
            })
            .collect::<Vec<_>>();
        large.push((
            "duplicate".to_owned(),
            LanguageEntry {
                text: "大字0".to_owned(),
                weight: 0,
            },
        ));
        deduplicate_reading_entries(&mut large);
        assert_eq!(large.len(), SMALL_READING_DEDUP + 1);
        assert_eq!(large[0].1.text, "大字0");
    }

    #[test]
    fn opening_a_list_reserves_only_unique_reading_rows() {
        let entries = [
            ("r0", "字", 0),
            ("r1", "字", 0),
            ("r2", "字", 0),
            ("r3", "字", 0),
            ("r4", "字", 0),
            ("r5", "字", 0),
            ("r6", "字", 0),
            ("r7", "字", 0),
        ];
        let (_dir, mut scheme) = scheme_with(&entries);
        scheme.syllables = vec![syllable(
            "keys",
            &["r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7"],
        )];

        scheme.open_list().unwrap();

        assert_eq!(scheme.list.len(), 1);
        assert!(scheme.list.capacity() < entries.len());
    }

    #[test]
    fn reconversion_buffers_keep_allowed_readings_and_ambiguity_on_the_stack() {
        let syllables = [
            syllable("su3", &["ㄋㄧˇ"]),
            syllable("28c", &["ㄋㄧˇ", "ㄌㄧˇ"]),
        ];

        let (positions, ambiguous) = reconversion_buffers(&syllables);

        assert_eq!(positions[0], &["ㄋㄧˇ".to_owned()]);
        assert_eq!(positions[1], &["ㄋㄧˇ".to_owned(), "ㄌㄧˇ".to_owned()]);
        assert_eq!(&ambiguous[..2], &[false, true]);
    }

    // 大千下每个位置只有一个读音，缓存键就是词库键；九键的多读音位置以 `|` 连接，钉住后只剩钉住的那个。
    #[test]
    fn cache_keys_describe_the_allowed_readings_in_order() {
        let mut syllables = [
            syllable("su3", &["ㄋㄧˇ"]),
            syllable("lc3", &["ㄏㄠˇ"]),
            syllable("28c", &["ㄋㄧˇ", "ㄌㄧˇ"]),
        ];
        let positions: Vec<&[String]> = syllables.iter().map(Syllable::allowed).collect();
        let mut description = String::new();
        describe(&positions[..2], &mut description);
        assert_eq!(description, "ㄋㄧˇ ㄏㄠˇ");
        describe(&positions, &mut description);
        assert_eq!(description, "ㄋㄧˇ ㄏㄠˇ ㄋㄧˇ|ㄌㄧˇ");
        syllables[2].locked = Some(1);
        let positions: Vec<&[String]> = syllables.iter().map(Syllable::allowed).collect();
        describe(&positions[1..], &mut description);
        assert_eq!(description, "ㄏㄠˇ ㄌㄧˇ");
    }

    #[test]
    fn cache_key_description_needs_only_the_output_allocation() {
        let syllables = [
            syllable("su3", &["ㄋㄧˇ"]),
            syllable("lc3", &["ㄏㄠˇ"]),
            syllable("28c", &["ㄋㄧˇ", "ㄌㄧˇ"]),
        ];
        let positions: Vec<&[String]> = syllables.iter().map(Syllable::allowed).collect();

        let (description, allocations) = crate::ime::personal_rerank::allocations::count(|| {
            let mut description = String::new();
            describe(&positions, &mut description);
            description
        });

        assert_eq!(description, "ㄋㄧˇ ㄏㄠˇ ㄋㄧˇ|ㄌㄧˇ");
        assert_eq!(allocations, 1);
    }

    #[test]
    fn reading_pending_suffix_buffer_allocates_once() {
        let (_dir, mut scheme) = scheme();
        scheme.conversion = (0..MAX_SYLLABLES)
            .map(|start| Span {
                start,
                end: start + 1,
                key: "ㄋㄧˇ".to_owned(),
                text: "合".to_owned(),
            })
            .collect();
        for digits in [false, true] {
            scheme.pending = if digits {
                PendingSyllable::default()
            } else {
                PendingSyllable {
                    initial: Some('ㄇ'),
                    medial: Some('ㄧ'),
                    rime: Some('ㄢ'),
                }
            };
            scheme.pending_digits = if digits { b"28".to_vec() } else { Vec::new() };
            let expected = format!(
                "{}{}",
                "合".repeat(MAX_SYLLABLES),
                if digits { "28" } else { "ㄇㄧㄢ" }
            );
            let mut reading = String::with_capacity(16);
            let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
                scheme.reading_into(&mut reading);
            });
            assert_eq!(reading, expected);
            assert_eq!(allocations, 1, "待定符号和数字应纳入一次容量预留");
            let (reading, allocations) =
                crate::ime::personal_rerank::allocations::count(|| scheme.reading());
            assert_eq!(reading, expected);
            assert_eq!(allocations, 1);
        }
    }

    #[test]
    fn editing_pending_digits_buffer_allocates_once() {
        let (_dir, mut scheme) = scheme();
        scheme.syllables = (0..MAX_SYLLABLES)
            .map(|_| syllable("28c", &["ㄋㄧˇ"]))
            .collect();
        scheme.pending_digits.extend_from_slice(b"28");
        let expected = format!("{}28", "28c".repeat(MAX_SYLLABLES));
        let mut keys = String::with_capacity(16);
        let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
            scheme.editing_text_into(&mut keys);
        });
        assert_eq!(keys, expected);
        assert_eq!(allocations, 1, "待定数字应纳入一次按键容量预留");
        let (keys, allocations) =
            crate::ime::personal_rerank::allocations::count(|| scheme.editing_text());
        assert_eq!(keys, expected);
        assert_eq!(allocations, 1);
    }

    #[test]
    fn editing_keys_growing_buffer_allocates_once() {
        let syllables = (0..MAX_SYLLABLES)
            .map(|_| syllable("su3", &["ㄋㄧˇ"]))
            .collect::<Vec<_>>();
        let pending = PendingSyllable {
            initial: Some('ㄇ'),
            medial: None,
            rime: Some('ㄚ'),
        };
        let expected = format!("{}a8", "su3".repeat(MAX_SYLLABLES));
        for capacity in [16, 0, 128] {
            let mut keys = String::with_capacity(capacity);
            if capacity > 0 {
                keys.push_str("舊值");
            }
            let old_capacity = keys.capacity();
            let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
                append_editing_keys(&syllables, &pending, 0, &mut keys);
            });
            assert_eq!(keys, expected);
            assert_eq!(allocations, usize::from(old_capacity < expected.len()));
            let capacity = keys.capacity();
            let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
                append_editing_keys(&[], &PendingSyllable::default(), 0, &mut keys);
            });
            assert!(keys.is_empty());
            assert_eq!(allocations, 0);
            assert_eq!(keys.capacity(), capacity);
        }
    }

    #[test]
    fn converted_text_growing_buffer_allocates_once() {
        let spans = (0..MAX_SYLLABLES)
            .map(|start| Span {
                start,
                end: start + 1,
                key: "ㄋㄧˇ".to_owned(),
                text: "合".to_owned(),
            })
            .collect::<Vec<_>>();
        let expected = "合".repeat(MAX_SYLLABLES);
        for capacity in [16, 0, 128] {
            let mut text = String::with_capacity(capacity);
            if capacity > 0 {
                text.push_str("舊值");
            }
            let old_capacity = text.capacity();
            let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
                append_converted_text(&spans, 0, &mut text);
            });
            assert_eq!(text, expected);
            assert_eq!(allocations, usize::from(old_capacity < expected.len()));
            let capacity = text.capacity();
            let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
                append_converted_text(&[], 0, &mut text);
            });
            assert!(text.is_empty());
            assert_eq!(allocations, 0);
            assert_eq!(text.capacity(), capacity);
        }
    }

    #[test]
    fn converted_text_appends_spans_in_order() {
        let spans = vec![
            Span {
                start: 0,
                end: 2,
                key: "ㄋㄧˇ ㄏㄠˇ".to_owned(),
                text: "你好".to_owned(),
            },
            Span {
                start: 2,
                end: 3,
                key: "ㄇㄚ˙".to_owned(),
                text: "嗎".to_owned(),
            },
        ];

        assert_eq!(build_converted_text(&spans), "你好嗎");
    }

    fn scheme() -> (tempfile::TempDir, ZhuyinScheme) {
        scheme_with(&ENTRIES)
    }

    fn scheme_with(entries: &[(&str, &str, i64)]) -> (tempfile::TempDir, ZhuyinScheme) {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("msime-zhuyin.db");
        let connection = Connection::open(&path).unwrap();
        connection.execute_batch(SCHEMA).unwrap();
        connection
            .execute(
                "INSERT INTO metadata VALUES (?1, ?2)",
                (METADATA_FORMAT_VERSION, FORMAT_VERSION.to_string()),
            )
            .unwrap();
        for &(key, text, weight) in entries {
            connection
                .execute(
                    "INSERT INTO entries VALUES (?1, ?2, ?3)",
                    (key, text, weight),
                )
                .unwrap();
            for syllable in key.split(' ') {
                connection
                    .execute("INSERT OR IGNORE INTO syllables VALUES (?1)", (syllable,))
                    .unwrap();
            }
        }
        drop(connection);
        let scheme = ZhuyinScheme::new(open_read_only(&path).unwrap());
        (dir, scheme)
    }

    /// Types `keys` as characters and returns what each claimed.
    fn type_keys(scheme: &mut ZhuyinScheme, keys: &str) -> Vec<bool> {
        keys.bytes()
            .map(|byte| scheme.handle_key(ZhuyinKey::Char(byte)).unwrap())
            .collect()
    }

    fn texts(scheme: &ZhuyinScheme) -> Vec<(&str, usize)> {
        scheme
            .candidates()
            .iter()
            .map(|candidate| (candidate.text.as_str(), candidate.start))
            .collect()
    }

    #[test]
    fn idle_claims_phonetic_keys_but_not_tone_keys() {
        let (_dir, mut scheme) = scheme();
        assert_eq!(scheme.spelling_symbols(), IDLE_SYMBOLS);
        for byte in *b"3467 " {
            assert!(!scheme.handle_key(ZhuyinKey::Char(byte)).unwrap());
            assert!(!scheme.is_composing());
        }
        for key in [
            ZhuyinKey::Enter,
            ZhuyinKey::Escape,
            ZhuyinKey::Backspace,
            ZhuyinKey::OpenList,
        ] {
            assert!(!scheme.handle_key(key).unwrap());
        }
        // Uppercase letters and other ASCII are not Dachen keys.
        assert_eq!(type_keys(&mut scheme, "A!'"), [false, false, false]);
        for start in ["1", ",", "-", "a"] {
            scheme.reset();
            assert_eq!(type_keys(&mut scheme, start), [true]);
            assert!(scheme.is_composing());
            assert_eq!(scheme.spelling_symbols(), DACHEN_SYMBOLS);
        }
        assert_eq!(scheme.reading(), "ㄇ");
        assert_eq!(scheme.editing_text(), "a");
    }

    #[test]
    fn slots_are_replaced_by_keys_of_the_same_kind() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "sxuj");
        assert_eq!(scheme.reading(), "ㄌㄨ");
        assert_eq!(scheme.editing_text(), "xj");
        type_keys(&mut scheme, "sul3");
        assert_eq!(scheme.converted_text(), "");
        assert_eq!(scheme.reading(), "ㄋㄧㄠ");
        type_keys(&mut scheme, "c");
        type_keys(&mut scheme, "j");
        assert_eq!(scheme.reading(), "ㄏㄨㄠ");
    }

    #[test]
    fn tone_keys_complete_only_known_syllables() {
        let (_dir, mut scheme) = scheme();
        // ㄋˇ is not in the inventory: the key is consumed and ㄋ stays pending.
        assert_eq!(type_keys(&mut scheme, "s3"), [true, true]);
        assert_eq!(scheme.reading(), "ㄋ");
        assert_eq!(scheme.editing_text(), "s");
        type_keys(&mut scheme, "u3");
        assert_eq!(scheme.reading(), "你");
        assert_eq!(scheme.editing_text(), "su3");
        // A tone digit with nothing pending is swallowed.
        assert_eq!(type_keys(&mut scheme, "4"), [true]);
        assert_eq!(scheme.reading(), "你");
        // Space is tone 1 and 7 the neutral tone.
        type_keys(&mut scheme, "a8 a87");
        assert_eq!(scheme.reading(), "你媽嗎");
        assert_eq!(scheme.editing_text(), "su3a8 a87");
        assert_eq!(scheme.take_committed(), "");
    }

    #[test]
    fn conversion_prefers_words() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3cl3");
        assert_eq!(scheme.converted_text(), "你好");
        type_keys(&mut scheme, "a8");
        assert_eq!(scheme.reading(), "你好ㄇㄚ");
        scheme.reset();
        type_keys(&mut scheme, "w96j0 ");
        assert_eq!(scheme.converted_text(), "臺灣");
    }

    #[test]
    fn the_list_holds_suffix_spans_longest_first() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "w96j0 ");
        assert!(scheme.handle_key(ZhuyinKey::OpenList).unwrap());
        assert!(scheme.list_open());
        assert_eq!(scheme.spelling_symbols(), LIST_OPEN_SYMBOLS);
        assert_eq!(
            texts(&scheme),
            [("臺灣", 0), ("台灣", 0), ("彎", 1), ("灣", 1)]
        );
        // Command 16 again closes it.
        assert!(scheme.handle_key(ZhuyinKey::OpenList).unwrap());
        assert!(!scheme.list_open());
        assert!(scheme.candidates().is_empty());
        // Space with nothing pending opens it too.
        assert!(scheme.handle_key(ZhuyinKey::Char(b' ')).unwrap());
        assert!(scheme.list_open());
    }

    #[test]
    fn the_list_holds_every_entry_of_a_span() {
        // ㄧˋ has 215 single characters in the real data; the list must not cut off the light ones.
        let texts: Vec<String> = (0..215u32)
            .map(|index| char::from_u32(0x4E00 + index).unwrap().to_string())
            .collect();
        let entries: Vec<(&str, &str, i64)> = texts
            .iter()
            .zip((1..=215i64).rev())
            .map(|(text, weight)| ("ㄧˋ", text.as_str(), weight))
            .collect();
        let (_dir, mut scheme) = scheme_with(&entries);
        type_keys(&mut scheme, "u4");
        assert!(scheme.handle_key(ZhuyinKey::OpenList).unwrap());
        assert_eq!(scheme.candidates().len(), 215);
        assert_eq!(scheme.list.capacity(), scheme.list.len());
        assert_eq!(scheme.candidates()[214].text, texts[214]);
    }

    #[test]
    fn reopening_the_list_reuses_its_row_storage() {
        let texts: Vec<String> = (0..215u32)
            .map(|index| char::from_u32(0x4E00 + index).unwrap().to_string())
            .collect();
        let mut entries: Vec<(&str, &str, i64)> = texts
            .iter()
            .zip((1..=215i64).rev())
            .map(|(text, weight)| ("ㄧˋ", text.as_str(), weight))
            .collect();
        entries.push(("ㄋㄧˇ", "你", 1));
        let (_dir, mut scheme) = scheme_with(&entries);

        type_keys(&mut scheme, "u4");
        assert!(scheme.handle_key(ZhuyinKey::OpenList).unwrap());
        let capacity = scheme.list.capacity();
        assert_eq!(scheme.list.len(), 215);
        assert!(scheme.handle_key(ZhuyinKey::OpenList).unwrap());

        scheme.reset();
        type_keys(&mut scheme, "su3");
        assert!(scheme.handle_key(ZhuyinKey::OpenList).unwrap());
        assert_eq!(scheme.list.len(), 1);
        assert!(scheme.list.capacity() >= capacity);
    }

    #[test]
    fn select_pins_without_committing_and_pins_survive_reconversion() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3 ");
        assert_eq!(texts(&scheme), [("你", 0), ("妳", 0), ("擬", 0)]);
        assert!(scheme.select(1).unwrap());
        assert!(!scheme.list_open());
        assert_eq!(scheme.take_committed(), "");
        assert_eq!(scheme.reading(), "妳");
        // The pinned 妳 holds even though 你好 is the better word.
        type_keys(&mut scheme, "cl3");
        assert_eq!(scheme.converted_text(), "妳好");
        // Choosing the longer span replaces the pin it overlaps.
        type_keys(&mut scheme, " ");
        assert_eq!(texts(&scheme), [("你好", 0), ("好", 1), ("郝", 1)]);
        assert!(scheme.select(2).unwrap());
        assert_eq!(scheme.converted_text(), "妳郝");
        type_keys(&mut scheme, " ");
        assert!(scheme.select(0).unwrap());
        assert_eq!(scheme.converted_text(), "你好");
        type_keys(&mut scheme, "w96");
        assert_eq!(scheme.converted_text(), "你好台");
        assert!(!scheme.select(0).unwrap());
        assert!(!scheme.list_open());
        // Backspace drops the last syllable; the pin on the others stays.
        scheme.handle_key(ZhuyinKey::Backspace).unwrap();
        assert_eq!(scheme.converted_text(), "你好");
        assert_eq!(scheme.take_committed(), "");
    }

    #[test]
    fn selecting_a_list_row_moves_its_owned_fields_into_the_pin() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3 ");
        let candidate = &scheme.list[1];
        let text = candidate.text.as_ptr();
        let key = candidate.key.as_ptr();

        assert!(scheme.select(1).unwrap());

        assert!(!scheme.list_open());
        assert_eq!(scheme.pins.len(), 1);
        assert_eq!(scheme.pins[0].text.as_ptr(), text);
        assert_eq!(scheme.pins[0].key.as_ptr(), key);
        assert_eq!(scheme.take_committed(), "");
    }

    #[test]
    fn selecting_a_missing_list_row_keeps_the_list_open() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3 ");
        let before = texts(&scheme)
            .into_iter()
            .map(|(text, start)| (text.to_owned(), start))
            .collect::<Vec<_>>();

        assert!(!scheme.select(before.len()).unwrap());

        assert!(scheme.list_open());
        assert_eq!(
            texts(&scheme)
                .into_iter()
                .map(|(text, start)| (text.to_owned(), start))
                .collect::<Vec<_>>(),
            before
        );
    }

    #[test]
    fn list_keys_close_or_fall_through() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3 ");
        assert!(scheme.list_open());
        // Selection digits and Space belong to the session while the list is open.
        assert_eq!(type_keys(&mut scheme, "1 3"), [false, false, false]);
        assert!(scheme.list_open());
        // 0 closes the list and types ㄢ.
        assert_eq!(type_keys(&mut scheme, "0"), [true]);
        assert!(!scheme.list_open());
        assert_eq!(scheme.reading(), "你ㄢ");
        type_keys(&mut scheme, " ");
        assert_eq!(scheme.reading(), "你安");
        // Esc and Backspace only close an open list.
        type_keys(&mut scheme, " ");
        assert!(scheme.handle_key(ZhuyinKey::Escape).unwrap());
        assert!(!scheme.list_open());
        assert_eq!(scheme.reading(), "你安");
        type_keys(&mut scheme, " ");
        assert!(scheme.handle_key(ZhuyinKey::Backspace).unwrap());
        assert_eq!(scheme.reading(), "你安");
        // A letter closes it and composes.
        type_keys(&mut scheme, " ");
        assert_eq!(type_keys(&mut scheme, "c"), [true]);
        assert!(!scheme.list_open());
        assert_eq!(scheme.reading(), "你安ㄏ");
    }

    #[test]
    fn enter_commits_the_conversion_and_esc_clears() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3cl3a");
        assert!(scheme.handle_key(ZhuyinKey::Enter).unwrap());
        assert_eq!(scheme.take_committed(), "你好");
        assert!(!scheme.is_composing());

        type_keys(&mut scheme, "su3cl3");
        assert!(scheme.handle_key(ZhuyinKey::Escape).unwrap());
        assert!(!scheme.is_composing());
        assert_eq!(scheme.take_committed(), "");

        type_keys(&mut scheme, "su3");
        assert_eq!(scheme.take_text(), "你");
        assert!(!scheme.is_composing());
    }

    #[test]
    fn backspace_drops_a_symbol_then_a_syllable() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3cl3ju");
        let mut shown = vec![scheme.reading()];
        while scheme.is_composing() {
            assert!(scheme.handle_key(ZhuyinKey::Backspace).unwrap());
            shown.push(scheme.reading());
        }
        assert_eq!(shown, ["你好ㄧ", "你好", "你", ""]);
        assert_eq!(scheme.spelling_symbols(), IDLE_SYMBOLS);
    }

    #[test]
    fn shift_punctuation_commits_then_inserts_the_mark() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, "su3cl3a");
        assert_eq!(type_keys(&mut scheme, "<"), [true]);
        assert_eq!(scheme.take_committed(), "你好，");
        assert!(!scheme.is_composing());
        assert_eq!(type_keys(&mut scheme, "["), [true]);
        assert_eq!(scheme.take_committed(), "「");
        type_keys(&mut scheme, "su3 ");
        assert_eq!(type_keys(&mut scheme, "?"), [true]);
        assert_eq!(scheme.take_committed(), "你？");
        assert!(!scheme.list_open());
    }

    #[test]
    fn the_21st_syllable_commits_the_leftmost_word() {
        let (_dir, mut scheme) = scheme();
        type_keys(&mut scheme, &"su3cl3".repeat(10));
        assert_eq!(scheme.converted_text(), "你好".repeat(10));
        assert_eq!(scheme.take_committed(), "");
        type_keys(&mut scheme, "su");
        assert_eq!(scheme.take_committed(), "");
        type_keys(&mut scheme, "3");
        assert_eq!(scheme.take_committed(), "你好");
        assert_eq!(scheme.converted_text(), format!("{}你", "你好".repeat(9)));
        assert_eq!(scheme.editing_text(), format!("{}su3", "su3cl3".repeat(9)));
        // The lookup cache keeps no key longer than the syllables that are left.
        let longest = scheme
            .best
            .entries
            .keys()
            .map(|key| key.split(' ').count())
            .max();
        assert_eq!(longest, Some(scheme.syllables.len()));

        // A pin to the right of the shifted word moves with its syllables.
        scheme.reset();
        type_keys(&mut scheme, &"su3cl3".repeat(10));
        type_keys(&mut scheme, " ");
        assert!(scheme.select(2).unwrap());
        assert_eq!(scheme.converted_text(), format!("{}你郝", "你好".repeat(9)));
        type_keys(&mut scheme, "su3");
        assert_eq!(scheme.take_committed(), "你好");
        assert_eq!(
            scheme.converted_text(),
            format!("{}你郝你", "你好".repeat(8))
        );
    }

    // ---- 注音九键 ----

    /// 大千夹具加上与 ㄋㄧˇ 同为 `28` + ˇ 的 ㄌㄧˇ、ㄉㄧˇ，以及三个符号的 ㄏㄨㄚ。
    fn nine_key_scheme() -> (tempfile::TempDir, ZhuyinScheme) {
        let mut entries = ENTRIES.to_vec();
        entries.extend([
            ("ㄌㄧˇ", "李", 1200),
            ("ㄉㄧˇ", "底", 600),
            ("ㄏㄨㄚ", "花", 500),
        ]);
        let (dir, mut scheme) = scheme_with(&entries);
        scheme.set_nine_key(true);
        (dir, scheme)
    }

    fn spellings(scheme: &ZhuyinScheme) -> Vec<&str> {
        scheme.spellings().iter().map(String::as_str).collect()
    }

    #[test]
    fn nine_key_tone_keys_end_a_syllable_against_every_matching_reading() {
        let (_dir, mut scheme) = nine_key_scheme();
        assert_eq!(scheme.spelling_symbols(), nine_key::IDLE_SYMBOLS);
        assert_eq!(type_keys(&mut scheme, "28"), [true, true]);
        assert_eq!(scheme.reading(), "28");
        assert_eq!(scheme.spelling_symbols(), nine_key::SYMBOLS);
        assert!(scheme.spellings().is_empty());
        // ˇ 结束音节：ㄋㄧˇ、ㄌㄧˇ、ㄉㄧˇ 都在 28 上，单字里 李 最重。
        assert_eq!(type_keys(&mut scheme, "c"), [true]);
        assert_eq!(scheme.reading(), "李");
        assert_eq!(scheme.editing_text(), "28c");
        assert_eq!(spellings(&scheme), ["ㄌㄧˇ", "ㄋㄧˇ", "ㄉㄧˇ"]);
        // 你好 够重，过得了九键的权重下限，双音节词按长度平方胜出；当前用的读音排到最前，其余按单字权重。
        type_keys(&mut scheme, "39c");
        assert_eq!(scheme.converted_text(), "你好");
        assert_eq!(scheme.editing_text(), "28c39c");
        assert_eq!(spellings(&scheme), ["ㄋㄧˇ", "ㄌㄧˇ", "ㄉㄧˇ"]);
        assert_eq!(scheme.conversion[0].key, "ㄋㄧˇ ㄏㄠˇ");
        assert_eq!(scheme.take_committed(), "");
    }

    #[test]
    fn spelling_refresh_failure_clears_previous_choices() {
        for count in [3, SMALL_SPELLING_RANK + 1] {
            let (dir, mut scheme) = nine_key_scheme();
            type_keys(&mut scheme, "28c");
            assert!(!scheme.spellings().is_empty());
            if count > SMALL_SPELLING_RANK {
                scheme.syllables[0].readings = (0..count)
                    .map(|index| format!("測試讀音{index:03}"))
                    .collect::<Vec<_>>()
                    .into();
            }
            scheme.best.clear();
            Connection::open(dir.path().join("msime-zhuyin.db"))
                .unwrap()
                .execute_batch("DROP TABLE entries")
                .unwrap();

            assert!(scheme.refresh_spellings().is_err());
            assert!(scheme.spellings().is_empty());
            assert_eq!(scheme.spelling_target, None);
        }
    }

    #[test]
    fn spelling_refresh_handles_changing_choice_counts() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c");
        for count in [SMALL_SPELLING_RANK + 1, 2, 4] {
            let readings = (0..count)
                .map(|index| format!("測試讀音{index:03}"))
                .collect::<Vec<_>>();
            scheme.syllables[0].readings = readings.clone().into();
            scheme.refresh_spellings().unwrap();
            assert_eq!(scheme.spellings(), readings);
            assert_eq!(scheme.spelling_target, Some(0));
        }
        scheme.syllables[0].locked = Some(0);
        scheme.refresh_spellings().unwrap();
        assert!(scheme.spellings().is_empty());
        assert_eq!(scheme.spelling_target, None);
        scheme.syllables[0].locked = None;
        scheme.refresh_spellings().unwrap();
        assert_eq!(scheme.spellings(), &*scheme.syllables[0].readings);
    }

    #[test]
    fn cached_best_preserves_rows_misses_and_query_errors() {
        let (dir, scheme) = nine_key_scheme();
        let mut best = BestCache::default();
        let readings = ["ㄋㄧˇ".to_owned(), "ㄌㄧˇ".to_owned()];
        let missing = ["測試缺失讀音".to_owned()];
        let uncached = ["ㄉㄧˇ".to_owned()];
        let check = |entry: Option<&(String, LanguageEntry)>| {
            let (key, entry) = entry.unwrap();
            assert_eq!(key, "ㄌㄧˇ");
            assert_eq!(entry.text, "李");
            assert_eq!(entry.weight, 1200);
            (key.as_ptr(), entry.text.as_ptr())
        };
        let pointers = cached_best(&scheme.dictionary, &mut best, &[&readings], check).unwrap();
        assert!(
            cached_best(&scheme.dictionary, &mut best, &[&missing], |entry| entry
                .is_none())
            .unwrap()
        );
        assert_eq!(best.entries.len(), 2);
        Connection::open(dir.path().join("msime-zhuyin.db"))
            .unwrap()
            .execute_batch("DROP TABLE entries")
            .unwrap();

        let cached_pointers =
            cached_best(&scheme.dictionary, &mut best, &[&readings], check).unwrap();
        assert_eq!(cached_pointers, pointers);
        assert!(
            cached_best(&scheme.dictionary, &mut best, &[&missing], |entry| entry
                .is_none())
            .unwrap()
        );
        for _ in 0..2 {
            assert!(
                cached_best(&scheme.dictionary, &mut best, &[&uncached], |_| {
                    panic!("词库查询失败不应消费词条")
                })
                .is_err()
            );
        }
        assert_eq!(best.entries.len(), 2);
        let capacity = best.description.capacity();
        best.clear();
        assert!(best.entries.is_empty());
        assert!(best.description.is_empty());
        assert_eq!(best.description.capacity(), capacity);
        assert!(cached_best(&scheme.dictionary, &mut best, &[&readings], |_| ()).is_err());
    }

    #[test]
    fn rejected_cached_single_rows_do_not_become_fallbacks() {
        let (_dir, mut scheme) = scheme_with(&[
            ("ㄋㄧˇ", "甲", 0),
            ("ㄏㄠˇ", "乙", 0),
            ("ㄇㄚ", "丙", 0),
            ("ㄊㄞˊ", "丁", -20),
            ("ㄏㄠˇ ㄇㄚ", "乙丙", 0),
            ("ㄇㄚ ㄊㄞˊ", "丙丁", -10),
        ]);
        scheme.syllables = ["ㄋㄧˇ", "ㄏㄠˇ", "ㄇㄚ", "ㄊㄞˊ"]
            .into_iter()
            .map(|reading| syllable("合成按鍵", &[reading]))
            .collect();

        scheme.reconvert().unwrap();

        assert_eq!(
            scheme
                .conversion
                .iter()
                .map(|span| span.text.as_str())
                .collect::<Vec<_>>(),
            ["甲", "乙", "丙丁"]
        );
        assert_eq!(scheme.conversion[2].key, "ㄇㄚ ㄊㄞˊ");
    }

    #[test]
    fn warmed_dense_conversion_only_clones_improving_paths() {
        let entries = (1..=MAX_SYLLABLES)
            .map(|len| (vec!["ㄋㄧˇ"; len].join(" "), "合".repeat(len), len as i64))
            .collect::<Vec<_>>();
        let rows = entries
            .iter()
            .map(|(key, text, weight)| (key.as_str(), text.as_str(), *weight))
            .collect::<Vec<_>>();
        let (dir, mut scheme) = scheme_with(&rows);
        scheme.syllables = (0..MAX_SYLLABLES)
            .map(|_| syllable("su3", &["ㄋㄧˇ"]))
            .collect();
        scheme.reconvert().unwrap();
        Connection::open(dir.path().join("msime-zhuyin.db"))
            .unwrap()
            .execute_batch("DROP TABLE entries")
            .unwrap();

        let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
            scheme.reconvert().unwrap();
        });

        assert_eq!(scheme.conversion.len(), 1);
        assert_eq!(scheme.conversion[0].key, entries.last().unwrap().0);
        assert_eq!(scheme.conversion[0].text, entries.last().unwrap().1);
        assert_eq!(
            allocations,
            MAX_SYLLABLES * 2 + 1,
            "只应复制首次改善路径的二十组词条字符串，并分配返回向量"
        );
    }

    #[test]
    fn warmed_conversion_cache_queries_do_not_allocate_descriptions() {
        for readings in [
            vec!["ㄋㄧˇ".to_owned()],
            vec!["ㄋㄧˇ".to_owned(), "ㄌㄧˇ".to_owned()],
        ] {
            let (dir, scheme) = nine_key_scheme();
            let expected = if readings.len() == 1 {
                ("ㄋㄧˇ", "你", 1000)
            } else {
                ("ㄌㄧˇ", "李", 1200)
            };
            let positions = [readings.as_slice(); MAX_SYLLABLES];
            let mut best = BestCache::default();
            for _ in 0..2 {
                for start in 0..positions.len() {
                    for end in start + 1..=positions.len() {
                        cached_best(
                            &scheme.dictionary,
                            &mut best,
                            &positions[start..end],
                            |_| (),
                        )
                        .unwrap();
                    }
                }
            }
            Connection::open(dir.path().join("msime-zhuyin.db"))
                .unwrap()
                .execute_batch("DROP TABLE entries")
                .unwrap();

            let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
                for start in 0..positions.len() {
                    for end in start + 1..=positions.len() {
                        cached_best(
                            &scheme.dictionary,
                            &mut best,
                            &positions[start..end],
                            |entry| {
                                if end == start + 1 {
                                    let (key, entry) = entry.unwrap();
                                    assert_eq!(key, expected.0);
                                    assert_eq!(entry.text, expected.1);
                                    assert_eq!(entry.weight, expected.2);
                                } else {
                                    assert!(entry.is_none());
                                }
                            },
                        )
                        .unwrap();
                    }
                }
            });
            assert_eq!(allocations, 0, "热缓存查询不应分配临时描述键");
        }
    }

    #[test]
    fn cached_single_reading_weights_keep_hits_misses_and_errors() {
        let (dir, scheme) = nine_key_scheme();
        let mut best = BestCache::default();
        let reading = ["ㄌㄧˇ".to_owned()];
        let missing = ["測試缺失讀音".to_owned()];
        assert_eq!(
            cached_best_weight(&scheme.dictionary, &mut best, &[&reading]).unwrap(),
            Some(1200)
        );
        assert_eq!(
            cached_best_weight(&scheme.dictionary, &mut best, &[&missing]).unwrap(),
            None
        );
        Connection::open(dir.path().join("msime-zhuyin.db"))
            .unwrap()
            .execute_batch("DROP TABLE entries")
            .unwrap();

        let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
            assert_eq!(
                cached_best_weight(&scheme.dictionary, &mut best, &[&reading]).unwrap(),
                Some(1200)
            );
            assert_eq!(
                cached_best_weight(&scheme.dictionary, &mut best, &[&missing]).unwrap(),
                None
            );
        });
        assert_eq!(allocations, 0);
        let readings = ["ㄌㄧˇ".to_owned(), "ㄋㄧˇ".to_owned()];
        assert!(cached_best_weight(&scheme.dictionary, &mut best, &[&readings]).is_err());
        assert!(cached_best_weight(&scheme.dictionary, &mut best, &[&reading, &reading]).is_err());
        assert_eq!(best.entries.len(), 2);
    }

    #[test]
    fn refreshing_short_spelling_choices_does_not_allocate_ranking_state() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c");
        assert_eq!(scheme.spellings.len(), 3);
        scheme.spellings.reserve(scheme.syllables[0].readings.len());

        let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
            scheme.refresh_spellings().unwrap();
        });

        assert_eq!(
            allocations, 0,
            "读取已有单读音词频仍分配了 {allocations} 次"
        );
        assert_eq!(spellings(&scheme), ["ㄌㄧˇ", "ㄋㄧˇ", "ㄉㄧˇ"]);
    }

    /// 今天 + 去 的读音和冷僻的 監聽器 落在同样的数字串上：ㄐㄧㄣ/ㄐㄧㄢ 都是 480，ㄊㄧㄢ/ㄊㄧㄥ 都是 280，ㄑㄩˋ/ㄑㄧˋ 都是 48ˋ。
    const AMBIGUOUS_WORD_ENTRIES: [(&str, &str, i64); 8] = [
        ("ㄐㄧㄣ", "今", 33812),
        ("ㄊㄧㄢ", "天", 31487),
        ("ㄑㄩˋ", "去", 28394),
        ("ㄐㄧㄣ ㄊㄧㄢ", "今天", 25469),
        ("ㄐㄧㄢ", "監", 100),
        ("ㄊㄧㄥ", "聽", 3000),
        ("ㄑㄧˋ", "器", 900),
        ("ㄐㄧㄢ ㄊㄧㄥ ㄑㄧˋ", "監聽器", 9),
    ];

    #[test]
    fn nine_key_light_long_words_do_not_beat_heavy_shorter_ones() {
        let (_dir, mut scheme) = scheme_with(&AMBIGUOUS_WORD_ENTRIES);
        scheme.set_nine_key(true);
        type_keys(&mut scheme, "480 280 48v");
        // 只比长度的话三音节的 監聽器（9）会压过 今天（25469）+ 去（28394）。
        assert_eq!(scheme.converted_text(), "今天去");
        // 钉住 ㄐㄧㄢ 之后今天不再匹配，这个位置的单字只剩 監（100），監聽器 过得了下限。
        let jian = scheme
            .spellings()
            .iter()
            .position(|reading| reading == "ㄐㄧㄢ")
            .unwrap();
        assert!(scheme.choose_spelling(jian).unwrap());
        assert_eq!(scheme.converted_text(), "監聽器");

        // 大千下每个位置只有一个读音，照旧按长度：打出 監聽器 的读音就得到 監聽器。
        let (_dir, mut scheme) = scheme_with(&AMBIGUOUS_WORD_ENTRIES);
        type_keys(&mut scheme, "ru0 wu/ fu4");
        assert_eq!(scheme.converted_text(), "監聽器");
    }

    #[test]
    fn nine_key_confirming_the_readings_in_use_keeps_the_text() {
        // 適之 和 是 + 之 用的是同一组读音，权重却低得过不了下限；5 上 ㄓˋ/ㄕˋ、ㄓ/ㄔ 两两同键，两个位置打出来都有歧义。
        let (_dir, mut scheme) = scheme_with(&[
            ("ㄕˋ", "是", 160_000),
            ("ㄓ", "之", 120_000),
            ("ㄕˋ ㄓ", "適之", 1),
            ("ㄓˋ", "至", 500),
            ("ㄔ", "吃", 800),
        ]);
        scheme.set_nine_key(true);
        type_keys(&mut scheme, "5v5 ");
        assert_eq!(scheme.converted_text(), "是之");
        // 读音条第一个就是当前用的读音；逐个确认，歧义仍按打字时算，適之 不会因为两个位置都钉住而冒出来。
        let mut confirmed = 0;
        while !scheme.spellings().is_empty() {
            assert!(scheme.choose_spelling(0).unwrap());
            assert_eq!(scheme.converted_text(), "是之");
            confirmed += 1;
        }
        assert_eq!(confirmed, 2);
    }

    #[test]
    fn nine_key_space_and_z_are_the_first_tone() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "29x80 ");
        assert_eq!(scheme.converted_text(), "臺灣");
        assert_eq!(scheme.editing_text(), "29x80 ");
        scheme.reset();
        assert_eq!(type_keys(&mut scheme, "29x80z"), [true; 6]);
        assert_eq!(scheme.converted_text(), "臺灣");
        scheme.reset();
        type_keys(&mut scheme, "17b17 ");
        assert_eq!(scheme.converted_text(), "嗎媽");
        assert!(scheme.nine_key());
    }

    #[test]
    fn nine_key_digit_edits_reuse_pending_storage() {
        let (_dir, mut scheme) = nine_key_scheme();
        scheme.nine_key_index().unwrap();
        scheme.pending_digits.reserve(nine_key::MAX_DIGITS);
        let pointer = scheme.pending_digits.as_ptr();

        let ((), allocations) = crate::ime::personal_rerank::allocations::count(|| {
            assert!(scheme.handle_key(ZhuyinKey::Char(b'2')).unwrap());
            assert!(scheme.handle_key(ZhuyinKey::Char(b'8')).unwrap());
            assert!(scheme.handle_key(ZhuyinKey::Char(b'2')).unwrap());
            assert_eq!(scheme.pending_digits, b"28");
            assert!(scheme.handle_key(ZhuyinKey::Backspace).unwrap());
            assert!(scheme.handle_key(ZhuyinKey::Char(b'9')).unwrap());
        });

        assert_eq!(allocations, 0);
        assert_eq!(scheme.pending_digits.as_ptr(), pointer);
        assert_eq!(scheme.pending_digits, b"29");
        assert_eq!(scheme.reading(), "29");
    }

    #[test]
    fn nine_key_completed_syllables_reuse_pending_digit_storage() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28");
        let pointer = scheme.pending_digits.as_ptr();
        let capacity = scheme.pending_digits.capacity();
        assert!(scheme.handle_key(ZhuyinKey::Char(b'c')).unwrap());
        assert!(scheme.pending_digits.is_empty());

        let (claimed, allocations) = crate::ime::personal_rerank::allocations::count(|| {
            scheme.handle_key(ZhuyinKey::Char(b'2')).unwrap()
        });
        assert!(claimed);
        assert_eq!(allocations, 0);
        assert_eq!(scheme.pending_digits.as_ptr(), pointer);
        assert_eq!(scheme.pending_digits.capacity(), capacity);
        assert_eq!(scheme.pending_digits, b"2");
        assert_eq!(scheme.reading(), "李2");
    }

    #[test]
    fn nine_key_tone_index_failure_restores_pending_digits() {
        let (dir, mut scheme) = nine_key_scheme();
        scheme.pending_digits.extend_from_slice(b"28");
        let pointer = scheme.pending_digits.as_ptr();
        Connection::open(dir.path().join("msime-zhuyin.db"))
            .unwrap()
            .execute_batch("DROP TABLE syllables")
            .unwrap();

        assert!(scheme.handle_key(ZhuyinKey::Char(b'c')).is_err());
        assert_eq!(scheme.pending_digits, b"28");
        assert_eq!(scheme.pending_digits.as_ptr(), pointer);
        assert!(scheme.syllables.is_empty());
        assert!(scheme.is_composing());
        assert_eq!(scheme.reading(), "28");
    }

    #[test]
    fn nine_key_index_failure_restores_pending_digits() {
        let (dir, mut scheme) = nine_key_scheme();
        scheme.pending_digits.extend_from_slice(b"2");
        let pointer = scheme.pending_digits.as_ptr();
        Connection::open(dir.path().join("msime-zhuyin.db"))
            .unwrap()
            .execute_batch("DROP TABLE syllables")
            .unwrap();

        assert!(scheme.handle_key(ZhuyinKey::Char(b'8')).is_err());

        assert_eq!(scheme.pending_digits, b"2");
        assert_eq!(scheme.pending_digits.as_ptr(), pointer);
    }

    #[test]
    fn nine_key_unknown_codes_stay_pending_and_extra_digits_are_swallowed() {
        let (_dir, mut scheme) = nine_key_scheme();
        // 28 加 ˋ 没有合法音节：声调键被认领，数字留着。
        assert_eq!(type_keys(&mut scheme, "28v"), [true, true, true]);
        assert_eq!(scheme.reading(), "28");
        // 282 不是任何音节的前缀，第三个数字被吞掉。
        assert_eq!(type_keys(&mut scheme, "2"), [true]);
        assert_eq!(scheme.reading(), "28");
        scheme.reset();
        // 三个符号已满，第四个数字被吞掉。
        type_keys(&mut scheme, "3871");
        assert_eq!(scheme.reading(), "387");
        type_keys(&mut scheme, " ");
        assert_eq!(scheme.reading(), "花");
        // 数字从空闲开始组字；夹具里没有 ㄐㄑㄒ 的音节，4 打不出任何音节，只被吞掉。
        scheme.reset();
        assert_eq!(type_keys(&mut scheme, "4"), [true]);
        assert!(!scheme.is_composing());
    }

    #[test]
    fn nine_key_claims_tone_letters_and_digits_but_no_other_letters() {
        let (_dir, mut scheme) = nine_key_scheme();
        // 空闲时声调字母、空格和其他字母都不认领：实体键盘上打 z 要上屏 z。
        assert_eq!(type_keys(&mut scheme, "zxcvb"), [false; 5]);
        assert!(!scheme.is_composing());
        assert_eq!(type_keys(&mut scheme, " sa"), [false, false, false]);
        // 组字中：大千键和其他字母都不认领。
        type_keys(&mut scheme, "28c");
        assert_eq!(type_keys(&mut scheme, "sau,"), [false; 4]);
        assert_eq!(scheme.reading(), "李");
        // 没有数字时声调字母被吞掉。
        assert_eq!(type_keys(&mut scheme, "x"), [true]);
        assert_eq!(scheme.reading(), "李");
        // Shift 标点照常提交转换文字再加标点。
        type_keys(&mut scheme, "39c2");
        assert_eq!(type_keys(&mut scheme, "?"), [true]);
        assert_eq!(scheme.take_committed(), "你好？");
        assert!(!scheme.is_composing());
    }

    #[test]
    fn nine_key_choosing_a_spelling_pins_the_reading() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c39c");
        assert!(!scheme.choose_spelling(3).unwrap());
        assert!(scheme.choose_spelling(1).unwrap());
        assert_eq!(scheme.converted_text(), "李好");
        assert_eq!(scheme.take_committed(), "");
        // 39c 只有一个读音，没有下一个目标。
        assert!(scheme.spellings().is_empty());
        assert!(!scheme.choose_spelling(0).unwrap());
        // 确认与当前转换相同的读音也会钉住，目标右移。
        type_keys(&mut scheme, "28c");
        assert_eq!(spellings(&scheme), ["ㄌㄧˇ", "ㄋㄧˇ", "ㄉㄧˇ"]);
        assert!(scheme.choose_spelling(0).unwrap());
        assert_eq!(scheme.converted_text(), "李好李");
        assert!(scheme.spellings().is_empty());
        assert_eq!(scheme.syllables[2].allowed(), ["ㄌㄧˇ"]);
        // Enter 提交转换文字，丢掉还没结束的数字。
        type_keys(&mut scheme, "2");
        assert_eq!(scheme.reading(), "李好李2");
        assert!(scheme.handle_key(ZhuyinKey::Enter).unwrap());
        assert_eq!(scheme.take_committed(), "李好李");
        assert!(!scheme.is_composing());
    }

    #[test]
    fn nine_key_list_rows_carry_keys_and_hide_the_spellings() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c39c");
        // 没有数字时空格打开列表。
        assert_eq!(type_keys(&mut scheme, " "), [true]);
        assert!(scheme.list_open());
        assert_eq!(scheme.spelling_symbols(), nine_key::LIST_OPEN_SYMBOLS);
        assert!(scheme.spellings().is_empty());
        assert!(!scheme.choose_spelling(0).unwrap());
        let rows: Vec<(&str, usize, &str)> = scheme
            .candidates()
            .iter()
            .map(|row| (row.text.as_str(), row.start, row.key.as_str()))
            .collect();
        assert_eq!(
            rows,
            [
                ("你好", 0, "ㄋㄧˇ ㄏㄠˇ"),
                ("好", 1, "ㄏㄠˇ"),
                ("郝", 1, "ㄏㄠˇ")
            ]
        );
        // 列表打开时空格留给运行时选行；数字关闭列表继续拼写。
        assert_eq!(type_keys(&mut scheme, " "), [false]);
        assert_eq!(type_keys(&mut scheme, "2"), [true]);
        assert!(!scheme.list_open());
        assert_eq!(scheme.reading(), "你好2");
        // 声调字母同样关闭列表。
        scheme.handle_key(ZhuyinKey::Backspace).unwrap();
        type_keys(&mut scheme, " ");
        assert!(scheme.list_open());
        assert_eq!(type_keys(&mut scheme, "c"), [true]);
        assert!(!scheme.list_open());
        assert_eq!(spellings(&scheme), ["ㄋㄧˇ", "ㄌㄧˇ", "ㄉㄧˇ"]);
    }

    #[test]
    fn nine_key_list_selection_resolves_the_syllables_it_covers() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c ");
        let rows: Vec<(&str, &str)> = scheme
            .candidates()
            .iter()
            .map(|row| (row.text.as_str(), row.key.as_str()))
            .collect();
        assert_eq!(
            rows,
            [
                ("李", "ㄌㄧˇ"),
                ("你", "ㄋㄧˇ"),
                ("底", "ㄉㄧˇ"),
                ("妳", "ㄋㄧˇ"),
                ("擬", "ㄋㄧˇ")
            ]
        );
        assert!(scheme.select(1).unwrap());
        assert_eq!(scheme.converted_text(), "你");
        assert_eq!(scheme.pins[0].key, "ㄋㄧˇ");
        // 被 pin 覆盖的音节算已解析，不再是钉读音的目标，也不写 `locked`。
        assert!(scheme.spellings().is_empty());
        assert_eq!(scheme.syllables[0].locked, None);
        type_keys(&mut scheme, "39c");
        assert_eq!(scheme.converted_text(), "你好");
        assert!(scheme.spellings().is_empty());
        // 删掉 pin 结尾的音节时 pin 一起删掉，音节恢复歧义。
        scheme.handle_key(ZhuyinKey::Backspace).unwrap();
        scheme.handle_key(ZhuyinKey::Backspace).unwrap();
        assert!(!scheme.is_composing());
        type_keys(&mut scheme, "28c ");
        assert!(scheme.select(1).unwrap());
        type_keys(&mut scheme, "39c");
        scheme.handle_key(ZhuyinKey::Backspace).unwrap();
        assert_eq!(scheme.converted_text(), "你");
        assert!(scheme.spellings().is_empty());
        // 再删 39c 之后的那一步删掉的是 28c 和以它结尾的 pin。
        scheme.handle_key(ZhuyinKey::Backspace).unwrap();
        type_keys(&mut scheme, "28c");
        assert_eq!(scheme.converted_text(), "李");
        assert_eq!(spellings(&scheme), ["ㄌㄧˇ", "ㄋㄧˇ", "ㄉㄧˇ"]);
    }

    #[test]
    fn current_spelling_lookup_does_not_allocate() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c");
        let conversion = &scheme.conversion;
        let (current, allocations) =
            crate::ime::personal_rerank::allocations::count(|| current_spelling(conversion, 0));

        assert_eq!(allocations, 0);
        assert_eq!(current, Some("ㄌㄧˇ"));
    }

    #[test]
    fn nine_key_backspace_drops_a_digit_then_a_syllable_with_its_lock() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c39c");
        assert!(scheme.choose_spelling(1).unwrap());
        type_keys(&mut scheme, "28");
        let mut shown = vec![(scheme.reading(), scheme.spelling_symbols())];
        while scheme.is_composing() {
            assert!(scheme.handle_key(ZhuyinKey::Backspace).unwrap());
            shown.push((scheme.reading(), scheme.spelling_symbols()));
        }
        assert_eq!(
            shown,
            [
                ("李好28".to_owned(), nine_key::SYMBOLS),
                ("李好2".to_owned(), nine_key::SYMBOLS),
                ("李好".to_owned(), nine_key::SYMBOLS),
                ("李".to_owned(), nine_key::SYMBOLS),
                (String::new(), nine_key::IDLE_SYMBOLS),
            ]
        );
        // 钉住的读音随音节一起删掉。
        type_keys(&mut scheme, "28c39c");
        assert_eq!(scheme.converted_text(), "你好");
        assert_eq!(spellings(&scheme), ["ㄋㄧˇ", "ㄌㄧˇ", "ㄉㄧˇ"]);
        // 列表打开时 Backspace 只关闭列表。
        type_keys(&mut scheme, " ");
        assert!(scheme.handle_key(ZhuyinKey::Backspace).unwrap());
        assert!(!scheme.list_open());
        assert_eq!(scheme.converted_text(), "你好");
    }

    #[test]
    fn nine_key_locks_stay_aligned_across_an_auto_shift() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, &"28c39c".repeat(10));
        assert_eq!(scheme.converted_text(), "你好".repeat(10));
        // 先确认第一个音节的读音，目标移到第三个音节，再把它钉成 ㄌㄧˇ。
        assert!(scheme.choose_spelling(0).unwrap());
        assert_eq!(scheme.spelling_target, Some(2));
        assert!(scheme.choose_spelling(1).unwrap());
        assert_eq!(scheme.spelling_target, Some(4));
        assert_eq!(
            scheme.converted_text(),
            format!("你好李好{}", "你好".repeat(8))
        );
        type_keys(&mut scheme, "28c");
        assert_eq!(scheme.take_committed(), "你好");
        assert_eq!(scheme.syllables.len(), MAX_SYLLABLES - 1);
        assert_eq!(scheme.syllables[0].allowed(), ["ㄌㄧˇ"]);
        assert_eq!(
            scheme.converted_text(),
            format!("李好{}李", "你好".repeat(8))
        );
        assert_eq!(scheme.spelling_target, Some(2));
    }

    #[test]
    fn nine_key_mode_switches_clear_the_composition_and_reset_keeps_the_mode() {
        let (_dir, mut scheme) = nine_key_scheme();
        type_keys(&mut scheme, "28c3");
        scheme.reset();
        assert!(scheme.nine_key());
        assert!(!scheme.is_composing());
        type_keys(&mut scheme, "28c3");
        scheme.set_nine_key(false);
        assert!(!scheme.is_composing());
        assert!(!scheme.nine_key());
        // 回到大千：数字按大千键处理，没有候选读音。
        assert_eq!(scheme.spelling_symbols(), IDLE_SYMBOLS);
        type_keys(&mut scheme, "su3");
        assert_eq!(scheme.reading(), "你");
        assert!(scheme.spellings().is_empty());
        assert!(!scheme.choose_spelling(0).unwrap());
        scheme.set_nine_key(true);
        assert!(!scheme.is_composing());
        assert_eq!(scheme.spelling_symbols(), nine_key::IDLE_SYMBOLS);
    }
}