use fhir_types::schema::FieldSchema;
use fhir_types::schema::Kind;
use fhir_types::schema::TypeSchema;
use fhir_types::schema::ValueKind;
use crate::tree::error::ResolveError;
use crate::tree::path::Step;
use crate::tree::element::Field;
use crate::tree::element::Location;
use crate::tree::element::Move;
use crate::tree::element::Table;
use crate::tree::element::Walk;
const REFERENTIAL: [&str; 3] = ["uri", "canonical", "url"];
const ELEMENT_TYPE: &str = "Element";
const EXTENSION_ELEMENT: &str = "extension";
const PRIMITIVE_VALUE: &str = "value";
impl<T: Table + ?Sized> Walk<'_, T> {
pub(super) fn take(&mut self, step: &Step, rest: &[Step]) -> Result<bool, ResolveError> {
match step {
Step::Element { name }
if name == PRIMITIVE_VALUE && matches!(self.location, Location::Primitive(_)) =>
{
self.primitive_value(rest).map(|()| false)
}
Step::Element { name } => self.element(name).map(|()| false),
Step::Type { name, .. } => self.type_filter(name, rest),
Step::Extension { url } => self.extension(url).map(|()| false),
Step::Resolve => self.resolve_step(rest).map(|()| true),
Step::Ordinal(ordinal) => {
self.moves.push(Move::Ordinal(*ordinal));
Ok(false)
}
Step::Index(position) => self.index(*position).map(|()| false),
Step::Predicate { expression } => {
self.moves.push(Move::Predicate(expression.clone()));
Ok(false)
}
}
}
fn element(&mut self, name: &str) -> Result<(), ResolveError> {
match &self.location {
Location::Complex(schema) => self.member(schema, name),
Location::Primitive(_) | Location::Attribute => {
self.enter_primitive_element(name)?;
self.primitive_member(name)
}
Location::PrimitiveElement => self.primitive_member(name),
Location::Choice(element) => Err(ResolveError::UnresolvedChoice {
element: element.clone(),
}),
Location::Resource => Err(ResolveError::ResourceContent {
element: self.owner.clone(),
}),
Location::Deferred => Err(ResolveError::NoChildren {
element: self.owner.clone(),
name: String::from(name),
}),
}
}
fn primitive_value(&self, rest: &[Step]) -> Result<(), ResolveError> {
match rest.first() {
None => Ok(()),
Some(next) => Err(ResolveError::NoChildren {
element: format!("{}.{PRIMITIVE_VALUE}", self.owner),
name: match next {
Step::Element { name } | Step::Type { name, .. } => name.clone(),
Step::Extension { .. } => String::from(EXTENSION_ELEMENT),
Step::Resolve => String::from("resolve()"),
Step::Ordinal(_) | Step::Index(_) | Step::Predicate { .. } => {
String::from(PRIMITIVE_VALUE)
}
},
}),
}
}
fn member(&mut self, schema: &'static TypeSchema, name: &str) -> Result<(), ResolveError> {
let (field, kind, key, types) =
named(schema, name).ok_or_else(|| ResolveError::UnknownElement {
owner: String::from(schema.path),
name: String::from(name),
})?;
let rivals = if let Kind::Choice(_) = kind {
Vec::new()
} else {
rivals(field, &key)
};
let resolved = Field {
path: String::from(field.path),
key,
kind,
min: field.min,
max: field.max,
types,
target_profiles: field.target_profiles,
rivals,
};
self.owner = String::from(field.path);
if let Kind::Choice(_) = kind {
self.location = Location::Choice(String::from(field.path));
self.moves.push(Move::Choice {
field: resolved,
schema: field,
});
return Ok(());
}
self.location = self.landing(kind)?;
self.moves.push(Move::Member(resolved));
Ok(())
}
fn primitive_member(&mut self, name: &str) -> Result<(), ResolveError> {
let field = self.element_member(name)?;
let path = format!("{}.{}", self.owner, field.name);
self.owner.clone_from(&path);
self.location = self.landing(field.kind)?;
self.moves.push(Move::Member(single(path, field)));
Ok(())
}
fn element_member(&self, name: &str) -> Result<&'static FieldSchema, ResolveError> {
let schema =
self.table
.type_named(ELEMENT_TYPE)
.ok_or_else(|| ResolveError::UnknownElement {
owner: self.owner.clone(),
name: String::from(ELEMENT_TYPE),
})?;
schema
.fields
.iter()
.find(|field| field.name == name)
.ok_or_else(|| ResolveError::NoChildren {
element: self.owner.clone(),
name: String::from(name),
})
}
fn enter_primitive_element(&mut self, name: &str) -> Result<(), ResolveError> {
let last = self
.moves
.last_mut()
.ok_or_else(|| ResolveError::NoChildren {
element: self.owner.clone(),
name: String::from(name),
})?;
let Move::Member(field) = last else {
return Err(ResolveError::NoChildren {
element: self.owner.clone(),
name: String::from(name),
});
};
*field = field.under(format!("_{}", field.key));
self.location = Location::PrimitiveElement;
Ok(())
}
fn type_filter(&mut self, name: &str, rest: &[Step]) -> Result<bool, ResolveError> {
match self.location.clone() {
Location::Choice(element) => self.choose(&element, name).map(|()| false),
Location::Complex(schema) => self.assert_complex(schema, name, rest),
Location::Resource => self.assert_resource(name),
Location::Primitive(_) | Location::Attribute => {
self.assert_primitive(name).map(|()| false)
}
Location::PrimitiveElement | Location::Deferred => Err(ResolveError::TypeAssertion {
element: self.owner.clone(),
requested: String::from(name),
actual: String::from("Element"),
}),
}
}
fn choose(&mut self, element: &str, name: &str) -> Result<(), ResolveError> {
let Some(Move::Choice { field, schema }) = self.moves.last() else {
return Err(ResolveError::UnresolvedChoice {
element: String::from(element),
});
};
let (suffix, kind) = schema
.choices()
.find(|form| form.suffix.eq_ignore_ascii_case(name))
.map(|form| (form.suffix, form.kind))
.ok_or_else(|| ResolveError::ChoiceType {
element: String::from(element),
requested: String::from(name),
admitted: schema
.choices()
.map(|form| form.suffix)
.collect::<Vec<_>>()
.join(", "),
})?;
let types = alternative(field.types, suffix);
let chosen = Field {
path: field.path.clone(),
key: format!("{}{suffix}", field.key),
kind,
min: field.min,
max: field.max,
types,
target_profiles: field.target_profiles,
rivals: rivals(schema, &format!("{}{suffix}", field.key)),
};
self.location = self.landing(kind)?;
let last = self.moves.len().saturating_sub(1);
if let Some(slot) = self.moves.get_mut(last) {
*slot = Move::Member(chosen);
}
Ok(())
}
fn assert_complex(
&mut self,
schema: &'static TypeSchema,
name: &str,
rest: &[Step],
) -> Result<bool, ResolveError> {
if schema.name.eq_ignore_ascii_case(name) {
return Ok(false);
}
if schema.name == "Reference" && self.table.is_resource(name) {
self.defer(Some(String::from(name)), rest);
return Ok(true);
}
Err(ResolveError::TypeAssertion {
element: self.owner.clone(),
requested: String::from(name),
actual: String::from(schema.name),
})
}
fn assert_resource(&mut self, name: &str) -> Result<bool, ResolveError> {
let schema = self
.table
.type_named(name)
.filter(|_| self.table.is_resource(name))
.ok_or_else(|| ResolveError::TypeAssertion {
element: self.owner.clone(),
requested: String::from(name),
actual: String::from("Resource"),
})?;
self.location = Location::Complex(schema);
Ok(false)
}
fn assert_primitive(&mut self, name: &str) -> Result<(), ResolveError> {
let Some(Move::Member(field)) = self.moves.last() else {
return Err(ResolveError::TypeAssertion {
element: self.owner.clone(),
requested: String::from(name),
actual: String::from("Element"),
});
};
if field
.types
.iter()
.any(|code| code.eq_ignore_ascii_case(name))
{
return Ok(());
}
Err(ResolveError::TypeAssertion {
element: field.path.clone(),
requested: String::from(name),
actual: field.types.join(", "),
})
}
fn extension(&mut self, url: &str) -> Result<(), ResolveError> {
if matches!(self.location, Location::Primitive(_) | Location::Attribute) {
self.enter_primitive_element(EXTENSION_ELEMENT)?;
}
let (field, path) = match &self.location {
Location::Complex(schema) => {
let (field, ..) = named(schema, EXTENSION_ELEMENT).ok_or_else(|| {
ResolveError::UnknownElement {
owner: String::from(schema.path),
name: String::from(EXTENSION_ELEMENT),
}
})?;
(field, String::from(field.path))
}
Location::PrimitiveElement => {
let field = self.element_member(EXTENSION_ELEMENT)?;
let path = format!("{}.{EXTENSION_ELEMENT}", self.owner);
(field, path)
}
Location::Choice(choice) => {
return Err(ResolveError::UnresolvedChoice {
element: choice.clone(),
});
}
Location::Resource => {
return Err(ResolveError::ResourceContent {
element: self.owner.clone(),
});
}
Location::Primitive(_) | Location::Attribute | Location::Deferred => {
return Err(ResolveError::NoChildren {
element: self.owner.clone(),
name: String::from(EXTENSION_ELEMENT),
});
}
};
self.owner.clone_from(&path);
self.location = self.landing(field.kind)?;
self.moves.push(Move::Extension {
field: single(path, field),
url: String::from(url),
});
Ok(())
}
fn resolve_step(&mut self, rest: &[Step]) -> Result<(), ResolveError> {
let referential = match &self.location {
Location::Complex(schema) => schema.name == "Reference",
Location::Primitive(_) => match self.moves.last() {
Some(Move::Member(field)) => {
field.types.iter().any(|code| REFERENTIAL.contains(code))
}
_ => false,
},
Location::Attribute
| Location::PrimitiveElement
| Location::Choice(_)
| Location::Resource
| Location::Deferred => false,
};
if !referential {
return Err(ResolveError::NotAReference {
element: self.owner.clone(),
});
}
let (expected, rest) = match rest.split_first() {
Some((Step::Type { name, .. }, tail)) if self.table.is_resource(name) => {
(Some(name.clone()), tail)
}
_ => (None, rest),
};
self.defer(expected, rest);
Ok(())
}
fn defer(&mut self, expected: Option<String>, rest: &[Step]) {
self.location = Location::Deferred;
self.moves.push(Move::Resolve {
expected,
continuation: rest.to_vec(),
});
}
fn index(&mut self, position: usize) -> Result<(), ResolveError> {
let repeats = match self.moves.last() {
Some(Move::Member(field) | Move::Choice { field, .. }) => field.repeats(),
Some(Move::Extension { .. }) => true,
_ => false,
};
if !repeats {
return Err(ResolveError::NotRepeating {
element: self.owner.clone(),
index: position,
});
}
self.moves.push(Move::Index(position));
Ok(())
}
fn landing(&self, kind: Kind) -> Result<Location, ResolveError> {
Ok(match kind {
Kind::Attribute => Location::Attribute,
Kind::Primitive(value) => Location::Primitive(value),
Kind::Xhtml => Location::Primitive(ValueKind::Text),
Kind::Resource => Location::Resource,
Kind::Choice(_) => Location::Choice(self.owner.clone()),
Kind::Complex(name) => {
let schema =
self.table
.type_named(name)
.ok_or_else(|| ResolveError::UnknownElement {
owner: self.owner.clone(),
name: String::from(name),
})?;
Location::Complex(schema)
}
})
}
}
type Named = (&'static FieldSchema, Kind, String, &'static [&'static str]);
fn named(schema: &'static TypeSchema, name: &str) -> Option<Named> {
if let Some(field) = schema.fields.iter().find(|field| field.name == name) {
return Some((field, field.kind, String::from(name), field.types));
}
let member = schema.member(name).filter(|member| !member.sibling)?;
let field = member.field;
let types = match member.choice {
Some(code) => alternative(field.types, code),
None => field.types,
};
Some((field, member.kind, String::from(name), types))
}
fn alternative(types: &'static [&'static str], suffix: &str) -> &'static [&'static str] {
types
.iter()
.position(|code| code.eq_ignore_ascii_case(suffix))
.and_then(|at| types.get(at))
.map_or(types, core::slice::from_ref)
}
fn rivals(field: &'static FieldSchema, chosen: &str) -> Vec<String> {
field
.choices()
.map(|form| format!("{}{}", field.name, form.suffix))
.filter(|key| key != chosen)
.collect()
}
fn single(path: String, field: &'static FieldSchema) -> Field {
Field {
path,
key: String::from(field.name),
kind: field.kind,
min: field.min,
max: field.max,
types: field.types,
target_profiles: field.target_profiles,
rivals: Vec::new(),
}
}