module;

#include <concepts>
#include <type_traits>

export module mean_field:eos.concepts;
export import :eos.relations;

export namespace mean_field::eos {
    namespace detail {
        template <typename EquationOfState, typename RelationType> struct ImplementsRelation : std::false_type { };

        template <
            typename EquationOfState,
            typename Output,
            typename... Inputs>
            struct ImplementsRelation<
                EquationOfState,
                Relation<
                    Output,
                    Inputs...>> : std::bool_constant <
                                  requires(
                                      const std::remove_cvref_t<EquationOfState> &equationOfState,
                                      QuantityValue<Inputs>... inputValues
                                  ) {
            {equationOfState.evaluate(Relation<Output, Inputs...>{}, inputValues...)}
                ->std::same_as<QuantityValue<Output>>;
        }>{};

        template <typename EquationOfState, typename Catalog> struct ImplementsRelationCatalog : std::false_type { };

        template <typename EquationOfState, typename... Relations>
        struct ImplementsRelationCatalog<EquationOfState, RelationCatalog<Relations...>>
            : std::bool_constant<(ImplementsRelation<EquationOfState, Relations>::value && ...)> { };

        template <typename Candidate, typename = void> struct IsEquationOfStateModel : std::false_type { };

        template <typename Candidate>
        struct IsEquationOfStateModel<Candidate, std::void_t<typename std::remove_cvref_t<Candidate>::Relations>>
            : std::bool_constant<
                  ValidRelationCatalog<typename std::remove_cvref_t<Candidate>::Relations> &&
                  ImplementsRelationCatalog<
                      std::remove_cvref_t<Candidate>,
                      typename std::remove_cvref_t<Candidate>::Relations>::value> { };

        template <typename EquationOfState, typename RelationType, typename InputQuantity>
        struct ImplementsPartialDerivative : std::false_type { };

        template <
            typename EquationOfState,
            typename Output,
            typename... Inputs,
            typename InputQuantity>
                struct ImplementsPartialDerivative<
                    EquationOfState,
                    Relation<
                        Output,
                        Inputs...>,
                    InputQuantity> : std::bool_constant <
                                     (std::same_as<
                                          InputQuantity,
                                          Inputs> ||
                                      ...) &&
            requires(
                const std::remove_cvref_t<EquationOfState> &equationOfState,
                QuantityValue<Inputs>... inputValues
            ) {
            {equationOfState
                 .partialDerivative(Relation<Output, Inputs...>{}, WithRespectTo<InputQuantity>{}, inputValues...)}
                ->std::same_as<PartialDerivative<Output, InputQuantity>>;
        }>{};
    } // namespace detail

    template <typename Candidate>
    concept EquationOfStateModel = detail::IsEquationOfStateModel<Candidate>::value;

    template <typename EquationOfState, typename RelationType>
    concept SupportsRelation =
        EquationOfStateModel<EquationOfState> && ThermodynamicRelationType<RelationType> &&
        relationCatalogContains<typename std::remove_cvref_t<EquationOfState>::Relations, RelationType>;

    template <typename EquationOfState, typename RelationType, typename InputQuantity>
    concept SupportsPartialDerivative =
        SupportsRelation<EquationOfState, RelationType> && ThermodynamicQuantityType<InputQuantity> &&
        detail::ImplementsPartialDerivative<EquationOfState, RelationType, InputQuantity>::value;

    template <typename Candidate>
    concept StructureSeedEquationOfState =
        EquationOfStateModel<Candidate> && SupportsRelation<Candidate, SpecificEnthalpyFromDensity>;

    template <typename Candidate>
    concept BarotropicClosureEquationOfState =
        EquationOfStateModel<Candidate> && SupportsRelation<Candidate, DensityFromSpecificEnthalpy> &&
        SupportsPartialDerivative<Candidate, DensityFromSpecificEnthalpy, dimensions::quantity::SpecificEnthalpy>;

    template <typename Candidate>
    concept PressureForceEquationOfState =
        EquationOfStateModel<Candidate> && SupportsRelation<Candidate, PressureFromSpecificEnthalpy> &&
        SupportsPartialDerivative<Candidate, PressureFromSpecificEnthalpy, dimensions::quantity::SpecificEnthalpy>;
} // namespace mean_field::eos