module;

#include <cmath>
#include <memory>
#include <mfem.hpp>
#include <stdexcept>
#include <utility>

module mean_field;
import :mapping.types;
import :mapping.compactification;
import :utils.user;

namespace {
    bool vector_is_finite(const mfem::Vector &vector) {
        for (int i = 0; i < vector.Size(); ++i) {
            if (!std::isfinite(vector(i)))
                return false;
        }
        return true;
    }

    bool matrix_is_finite(const mfem::DenseMatrix &matrix) {
        for (int i = 0; i < matrix.Height(); ++i) {
            for (int j = 0; j < matrix.Width(); ++j) {
                if (!std::isfinite(matrix(i, j)))
                    return false;
            }
        }
        return true;
    }
} // namespace

namespace mean_field::mapping {
    ElementCompactificationData::ElementCompactificationData(
        const mfem::FiniteElement &element,
        const mfem::Vector &dofs
    )
        : m_element(&element),
          m_dofs(dofs) {
        if (element.GetRangeType() != mfem::FiniteElement::SCALAR) {
            throw std::invalid_argument("Compactification coordinate requires a scalar finite element.");
        }

        if (element.GetMapType() != mfem::FiniteElement::VALUE) {
            throw std::invalid_argument(
                "Compactification coordinate requires a value-mapped scalar "
                "finite "
                "element."
            );
        }

        if (element.GetDerivType() != mfem::FiniteElement::GRAD) {
            throw std::invalid_argument(
                "Compactification coordinate finite element must provide a "
                "gradient."
            );
        }

        if (element.GetDof() <= 0) {
            throw std::invalid_argument(
                "Compactification coordinate finite element has no degrees of "
                "freedom."
            );
        }

        if (dofs.Size() != element.GetDof()) {
            throw std::invalid_argument(
                "Compactification coordinate DOF count does not match its "
                "finite "
                "element."
            );
        }
    }

    const mfem::FiniteElement &ElementCompactificationData::GetElement() const noexcept {
        return *m_element;
    }

    const mfem::Vector &ElementCompactificationData::GetDofs() const noexcept {
        return m_dofs;
    }

    int ElementCompactificationData::GetDofCount() const noexcept {
        return m_dofs.Size();
    }

    ElementDisplacementData::ElementDisplacementData(
        const mfem::FiniteElement &element,
        const mfem::Vector &displacement_dofs,
        const mfem::Ordering::Type ordering
    )
        : m_element(&element),
          m_dimension(0),
          m_ordering(ordering) {
        const int dof_count = element.GetDof();
        if (dof_count <= 0)
            throw std::invalid_argument(
                "The displacement element must have at least one degree of "
                "freedom."
            );
        if (displacement_dofs.Size() <= 0 || displacement_dofs.Size() % dof_count != 0) {
            throw std::invalid_argument(
                "The displacement vector size must be a positive multiple of "
                "the "
                "element degree-of-freedom count."
            );
        }

        m_dimension = displacement_dofs.Size() / dof_count;
        m_dof_matrix.SetSize(dof_count, m_dimension);

        if (ordering == mfem::Ordering::byNODES) {
            for (int component = 0; component < m_dimension; ++component) {
                for (int i = 0; i < dof_count; ++i) {
                    m_dof_matrix(i, component) = displacement_dofs(i + component * dof_count);
                }
            }
        } else if (ordering == mfem::Ordering::byVDIM) {
            for (int i = 0; i < dof_count; ++i) {
                for (int component = 0; component < m_dimension; ++component) {
                    m_dof_matrix(i, component) = displacement_dofs(component + i * m_dimension);
                }
            }
        } else {
            throw std::invalid_argument("Unsupported MFEM displacement ordering.");
        }
    }

    const mfem::FiniteElement &ElementDisplacementData::GetElement() const noexcept {
        return *m_element;
    }

    const mfem::DenseMatrix &ElementDisplacementData::GetDofMatrix() const noexcept {
        return m_dof_matrix;
    }

    int ElementDisplacementData::GetDimension() const noexcept {
        return m_dimension;
    }

    int ElementDisplacementData::GetDofCount() const noexcept {
        return m_element->GetDof();
    }

    mfem::Ordering::Type ElementDisplacementData::GetOrdering() const noexcept {
        return m_ordering;
    }

    ElementDisplacementData ElementDisplacementDataFromElementVDofs(
        const mfem::FiniteElement &element,
        const mfem::Vector &displacement_dofs
    ) {
        return ElementDisplacementData(element, displacement_dofs, mfem::Ordering::byNODES);
    }

