use std::sync::Arc;
use crate::resolve::program::Program;
use crate::resolve::program::binding::TemplateId;
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum SelectError {
#[error("no compiled program answers {wanted}")]
NoMatch {
wanted: String,
},
#[error("{} programs answer {wanted}: {}", candidates.len(), candidates.join(", "))]
Ambiguous {
wanted: String,
candidates: Vec<String>,
},
#[error(
"no compiled program answers {wanted}; {} claim a profile with another version: {}",
mismatches.len(),
mismatches.join(", ")
)]
ProfileVersion {
wanted: String,
mismatches: Vec<String>,
},
}
pub fn select_by_profile<'a>(
programs: &'a [Arc<Program>],
claimed: &[String],
template: Option<&TemplateId>,
) -> Result<&'a Arc<Program>, SelectError> {
let wanted = format!("the profiles [{}]", claimed.join(", "));
let mut found: Vec<&'a Arc<Program>> = Vec::new();
let mut mismatches: Vec<String> = Vec::new();
for program in programs {
let url = program.profile().url().as_str();
let Some(entry) = claimed.iter().find(|entry| profile_url(entry) == url) else {
continue;
};
if let (Some(claimed_version), Some(pinned)) = (
profile_version(entry),
program.profile().version().version(),
) && claimed_version != pinned
{
mismatches.push(format!(
"the instance claims `{claimed_version}` where {} pins `{pinned}`",
program.context()
));
continue;
}
found.push(program);
}
narrow(found, template, wanted).map_err(|error| match error {
SelectError::NoMatch { wanted } if !mismatches.is_empty() => {
SelectError::ProfileVersion { wanted, mismatches }
}
error => error,
})
}
pub fn select_by_template<'a>(
programs: &'a [Arc<Program>],
template: &TemplateId,
) -> Result<&'a Arc<Program>, SelectError> {
let found: Vec<&'a Arc<Program>> = programs
.iter()
.filter(|program| program.template().id() == template)
.collect();
narrow(found, None, format!("the template `{template}`"))
}
fn narrow<'a>(
found: Vec<&'a Arc<Program>>,
template: Option<&TemplateId>,
wanted: String,
) -> Result<&'a Arc<Program>, SelectError> {
let narrowed: Vec<&'a Arc<Program>> = match template {
Some(pin) => found
.into_iter()
.filter(|program| program.template().id() == pin)
.collect(),
None => found,
};
match *narrowed.as_slice() {
[only] => Ok(only),
[] => Err(SelectError::NoMatch { wanted }),
_ => Err(SelectError::Ambiguous {
wanted,
candidates: narrowed.iter().map(|program| describe(program)).collect(),
}),
}
}
fn describe(program: &Program) -> String {
format!("{} ({})", program.context(), program.template().id())
}
fn profile_url(canonical: &str) -> &str {
canonical.split('|').next().unwrap_or(canonical)
}
fn profile_version(canonical: &str) -> Option<&str> {
let mut parts = canonical.splitn(2, '|');
let _url = parts.next();
parts.next().filter(|version| !version.is_empty())
}