use crate::charset::{CharSet, SetCatalog, is_punctuation, locale_names};
use crate::rules::TEXT;
use std::collections::BTreeSet;
const PRESETS: &[&str] = &[
"caveman",
"typography",
"math",
"legal",
"marks",
"box",
"emoji",
"cr",
];
#[derive(Debug, PartialEq, Eq)]
pub(super) enum Grant {
Sets(Vec<(String, Vec<char>)>),
Any(Vec<char>),
}
pub(super) struct Candidates {
presets: Vec<CharSet>,
locales: Vec<CharSet>,
}
impl Candidates {
pub(super) fn builtin() -> Self {
let catalog = SetCatalog::builtin();
let resolve = |name: &str| catalog.resolve(name, TEXT).ok();
let letters = locale_names().filter(|name| !is_punctuation(name));
Self {
presets: PRESETS.iter().filter_map(|name| resolve(name)).collect(),
locales: letters.filter_map(resolve).collect(),
}
}
pub(super) fn cover(&self, needed: &BTreeSet<char>) -> Grant {
let mut left = needed.clone();
let mut chosen = self.presets_for(&mut left);
if left.is_empty() {
return Grant::Sets(chosen);
}
let Some(locales) = self.letters(&left) else {
return Grant::Any(left.into_iter().collect());
};
for locale in locales {
chosen.push(taken(locale, &mut left));
}
Grant::Sets(chosen)
}
pub(super) fn allows(&self, grant: &Grant, c: char) -> bool {
let Grant::Sets(sets) = grant else {
return true;
};
let mut all = self.presets.iter().chain(&self.locales);
all.any(|set| {
set.contains(c) && sets.iter().any(|(n, _)| *n == set.name)
})
}
fn presets_for(
&self,
left: &mut BTreeSet<char>,
) -> Vec<(String, Vec<char>)> {
let mut chosen = Vec::new();
while let Some(best) = best(&self.presets, left) {
chosen.push(taken(best, left));
}
chosen
}
fn letters(&self, left: &BTreeSet<char>) -> Option<Vec<&CharSet>> {
let whole = smallest_covering(&self.locales, left);
if whole.is_some_and(|set| set.name == LOAN_LETTERS || is_base(set)) {
return whole.map(|set| vec![set]);
}
self.split(left).or_else(|| whole.map(|set| vec![set]))
}
fn split(&self, left: &BTreeSet<char>) -> Option<Vec<&CharSet>> {
let first = best(self.locales.iter().filter(|set| is_base(set)), left)?;
let rest = left.iter().copied().filter(|c| !first.contains(*c));
let second = smallest_covering(&self.locales, &rest.collect())?;
Some(vec![first, second])
}
}
fn is_base(set: &CharSet) -> bool {
!set.name.contains('-')
}
fn best<'a>(
sets: impl IntoIterator<Item = &'a CharSet>,
left: &BTreeSet<char>,
) -> Option<&'a CharSet> {
let gain =
|set: &CharSet| left.iter().filter(|c| set.contains(**c)).count();
let mut found: Option<(&CharSet, usize)> = None;
for set in sets {
let won = gain(set);
let better = found.is_none_or(|(held, had)| {
won > had || (won == had && size(set) < size(held))
});
if won > 0 && better {
found = Some((set, won));
}
}
found.map(|(set, _)| set)
}
const LOAN_LETTERS: &str = "en-aux";
fn smallest_covering<'a>(
locales: &'a [CharSet],
left: &BTreeSet<char>,
) -> Option<&'a CharSet> {
let covers = |set: &&CharSet| left.iter().all(|c| set.contains(*c));
let covering = locales.iter().filter(covers);
let loan = covering.clone().find(|set| set.name == LOAN_LETTERS);
loan.or_else(|| covering.min_by(|a, b| rank(a).cmp(&rank(b))))
}
fn taken(set: &CharSet, left: &mut BTreeSet<char>) -> (String, Vec<char>) {
let covered: Vec<char> =
left.iter().copied().filter(|c| set.contains(*c)).collect();
left.retain(|c| !set.contains(*c));
(set.name.clone(), covered)
}
fn rank(set: &CharSet) -> (bool, u32, &str) {
(!is_base(set), size(set), set.name.as_str())
}
fn size(set: &CharSet) -> u32 {
set.ranges.iter().fold(0_u32, |sum, range| {
let width = u32::from(range.end).saturating_sub(u32::from(range.start));
sum.saturating_add(width).saturating_add(1)
})
}