json-ld 0.22.0

use btree_indexmap::BTreeIndexMultiSet;
use json_syntax::{JsonObject, JsonValue};
use mown::Mown;
use rdf_syntax::Id;

use crate::{
	JsonLdBacktraceBuilder, JsonLdLenient, JsonLdLocatedError, JsonLdNode, JsonLdProcessingMode,
	JsonLdTerm, JsonLdType,
	algorithms::{
		AsyncJsonLdEnvironment, AsyncProcessingEnvironmentRef,
		compaction::{Compactor, object::value::add_value},
		context_processing::JsonLdContextProcessingOptions,
	},
	context::JsonLdContainer,
	syntax::{JsonLdContainerItem, JsonLdKeyword},
};

mod property;

fn optional_string(s: Option<String>) -> JsonValue {
	s.map(Into::into).unwrap_or_else(|| JsonValue::Null)
}

impl Compactor<'_> {
	/// Compact the given indexed node.
	#[allow(clippy::too_many_arguments)]
	pub async fn compact_indexed_node_with(
		&self,
		env: &impl AsyncJsonLdEnvironment,
		node: &JsonLdNode,
		index: Option<&str>,
		location: JsonLdBacktraceBuilder<'_>,
	) -> Result<JsonValue, JsonLdLocatedError> {
		// If active context has a previous context, the active context is not propagated.
		// If element does not contain an @value entry, and element does not consist of
		// a single @id entry, set active context to previous context from active context,
		// as the scope of a term-scoped context does not apply when processing new node objects.
		let mut active_context = Mown::Borrowed(self.active_context);
		if !(node.is_empty() && node.id.is_some()) {
			// does not consist of a single @id entry
			if let Some(previous_context) = self.active_context.previous_context() {
				active_context = Mown::Borrowed(previous_context);
			}
		}

		// If the term definition for active property in active context has a local context:
		// FIXME https://github.com/w3c/json-ld-api/issues/502
		//       Seems that the term definition should be looked up in `type_scoped_context`.
		if let Some(active_property) = self.active_property
			&& let Some(active_property_definition) = self.type_scoped_context.get(active_property)
			&& let Some(local_context) = active_property_definition.context()
		{
			let def_loc =
				location.push_backtrace(active_property_definition.location().unwrap_or_default());
			let scoped_context_loc = def_loc.object_value(JsonLdKeyword::Context);

			active_context = Mown::Owned(
				local_context
					.process_with(
						AsyncProcessingEnvironmentRef(env),
						active_property_definition.base_url(),
						active_context.as_ref(),
						JsonLdContextProcessingOptions::from(self.options).with_override(),
						scoped_context_loc,
					)
					.await?
					.into_raw(),
			)
		}

		// let inside_reverse = active_property == Some("@reverse");
		let mut result = JsonObject::default();

		if let Some(types) = &node.types
			&& !types.is_empty()
		{
			// If element has an @type entry, create a new array compacted types initialized by
			// transforming each expanded type of that entry into its compacted form by IRI
			// compacting expanded type. Then, for each term in compacted types ordered
			// lexicographically:
			let type_loc = location.object_entry("@type");
			let mut compacted_types = Vec::new();
			for (i, ty) in types.iter().enumerate() {
				let compacted_ty = self
					.with_active_context(self.type_scoped_context)
					.compact_iri(
						&ty.clone().into_term(),
						true,
						false,
						type_loc.array_index(i),
					)?;
				compacted_types.push(compacted_ty)
			}

			compacted_types.sort_by(|a, b| a.as_ref().unwrap().cmp(b.as_ref().unwrap()));

			for term in &compacted_types {
				if let Some(term_definition) = self
					.type_scoped_context
					.get(term.as_ref().unwrap().as_str())
					&& let Some(local_context) = term_definition.context()
				{
					let processing_options =
						JsonLdContextProcessingOptions::from(self.options).without_propagation();
					let def_loc =
						type_loc.push_backtrace(term_definition.location().unwrap_or_default());
					let scoped_context_loc = def_loc.object_value(JsonLdKeyword::Context);
					active_context = Mown::Owned(
						local_context
							.process_with(
								AsyncProcessingEnvironmentRef(env),
								term_definition.base_url(),
								active_context.as_ref(),
								processing_options,
								scoped_context_loc,
							)
							.await?
							.into_raw(),
					)
				}
			}
		}

		// For each key expanded property and value expanded value in element, ordered
		// lexicographically by expanded property if ordered is true:
		let mut expanded_entries: Vec<_> = node.properties().iter().collect();
		if self.options.ordered {
			expanded_entries.sort_by(|(a, _), (b, _)| a.as_str().cmp(b.as_str()))
		}

		// If expanded property is @id:
		if let Some(id_entry) = &node.id {
			let id = id_entry.clone().into_term();
			let id_loc = location.object_entry("@id");

			if node.is_empty() {
				// This captures step 7:
				// If element has an @value or @id entry and the result of using the
				// Value Compaction algorithm, passing active context, active property,
				// and element as value is a scalar, or the term definition for active property
				// has a type mapping of @json, return that result.
				//
				// in the Value Compaction Algorithm, step 7:
				// If value has an @id entry and has no other entries other than @index:
				//
				// If the type mapping of active property is set to @id,
				// set result to the result of IRI compacting the value associated with the
				// @id entry using false for vocab.
				let type_mapping = match self.active_property {
					Some(prop) => match active_context.get(prop) {
						Some(def) => def.typ(),
						None => None,
					},
					None => None,
				};

				if type_mapping == Some(&JsonLdType::Id) {
					let compacted_value = self
						.with_active_context(&active_context)
						.compact_iri(&id, false, false, id_loc)?;
					return Ok(optional_string(compacted_value));
				}

				// Otherwise, if the type mapping of active property is set to @vocab,
				// set result to the result of IRI compacting the value associated with the @id entry.
				if type_mapping == Some(&JsonLdType::Vocab) {
					let compacted_value = self
						.with_active_context(&active_context)
						.compact_iri(&id, true, false, id_loc)?;
					return Ok(optional_string(compacted_value));
				}
			}

			// If expanded value is a string, then initialize compacted value by IRI
			// compacting expanded value with vocab set to false.
			let compacted_value = self
				.with_active_context(&active_context)
				.compact_iri(&id, false, false, id_loc)?;

			// Initialize alias by IRI compacting expanded property.
			let alias = self.with_active_context(&active_context).compact_iri(
				&JsonLdTerm::Keyword(JsonLdKeyword::Id),
				true,
				false,
				id_loc,
			)?;

			// Add an entry alias to result whose value is set to compacted value and continue
			// to the next expanded property.
			if let Some(key) = alias {
				result.insert(key, optional_string(compacted_value));
			}
		}

		self.with_active_context(&active_context).compact_types(
			&mut result,
			node.types.as_ref(),
			location,
		)?;

		// If expanded property is @reverse:
		if let Some(reverse_properties) = node.reverse_properties_entry()
			&& !reverse_properties.is_empty()
		{
			let rev_loc = location.object_entry("@reverse");
			// Initialize compacted value to the result of using this algorithm recursively,
			// passing active context, @reverse for active property,
			// expanded value for element, and the compactArrays and ordered flags.
			let active_property = "@reverse";
			if let Some(active_property_definition) = active_context.get(active_property)
				&& let Some(local_context) = active_property_definition.context()
			{
				let def_loc = rev_loc
					.push_backtrace(active_property_definition.location().unwrap_or_default());
				let scoped_context_loc = def_loc.object_value(JsonLdKeyword::Context);

				active_context = Mown::Owned(
					local_context
						.process_with(
							AsyncProcessingEnvironmentRef(env),
							active_property_definition.base_url(),
							active_context.as_ref(),
							JsonLdContextProcessingOptions::from(self.options).with_override(),
							scoped_context_loc,
						)
						.await?
						.into_raw(),
				)
			}

			let mut reverse_result = JsonObject::default();
			for (expanded_property, expanded_value) in reverse_properties.iter() {
				let prop_loc = rev_loc.object_entry(expanded_property.as_str());
				self.with_active_context(&active_context)
					.compact_property(
						env,
						&mut reverse_result,
						expanded_property.clone().into(),
						expanded_value.iter(),
						true,
						prop_loc,
					)
					.await?;
			}

			// For each property and value in compacted value:
			let mut reverse_map = JsonObject::default();
			for (property, mapped_value) in reverse_result.iter_mut() {
				let mut value = JsonValue::Null;
				std::mem::swap(&mut value, &mut *mapped_value);

				// If the term definition for property in the active context indicates that
				// property is a reverse property
				if let Some(term_definition) = active_context.get(property.as_str())
					&& term_definition.reverse_property()
				{
					// Initialize as array to true if the container mapping for property in
					// the active context includes @set, otherwise the negation of compactArrays.
					let as_array = term_definition
						.container()
						.contains(JsonLdContainerItem::Set)
						|| !self.options.compact_arrays;

					// Use add value to add value to the property entry in result using as array.
					add_value(&mut result, property, value, as_array);
					continue;
				}

				reverse_map.insert(property.clone(), value);
			}

			if !reverse_map.is_empty() {
				// Initialize alias by IRI compacting @reverse.
				let alias = self.with_active_context(&active_context).compact_iri(
					&JsonLdTerm::Keyword(JsonLdKeyword::Reverse),
					true,
					false,
					rev_loc,
				)?;

				// Set the value of the alias entry of result to compacted value.
				result.insert(alias.unwrap(), reverse_map.into());
			}
		}

		// If expanded property is @index and active property has a container mapping in
		// active context that includes @index,
		if let Some(index_entry) = index {
			let index_loc = location.object_entry("@index");
			let mut index_container = false;
			if let Some(active_property) = self.active_property
				&& let Some(active_property_definition) = active_context.get(active_property)
				&& active_property_definition
					.container()
					.contains(JsonLdContainerItem::Index)
			{
				// then the compacted result will be inside of an @index container,
				// drop the @index entry by continuing to the next expanded property.
				index_container = true;
			}

			if !index_container {
				// Initialize alias by IRI compacting expanded property.
				let alias = self.with_active_context(&active_context).compact_iri(
					&JsonLdTerm::Keyword(JsonLdKeyword::Index),
					true,
					false,
					index_loc,
				)?;

				// Add an entry alias to result whose value is set to expanded value and continue with the next expanded property.
				result.insert(alias.unwrap(), index_entry.into());
			}
		}

		if let Some(graph_entry) = node.graph_entry() {
			let graph_loc = location.object_entry("@graph");
			self.with_active_context(&active_context)
				.compact_property(
					env,
					&mut result,
					JsonLdTerm::Keyword(JsonLdKeyword::Graph),
					graph_entry.iter(),
					false,
					graph_loc,
				)
				.await?
		}

		for (expanded_property, expanded_value) in expanded_entries {
			let prop_loc = location.object_entry(expanded_property.as_str());
			self.with_active_context(&active_context)
				.compact_property(
					env,
					&mut result,
					expanded_property.clone().into(),
					expanded_value.iter(),
					false,
					prop_loc,
				)
				.await?
		}

		if let Some(included_entry) = node.included_entry() {
			let included_loc = location.object_entry("@included");
			self.with_active_context(&active_context)
				.compact_property(
					env,
					&mut result,
					JsonLdTerm::Keyword(JsonLdKeyword::Included),
					included_entry.iter(),
					false,
					included_loc,
				)
				.await?
		}

		Ok(result.into())
	}

	/// Compact the given list of types into the given `result` compacted object.
	fn compact_types(
		self,
		result: &mut JsonObject,
		types: Option<&BTreeIndexMultiSet<JsonLdLenient<Id>>>,
		location: JsonLdBacktraceBuilder<'_>,
	) -> Result<(), JsonLdLocatedError> {
		// If expanded property is @type:
		if let Some(types) = types
			&& !types.is_empty()
		{
			let type_loc = location.object_entry("@type");
			// If expanded value is a string,
			// then initialize compacted value by IRI compacting expanded value using
			// type-scoped context for active context.
			let compacted_value = if types.len() == 1 {
				optional_string(
					self.with_active_context(self.type_scoped_context)
						.compact_iri(
							&types[0].clone().into_term(),
							true,
							false,
							type_loc.array_index(0),
						)?,
				)
			} else {
				// Otherwise, expanded value must be a @type array:
				// Initialize compacted value to an empty array.
				let mut compacted_value = Vec::with_capacity(types.len());

				// For each item expanded type in expanded value:
				for (i, ty) in types.iter().enumerate() {
					let ty = ty.clone().into_term();

					// Set term by IRI compacting expanded type using type-scoped context for active context.
					let compacted_ty = self
						.with_active_context(self.type_scoped_context)
						.compact_iri(&ty, true, false, type_loc.array_index(i))?;

					// Append term, to compacted value.
					compacted_value.push(optional_string(compacted_ty))
				}

				JsonValue::Array(compacted_value.into_iter().collect())
			};

			// Initialize alias by IRI compacting expanded property.
			let alias = self
				.compact_iri(
					&JsonLdTerm::Keyword(JsonLdKeyword::Type),
					true,
					false,
					type_loc,
				)?
				.unwrap();

			// Initialize as array to true if processing mode is json-ld-1.1 and the
			// container mapping for alias in the active context includes @set,
			// otherwise to the negation of compactArrays.
			let container_mapping = match self.active_context.get(alias.as_str()) {
				Some(def) => def.container(),
				None => JsonLdContainer::Null,
			};
			let as_array = (self.options.processing_mode == JsonLdProcessingMode::JsonLd1_1
				&& container_mapping.contains(JsonLdContainerItem::Set))
				|| !self.options.compact_arrays;

			// Use add value to add compacted value to the alias entry in result using as array.
			add_value(result, &alias, compacted_value, as_array)
		}

		Ok(())
	}
}