use fhir_types::r4::coding::Coding;
use crate::engine::cell::Produced;
use crate::engine::fhir::FhirValue;
use crate::engine::lens::Fallback;
use crate::engine::lens::coded_text::CODEABLE_CONCEPT_CELL;
use crate::engine::lens::coded_text::CODING_CELL;
use crate::engine::lens::text;
use crate::engine::rm::RmValue;
use crate::engine::terminology;
use crate::engine::terminology::TerminologyError;
use crate::resolve::program::mapping::Mapping;
use crate::tree::element::Table;
use crate::engine::traverse::Run;
use crate::engine::traverse::error::EngineError;
const VALUE: &str = "DV_TEXT.value";
const LOCAL: &str = "local";
const OPENEHR: &str = "openehr";
impl<T: Table + ?Sized> Run<'_, T> {
pub(super) fn resolve_display(
&self,
mapping: &Mapping,
view: &FhirValue,
produced: &mut Produced<RmValue>,
) -> Result<(), EngineError> {
let found = match produced.value {
RmValue::CodedText(ref mut coded) => {
let system = String::from(coded.defining_code.terminology_id.name());
let version = String::from(coded.defining_code.terminology_id.version_id());
let code = coded.defining_code.code_string.clone();
let from_code = coding_of(view, &system, &code).is_some_and(undisplayed)
&& filled_from_code(&produced.fallbacks, &[CODING_CELL, CODEABLE_CONCEPT_CELL]);
if !from_code || coded.value != code || system == LOCAL {
return Ok(());
}
let display = if system == OPENEHR {
self.openehr_rubric(&code)
} else {
let version = (!version.is_empty()).then_some(version.as_str());
self.looked_up(mapping, system, code, version)?
};
if let Some(ref display) = display {
coded.value.clone_from(display);
}
display
}
RmValue::Text(ref mut rubric) => {
let Some(coding) = first_coding(view) else {
return Ok(());
};
let (Some(system), Some(code)) = (
coding.system.as_ref().and_then(|uri| uri.value.as_deref()),
coding.code.as_ref().and_then(|held| held.value.as_deref()),
) else {
return Ok(());
};
let from_code = undisplayed(coding)
&& filled_from_code(&produced.fallbacks, &[text::CODEABLE_CONCEPT_CELL]);
if !from_code || rubric.value != code {
return Ok(());
}
let version = coding
.version
.as_ref()
.and_then(|held| held.value.as_deref())
.filter(|held| !held.is_empty());
let display =
self.looked_up(mapping, String::from(system), String::from(code), version)?;
if let Some(ref display) = display {
rubric.value.clone_from(display);
}
display
}
_ => return Ok(()),
};
if found.is_some() {
produced.fallbacks.retain(|taken| taken.field() != VALUE);
}
Ok(())
}
fn openehr_rubric(&self, code: &str) -> Option<String> {
let language = self.index.web_template().default_language.as_str();
openehr_term::bundle::openehr()
.concept_rubric(code, language)
.map(String::from)
}
fn looked_up(
&self,
mapping: &Mapping,
system: String,
code: String,
version: Option<&str>,
) -> Result<Option<String>, EngineError> {
let request = terminology::lookup_request(&system, &code, version);
let seam = self.seams.terminology();
let found = match seam.lookup(&request) {
Ok(found) => found,
Err(TerminologyError::NotConfigured) => return Ok(None),
Err(source) => {
return Err(EngineError::DisplayLookup {
mapping: String::from(mapping.name()),
system,
code,
source: Box::new(source),
});
}
};
let display = found
.as_ref()
.and_then(|answer| answer.display.value.as_deref())
.filter(|display| !display.is_empty());
match display {
Some(display) => Ok(Some(String::from(display))),
None if seam.display_fallback() => Ok(None),
None => Err(EngineError::UnknownDisplay {
mapping: String::from(mapping.name()),
system,
code,
}),
}
}
}
fn undisplayed(coding: &Coding) -> bool {
coding
.display
.as_ref()
.and_then(|display| display.value.as_deref())
.is_none_or(str::is_empty)
}
fn filled_from_code(fallbacks: &[Fallback], cells: &[&str]) -> bool {
fallbacks
.iter()
.any(|taken| taken.field() == VALUE && cells.contains(&taken.cell()))
}
fn first_coding(view: &FhirValue) -> Option<&Coding> {
match *view {
FhirValue::CodeableConcept(ref concept) => concept.coding.first(),
_ => None,
}
}
fn coding_of<'view>(view: &'view FhirValue, system: &str, code: &str) -> Option<&'view Coding> {
let names = |coding: &&Coding| {
coding.system.as_ref().and_then(|uri| uri.value.as_deref()) == Some(system)
&& coding.code.as_ref().and_then(|held| held.value.as_deref()) == Some(code)
};
match *view {
FhirValue::Coding(ref coding) => Some(coding.as_ref()).filter(names),
FhirValue::CodeableConcept(ref concept) => concept.coding.iter().find(names),
_ => None,
}
}