module;

#include <cmath>
#include <stdexcept>

export module mean_field:surface.base;

export import :eos.base;

export namespace mean_field::surface {
    struct ResolvedSurfaceCondition final {
        double targetEnthalpy{0.0};

        explicit ResolvedSurfaceCondition(const double requestedTargetEnthalpy)
            : targetEnthalpy(requestedTargetEnthalpy) {
            if (!std::isfinite(targetEnthalpy) || targetEnthalpy < 0.0) {
                throw std::invalid_argument(
                    "A resolved surface enthalpy must be finite and "
                    "non-negative."
                );
            }
        }

        [[nodiscard]] double residual(const double enthalpy) const {
            if (!std::isfinite(enthalpy)) {
                throw std::invalid_argument("A surface enthalpy value must be finite.");
            }

            return enthalpy - targetEnthalpy;
        }

        [[nodiscard]] static double jacobianAction(const double enthalpyVariation) {
            if (!std::isfinite(enthalpyVariation)) {
                throw std::invalid_argument("A surface enthalpy variation must be finite.");
            }

            return enthalpyVariation;
        }
    };

    class SurfaceBase {
    public:
        virtual ~SurfaceBase() = default;

        [[nodiscard]] virtual ResolvedSurfaceCondition
        resolve(const mean_field::eos::EquationOfState &equationOfState) const               = 0;

        virtual void validate(const mean_field::eos::EquationOfState &equationOfState) const = 0;

    protected:
        SurfaceBase() = default;
    };
} // namespace mean_field::surface