module;

export module mean_field:surface.compiled;

export import :eos.pressure_surface;
export import :surface.constant;
export import :surface.dependencies;

export namespace mean_field::surface {
    template <
        eos::EquationOfStateModel EquationOfState,
        SurfaceConstraintFormulationType Formulation,
        eos::ThermodynamicRelationType SelectedRelation,
        typename Dependencies>
    class CompiledPressureSurfaceConstraint final {
    public:
        using PhysicalCondition   = ConstantPressureSurface;
        using PhysicalQuantity    = eos::quantity::Pressure;
        using CarrierQuantity     = typename Formulation::CarrierQuantity;
        using CarrierField        = typename Formulation::CarrierField;
        using Relation            = SelectedRelation;
        using SurfaceDependencies = Dependencies;

        CompiledPressureSurfaceConstraint(
            const ConstantPressureSurface condition,
            const EquationOfState &equationOfState
        ) noexcept
            : m_condition(condition),
              m_resolvedRelation(
                  equationOfState,
                  condition.targetPressure()
              ) {
        }

        [[nodiscard]] eos::PressureValue targetPressure() const noexcept {
            return m_condition.targetPressure();
        }

        [[nodiscard]] PressureSurfaceDescriptor descriptor() const noexcept {
            return m_condition.descriptor();
        }

        [[nodiscard]] static constexpr RuntimeSurfaceConstraintDependencies runtimeDependencies() noexcept {
            return SurfaceDependencies::runtimeDescription();
        }

        template <typename SurfaceState> [[nodiscard]] double residual(const SurfaceState &state) const {
            return state.value(CarrierQuantity{}).value() - m_resolvedRelation.requiredCarrierValue(state).value();
        }

        template <
            typename SurfaceState,
            typename SurfaceVariation>
        [[nodiscard]] double jacobianAction(
            const SurfaceState &state,
            const SurfaceVariation &variation
        ) const {
            return variation.value(CarrierQuantity{}).value() -
                   m_resolvedRelation.carrierCorrectionJacobianAction(state, variation);
        }

    private:
        ConstantPressureSurface m_condition;
        eos::ResolvedPressureSurfaceRelation<EquationOfState, Relation> m_resolvedRelation;
    };
} // namespace mean_field::surface