    DomainMapper::Workspace::Workspace(const int dimension) {
        SetDimension(dimension);
    }

    void DomainMapper::Workspace::SetDimension(const int dimension) {
        if (dimension <= 0) {
            throw std::invalid_argument("Domain mapping workspace dimension must be positive.");
        }

        m_dimension = dimension;

        m_field_value.SetSize(dimension);
        m_field_jacobian.SetSize(dimension, dimension);

        m_compactification_point.coordinate = 0.0;
        m_compactification_point.coordinate_gradient.SetSize(dimension);

        m_reference_normal.SetSize(dimension);
        m_mapped_normal.SetSize(dimension);
        m_full_element_jacobian.SetSize(dimension, dimension);

        m_vector_temp.SetSize(dimension);
        m_matrix_temp_1.SetSize(dimension, dimension);
        m_matrix_temp_2.SetSize(dimension, dimension);

        m_exterior_result.physical_position.SetSize(dimension);
        m_exterior_result.mapping_jacobian.SetSize(dimension, dimension);

        m_exterior_variation.physical_position_variation.SetSize(dimension);
        m_exterior_variation.mapping_jacobian_variation.SetSize(dimension, dimension);
    }

    int DomainMapper::Workspace::GetDimension() const noexcept {
        return m_dimension;
    }

    DomainMapper::DomainMapper(
        const utils::DomainMapperOptions options,
        std::unique_ptr<const compactification::ExteriorDomainMap> exterior_map
    )
        : m_options(options),
          m_exterior_map(std::move(exterior_map)) {
        if (m_options.dimension <= 0)
            throw std::invalid_argument("The domain-mapping dimension must be positive.");
        if (m_options.vacuum_element_attribute <= 0)
            throw std::invalid_argument("The vacuum element attribute must be positive.");
        if (!m_exterior_map)
            throw std::invalid_argument("DomainMapper requires an exterior-domain mapping.");
    }

    bool DomainMapper::IsCompactifiedElement(const mfem::ElementTransformation &transformation) const noexcept {
        return transformation.Attribute == m_options.vacuum_element_attribute;
    }

    int DomainMapper::GetDimension() const noexcept {
        return m_options.dimension;
    }

    const compactification::ExteriorDomainMap &DomainMapper::GetExteriorMap() const noexcept {
        return *m_exterior_map;
    }

    GridFunctionMappingEvaluator::GridFunctionMappingEvaluator(
        const DomainMapper &mapper,
        const mfem::GridFunction &displacement,
        const mfem::GridFunction &compactification_coordinate
    )
        : m_mapper(mapper),
          m_displacement(displacement),
          m_compactification_coordinate(compactification_coordinate),
          m_displacement_space(displacement.FESpace()),
          m_compactification_space(compactification_coordinate.FESpace()),
          m_displacement_space_sequence(m_displacement_space != nullptr ? m_displacement_space->GetSequence() : -1),
          m_compactification_space_sequence(
              m_compactification_space != nullptr ? m_compactification_space->GetSequence() : -1
          ),
          m_workspace(mapper.GetDimension()) {
        if (m_displacement_space == nullptr) {
            throw std::invalid_argument("Grid-function mapping requires a displacement finite-element space.");
        }
        if (m_compactification_space == nullptr) {
            throw std::invalid_argument(
                "Grid-function mapping requires a compactification finite-element "
                "space."
            );
        }
        if (m_displacement_space->GetMesh() != m_compactification_space->GetMesh()) {
            throw std::invalid_argument("Grid-function mapping fields must use the same mesh.");
        }
        if (m_displacement.VectorDim() != mapper.GetDimension()) {
            throw std::invalid_argument("The displacement dimension does not match the domain mapper.");
        }
        if (m_compactification_coordinate.VectorDim() != 1) {
            throw std::invalid_argument("The compactification coordinate must be a scalar grid function.");
        }
        if (m_displacement_space->GetMesh()->SpaceDimension() != mapper.GetDimension()) {
            throw std::invalid_argument("The mapping dimension does not match the mesh space dimension.");
        }
    }

    void GridFunctionMappingEvaluator::InvalidateCache() noexcept {
        m_displacement_data.reset();
        m_compactification_data.reset();
        m_cached_element_id = -1;
    }

    void GridFunctionMappingEvaluator::ValidateFieldBindings() const {
        if (m_displacement.FESpace() != m_displacement_space) {
            throw std::invalid_argument(
                "The displacement grid function was rebound after construction of "
                "its mapping evaluator."
            );
        }
        if (m_compactification_coordinate.FESpace() != m_compactification_space) {
            throw std::invalid_argument(
                "The compactification grid function was rebound after construction "
                "of its mapping evaluator."
            );
        }
    }

