use core::str::FromStr;
use fhir_types::codec::Value;
use fhir_types::r4::ratio::Ratio;
use openehr_rm::v1_2::data_types::quantity::date_time::dv_duration::DvDuration;
use openehr_rm::v1_2::data_types::quantity::dv_quantity::DvQuantity;
use rust_decimal::Decimal;
use crate::engine::library::class_at;
use crate::engine::library::datum;
use crate::engine::library::decode;
use crate::engine::library::duration;
use crate::engine::library::duration::TimeUnit;
use crate::engine::library::dv_quantity;
use crate::engine::library::encode;
use crate::engine::library::port_value;
use crate::engine::library::quantity_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;
pub const DOSAGE_RATE: &str = "ratio_to_dosage";
pub const ACTION_RATE: &str = "ratio_to_dosage_action";
const RATE: &str = "items[at0134]";
const DURATION: &str = "items[at0102]";
pub const PORTS: &[&str] = &[RATE, DURATION];
const DV_QUANTITY: &str = "DV_QUANTITY";
const DV_DURATION: &str = "DV_DURATION";
const SIGNIFICANT_DIGITS: usize = 28;
pub fn to_openehr(code: &str, element: &Value) -> Result<Ports, MappingCodeError> {
let ratio: Ratio = decode(code, "Ratio", element)?;
if ratio.id.is_some() || !ratio.extension.is_empty() {
return Err(refused(
code,
"the ratio carries an id or an extension, which the archetype has no place for",
));
}
let (numerator, denominator) = match (ratio.numerator.as_ref(), ratio.denominator.as_ref()) {
(None, None) => return Ok(Ports::new()),
(Some(numerator), Some(denominator)) => (numerator, denominator),
_ => {
return Err(refused(
code,
"a ratio names both a numerator and a denominator (R4 `rat-1`)",
));
}
};
let (amount, amount_units) = ucum_amount(code, numerator)?;
let (time, time_units) = ucum_amount(code, denominator)?;
let unit = TimeUnit::from_ucum(time_units).ok_or_else(|| {
refused(
code,
format!("the denominator's unit `{time_units}` is no unit of time"),
)
})?;
let rate = exact(code, amount, time, Decimal::checked_div)?.normalize();
let filled = rate.mantissa().unsigned_abs().to_string().len() >= SIGNIFICANT_DIGITS;
if filled || rate.checked_mul(number(code, time)?) != Some(number(code, amount)?) {
return Err(refused(
code,
format!("{amount} over {time} has no exact decimal rate"),
));
}
let rate = dv_quantity(
code,
&ucum_quantity(&rate.to_string(), &format!("{amount_units}/{time_units}")),
)?;
let duration = duration::to_iso(code, time, unit)?;
Ok(Ports::new()
.with(RATE, datum(DV_QUANTITY, &rate))
.with(DURATION, datum(DV_DURATION, &duration)))
}
pub fn to_fhir(code: &str, ports: &Ports) -> Result<Option<Value>, MappingCodeError> {
let (Some(rate_class), Some(_)) = (class_at(ports, RATE), class_at(ports, DURATION)) else {
return Ok(None);
};
if rate_class != DV_QUANTITY {
return Err(refused(
code,
"the rate is text, and a rate with a duration reads as a Ratio of quantities",
));
}
let (Some(rate), Some(held)) = (
port_value::<DvQuantity>(code, ports, RATE)?,
port_value::<DvDuration>(code, ports, DURATION)?,
) else {
return Ok(None);
};
let rate = quantity_of(code, &rate)?;
let (rate_value, rate_units) = ucum_amount(code, &rate)?;
let (time, unit) = duration::from_iso(code, &held)?;
let amount_units = rate_units
.strip_suffix(unit.ucum())
.and_then(|units| units.strip_suffix('/'))
.filter(|units| !units.is_empty())
.ok_or_else(|| {
refused(
code,
format!(
"the rate's units `{rate_units}` are no amount per `{}`, the unit of the \
duration `{}`",
unit.ucum(),
held.value
),
)
})?;
let amount = exact(code, rate_value, &time, Decimal::checked_mul)?;
let ratio = Ratio {
numerator: Some(ucum_quantity(&amount.normalize().to_string(), amount_units)),
denominator: Some(ucum_quantity(&time, unit.ucum())),
..Ratio::default()
};
encode(code, &ratio).map(Some)
}
fn number(code: &str, text: &str) -> Result<Decimal, MappingCodeError> {
Decimal::from_str(text)
.map_err(|error| refused(code, format!("`{text}` is no exact decimal: {error}")))
}
fn exact(
code: &str,
left: &str,
right: &str,
operation: impl Fn(Decimal, Decimal) -> Option<Decimal>,
) -> Result<Decimal, MappingCodeError> {
operation(number(code, left)?, number(code, right)?).ok_or_else(|| {
refused(
code,
format!("{left} and {right} have no exact decimal result"),
)
})
}