use crate::fix::Map;
use crate::lint::{
DOUBLE_ENCODED, Damage as Run, Hazards, double_encoded, inside,
};
use crate::scan::{Hit, scan_str};
use std::collections::{BTreeMap, BTreeSet, HashSet};
#[derive(Debug, Default)]
pub(super) struct Kind {
pub files: usize,
pub needed: BTreeSet<char>,
tallies: Vec<BTreeMap<char, usize>>,
pub hazards: BTreeMap<char, (String, String)>,
pub sequences: bool,
}
pub(super) struct Survey {
pub kinds: BTreeMap<String, Kind>,
pub skipped: usize,
map: HashSet<char>,
keep: bool,
hazards: Hazards,
}
impl Survey {
pub(super) fn new(keep: bool) -> Self {
Self {
kinds: BTreeMap::new(),
skipped: 0,
keep,
map: to_ascii(&Map::builtin()),
hazards: Hazards::builtin(),
}
}
pub(super) fn add(&mut self, shown: &str, text: &str) {
let exempt = self.hazards.exempt(text);
let runs = double_encoded(text);
let kind = self.kinds.entry(pattern_of(shown)).or_default();
kind.begin(&runs, shown);
for hit in needing(text, &runs) {
if let Some(lint) = self.hazards.lint_at(hit, &exempt) {
kind.hazard(hit.character, lint.name, shown);
} else if exempt.binary_search(&hit.position.byte).is_ok() {
kind.sequences = true;
} else {
let mapped = !self.keep && self.map.contains(&hit.character);
kind.file(hit.character, mapped);
}
}
}
}
impl Kind {
fn begin(&mut self, runs: &[Run], shown: &str) {
self.files = self.files.saturating_add(1);
self.tallies.push(BTreeMap::new());
for run in runs {
self.hazard(run.decoded, DOUBLE_ENCODED.name, shown);
}
}
fn hazard(&mut self, c: char, lint: &'static str, shown: &str) {
let first = (String::new(), shown.to_owned());
let (names, _) = self.hazards.entry(c).or_insert(first);
if names.split(", ").any(|name| name == lint) {
return;
}
if !names.is_empty() {
names.push_str(", ");
}
names.push_str(lint);
}
fn file(&mut self, c: char, mapped: bool) {
match self.tallies.last_mut() {
Some(tally) if mapped => {
let seen = tally.entry(c).or_insert(0);
*seen = seen.saturating_add(1);
}
_ => {
self.needed.insert(c);
}
}
}
pub(super) fn fixable(&self) -> BTreeSet<char> {
self.tallies
.iter()
.flat_map(|tally| tally.keys().copied())
.collect()
}
pub(super) fn unfixed(
&self,
granted: &dyn Fn(char) -> bool,
) -> (usize, usize) {
let each = self.tallies.iter().map(|tally| {
let left = tally.iter().filter(|(c, _)| !granted(**c));
left.fold(0_usize, |sum, (_, n)| sum.saturating_add(*n))
});
each.filter(|n| *n > 0).fold((0, 0), |(all, files), n| {
(all.saturating_add(n), files.saturating_add(1))
})
}
}
fn to_ascii(map: &Map) -> HashSet<char> {
let each = map.entries().iter().filter_map(|entry| {
let mut chars = entry.from.chars();
let (Some(c), None) = (chars.next(), chars.next()) else {
return None;
};
entry.to.is_ascii().then_some(c)
});
each.collect()
}
fn plain(c: char) -> bool {
c == '\t' || c == '\n' || (' '..='~').contains(&c)
}
pub(super) fn pattern_of(shown: &str) -> String {
let name = shown.rsplit('/').next().unwrap_or(shown);
match name.rsplit_once('.') {
Some((stem, ext)) if !stem.is_empty() && !ext.is_empty() => {
format!("*.{ext}")
}
_ => name.to_owned(),
}
}
fn needing(text: &str, runs: &[Run]) -> Vec<Hit> {
let mut hits = scan_str(text, plain);
hits.retain(|hit| !inside(runs, hit.position.byte));
hits
}