module;

#include <concepts>
#include <cstddef>
#include <tuple>
#include <type_traits>

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

export namespace mean_field::eos {
    template <typename... Quantities> struct QuantityList final { };

    template <typename Output, typename... Inputs> struct Relation final {
        using OutputQuantity                    = Output;
        using InputQuantities                   = QuantityList<Inputs...>;

        static constexpr std::size_t inputCount = sizeof...(Inputs);
    };

    template <typename... Relations> struct RelationCatalog final {
        static constexpr std::size_t size = sizeof...(Relations);
    };

    namespace detail {
        template <typename... Types> struct TypesAreUnique;

        template <typename Candidate> struct IsThermodynamicRelation : std::false_type { };

        template <typename Output, typename... Inputs>
        struct IsThermodynamicRelation<Relation<Output, Inputs...>>
            : std::bool_constant<
                  ThermodynamicQuantityType<Output> && (ThermodynamicQuantityType<Inputs> && ...) &&
                  TypesAreUnique<Inputs...>::value> { };

        template <typename... Types> struct TypesAreUnique : std::true_type { };

        template <typename First, typename... Remaining>
        struct TypesAreUnique<First, Remaining...>
            : std::bool_constant<(!std::same_as<First, Remaining> && ...) && TypesAreUnique<Remaining...>::value> { };

        template <typename Candidate> struct IsValidRelationCatalog : std::false_type { };

        template <typename... Relations>
        struct IsValidRelationCatalog<RelationCatalog<Relations...>>
            : std::bool_constant<
                  (sizeof...(Relations) > 0) && (IsThermodynamicRelation<Relations>::value && ...) &&
                  TypesAreUnique<Relations...>::value> { };

        template <typename Catalog, typename RelationType> struct CatalogContainsRelation : std::false_type { };

        template <typename... Relations, typename RelationType>
        struct CatalogContainsRelation<RelationCatalog<Relations...>, RelationType>
            : std::bool_constant<(std::same_as<RelationType, Relations> || ...)> { };

        template <typename RelationType, typename Quantity> struct RelationContainsInput : std::false_type { };

        template <typename Output, typename... Inputs, typename Quantity>
        struct RelationContainsInput<Relation<Output, Inputs...>, Quantity>
            : std::bool_constant<(std::same_as<Quantity, Inputs> || ...)> { };

        template <std::size_t Index, typename Quantities> struct QuantityAt;

        template <std::size_t Index, typename... Quantities> struct QuantityAt<Index, QuantityList<Quantities...>> {
            using Type = std::tuple_element_t<Index, std::tuple<Quantities...>>;
        };
    } // namespace detail

    template <typename Candidate>
    concept ThermodynamicRelationType = detail::IsThermodynamicRelation<std::remove_cv_t<Candidate>>::value;

    template <typename Candidate>
    concept ValidRelationCatalog = detail::IsValidRelationCatalog<std::remove_cv_t<Candidate>>::value;

    template <typename Catalog, typename RelationType>
    inline constexpr bool relationCatalogContains =
        detail::CatalogContainsRelation<std::remove_cv_t<Catalog>, std::remove_cv_t<RelationType>>::value;

    template <typename RelationType, typename Quantity>
    inline constexpr bool relationContainsInput =
        detail::RelationContainsInput<std::remove_cv_t<RelationType>, std::remove_cv_t<Quantity>>::value;

    template <ThermodynamicRelationType RelationType> using RelationOutputT = typename RelationType::OutputQuantity;

    template <std::size_t Index, ThermodynamicRelationType RelationType>
    using RelationInputT      = typename detail::QuantityAt<Index, typename RelationType::InputQuantities>::Type;

    using PressureFromDensity = Relation<dimensions::quantity::Pressure, dimensions::quantity::Density>;
    using PressureFromSpecificEnthalpy =
        Relation<dimensions::quantity::Pressure, dimensions::quantity::SpecificEnthalpy>;
    using SpecificEnthalpyFromDensity = Relation<dimensions::quantity::SpecificEnthalpy, dimensions::quantity::Density>;
    using SpecificEnthalpyFromPressure =
        Relation<dimensions::quantity::SpecificEnthalpy, dimensions::quantity::Pressure>;
    using DensityFromSpecificEnthalpy = Relation<dimensions::quantity::Density, dimensions::quantity::SpecificEnthalpy>;
} // namespace mean_field::eos