    bool GridFunctionMappingEvaluator::InvalidateForChangedSpaces() {
        const long displacement_sequence     = m_displacement_space->GetSequence();
        const long compactification_sequence = m_compactification_space->GetSequence();

        if (displacement_sequence == m_displacement_space_sequence &&
            compactification_sequence == m_compactification_space_sequence) {
            return false;
        }

        InvalidateCache();
        m_displacement_space_sequence     = displacement_sequence;
        m_compactification_space_sequence = compactification_sequence;
        return true;
    }

    void GridFunctionMappingEvaluator::Refresh() {
        ValidateFieldBindings();

        if (InvalidateForChangedSpaces()) {
            return;
        }

        const int element_id = m_cached_element_id;
        InvalidateCache();

        if (element_id >= 0) {
            LoadElement(element_id);
        }
    }

    void GridFunctionMappingEvaluator::LoadElement(const int element_id) {
        ValidateFieldBindings();
        (void)InvalidateForChangedSpaces();

        if (element_id == m_cached_element_id) {
            return;
        }

        const mfem::FiniteElementSpace &displacement_space     = *m_displacement_space;
        const mfem::FiniteElementSpace &compactification_space = *m_compactification_space;

        MFEM_VERIFY(
            element_id >= 0 && element_id < displacement_space.GetMesh()->GetNE(),
            "Grid-function mapping received an invalid element ID."
        );

        mfem::DofTransformation *displacement_transformation =
            displacement_space.GetElementVDofs(element_id, m_displacement_dofs);
        compactification_space.GetElementDofs(element_id, m_compactification_dofs);

        m_displacement.GetSubVector(m_displacement_dofs, m_element_displacement);
        m_compactification_coordinate.GetSubVector(m_compactification_dofs, m_element_compactification);

        if (displacement_transformation != nullptr) {
            displacement_transformation->InvTransformPrimal(m_element_displacement);
        }

        const mfem::FiniteElement &displacement_element     = *displacement_space.GetFE(element_id);
        const mfem::FiniteElement &compactification_element = *compactification_space.GetFE(element_id);

        m_displacement_data                                 = std::make_unique<ElementDisplacementData>(
            ElementDisplacementDataFromElementVDofs(displacement_element, m_element_displacement)
        );
        m_compactification_data =
            std::make_unique<ElementCompactificationData>(compactification_element, m_element_compactification);
        m_cached_element_id = element_id;
    }

    MappingStatus GridFunctionMappingEvaluator::EvaluatePoint(
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        MappingPointContext &context
    ) {
        LoadElement(transformation.ElementNo);
        const ElementMappingData data{
            .displacement = *m_displacement_data, .compactification = *m_compactification_data
        };
        return m_mapper.EvaluatePoint(data, transformation, integration_point, m_workspace, context);
    }

    MappingStatus GridFunctionMappingEvaluator::EvaluateVolume(
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        VolumeMappingContext &context
    ) {
        LoadElement(transformation.ElementNo);
        const ElementMappingData data{
            .displacement = *m_displacement_data, .compactification = *m_compactification_data
        };
        return m_mapper.EvaluateVolume(data, transformation, integration_point, m_workspace, context);
    }

    MappingStatus GridFunctionMappingEvaluator::EvaluateFace(
        mfem::FaceElementTransformations &transformation,
        const FaceElementSide side,
        const mfem::IntegrationPoint &integration_point,
        FaceMappingContext &context
    ) {
        mfem::ElementTransformation *element_transformation =
            side == FaceElementSide::element_1 ? transformation.Elem1 : transformation.Elem2;
        MFEM_VERIFY(element_transformation != nullptr, "Grid-function face mapping requires the requested element.");
        LoadElement(element_transformation->ElementNo);
        const ElementMappingData data{
            .displacement = *m_displacement_data, .compactification = *m_compactification_data
        };
        return m_mapper.EvaluateFace(data, transformation, side, integration_point, m_workspace, context);
    }

    VolumeQuadratureContext GridFunctionMappingEvaluator::GetQuadratureContext(
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point
    ) {
        VolumeMappingContext context;
        MFEM_VERIFY(
            EvaluateVolume(transformation, integration_point, context) == MappingStatus::valid,
            "Volume quadrature encountered an invalid domain mapping."
        );
        return context.quadrature;
    }

