use openehr_rm::v1_2::typing::base_name;
use std::collections::BTreeSet;
use openehr_mapping_core::composition::CanonicalComposition;
use openehr_mapping_core::composition::RmPosition;
use openehr_mapping_core::index::ResolvedNode;
use openehr_mapping_core::index::WebTemplateIndex;
use openehr_mapping_core::index::paths::FlatId;
use openehr_rm::v1_2::model;
use openehr_sdt::flat::path::FlatKey;
use openehr_sdt::flat::path::Segment;
use crate::engine::outcome::Location;
use crate::engine::outcome::Loss;
use crate::engine::outcome::Warning;
use crate::resolve::derive;
use crate::resolve::program::Program;
use crate::engine::traverse::error::EngineError;
const CONTENT_ATTRIBUTES: &[&str] = &["timing", "expiry_time"];
pub(super) type Instance = (FlatId, Vec<u32>);
pub(super) fn instance_of(flat_id: &FlatId, positions: &[RmPosition]) -> Instance {
(
flat_id.clone(),
positions.iter().map(|position| position.get()).collect(),
)
}
pub(super) fn unread(
program: &Program,
index: &WebTemplateIndex,
composition: &CanonicalComposition,
instance: &[RmPosition],
read: &BTreeSet<Instance>,
) -> Result<Vec<Warning>, EngineError> {
let refuse = |node: &str| {
let node = String::from(node);
move |source| EngineError::Template {
mapping: String::from(program.context().as_str()),
node,
source: Box::new(source),
}
};
let flat = index.flatten(composition).map_err(refuse(""))?;
let root = program.root().map(|root| format!("{}/", root.as_str()));
let pinned: Vec<u32> = instance.iter().map(|position| position.get()).collect();
let mut seen: BTreeSet<Instance> = BTreeSet::new();
let mut warnings = Vec::new();
for key in flat.keys() {
let Some(held) = held_instance(key, root.as_deref(), &pinned) else {
continue;
};
if read.contains(&held) || !seen.insert(held.clone()) {
continue;
}
let Some((node, node_id, attribute)) = element_of(index, &held, read) else {
continue;
};
let mut at = Vec::with_capacity(held.1.len());
for &position in &held.1 {
at.push(
RmPosition::new(position).map_err(|source| EngineError::Position {
mapping: String::from(program.context().as_str()),
source,
})?,
);
}
let mut path = index
.entry_path(composition, node, &at)
.map_err(refuse(node.flat_id().as_str()))?
.map_or_else(
|| String::from(node.aql_path().as_str()),
|path| path.to_string(),
);
if let Some(attribute) = attribute {
path.push('/');
path.push_str(attribute);
}
warnings.push(Warning::new(
Loss::Unread {
node: String::from(node_id),
},
Location::default().with_openehr(path),
));
}
Ok(warnings)
}
fn held_instance(key: &str, root: Option<&str>, pinned: &[u32]) -> Option<Instance> {
let parsed = FlatKey::parse(key).ok()?;
if parsed.is_ctx() || parsed.segments.iter().any(Segment::is_rm_attribute) {
return None;
}
let names: Vec<&str> = parsed
.segments
.iter()
.map(|segment| segment.name.as_str())
.collect();
let flat_id = FlatId::new(names.join("/"));
if root.is_some_and(|root| !format!("{}/", flat_id.as_str()).starts_with(root)) {
return None;
}
let positions: Vec<u32> = parsed
.segments
.iter()
.filter_map(|segment| segment.index)
.map(|index| index.saturating_add(1))
.collect();
positions
.starts_with(pinned)
.then_some((flat_id, positions))
}
fn element_of<'index>(
index: &'index WebTemplateIndex,
held: &Instance,
read: &BTreeSet<Instance>,
) -> Option<(&'index ResolvedNode, &'index str, Option<&'static str>)> {
if let Ok(node) = index.node_by_flat_id(&held.0) {
let node_id = node
.node_id()
.filter(|id| id.starts_with("at") || id.starts_with("id"))?;
if model::is_a(base_name(node.rm_type()), derive::STRUCTURAL) {
return None;
}
return Some((node, node_id, None));
}
let (parent, name) = held.0.as_str().rsplit_once('/')?;
let &name = CONTENT_ATTRIBUTES.iter().find(|&&known| known == name)?;
let below = (FlatId::new(parent), held.1.clone());
if read.contains(&below) {
return None;
}
let node = index.node_by_flat_id(&below.0).ok()?;
Some((node, name, Some(name)))
}