use openehr_mapping_core::diagnostic::ModelPath;
use openehr_rm::v1_2::model;
use crate::engine::rm::carried::Carried;
use crate::engine::rm::carried::carried;
use crate::model::ast::ManualEntry;
use crate::model::ast::ModelMappingFile;
use crate::model::ast::keyword::Direction;
use crate::resolve::compile::Compiler;
use crate::resolve::error::ResolveCode;
use crate::resolve::extensions::diagnostic;
use crate::resolve::program::manual::ManualPath;
use crate::resolve::program::target::OpenehrTarget;
use crate::resolve::program::target::Target;
const CODED_TEXT: &str = "DV_CODED_TEXT";
const TEXT: &str = "DV_TEXT";
impl<'a> Compiler<'a> {
pub(in crate::resolve::compile) fn free_text(
&mut self,
file: &'a ModelMappingFile,
entry: &ManualEntry,
path: &ModelPath,
direction: Option<Direction>,
openehr: Vec<ManualPath>,
) -> Vec<ManualPath> {
if direction == Some(Direction::OpenehrToFhir) {
return openehr;
}
let targets: Vec<&OpenehrTarget> = openehr
.iter()
.filter_map(|written| match *written.target() {
Target::Openehr(ref target) => Some(target.as_ref()),
Target::Fhir(_) => None,
})
.collect();
let mut free: Vec<String> = Vec::new();
for target in &targets {
let node = target.node();
let flat_id = node.flat_id().as_str();
if node.rm_type() != CODED_TEXT
|| target.on_element()
|| free.iter().any(|seen| seen == flat_id)
{
continue;
}
let written: Vec<Vec<&str>> = targets
.iter()
.filter(|other| other.node().flat_id() == node.flat_id())
.map(|other| written(other))
.collect();
if !creates_text(&written) {
continue;
}
if !node.list_open() {
self.diagnostics.push(diagnostic(
file.file(),
file.header().name().value(),
ResolveCode::ClosedValueSet,
entry.name.position(),
&path.field("openehr"),
format!(
"`{}` writes no `defining_code` at the DV_CODED_TEXT node `{}`, so it \
creates a DV_TEXT, and the node's value set is closed",
entry.name.value(),
node.aql_path().as_str()
),
));
}
free.push(String::from(flat_id));
}
openehr
.into_iter()
.map(|written| match *written.target() {
Target::Openehr(ref target)
if free
.iter()
.any(|flat_id| flat_id == target.node().flat_id().as_str()) =>
{
let target = target.as_ref().clone().with_value_class(TEXT);
ManualPath::new(Target::Openehr(Box::new(target)), written.value().clone())
}
_ => written,
})
.collect()
}
}
fn written(target: &OpenehrTarget) -> Vec<&str> {
let segments: Vec<&str> = target
.tail()
.segments
.iter()
.map(|segment| segment.attribute.as_str())
.collect();
if segments.is_empty() {
vec!["value"]
} else {
segments
}
}
fn creates_text(written: &[Vec<&str>]) -> bool {
written.iter().all(|tail| {
tail.first()
.is_some_and(|first| model::attribute(TEXT, first).is_some())
&& carried(TEXT, tail).is_some_and(|(_, held)| held == Carried::Text)
}) && model::attributes(TEXT)
.filter(|attribute| attribute.is_mandatory)
.all(|attribute| {
written
.iter()
.any(|tail| tail.first() == Some(&attribute.name))
})
}