    FaceQuadratureContext GridFunctionMappingEvaluator::GetFaceQuadratureContext(
        mfem::FaceElementTransformations &transformation,
        const mfem::IntegrationPoint &integration_point,
        const FaceElementSide side
    ) {
        FaceMappingContext context;
        MFEM_VERIFY(
            EvaluateFace(transformation, side, integration_point, context) == MappingStatus::valid,
            "Face quadrature encountered an invalid domain mapping."
        );
        return context.quadrature;
    }

    void GridFunctionMappingEvaluator::GetPhysicalPoint(
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        mfem::Vector &physical_position
    ) {
        MappingPointContext context;
        MFEM_VERIFY(
            EvaluatePoint(transformation, integration_point, context) == MappingStatus::valid,
            "Physical-point evaluation encountered an invalid domain "
            "mapping."
        );
        physical_position = context.physical_position;
    }

    void DomainMapper::ValidateElementData(const ElementMappingData &element_data) const {
        const ElementDisplacementData &displacement         = element_data.displacement;
        const ElementCompactificationData &compactification = element_data.compactification;

        if (displacement.GetDimension() != m_options.dimension) {
            throw std::invalid_argument(
                "Displacement field dimension does not match the domain mapper "
                "dimension."
            );
        }

        if (displacement.GetElement().GetDim() != m_options.dimension) {
            throw std::invalid_argument(
                "Displacement finite element dimension does not match the "
                "domain "
                "mapper dimension."
            );
        }

        if (compactification.GetElement().GetDim() != m_options.dimension) {
            throw std::invalid_argument(
                "Compactification finite element dimension does not match the "
                "domain "
                "mapper dimension."
            );
        }

        if (displacement.GetElement().GetGeomType() != compactification.GetElement().GetGeomType()) {
            throw std::invalid_argument(
                "Displacement and compactification finite elements have "
                "different "
                "geometries."
            );
        }

        if (compactification.GetElement().GetRangeType() != mfem::FiniteElement::SCALAR) {
            throw std::invalid_argument("Compactification coordinate requires a scalar finite element.");
        }

        if (compactification.GetElement().GetMapType() != mfem::FiniteElement::VALUE) {
            throw std::invalid_argument(
                "Compactification coordinate requires a value-mapped finite "
                "element."
            );
        }

        if (compactification.GetElement().GetDerivType() != mfem::FiniteElement::GRAD) {
            throw std::invalid_argument(
                "Compactification coordinate finite element does not provide a "
                "gradient."
            );
        }

        if (compactification.GetDofCount() != compactification.GetElement().GetDof()) {
            throw std::invalid_argument(
                "Compactification coordinate DOF count does not match its "
                "finite "
                "element."
            );
        }
    }

    MappingStatus DomainMapper::EvaluateCompactificationCoordinate(
        const ElementCompactificationData &compactification,
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        Workspace &workspace,
        CompactificationPointData &point_data
    ) const {
        const mfem::FiniteElement &element = compactification.GetElement();
        const mfem::Vector &dofs           = compactification.GetDofs();
        const int dof_count                = element.GetDof();

        if (workspace.GetDimension() != m_options.dimension || transformation.GetSpaceDim() != m_options.dimension ||
            element.GetDim() != m_options.dimension) {
            return MappingStatus::invalid_dimension;
        }

        if (dofs.Size() != dof_count) {
            return MappingStatus::invalid_dimension;
        }

        for (int i = 0; i < dofs.Size(); ++i) {
            if (!std::isfinite(dofs(i)))
                return MappingStatus::non_finite_input;
        }

        transformation.SetIntPoint(&integration_point);

        workspace.m_compactification_shape.SetSize(dof_count);
        workspace.m_compactification_dshape.SetSize(dof_count, m_options.dimension);

        element.CalcShape(integration_point, workspace.m_compactification_shape);
        element.CalcPhysDShape(transformation, workspace.m_compactification_dshape);

        point_data.coordinate = dofs * workspace.m_compactification_shape;
        point_data.coordinate_gradient.SetSize(m_options.dimension);
        workspace.m_compactification_dshape.MultTranspose(dofs, point_data.coordinate_gradient);

        if (!std::isfinite(point_data.coordinate)) {
            return MappingStatus::non_finite_result;
        }

        for (int d = 0; d < point_data.coordinate_gradient.Size(); ++d) {
            if (!std::isfinite(point_data.coordinate_gradient(d)))
                return MappingStatus::non_finite_result;
        }

        return MappingStatus::valid;
    }

