use fhir_types::codec::Value;
use fhir_types::r4::quantity::Quantity;
use fhir_types::r4::range::Range;
use openehr_rm::v1_2::data_types::quantity::dv_interval::DvInterval;
use openehr_rm::v1_2::data_types::quantity::dv_quantity::DvQuantity;
use openehr_rm::v1_2::data_types::text::dv_text::DvTextData;
use crate::engine::library::class_at;
use crate::engine::library::datum;
use crate::engine::library::decode;
use crate::engine::library::duration::plain_decimal;
use crate::engine::library::dv_interval;
use crate::engine::library::encode;
use crate::engine::library::port_value;
use crate::engine::library::range_of;
use crate::engine::library::refused;
use crate::engine::library::ucum_amount;
use crate::engine::library::ucum_quantity;
use crate::engine::traverse::functions::MappingCodeError;
use crate::engine::traverse::functions::Ports;
use crate::engine::traverse::functions::SELF_PORT;
pub const DOSE_RANGE: &str = "dosageQuantityToRange";
pub const RANGE_TEXT: &str = "rangeToText";
pub const PORTS: &[&str] = &[SELF_PORT];
const INTERVAL: &str = "DV_INTERVAL<DV_QUANTITY>";
const TEXT: &str = "DV_TEXT";
const BETWEEN: &str = " - ";
pub fn dose_range_to_openehr(element: &Value) -> Result<Ports, MappingCodeError> {
let code = DOSE_RANGE;
let range = plain_range(code, element)?;
if range.low.is_none() && range.high.is_none() {
return Err(refused(code, "the range names neither bound"));
}
let interval = dv_interval(code, &range)?;
Ok(Ports::new().with(SELF_PORT, datum(INTERVAL, &interval)))
}
pub fn dose_range_to_fhir(ports: &Ports) -> Result<Option<Value>, MappingCodeError> {
let code = DOSE_RANGE;
if class_at(ports, SELF_PORT) != Some(INTERVAL) {
return Ok(None);
}
let Some(interval) = port_value::<DvInterval<DvQuantity>>(code, ports, SELF_PORT)? else {
return Ok(None);
};
if interval.lower.is_none() != interval.lower_unbounded
|| interval.upper.is_none() != interval.upper_unbounded
{
return Err(refused(
code,
"a side of the interval holds no bound and is not unbounded",
));
}
encode(code, &range_of(code, &interval)?).map(Some)
}
pub fn range_text_to_openehr(element: &Value) -> Result<Ports, MappingCodeError> {
let code = RANGE_TEXT;
let range = plain_range(code, element)?;
let (Some(low), Some(high)) = (range.low.as_ref(), range.high.as_ref()) else {
return Err(refused(code, "a range written as text names both bounds"));
};
let text = format!("{}{BETWEEN}{}", written(code, low)?, written(code, high)?);
let value = DvTextData {
value: text,
hyperlink: None,
formatting: None,
mappings: None,
language: None,
encoding: None,
};
Ok(Ports::new().with(SELF_PORT, datum(TEXT, &value)))
}
pub fn range_text_to_fhir(ports: &Ports) -> Result<Option<Value>, MappingCodeError> {
let code = RANGE_TEXT;
if class_at(ports, SELF_PORT) != Some(TEXT) {
return Ok(None);
}
let Some(text) = port_value::<DvTextData>(code, ports, SELF_PORT)? else {
return Ok(None);
};
if text.hyperlink.is_some()
|| text.formatting.is_some()
|| text.mappings.is_some()
|| text.language.is_some()
|| text.encoding.is_some()
{
return Err(refused(
code,
"the text carries a hyperlink, formatting, mappings, a language or an encoding, which \
a Range has no place for",
));
}
let (low, high) = text.value.split_once(BETWEEN).ok_or_else(|| {
refused(
code,
format!("`{}` is no range written as text", text.value),
)
})?;
let range = Range {
low: Some(read(code, low)?),
high: Some(read(code, high)?),
..Range::default()
};
encode(code, &range).map(Some)
}
fn plain_range(code: &str, element: &Value) -> Result<Range, MappingCodeError> {
let range: Range = decode(code, "Range", element)?;
if range.id.is_some() || !range.extension.is_empty() {
return Err(refused(
code,
"the range carries an id or an extension, which the archetype has no place for",
));
}
Ok(range)
}
fn written(code: &str, bound: &Quantity) -> Result<String, MappingCodeError> {
let (value, units) = ucum_amount(code, bound)?;
Ok(format!("{value} {units}"))
}
fn read(code: &str, bound: &str) -> Result<Quantity, MappingCodeError> {
let (value, units) = bound
.split_once(' ')
.filter(|(value, units)| {
plain_decimal(value).is_some() && !units.is_empty() && !units.contains(' ')
})
.ok_or_else(|| {
refused(
code,
format!("`{bound}` is no bound written as `<value> <code>`"),
)
})?;
Ok(ucum_quantity(value, units))
}