use fhir_types::r4::primitives;
use openehr_base::containers::NonEmptyVec;
use openehr_base::v1_3::base_types::identification::party_ref::PartyRef;
use openehr_mapping_core::index::ResolvedNode;
use openehr_rm::v1_2::common::generic::party_identified::PartyIdentifiedData;
use crate::engine::demographics::PartyIdentity;
use crate::engine::fhir::FhirValue;
use crate::engine::lens::Lens;
use crate::engine::lens::LensError;
use crate::engine::lens::party::PartyLens;
use crate::engine::lens::party_ref::PartyRefLens;
use crate::engine::lens::party_ref::target_of;
use crate::engine::rm::RmValue;
use crate::engine::traverse::Run;
use crate::engine::traverse::build::COMPOSER;
use crate::engine::traverse::error::EngineError;
use crate::model::ast::keyword::Direction;
use crate::resolve::program::mapping::Mapping;
use crate::resolve::program::target::FhirTarget;
use crate::tree::element::Table;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum Shape {
Identifier,
ExternalRef,
}
impl Shape {
pub(super) fn at(node: &ResolvedNode) -> Self {
if node.aql_path().as_str() == COMPOSER {
Self::ExternalRef
} else {
Self::Identifier
}
}
}
impl<T: Table + ?Sized> Run<'_, T> {
pub(super) fn identity_of(
&self,
mapping: &Mapping,
literal: &str,
) -> Result<PartyIdentity, EngineError> {
self.seams
.demographics()
.resolve(literal)
.map_err(|source| EngineError::Demographics {
mapping: String::from(mapping.name()),
source: Box::new(source),
})
}
pub(super) fn party_ref_of(
&self,
mapping: &Mapping,
target: &FhirTarget,
view: &FhirValue,
) -> Result<RmValue, EngineError> {
let refuse = |source: LensError| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
};
let FhirValue::Reference(reference) = view else {
return Err(refuse(LensError::NoCell {
rm_type: String::from("PARTY_REF"),
kind: view.kind().as_str(),
direction: Direction::FhirToOpenehr,
}));
};
let lens = PartyRefLens::new(self.reference_target(mapping, target)?);
let mut relative = reference.as_ref().clone();
if let Some(literal) = PartyLens::deferred(reference) {
let identity = self.identity_of(mapping, literal)?;
let found = self
.seams
.demographics()
.reference_of(&identity)
.ok_or_else(|| EngineError::ForeignParty {
mapping: String::from(mapping.name()),
reference: String::from(literal),
})?;
relative.reference = Some(primitives::String::from(found));
}
lens.put(&relative, None)
.map(RmValue::PartyRef)
.map_err(refuse)
}
pub(super) fn reference_of_party(
&self,
mapping: &Mapping,
target: &FhirTarget,
party: &PartyRef,
) -> Result<FhirValue, EngineError> {
PartyRefLens::new(self.reference_target(mapping, target)?)
.get(party)
.map(|reference| FhirValue::Reference(Box::new(reference)))
.map_err(|source| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
})
}
fn reference_target(
&self,
mapping: &Mapping,
target: &FhirTarget,
) -> Result<&'static str, EngineError> {
target_of(self.table, target.resolved().target_profiles()).ok_or_else(|| {
EngineError::PartyRefTarget {
mapping: String::from(mapping.name()),
element: String::from(target.resolved().leaf()),
}
})
}
pub(super) fn identified(
&self,
mapping: &Mapping,
view: &FhirValue,
value: RmValue,
shape: Shape,
) -> Result<RmValue, EngineError> {
let (RmValue::Party(party), FhirValue::Reference(reference)) = (value.clone(), view) else {
return Ok(value);
};
let Some(literal) = PartyLens::deferred(reference) else {
return Ok(value);
};
let identity = self.identity_of(mapping, literal)?;
Ok(RmValue::Party(match shape {
Shape::Identifier => with_identifier(party, &identity),
Shape::ExternalRef => PartyIdentifiedData {
external_ref: Some(identity.to_party_ref()),
..party
},
}))
}
pub(super) fn minted(&self, value: &RmValue) -> (RmValue, Option<String>) {
let RmValue::Party(ref party) = *value else {
return (value.clone(), None);
};
let demographics = self.seams.demographics();
let named = |identity: Option<PartyIdentity>| {
identity.and_then(|identity| demographics.reference_of(&identity))
};
let mut reference = None;
let mut kept = Vec::new();
for identifier in party.identifiers.as_deref().unwrap_or_default() {
match named(PartyIdentity::from_identifier(identifier)) {
Some(found) if reference.is_none() => reference = Some(found),
_ => kept.push(identifier.clone()),
}
}
let mut external_ref = party.external_ref.clone();
if reference.is_none()
&& let Some(found) = named(
external_ref
.as_ref()
.and_then(PartyIdentity::from_party_ref),
)
{
reference = Some(found);
external_ref = None;
}
let stripped = PartyIdentifiedData {
external_ref,
name: party.name.clone(),
identifiers: NonEmptyVec::new(kept).ok(),
};
(RmValue::Party(stripped), reference)
}
}
fn with_identifier(party: PartyIdentifiedData, identity: &PartyIdentity) -> PartyIdentifiedData {
let mut identifiers = party
.identifiers
.map(NonEmptyVec::into_vec)
.unwrap_or_default();
identifiers.insert(0, identity.to_identifier());
PartyIdentifiedData {
external_ref: party.external_ref,
name: party.name,
identifiers: NonEmptyVec::new(identifiers).ok(),
}
}