    void DomainMapper::EvaluateField(
        const ElementDisplacementData &field,
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        Workspace &workspace,
        mfem::Vector &value,
        mfem::DenseMatrix &jacobian
    ) const {
        transformation.SetIntPoint(&integration_point);

        const mfem::FiniteElement &element  = field.GetElement();
        const mfem::DenseMatrix &dof_matrix = field.GetDofMatrix();

        workspace.m_shape.SetSize(element.GetDof());
        workspace.m_mesh_dshape.SetSize(element.GetDof(), m_options.dimension);

        element.CalcShape(integration_point, workspace.m_shape);
        element.CalcPhysDShape(transformation, workspace.m_mesh_dshape);

        value.SetSize(m_options.dimension);
        dof_matrix.MultTranspose(workspace.m_shape, value);

        jacobian.SetSize(m_options.dimension, m_options.dimension);
        mfem::MultAtB(dof_matrix, workspace.m_mesh_dshape, jacobian);
    }

    MappingStatus DomainMapper::EvaluatePoint(
        const ElementMappingData &element_data,
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        Workspace &workspace,
        MappingPointContext &context
    ) const {
        ValidateElementData(element_data);

        if (workspace.GetDimension() != m_options.dimension)
            throw std::invalid_argument("The mapping workspace has the wrong dimension.");
        if (transformation.GetSpaceDim() != m_options.dimension)
            throw std::invalid_argument("The element transformation has the wrong spatial dimension.");
        if (transformation.GetGeometryType() != element_data.displacement.GetElement().GetGeomType())
            throw std::invalid_argument(
                "The element transformation geometry does not match the "
                "supplied "
                "element data."
            );

        transformation.SetIntPoint(&integration_point);

        context.reference_position.SetSize(m_options.dimension);
        transformation.Transform(integration_point, context.reference_position);

        EvaluateField(
            element_data.displacement, transformation, integration_point, workspace, workspace.m_field_value,
            workspace.m_field_jacobian
        );

        if (!vector_is_finite(context.reference_position) || !vector_is_finite(workspace.m_field_value) ||
            !matrix_is_finite(workspace.m_field_jacobian)) {
            return MappingStatus::non_finite_input;
        }

        context.displaced_position.SetSize(m_options.dimension);
        context.displaced_position = context.reference_position;
        context.displaced_position += workspace.m_field_value;

        context.displacement_jacobian.SetSize(m_options.dimension, m_options.dimension);
        context.displacement_jacobian = workspace.m_field_jacobian;
        for (int i = 0; i < m_options.dimension; ++i)
            context.displacement_jacobian(i, i) += 1.0;

        context.compactified = IsCompactifiedElement(transformation);

        if (context.compactified) {
            const MappingStatus coordinate_status = EvaluateCompactificationCoordinate(
                element_data.compactification, transformation, integration_point, workspace,
                workspace.m_compactification_point
            );

            if (coordinate_status != MappingStatus::valid)
                return coordinate_status;

            const compactification::ExteriorMapInput exterior_input{
                .reference_position                   = context.reference_position,
                .displaced_position                   = context.displaced_position,
                .displacement_jacobian                = context.displacement_jacobian,
                .compactification_coordinate          = workspace.m_compactification_point.coordinate,
                .compactification_coordinate_gradient = workspace.m_compactification_point.coordinate_gradient
            };

            const MappingStatus exterior_status = m_exterior_map->Evaluate(exterior_input, workspace.m_exterior_result);
            if (exterior_status != MappingStatus::valid)
                return exterior_status;

            context.physical_position = workspace.m_exterior_result.physical_position;
            context.mapping_jacobian  = workspace.m_exterior_result.mapping_jacobian;
        } else {
            context.physical_position = context.displaced_position;
            context.mapping_jacobian  = context.displacement_jacobian;
        }

        if (!vector_is_finite(context.physical_position) || !matrix_is_finite(context.mapping_jacobian))
            return MappingStatus::non_finite_result;

        context.mapping_determinant = context.mapping_jacobian.Det();
        if (!std::isfinite(context.mapping_determinant))
            return MappingStatus::non_finite_result;
        if (context.mapping_determinant <= 0.0)
            return MappingStatus::non_positive_determinant;

        context.inverse_mapping_jacobian.SetSize(m_options.dimension, m_options.dimension);
        mfem::CalcInverse(context.mapping_jacobian, context.inverse_mapping_jacobian);

        if (!matrix_is_finite(context.inverse_mapping_jacobian))
            return MappingStatus::non_finite_result;

        return MappingStatus::valid;
    }

