use std::collections::{HashMap, HashSet};
use super::law::{dir_of, inside};
use crate::ordinance::Ordinance;
use crate::survey::Survey;
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Standing {
Ambient,
Granted,
Ungranted,
}
impl Standing {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Ambient => "ambient",
Self::Granted => "granted",
Self::Ungranted => "ungranted",
}
}
}
#[derive(Default)]
pub struct Census {
pub files: usize,
pub edges: usize,
pub unjudged_imports: usize,
pub modules: Vec<(String, Standing)>,
pub hops: Vec<(u32, usize)>,
pub zones: Vec<(String, usize)>,
pub sealable: Vec<String>,
pub seal_debt: Vec<(String, usize)>,
}
#[must_use]
pub(super) fn take(survey: &Survey, ordinance: &Ordinance) -> Census {
let entries = fronted(survey);
let sealed: Vec<&str> = ordinance.seals.iter().map(|s| s.path.as_str()).collect();
let mut bypassed: HashMap<&str, usize> = HashMap::new();
for edge in &survey.edges {
let parent = dir_of(&edge.dst);
let Some(entry) = entries.get(parent) else { continue };
if edge.dst == *entry || inside(&edge.src, parent) || edge.src == *entry {
continue;
}
if ordinance.is_facade(&edge.src) {
continue;
}
*bypassed.entry(parent).or_default() += 1;
}
let mut sealable: Vec<String> = entries
.keys()
.filter(|d| !sealed.contains(d) && !bypassed.contains_key(*d))
.map(|d| (*d).to_owned())
.collect();
sealable.sort();
let mut seal_debt: Vec<(String, usize)> = bypassed
.iter()
.filter(|(d, _)| !sealed.contains(*d))
.map(|(d, n)| ((*d).to_owned(), *n))
.collect();
seal_debt.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
let mut hops: HashMap<u32, usize> = HashMap::new();
for edge in &survey.edges {
*hops.entry(edge.hops).or_default() += 1;
}
let mut hops: Vec<(u32, usize)> = hops.into_iter().collect();
hops.sort_unstable();
let mut held: HashMap<usize, usize> = HashMap::new();
for file in &survey.files {
if let Some(zone) = ordinance.zone_of(file) {
*held.entry(zone.rank).or_default() += 1;
}
}
Census {
files: survey.files.len(),
edges: survey.edges.len(),
unjudged_imports: survey.skipped,
modules: standing(survey, ordinance),
hops,
zones: ordinance
.zones
.iter()
.map(|z| (z.name.clone(), held.get(&z.rank).copied().unwrap_or_default()))
.collect(),
sealable,
seal_debt,
}
}
fn standing(survey: &Survey, ordinance: &Ordinance) -> Vec<(String, Standing)> {
let ambient = survey.dialect.ambient();
survey
.modules()
.into_iter()
.map(|name| {
let standing = if ambient.contains(&name) {
Standing::Ambient
} else if survey
.outside
.iter()
.filter(|o| o.spec == name)
.all(|o| ordinance.may_use(&o.src, name))
{
Standing::Granted
} else {
Standing::Ungranted
};
(name.to_owned(), standing)
})
.collect()
}
fn fronted(survey: &Survey) -> HashMap<&str, &str> {
let extension = survey.dialect.extensions().first().copied().unwrap_or_default();
let have: HashSet<&str> = survey.files.iter().map(String::as_str).collect();
let mut directories: Vec<&str> = have.iter().map(|f| dir_of(f)).filter(|d| *d != ".").collect();
directories.sort_unstable();
directories.dedup();
let mut out = HashMap::new();
for directory in directories {
let name = directory.rsplit_once('/').map_or(directory, |(_, n)| n);
let candidates =
[format!("{directory}/{name}.{extension}"), format!("{directory}.{extension}")];
if let Some(entry) = candidates.iter().find_map(|c| have.get(c.as_str())) {
out.insert(directory, *entry);
}
}
out
}