module;

#include <concepts>
#include <type_traits>

#include <mfem.hpp>

export module mean_field:deformation.vacuum_extension;

export import :deformation.descriptors;

export namespace mean_field::deformation {
    template <typename Candidate>
    concept PreparedVacuumDeformationExtension = requires(
        const std::remove_cvref_t<Candidate> &preparedExtension,
        const mfem::Vector &surfaceDisplacement,
        const mfem::Vector &surfaceDisplacementDirection,
        const mfem::Vector &vacuumDisplacementDual,
        mfem::Vector &vacuumDisplacement,
        mfem::Vector &surfaceDisplacementDual
    ) {
        { preparedExtension.descriptor() } noexcept -> std::same_as<VacuumDeformationExtensionDescriptor>;
        { preparedExtension.surfaceDisplacementSize() } noexcept -> std::same_as<int>;
        { preparedExtension.vacuumDisplacementSize() } noexcept -> std::same_as<int>;
        { preparedExtension.scalarTrueDofCount() } noexcept -> std::same_as<int>;
        { preparedExtension.hasVacuumSupport(0) } -> std::same_as<bool>;
        { preparedExtension.buildVacuumDisplacement(surfaceDisplacement, vacuumDisplacement) } -> std::same_as<void>;
        {
            preparedExtension.applyJacobian(surfaceDisplacement, surfaceDisplacementDirection, vacuumDisplacement)
        } -> std::same_as<void>;
        {
            preparedExtension.applyJacobianTranspose(
                surfaceDisplacement, vacuumDisplacementDual, surfaceDisplacementDual
            )
        } -> std::same_as<void>;
        {
            preparedExtension.applyPullbackDerivative(
                surfaceDisplacement, surfaceDisplacementDirection, vacuumDisplacementDual, surfaceDisplacementDual
            )
        } -> std::same_as<void>;
    };

    template <typename Candidate>
    concept VacuumDeformationExtension = requires(const std::remove_cvref_t<Candidate> &extension) {
        typename std::remove_cvref_t<Candidate>::PreparedType;
        requires PreparedVacuumDeformationExtension<typename std::remove_cvref_t<Candidate>::PreparedType>;
        { extension.descriptor() } noexcept -> std::same_as<VacuumDeformationExtensionDescriptor>;
        { extension.validate() } -> std::same_as<void>;
    };

    template <typename Extension, typename CompilationContext>
    concept VacuumDeformationExtensionCompilable =
        VacuumDeformationExtension<Extension> && requires(
                                                     const std::remove_cvref_t<Extension> &extension,
                                                     const std::remove_cvref_t<CompilationContext> &context
                                                 ) {
            {
                compileVacuumDeformationExtension(extension, context)
            } -> std::same_as<typename std::remove_cvref_t<Extension>::PreparedType>;
        };
} // namespace mean_field::deformation