    MappingStatus DomainMapper::EvaluateVolume(
        const ElementMappingData &element_data,
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        Workspace &workspace,
        VolumeMappingContext &context
    ) const {
        const MappingStatus point_status =
            EvaluatePoint(element_data, transformation, integration_point, workspace, context.mapping);
        if (point_status != MappingStatus::valid)
            return point_status;

        transformation.SetIntPoint(&integration_point);
        mfem::Mult(context.mapping.mapping_jacobian, transformation.Jacobian(), workspace.m_full_element_jacobian);

        context.quadrature.J_inv.SetSize(m_options.dimension, m_options.dimension);
        mfem::CalcInverse(workspace.m_full_element_jacobian, context.quadrature.J_inv);

        context.quadrature.detJ = context.mapping.mapping_determinant;
        context.quadrature.weight =
            integration_point.weight * transformation.Weight() * context.mapping.mapping_determinant;

        if (!matrix_is_finite(context.quadrature.J_inv) || !std::isfinite(context.quadrature.weight))
            return MappingStatus::non_finite_result;
        if (context.quadrature.weight <= 0.0)
            return MappingStatus::non_positive_determinant;

        return MappingStatus::valid;
    }

    mfem::ElementTransformation &DomainMapper::SelectFaceElementTransformation(
        mfem::FaceElementTransformations &transformation,
        const FaceElementSide side
    ) {
        if (side == FaceElementSide::element_1) {
            MFEM_VERIFY(transformation.Elem1 != nullptr, "The face does not have an element-1 transformation.");
            return *transformation.Elem1;
        }

        MFEM_VERIFY(transformation.Elem2 != nullptr, "The face does not have an element-2 transformation.");
        return *transformation.Elem2;
    }

    const mfem::IntegrationPoint &DomainMapper::SelectFaceElementIntegrationPoint(
        mfem::FaceElementTransformations &transformation,
        const FaceElementSide side
    ) {
        mfem::ElementTransformation &element_transformation = SelectFaceElementTransformation(transformation, side);
        return element_transformation.GetIntPoint();
    }

    MappingStatus DomainMapper::EvaluateFace(
        const ElementMappingData &element_data,
        mfem::FaceElementTransformations &transformation,
        const FaceElementSide side,
        const mfem::IntegrationPoint &integration_point,
        Workspace &workspace,
        FaceMappingContext &context
    ) const {
        transformation.SetAllIntPoints(&integration_point);
        mfem::ElementTransformation &element_transformation = SelectFaceElementTransformation(transformation, side);
        const mfem::IntegrationPoint &element_integration_point =
            SelectFaceElementIntegrationPoint(transformation, side);

        const MappingStatus point_status =
            EvaluatePoint(element_data, element_transformation, element_integration_point, workspace, context.mapping);
        if (point_status != MappingStatus::valid)
            return point_status;

        workspace.m_reference_normal.SetSize(m_options.dimension);
        mfem::CalcOrtho(transformation.Jacobian(), workspace.m_reference_normal);
        if (side == FaceElementSide::element_2)
            workspace.m_reference_normal *= -1.0;

        const double reference_normal_magnitude = workspace.m_reference_normal.Norml2();
        if (!std::isfinite(reference_normal_magnitude) || reference_normal_magnitude <= 0.0)
            return MappingStatus::non_finite_result;

        context.reference_normal.SetSize(m_options.dimension);
        context.reference_normal = workspace.m_reference_normal;
        context.reference_normal /= reference_normal_magnitude;

        context.mapping.inverse_mapping_jacobian.MultTranspose(workspace.m_reference_normal, workspace.m_mapped_normal);
        workspace.m_mapped_normal *= context.mapping.mapping_determinant;

        const double mapped_normal_magnitude = workspace.m_mapped_normal.Norml2();
        if (!std::isfinite(mapped_normal_magnitude) || mapped_normal_magnitude <= 0.0)
            return MappingStatus::non_finite_result;

        context.quadrature.normal.SetSize(m_options.dimension);
        context.quadrature.normal = workspace.m_mapped_normal;
        context.quadrature.normal /= mapped_normal_magnitude;

        context.reference_surface_weight = integration_point.weight * reference_normal_magnitude;
        context.physical_surface_weight  = integration_point.weight * mapped_normal_magnitude;

        context.quadrature.ds            = context.reference_surface_weight;
        context.quadrature.v_dot_n_scale = mapped_normal_magnitude / reference_normal_magnitude;

        if (!vector_is_finite(context.quadrature.normal) || !std::isfinite(context.reference_surface_weight) ||
            !std::isfinite(context.physical_surface_weight) || !std::isfinite(context.quadrature.v_dot_n_scale)) {
            return MappingStatus::non_finite_result;
        }

        return MappingStatus::valid;
    }

