module;

#include <cmath>
#include <format>
#include <stdexcept>
#include <type_traits>

export module mean_field:surface.constant;

export import :dimensions.quantities;

export namespace mean_field::surface {
    struct PressureSurfaceDescriptor final {
        double targetPressure;
    };

    /*
     * The only physical surface condition currently supported by
     * MeanField. It says nothing about which thermodynamic variable appears
     * in a nonlinear state vector; resolving pressure into that representation
     * is an EOS responsibility.
     */
    class ConstantPressureSurface final {
    public:
        struct Parameters final {
            dimensions::PressureValue Psurf;
        };

        using PhysicalQuantity = dimensions::quantity::Pressure;
        using TargetValue      = dimensions::PressureValue;

        explicit ConstantPressureSurface(const Parameters parameters) : ConstantPressureSurface(parameters.Psurf) {
        }

        explicit ConstantPressureSurface(const TargetValue targetPressure) : m_targetPressure(targetPressure) {
            if (!std::isfinite(targetPressure.value())) {
                throw std::invalid_argument(
                    std::format(
                        "The target surface pressure must be finite. Instead P = {} was provided.",
                        targetPressure.value()
                    )
                );
            }
            if (targetPressure.value() < 0.0) {
                throw std::invalid_argument(
                    std::format(
                        "The target surface pressure must be non-negative. Instead P = {} was provided.",
                        targetPressure.value()
                    )
                );
            }
        }

        [[nodiscard]] TargetValue targetPressure() const noexcept {
            return m_targetPressure;
        }

        [[nodiscard]] PressureSurfaceDescriptor descriptor() const noexcept {
            return PressureSurfaceDescriptor{.targetPressure = m_targetPressure.value()};
        }

    private:
        TargetValue m_targetPressure;
    };

    template <typename Candidate>
    concept ConstantPressureSurfaceType = std::same_as<std::remove_cvref_t<Candidate>, ConstantPressureSurface>;

    // Familiar physical terminology retained as a synonym, not as a second
    // surface-condition type.
    using Isobaric                      = ConstantPressureSurface;
} // namespace mean_field::surface