#include "serif/equations/angular_momentum.hpp"
#include "serif/equations/barotropic_density.hpp"
#include "serif/equations/mass_normalization.hpp"
#include "serif/equations/primal_gravity.hpp"
#include "serif/equations/surface_potential.hpp"
#include "serif/eos/models/polytropic.hpp"
#include "serif/model/eos_reference.hpp"
#include "serif/model/execution_validation.hpp"
#include "serif/model/normalization/plan.hpp"
#include "serif/solver/normalization/computations.hpp"

namespace serif::compile_time_checks::barotropic_density {
    namespace blocks = discretization::blocks;
    namespace dependencies = utils::dependencies;
    namespace normalization = solver::normalization;

    /** @brief Declare only the mechanical EOS capabilities; no enthalpy, polytropic parameters, or curvature is available. */
    struct MechanicalBarotrope final {
        using Relations = eos::relations::RelationCatalog<eos::relations::PressureFromDensity,
            eos::relations::DensityFromPressure, eos::relations::PressurePotentialFromDensity>;
        /** @brief Declare pressure evaluation for capability checking without a runtime implementation. */
        dimensions::PressureValue evaluate(eos::relations::PressureFromDensity, dimensions::DensityValue) const;
        /** @brief Declare the prescribed-pressure surface density. */
        dimensions::DensityValue evaluate(eos::relations::DensityFromPressure, dimensions::PressureValue) const;
        /** @brief Declare the mechanical primitive independently of thermodynamic enthalpy. */
        dimensions::BarotropicPressurePotentialValue evaluate(eos::relations::PressurePotentialFromDensity, dimensions::DensityValue) const;
        /** @brief Declare the sole pressure derivative required by the local balance. */
        dimensions::PartialDerivative<dimensions::Pressure, dimensions::MassDensity> partial_derivative(
            eos::relations::PressureFromDensity, dimensions::WithRespectTo<dimensions::MassDensity>, dimensions::DensityValue) const;
    };

    using Balance = equations::BarotropicDensityBalance<MechanicalBarotrope>;
    using BorrowedBalance = equations::BarotropicDensityBalance<model::EosReference<MechanicalBarotrope>>;
    using Registry = equations::EquationRegistry<Balance, equations::PrimalPoissonBalance,
        equations::MassNormalization, equations::AngularMomentumConstraint>;
    using Description = model::EquilibriumEquations<Registry, equations::SurfacePotentialBalance, geometry::surface::Isobaric>;
    struct BoundDescription {
        using Description = barotropic_density::Description;
        using Plan = model::EquilibriumPlan<MechanicalBarotrope, Description>;
    };
    using Plan = BoundDescription::Plan;
    using Rules = model::normalization::PlanFor<normalization::AutomaticPlan, normalization::Dimensionless, BoundDescription>;

    static_assert(dimensions::ThermodynamicQuantityType<dimensions::BarotropicPressurePotential>);
    static_assert(!std::same_as<dimensions::BarotropicPressurePotential, dimensions::SpecificEnthalpy>);
    static_assert(eos::models::EOSSupportingRelation<eos::models::Polytrope, eos::relations::PressurePotentialFromDensity>);
    static_assert(eos::models::EOSModel<MechanicalBarotrope>);
    static_assert(!eos::models::EOSSupportingRelation<MechanicalBarotrope, eos::relations::SpecificEnthalpyFromDensity>);
    static_assert(!eos::models::EOSSupportingSecondPartialDerivative<MechanicalBarotrope,
        eos::relations::PressureFromDensity, dimensions::MassDensity, dimensions::MassDensity>);
    static_assert(operators::VolumeEquation<Balance>);
    static_assert(operators::VolumeEquation<BorrowedBalance>);
    static_assert(std::same_as<Balance::TestOperand, discretization::forms::Operand<blocks::density::mass>>);
    static_assert(std::same_as<Balance::ResidualQuantity, dimensions::BarotropicPressurePotential>);
    static_assert(model::ExecutableEquilibriumDescription<Description>);
    static_assert(Plan::has_shape && Plan::has_primal_gravity);
    static_assert(dependencies::key_count_v<Plan::Values> == 5);
    static_assert(dependencies::key_count_v<Plan::Residuals> == 5);
    static_assert(std::same_as<Plan::Surface::Formulation::CarrierTerm, blocks::density::mass>);
    static_assert(normalization::NormalizationPreparable<Rules, Plan::Layout>);
    static_assert(normalization::CompleteNormalizationFor<Rules, Plan::Values, Plan::Residuals>);
    static_assert(std::same_as<dependencies::bound_type_t<Rules::Residuals, blocks::density::mass>,
        normalization::WithPointRows<normalization::DimensionlessRieszCoordinate<dimensions::BarotropicPressurePotential,
            normalization::ReferenceVolumeMetric<blocks::density::mass>>, dimensions::MassDensity, model::normalization::SurfaceRows>>);
    static_assert(std::same_as<dependencies::bound_type_t<Rules::Values, blocks::density::mass>,
        normalization::DimensionlessRieszCoordinate<dimensions::MassDensity, normalization::ReferenceVolumeMetric<blocks::density::mass>>>);
}