    MappingStatus DomainMapper::EvaluatePointVariation(
        const ElementMappingData &element_data,
        const ElementDisplacementData &direction,
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        const MappingPointContext &base_context,
        Workspace &workspace,
        MappingPointVariation &variation
    ) const {
        ValidateElementData(element_data);
        const ElementMappingData direction_data{
            .displacement = direction, .compactification = element_data.compactification
        };
        ValidateElementData(direction_data);

        if (element_data.displacement.GetDofCount() != direction.GetDofCount())
            throw std::invalid_argument(
                "The displacement and direction elements have different "
                "degree-of-freedom counts."
            );
        if (workspace.GetDimension() != m_options.dimension)
            throw std::invalid_argument("The mapping workspace has the wrong dimension.");
        if (base_context.compactified != IsCompactifiedElement(transformation))
            throw std::invalid_argument(
                "The base mapping context does not match the current element "
                "domain."
            );

        EvaluateField(
            direction, transformation, integration_point, workspace, workspace.m_field_value, workspace.m_field_jacobian
        );

        if (!vector_is_finite(workspace.m_field_value) || !matrix_is_finite(workspace.m_field_jacobian))
            return MappingStatus::non_finite_input;

        variation.displacement_variation          = workspace.m_field_value;
        variation.displacement_jacobian_variation = workspace.m_field_jacobian;

        if (base_context.compactified) {
            const MappingStatus coordinate_status = EvaluateCompactificationCoordinate(
                element_data.compactification, transformation, integration_point, workspace,
                workspace.m_compactification_point
            );

            if (coordinate_status != MappingStatus::valid)
                return coordinate_status;

            const compactification::ExteriorMapInput exterior_input{
                .reference_position                   = base_context.reference_position,
                .displaced_position                   = base_context.displaced_position,
                .displacement_jacobian                = base_context.displacement_jacobian,
                .compactification_coordinate          = workspace.m_compactification_point.coordinate,
                .compactification_coordinate_gradient = workspace.m_compactification_point.coordinate_gradient
            };

            workspace.m_exterior_result.physical_position = base_context.physical_position;
            workspace.m_exterior_result.mapping_jacobian  = base_context.mapping_jacobian;

            const compactification::ExteriorMapDirection exterior_direction{
                .displaced_position_variation    = variation.displacement_variation,
                .displacement_jacobian_variation = variation.displacement_jacobian_variation
            };

            // ReSharper disable once CppTooWideScopeInitStatement
            const MappingStatus exterior_status = m_exterior_map->EvaluateVariation(
                exterior_input, workspace.m_exterior_result, exterior_direction, workspace.m_exterior_variation
            );

            if (exterior_status != MappingStatus::valid) {
                return exterior_status;
            }

            variation.physical_position_variation = workspace.m_exterior_variation.physical_position_variation;
            variation.mapping_jacobian_variation  = workspace.m_exterior_variation.mapping_jacobian_variation;
        } else {
            variation.physical_position_variation = variation.displacement_variation;
            variation.mapping_jacobian_variation  = variation.displacement_jacobian_variation;
        }

        mfem::Mult(
            base_context.inverse_mapping_jacobian, variation.mapping_jacobian_variation, workspace.m_matrix_temp_1
        );

        double trace = 0.0;
        for (int i = 0; i < m_options.dimension; ++i)
            trace += workspace.m_matrix_temp_1(i, i);
        variation.mapping_determinant_variation = base_context.mapping_determinant * trace;

        variation.inverse_mapping_jacobian_variation.SetSize(m_options.dimension, m_options.dimension);
        mfem::Mult(
            workspace.m_matrix_temp_1, base_context.inverse_mapping_jacobian,
            variation.inverse_mapping_jacobian_variation
        );
        variation.inverse_mapping_jacobian_variation *= -1.0;

        if (!vector_is_finite(variation.physical_position_variation) ||
            !matrix_is_finite(variation.mapping_jacobian_variation) ||
            !matrix_is_finite(variation.inverse_mapping_jacobian_variation) ||
            !std::isfinite(variation.mapping_determinant_variation)) {
            return MappingStatus::non_finite_result;
        }

        return MappingStatus::valid;
    }

