use fhir_types::r4::codeable_concept::CodeableConcept;
use fhir_types::r4::coding::Coding;
use crate::engine::fhir::FhirValue;
use crate::engine::outcome::Loss;
use crate::engine::outcome::SkipReason;
use crate::engine::outcome::Warning;
use crate::engine::terminology;
use crate::engine::terminology::TerminologyError;
use crate::resolve::program::mapping::Mapping;
use crate::resolve::program::target::FhirTarget;
use crate::resolve::program::target::OpenehrTarget;
use crate::tree::Occurrence;
use crate::tree::element::Move;
use crate::tree::element::Table;
use crate::engine::traverse::Run;
use crate::engine::traverse::error::EngineError;
#[derive(Debug, Clone, Copy)]
pub(super) struct Output<'o> {
pub(super) required: bool,
pub(super) element: &'o str,
pub(super) occurrence: &'o Occurrence,
}
impl<'o> Output<'o> {
pub(super) fn openehr(target: &'o OpenehrTarget, occurrence: &'o Occurrence) -> Self {
let node = target.node();
Self {
required: node.min().is_some_and(|min| min >= 1),
element: node.aql_path().as_str(),
occurrence,
}
}
pub(super) fn fhir(target: &'o FhirTarget, occurrence: &'o Occurrence) -> Self {
Self {
required: required(target),
element: target.resolved().leaf(),
occurrence,
}
}
}
pub(super) type TranslationKey = (String, String, Option<String>, String);
impl<T: Table + ?Sized> Run<'_, T> {
pub(super) fn translated(
&mut self,
mapping: &Mapping,
view: FhirValue,
output: Output<'_>,
) -> Result<Option<FhirValue>, EngineError> {
let Some(url) = mapping.conceptmap() else {
return Ok(Some(view));
};
let refuse = |source: TerminologyError| EngineError::Terminology {
mapping: String::from(mapping.name()),
conceptmap: String::from(url),
source: Box::new(source),
};
let translated = match view {
FhirValue::Coding(coding) => {
self.concept_of(url, &coding)
.map_err(refuse)?
.map(|concept| {
FhirValue::Coding(Box::new(terminology::translated(&coding, &concept)))
})
}
FhirValue::CodeableConcept(concept) if concept.coding.is_empty() => {
return Ok(Some(FhirValue::CodeableConcept(concept)));
}
FhirValue::CodeableConcept(concept) => self
.translate_concept(url, &concept)
.map_err(refuse)?
.map(|translated| FhirValue::CodeableConcept(Box::new(translated))),
other @ (FhirValue::String(_)
| FhirValue::Date(_)
| FhirValue::DateTime(_)
| FhirValue::Instant(_)
| FhirValue::Boolean(_)
| FhirValue::Period(_)
| FhirValue::Reference(_)
| FhirValue::Identifier(_)
| FhirValue::Quantity(_)
| FhirValue::Integer(_)
| FhirValue::UnsignedInt(_)
| FhirValue::PositiveInt(_)
| FhirValue::Decimal(_)
| FhirValue::Count(_)
| FhirValue::Time(_)
| FhirValue::Duration(_)
| FhirValue::Url(_)
| FhirValue::Attachment(_)
| FhirValue::Range(_)) => return Ok(Some(other)),
};
if translated.is_none() {
self.untranslated(mapping, url, output)?;
}
Ok(translated)
}
fn concept_of(
&mut self,
url: &str,
source: &Coding,
) -> Result<Option<Coding>, TerminologyError> {
let request = terminology::request(url, source)?;
let key: TranslationKey = (
String::from(url),
request
.system
.as_ref()
.and_then(|uri| uri.value.clone())
.unwrap_or_default(),
request
.version
.as_ref()
.and_then(|version| version.value.clone()),
request
.code
.as_ref()
.and_then(|code| code.value.clone())
.unwrap_or_default(),
);
if let Some(held) = self.translations.get(&key) {
return Ok(held.clone());
}
let response = self.seams.terminology().translate(&request)?;
let concept = terminology::accepted(&response)?;
self.translations.insert(key, concept.clone());
Ok(concept)
}
fn translate_concept(
&mut self,
url: &str,
source: &CodeableConcept,
) -> Result<Option<CodeableConcept>, TerminologyError> {
let mut codings: Vec<Coding> = Vec::new();
let mut first: Option<Coding> = None;
for coding in &source.coding {
let Some(concept) = self.concept_of(url, coding)? else {
continue;
};
let translated = terminology::translated(coding, &concept);
let known = codings
.iter()
.any(|held| held.system == translated.system && held.code == translated.code);
if !known {
codings.push(translated);
}
first.get_or_insert(concept);
}
let Some(first) = first else {
return Ok(None);
};
let text = terminology::translated(
&Coding {
display: source.text.clone(),
..Coding::default()
},
&first,
)
.display;
Ok(Some(CodeableConcept {
coding: codings,
text,
..CodeableConcept::default()
}))
}
}
impl<T: Table + ?Sized> Run<'_, T> {
fn untranslated(
&mut self,
mapping: &Mapping,
conceptmap: &str,
output: Output<'_>,
) -> Result<(), EngineError> {
let conceptmap = String::from(conceptmap);
if output.required {
return Err(EngineError::Untranslated {
mapping: String::from(mapping.name()),
conceptmap,
element: String::from(output.element),
});
}
let location = self.locate(mapping, output.occurrence);
self.warnings.push(Warning::new(
Loss::Skipped {
mapping: String::from(mapping.name()),
reason: SkipReason::Untranslated { conceptmap },
},
location,
));
Ok(())
}
}
fn required(target: &FhirTarget) -> bool {
target
.resolved()
.moves()
.iter()
.rev()
.find_map(|step| match *step {
Move::Member(ref field)
| Move::Choice { ref field, .. }
| Move::Extension { ref field, .. } => Some(field.min() >= 1),
Move::Ordinal(_) | Move::Index(_) | Move::Predicate(_) | Move::Resolve { .. } => None,
})
.unwrap_or(false)
}