    MappingStatus DomainMapper::EvaluateVolumeVariation(
        const ElementMappingData &element_data,
        const ElementDisplacementData &direction,
        mfem::ElementTransformation &transformation,
        const mfem::IntegrationPoint &integration_point,
        const VolumeMappingContext &base_context,
        Workspace &workspace,
        VolumeMappingVariation &variation
    ) const {
        const MappingStatus point_status = EvaluatePointVariation(
            element_data, direction, transformation, integration_point, base_context.mapping, workspace,
            variation.mapping
        );
        if (point_status != MappingStatus::valid)
            return point_status;

        transformation.SetIntPoint(&integration_point);
        mfem::Mult(
            variation.mapping.mapping_jacobian_variation, transformation.Jacobian(), workspace.m_full_element_jacobian
        );
        mfem::Mult(base_context.quadrature.J_inv, workspace.m_full_element_jacobian, workspace.m_matrix_temp_1);

        variation.inverse_element_jacobian_variation.SetSize(m_options.dimension, m_options.dimension);
        mfem::Mult(
            workspace.m_matrix_temp_1, base_context.quadrature.J_inv, variation.inverse_element_jacobian_variation
        );
        variation.inverse_element_jacobian_variation *= -1.0;

        variation.weight_variation =
            integration_point.weight * transformation.Weight() * variation.mapping.mapping_determinant_variation;

        if (!matrix_is_finite(variation.inverse_element_jacobian_variation) ||
            !std::isfinite(variation.weight_variation))
            return MappingStatus::non_finite_result;

        return MappingStatus::valid;
    }

    MappingStatus DomainMapper::EvaluateFaceVariation(
        const ElementMappingData &element_data,
        const ElementDisplacementData &direction,
        mfem::FaceElementTransformations &transformation,
        const FaceElementSide side,
        const mfem::IntegrationPoint &integration_point,
        const FaceMappingContext &base_context,
        Workspace &workspace,
        FaceMappingVariation &variation
    ) const {
        transformation.SetAllIntPoints(&integration_point);
        mfem::ElementTransformation &element_transformation = SelectFaceElementTransformation(transformation, side);
        const mfem::IntegrationPoint &element_integration_point =
            SelectFaceElementIntegrationPoint(transformation, side);

        const MappingStatus point_status = EvaluatePointVariation(
            element_data, direction, element_transformation, element_integration_point, base_context.mapping, workspace,
            variation.mapping
        );
        if (point_status != MappingStatus::valid)
            return point_status;

        workspace.m_reference_normal.SetSize(m_options.dimension);
        mfem::CalcOrtho(transformation.Jacobian(), workspace.m_reference_normal);
        if (side == FaceElementSide::element_2)
            workspace.m_reference_normal *= -1.0;

        const double reference_normal_magnitude = workspace.m_reference_normal.Norml2();
        if (!std::isfinite(reference_normal_magnitude) || reference_normal_magnitude <= 0.0)
            return MappingStatus::non_finite_result;

        base_context.mapping.inverse_mapping_jacobian.MultTranspose(
            workspace.m_reference_normal, workspace.m_vector_temp
        );
        workspace.m_mapped_normal = workspace.m_vector_temp;
        workspace.m_mapped_normal *= base_context.mapping.mapping_determinant;

        variation.physical_normal_variation.SetSize(m_options.dimension);
        variation.mapping.inverse_mapping_jacobian_variation.MultTranspose(
            workspace.m_reference_normal, variation.physical_normal_variation
        );
        variation.physical_normal_variation *= base_context.mapping.mapping_determinant;
        variation.physical_normal_variation.Add(
            variation.mapping.mapping_determinant_variation, workspace.m_vector_temp
        );

        const double mapped_normal_magnitude = workspace.m_mapped_normal.Norml2();
        if (!std::isfinite(mapped_normal_magnitude) || mapped_normal_magnitude <= 0.0)
            return MappingStatus::non_finite_result;

        const double mapped_normal_magnitude_variation =
            base_context.quadrature.normal * variation.physical_normal_variation;

        variation.physical_normal_variation.Add(-mapped_normal_magnitude_variation, base_context.quadrature.normal);
        variation.physical_normal_variation /= mapped_normal_magnitude;

        variation.physical_surface_weight_variation = integration_point.weight * mapped_normal_magnitude_variation;
        variation.normal_flux_scale_variation       = mapped_normal_magnitude_variation / reference_normal_magnitude;

        if (!vector_is_finite(variation.physical_normal_variation) ||
            !std::isfinite(variation.physical_surface_weight_variation) ||
            !std::isfinite(variation.normal_flux_scale_variation)) {
            return MappingStatus::non_finite_result;
        }

        return MappingStatus::valid;
    }
} // namespace mean_field::mapping