module;

#include <concepts>
#include <type_traits>

export module mean_field:operators.stellar_equilibrium_compiler;

export import :model.compiled_fixed_angular_momentum;
export import :model.compiled_fixed_central_density;
export import :model.typed_stellar;
export import :utils.blocks;

export namespace mean_field::operators {
/*
 * A coupling is the symbolic statement that one Jacobian block may be
 * nonzero. Specifications contribute these statements independently of
 * the final row and column layout.
 */
template <typename ResidualBlock, typename ValueBlock>
struct StellarEquilibriumJacobianCoupling final {
  using Residual = ResidualBlock;
  using Value = ValueBlock;

  using ResidualBlockType = ResidualBlock;
  using ValueBlockType = ValueBlock;
};

template <typename ResidualBlock, typename ValueBlock>
using EquilibriumJacobianCoupling =
    StellarEquilibriumJacobianCoupling<ResidualBlock, ValueBlock>;

namespace detail {
template <typename... Lists> struct ConcatenateBlockLists;

template <> struct ConcatenateBlockLists<> {
  using Type = utils::blocks::type_list<>;
};

template <typename... Types>
struct ConcatenateBlockLists<utils::blocks::type_list<Types...>> {
  using Type = utils::blocks::type_list<Types...>;
};

template <typename... First, typename... Second, typename... Remaining>
struct ConcatenateBlockLists<utils::blocks::type_list<First...>,
                             utils::blocks::type_list<Second...>,
                             Remaining...> {
  using Type = typename ConcatenateBlockLists<
      utils::blocks::type_list<First..., Second...>, Remaining...>::Type;
};

template <typename... Lists>
using ConcatenateBlockListsT = typename ConcatenateBlockLists<Lists...>::Type;

template <typename List, typename Type> struct AppendUniqueBlockType;

template <typename... Types, typename Type>
struct AppendUniqueBlockType<utils::blocks::type_list<Types...>, Type> {
  using TypeValue = std::conditional_t<
      utils::blocks::contains_type_v<Type, utils::blocks::type_list<Types...>>,
      utils::blocks::type_list<Types...>,
      utils::blocks::type_list<Types..., Type>>;
};

template <typename Accumulated, typename Remaining> struct UniqueBlockListImpl;

template <typename Accumulated>
struct UniqueBlockListImpl<Accumulated, utils::blocks::type_list<>> {
  using Type = Accumulated;
};

template <typename Accumulated, typename Head, typename... Tail>
struct UniqueBlockListImpl<Accumulated,
                           utils::blocks::type_list<Head, Tail...>> {
  using Type = typename UniqueBlockListImpl<
      typename AppendUniqueBlockType<Accumulated, Head>::TypeValue,
      utils::blocks::type_list<Tail...>>::Type;
};

template <typename List>
using UniqueBlockListT =
    typename UniqueBlockListImpl<utils::blocks::type_list<>, List>::Type;

template <typename... Lists>
using UniqueConcatenateBlockListsT =
    UniqueBlockListT<ConcatenateBlockListsT<Lists...>>;

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

template <typename... Blocks>
struct IsValueBlockList<utils::blocks::type_list<Blocks...>>
    : std::bool_constant<
          (std::derived_from<Blocks, utils::blocks::value_block_base> && ...) &&
          utils::blocks::types_are_unique_v<
              utils::blocks::type_list<Blocks...>>> {};

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

template <typename... Blocks>
struct IsResidualBlockList<utils::blocks::type_list<Blocks...>>
    : std::bool_constant<
          (std::derived_from<Blocks, utils::blocks::residual_block_base> &&
           ...) &&
          utils::blocks::types_are_unique_v<
              utils::blocks::type_list<Blocks...>>> {};

template <typename GeneratedValues> struct GeneratedValueBlocksFor;

template <typename... GeneratedValues>
struct GeneratedValueBlocksFor<models::ModelTypeList<GeneratedValues...>> {
  using Type = utils::blocks::type_list<
      utils::blocks::generated_value_block<GeneratedValues>...>;
};

template <typename GeneratedResiduals> struct GeneratedResidualBlocksFor;

template <typename... GeneratedResiduals>
struct GeneratedResidualBlocksFor<
    models::ModelTypeList<GeneratedResiduals...>> {
  using Type = utils::blocks::type_list<
      utils::blocks::generated_residual_block<GeneratedResiduals>...>;
};

/*
 * One translation boundary turns physics-facing stellar names into backend
 * blocks.  Existing backend block types pass through unchanged, which keeps
 * the advanced extension API open without making built-in physics declarations
 * depend on utils.blocks.
 */
template <typename DeclaredDependency>
struct UnmappedStellarDependency final {};

template <typename Blocks, typename DeclaredDependency>
struct SingleGeneratedBlock {
  using Type = UnmappedStellarDependency<DeclaredDependency>;
  static constexpr bool available = false;
};

template <typename Block, typename DeclaredDependency>
struct SingleGeneratedBlock<utils::blocks::type_list<Block>,
                            DeclaredDependency> {
  using Type = Block;
  static constexpr bool available = true;
};

template <models::ModelSpecification Specification, typename Dependency>
struct StellarDependencyBlock {
  using Type = UnmappedStellarDependency<Dependency>;
  static constexpr bool mapped = false;
};

template <models::ModelSpecification Specification, typename Block>
  requires(std::derived_from<Block, utils::blocks::value_block_base> ||
           std::derived_from<Block, utils::blocks::residual_block_base>)
struct StellarDependencyBlock<Specification, Block> {
  using Type = Block;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<Specification, models::stellar::state::Density> {
  using Type = utils::blocks::density::mass::value;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<Specification,
                              models::stellar::state::SurfaceShape> {
  using Type = utils::blocks::surface_deformation::parameters::value;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<Specification,
                              models::stellar::state::GravityGradient> {
  using Type = utils::blocks::gravity::gradient::value;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<
    Specification, models::stellar::state::GravitationalPotential> {
  using Type = utils::blocks::gravity::poisson::value;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<Specification,
                              models::stellar::state::SpecificEnthalpy> {
  using Type = utils::blocks::enthalpy::specific::value;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<
    Specification, models::stellar::state::OwnGeneratedCoordinate> {
private:
  using GeneratedBlocks = typename GeneratedValueBlocksFor<
      typename models::SpecificationContribution<
          Specification>::GeneratedValues>::Type;
  using Selection = SingleGeneratedBlock<
      GeneratedBlocks, models::stellar::state::OwnGeneratedCoordinate>;

public:
  using Type = typename Selection::Type;
  static constexpr bool mapped = Selection::available;
};

template <models::ModelSpecification Specification,
          models::ModelSpecification Owner>
struct StellarDependencyBlock<
    Specification, models::stellar::state::GeneratedCoordinateOf<Owner>> {
private:
  using GeneratedBlocks = typename GeneratedValueBlocksFor<
      typename models::SpecificationContribution<Owner>::GeneratedValues>::Type;
  using Dependency = models::stellar::state::GeneratedCoordinateOf<Owner>;
  using Selection = SingleGeneratedBlock<GeneratedBlocks, Dependency>;

public:
  using Type = typename Selection::Type;
  static constexpr bool mapped = Selection::available;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<
    Specification, models::stellar::equation::GravityGradientDefinition> {
  using Type = utils::blocks::gravity::gradient::residual;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<Specification,
                              models::stellar::equation::PoissonEquation> {
  using Type = utils::blocks::gravity::poisson::residual;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<Specification,
                              models::stellar::equation::DensityClosure> {
  using Type = utils::blocks::density::mass::residual;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<
    Specification, models::stellar::equation::SurfaceShapeBalance> {
  using Type =
      utils::blocks::surface_deformation::shape_equilibrium::residual;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<
    Specification, models::stellar::equation::HydrostaticBalance> {
  using Type = utils::blocks::enthalpy::specific::residual;
  static constexpr bool mapped = true;
};

template <models::ModelSpecification Specification>
struct StellarDependencyBlock<Specification,
                              models::stellar::equation::OwnConstraint> {
private:
  using GeneratedBlocks = typename GeneratedResidualBlocksFor<
      typename models::SpecificationContribution<
          Specification>::GeneratedResiduals>::Type;
  using Selection = SingleGeneratedBlock<
      GeneratedBlocks, models::stellar::equation::OwnConstraint>;

public:
  using Type = typename Selection::Type;
  static constexpr bool mapped = Selection::available;
};

template <models::ModelSpecification Specification,
          models::ModelSpecification Owner>
struct StellarDependencyBlock<
    Specification, models::stellar::equation::ConstraintOf<Owner>> {
private:
  using GeneratedBlocks = typename GeneratedResidualBlocksFor<
      typename models::SpecificationContribution<Owner>::GeneratedResiduals>::Type;
  using Dependency = models::stellar::equation::ConstraintOf<Owner>;
  using Selection = SingleGeneratedBlock<GeneratedBlocks, Dependency>;

public:
  using Type = typename Selection::Type;
  static constexpr bool mapped = Selection::available;
};

template <models::ModelSpecification Specification, typename Dependencies>
struct CompileStellarDependencies {
  using Type = utils::blocks::type_list<
      UnmappedStellarDependency<Dependencies>>;
  static constexpr bool complete = false;
};

template <models::ModelSpecification Specification, typename... Dependencies>
struct CompileStellarDependencies<Specification,
                                  models::ModelTypeList<Dependencies...>> {
  using Type = utils::blocks::type_list<
      typename StellarDependencyBlock<Specification, Dependencies>::Type...>;
  static constexpr bool complete =
      (StellarDependencyBlock<Specification, Dependencies>::mapped && ...);
};

template <typename Residual, typename Values> struct CoupleResidualToValues;

template <typename Residual, typename... Values>
struct CoupleResidualToValues<Residual, utils::blocks::type_list<Values...>> {
  using Type = utils::blocks::type_list<
      StellarEquilibriumJacobianCoupling<Residual, Values>...>;
};

template <typename Residuals, typename Values>
struct CartesianJacobianCouplings;

template <typename... Residuals, typename Values>
struct CartesianJacobianCouplings<utils::blocks::type_list<Residuals...>,
                                  Values> {
  using Type = ConcatenateBlockListsT<
      typename CoupleResidualToValues<Residuals, Values>::Type...>;
};

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

template <typename Residual, typename Value>
struct IsJacobianCoupling<StellarEquilibriumJacobianCoupling<Residual, Value>>
    : std::bool_constant<
          std::derived_from<Residual, utils::blocks::residual_block_base> &&
          std::derived_from<Value, utils::blocks::value_block_base>> {};

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

template <typename... Couplings>
struct IsJacobianCouplingList<utils::blocks::type_list<Couplings...>>
    : std::bool_constant<(IsJacobianCoupling<Couplings>::value && ...) &&
                         utils::blocks::types_are_unique_v<
                             utils::blocks::type_list<Couplings...>>> {};

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

template <typename Owner>
struct IsGeneratedValueBlock<utils::blocks::generated_value_block<Owner>>
    : std::true_type {};

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

template <typename Owner>
struct IsGeneratedResidualBlock<utils::blocks::generated_residual_block<Owner>>
    : std::true_type {};

template <typename Coupling>
inline constexpr bool isGeneratedBorderIncidentCoupling =
    IsGeneratedValueBlock<typename Coupling::Value>::value ||
    IsGeneratedResidualBlock<typename Coupling::Residual>::value;

template <typename Couplings> struct GeneratedBorderIncidentCouplings;

template <>
struct GeneratedBorderIncidentCouplings<utils::blocks::type_list<>> {
  using Type = utils::blocks::type_list<>;
};

template <typename Head, typename... Tail>
struct GeneratedBorderIncidentCouplings<
    utils::blocks::type_list<Head, Tail...>> {
private:
  using Remaining = typename GeneratedBorderIncidentCouplings<
      utils::blocks::type_list<Tail...>>::Type;

public:
  using Type = std::conditional_t<
      isGeneratedBorderIncidentCoupling<Head>,
      ConcatenateBlockListsT<utils::blocks::type_list<Head>, Remaining>,
      Remaining>;
};

template <bool Registered, typename GeneratedValues,
          typename GeneratedResiduals, typename DependsOn, typename Affects>
struct DeclarativeStellarEquilibriumSpecificationCompilation {
  using GeneratedValueBlocks = GeneratedValues;
  using GeneratedResidualBlocks = GeneratedResiduals;
  using DependsOnValueBlocks = DependsOn;
  using AffectedResidualBlocks = Affects;

  /*
   * Preserve the two physical meanings in the declaration instead of
   * flattening their endpoints into independent unions:
   *
   *   constraint equation <- everything named in Reads
   *   changed equations    <- Reads plus the generated coordinate
   *
   * The second group deliberately includes Affects x Reads.  Nonlinear
   * constraints and multiplier forces generally contribute Hessian-like
   * state derivatives there.  Linear contributions simply assemble zero on
   * those structurally permitted edges.
   */
  using ConstraintInputValueBlocks = DependsOnValueBlocks;
  using ConstraintOutputResidualBlocks = GeneratedResidualBlocks;
  using ChangedEquationInputValueBlocks = UniqueConcatenateBlockListsT<
      DependsOnValueBlocks, GeneratedValueBlocks>;
  using ChangedEquationOutputResidualBlocks = AffectedResidualBlocks;

  using ConstraintJacobianCouplings =
      typename CartesianJacobianCouplings<GeneratedResidualBlocks,
                                          DependsOnValueBlocks>::Type;
  using ChangedEquationJacobianCouplings =
      typename CartesianJacobianCouplings<AffectedResidualBlocks,
                                          ChangedEquationInputValueBlocks>::Type;

  // Compatibility names retained for backend code that distinguishes the
  // generated row from the generated-coordinate column.
  using GeneratedRowJacobianCouplings = ConstraintJacobianCouplings;
  using AffectedRowJacobianCouplings =
      typename CartesianJacobianCouplings<AffectedResidualBlocks,
                                          GeneratedValueBlocks>::Type;
  using AffectedStateJacobianCouplings =
      typename CartesianJacobianCouplings<AffectedResidualBlocks,
                                          DependsOnValueBlocks>::Type;

  using JacobianCouplings = UniqueConcatenateBlockListsT<
      ConstraintJacobianCouplings, ChangedEquationJacobianCouplings>;
  using IncidentJacobianCouplings =
      typename GeneratedBorderIncidentCouplings<JacobianCouplings>::Type;

  // Correction is the Newton-facing name for a value coordinate.
  using GeneratedCorrectionBlocks = GeneratedValueBlocks;

  static constexpr bool registered = Registered;
  static constexpr bool complete =
      registered && IsValueBlockList<GeneratedValueBlocks>::value &&
      IsResidualBlockList<GeneratedResidualBlocks>::value &&
      IsValueBlockList<DependsOnValueBlocks>::value &&
      IsResidualBlockList<AffectedResidualBlocks>::value &&
      IsJacobianCouplingList<JacobianCouplings>::value &&
      (GeneratedValueBlocks::size == GeneratedResidualBlocks::size) &&
      ((GeneratedValueBlocks::size == 0 && DependsOnValueBlocks::size == 0 &&
        AffectedResidualBlocks::size == 0) ||
       (GeneratedValueBlocks::size > 0 && DependsOnValueBlocks::size > 0 &&
        AffectedResidualBlocks::size > 0));
};

using EmptySpecificationCompilation =
    DeclarativeStellarEquilibriumSpecificationCompilation<
        false, utils::blocks::type_list<>, utils::blocks::type_list<>,
        utils::blocks::type_list<>, utils::blocks::type_list<>>;

template <models::ModelSpecification Specification>
struct SelfDescribingSpecificationCompilationInputs {
  using Contribution = models::SpecificationContribution<Specification>;
  using DependsOn =
      CompileStellarDependencies<Specification, typename Contribution::DependsOn>;
  using Affects =
      CompileStellarDependencies<Specification, typename Contribution::Affects>;

  using GeneratedValueBlocks = typename GeneratedValueBlocksFor<
      typename Contribution::GeneratedValues>::Type;
  using GeneratedResidualBlocks = typename GeneratedResidualBlocksFor<
      typename Contribution::GeneratedResiduals>::Type;
  using DependsOnValueBlocks = typename DependsOn::Type;
  using AffectedResidualBlocks = typename Affects::Type;

  static constexpr bool registered =
      Contribution::hasDeclarativeDefinition && DependsOn::complete &&
      Affects::complete;
};

template <models::ModelSpecification Specification>
struct SelfDescribingSpecificationCompilation
    : DeclarativeStellarEquilibriumSpecificationCompilation<
          SelfDescribingSpecificationCompilationInputs<Specification>::registered,
          typename SelfDescribingSpecificationCompilationInputs<
              Specification>::GeneratedValueBlocks,
          typename SelfDescribingSpecificationCompilationInputs<
              Specification>::GeneratedResidualBlocks,
          typename SelfDescribingSpecificationCompilationInputs<
              Specification>::DependsOnValueBlocks,
          typename SelfDescribingSpecificationCompilationInputs<
              Specification>::AffectedResidualBlocks> {};
} // namespace detail

/*
 * Public, inspectable per-specification compilation metadata. The primary
 * is deliberately well formed and incomplete, so testing an arbitrary type
 * in a requires-expression never triggers a diagnostic.
 */
template <typename Specification>
struct StellarEquilibriumSpecificationCompilation
    : detail::EmptySpecificationCompilation {};

template <models::ModelSpecification Specification>
struct StellarEquilibriumSpecificationCompilation<Specification>
    : detail::SelfDescribingSpecificationCompilation<Specification> {};

namespace detail {
template <typename Specification, typename = void>
struct SpecificationCompilationIsComplete : std::false_type {};

template <typename Specification>
struct SpecificationCompilationIsComplete<
    Specification,
    std::void_t<typename StellarEquilibriumSpecificationCompilation<
                    Specification>::GeneratedValueBlocks,
                typename StellarEquilibriumSpecificationCompilation<
                    Specification>::GeneratedResidualBlocks,
                typename StellarEquilibriumSpecificationCompilation<
                    Specification>::DependsOnValueBlocks,
                typename StellarEquilibriumSpecificationCompilation<
                    Specification>::AffectedResidualBlocks,
                typename StellarEquilibriumSpecificationCompilation<
                    Specification>::JacobianCouplings,
                std::bool_constant<StellarEquilibriumSpecificationCompilation<
                    Specification>::registered>,
                std::bool_constant<StellarEquilibriumSpecificationCompilation<
                    Specification>::complete>>>
    : std::bool_constant<
          StellarEquilibriumSpecificationCompilation<
              Specification>::registered &&
          StellarEquilibriumSpecificationCompilation<Specification>::complete &&
          IsValueBlockList<typename StellarEquilibriumSpecificationCompilation<
              Specification>::GeneratedValueBlocks>::value &&
          IsResidualBlockList<
              typename StellarEquilibriumSpecificationCompilation<
                  Specification>::GeneratedResidualBlocks>::value &&
          IsValueBlockList<typename StellarEquilibriumSpecificationCompilation<
              Specification>::DependsOnValueBlocks>::value &&
          IsResidualBlockList<
              typename StellarEquilibriumSpecificationCompilation<
                  Specification>::AffectedResidualBlocks>::value &&
          IsJacobianCouplingList<
              typename StellarEquilibriumSpecificationCompilation<
                  Specification>::JacobianCouplings>::value> {};
} // namespace detail

template <typename Candidate>
inline constexpr bool stellarEquilibriumSpecificationCompilationComplete =
    detail::SpecificationCompilationIsComplete<
        std::remove_cvref_t<Candidate>>::value;

template <typename Candidate>
concept StellarEquilibriumSpecificationCompilable =
    stellarEquilibriumSpecificationCompilationComplete<Candidate>;

namespace detail {
/*
 * This five-by-five physical core is independent of global constraints.
 * Even FixedTotalMass is compiled as a contribution, keeping C and R_M
 * visible in that specification's metadata.
 */
using StellarPhysicsValueBlocks = utils::blocks::type_list<
    utils::blocks::density::mass::value,
    utils::blocks::surface_deformation::parameters::value,
    utils::blocks::gravity::gradient::value,
    utils::blocks::gravity::poisson::value,
    utils::blocks::enthalpy::specific::value>;

using StellarPhysicsResidualBlocks = utils::blocks::type_list<
    utils::blocks::gravity::gradient::residual,
    utils::blocks::gravity::poisson::residual,
    utils::blocks::density::mass::residual,
    utils::blocks::surface_deformation::shape_equilibrium::residual,
    utils::blocks::enthalpy::specific::residual>;

using StellarPhysicsJacobianRows = utils::blocks::type_list<
    utils::blocks::block_row<
        utils::blocks::gravity::gradient::residual,
        utils::blocks::gravity::gradient::value,
        utils::blocks::gravity::poisson::value,
        utils::blocks::surface_deformation::parameters::value>,
    utils::blocks::block_row<
        utils::blocks::gravity::poisson::residual,
        utils::blocks::gravity::gradient::value,
        utils::blocks::density::mass::value,
        utils::blocks::surface_deformation::parameters::value>,
    utils::blocks::block_row<
        utils::blocks::density::mass::residual,
        utils::blocks::density::mass::value,
        utils::blocks::enthalpy::specific::value,
        utils::blocks::surface_deformation::parameters::value>,
    utils::blocks::block_row<
        utils::blocks::surface_deformation::shape_equilibrium::residual,
        utils::blocks::density::mass::value,
        utils::blocks::surface_deformation::parameters::value,
        utils::blocks::gravity::gradient::value,
        utils::blocks::enthalpy::specific::value>,
    utils::blocks::block_row<
        utils::blocks::enthalpy::specific::residual,
        utils::blocks::enthalpy::specific::value,
        utils::blocks::gravity::poisson::value,
        utils::blocks::surface_deformation::parameters::value>>;

template <typename Row> struct JacobianRowCouplings;

template <typename Residual, typename... Values>
struct JacobianRowCouplings<utils::blocks::block_row<Residual, Values...>> {
  using Type = utils::blocks::type_list<
      StellarEquilibriumJacobianCoupling<Residual, Values>...>;
};

template <typename Rows> struct FlattenJacobianRows;

template <typename... Rows>
struct FlattenJacobianRows<utils::blocks::type_list<Rows...>> {
  using Type =
      ConcatenateBlockListsT<typename JacobianRowCouplings<Rows>::Type...>;
};

using StellarPhysicsJacobianCouplings =
    typename FlattenJacobianRows<StellarPhysicsJacobianRows>::Type;

template <typename SpecificationSet>
struct SpecificationSetCompilationsAreComplete;

template <models::ModelSpecification... Specifications>
struct SpecificationSetCompilationsAreComplete<
    models::detail::SpecificationSetStorage<Specifications...>>
    : std::bool_constant<(
          stellarEquilibriumSpecificationCompilationComplete<Specifications> &&
          ...)> {};

template <typename SpecificationSet, bool Complete>
struct CollectStellarEquilibriumContributionsImpl {
  using GeneratedValueBlocks = utils::blocks::type_list<>;
  using GeneratedResidualBlocks = utils::blocks::type_list<>;
  using ContributionJacobianCouplings = utils::blocks::type_list<>;
  using IncidentJacobianCouplings = ContributionJacobianCouplings;

  static constexpr bool complete = false;
};

template <models::ModelSpecification... Specifications>
struct CollectStellarEquilibriumContributionsImpl<
    models::detail::SpecificationSetStorage<Specifications...>, true> {
  using GeneratedValueBlocks = ConcatenateBlockListsT<
      typename StellarEquilibriumSpecificationCompilation<
          Specifications>::GeneratedValueBlocks...>;
  using GeneratedResidualBlocks = ConcatenateBlockListsT<
      typename StellarEquilibriumSpecificationCompilation<
          Specifications>::GeneratedResidualBlocks...>;
  using ContributionJacobianCouplings = UniqueConcatenateBlockListsT<
      typename StellarEquilibriumSpecificationCompilation<
          Specifications>::JacobianCouplings...>;
  using IncidentJacobianCouplings = UniqueConcatenateBlockListsT<
      typename StellarEquilibriumSpecificationCompilation<
          Specifications>::IncidentJacobianCouplings...>;

  static constexpr bool complete = true;
};

template <typename SpecificationSet>
using CollectStellarEquilibriumContributions =
    CollectStellarEquilibriumContributionsImpl<
        SpecificationSet,
        SpecificationSetCompilationsAreComplete<SpecificationSet>::value>;

template <typename Residual, typename Couplings> struct ValuesCoupledToResidual;

template <typename Residual>
struct ValuesCoupledToResidual<Residual, utils::blocks::type_list<>> {
  using Type = utils::blocks::type_list<>;
};

template <typename Residual, typename HeadResidual, typename HeadValue,
          typename... Tail>
struct ValuesCoupledToResidual<
    Residual,
    utils::blocks::type_list<
        StellarEquilibriumJacobianCoupling<HeadResidual, HeadValue>, Tail...>> {
private:
  using Remaining =
      typename ValuesCoupledToResidual<Residual,
                                       utils::blocks::type_list<Tail...>>::Type;

public:
  using Type = std::conditional_t<
      std::same_as<Residual, HeadResidual>,
      ConcatenateBlockListsT<utils::blocks::type_list<HeadValue>, Remaining>,
      Remaining>;
};

template <typename Residual, typename Values> struct MakeJacobianRow;

template <typename Residual, typename... Values>
struct MakeJacobianRow<Residual, utils::blocks::type_list<Values...>> {
  using Type = utils::blocks::block_row<Residual, Values...>;
};

template <typename Residuals, typename Couplings> struct SynthesizeJacobianRows;

template <typename... Residuals, typename Couplings>
struct SynthesizeJacobianRows<utils::blocks::type_list<Residuals...>,
                              Couplings> {
  using Type = utils::blocks::type_list<typename MakeJacobianRow<
      Residuals,
      typename ValuesCoupledToResidual<Residuals, Couplings>::Type>::Type...>;
};

template <typename Couplings, typename ValueBlocks, typename ResidualBlocks>
struct CouplingEndpointsBelongToForm : std::false_type {};

template <typename ValueBlocks, typename ResidualBlocks, typename... Couplings>
struct CouplingEndpointsBelongToForm<utils::blocks::type_list<Couplings...>,
                                     ValueBlocks, ResidualBlocks>
    : std::bool_constant<((utils::blocks::contains_type_v<
                               typename Couplings::Value, ValueBlocks> &&
                           utils::blocks::contains_type_v<
                               typename Couplings::Residual, ResidualBlocks>) &&
                          ...)> {};

template <typename Candidate> struct CompileStellarEquilibriumSystem {
  using GeneratedValueBlocks = utils::blocks::type_list<>;
  using GeneratedCorrectionBlocks = GeneratedValueBlocks;
  using GeneratedResidualBlocks = utils::blocks::type_list<>;
  using BaseJacobianCouplings = utils::blocks::type_list<>;
  using ContributionJacobianCouplings = utils::blocks::type_list<>;
  using IncidentJacobianCouplings = ContributionJacobianCouplings;
  using JacobianCouplings = utils::blocks::type_list<>;

  static constexpr bool compilable = false;
};

template <model::StellarModelType Model>
struct CompileStellarEquilibriumSystem<Model> {
  using ModelType = std::remove_cvref_t<Model>;
  using Contributions = CollectStellarEquilibriumContributions<
      typename ModelType::SpecificationTypes>;

  using GeneratedValueBlocks = typename Contributions::GeneratedValueBlocks;
  using GeneratedCorrectionBlocks = GeneratedValueBlocks;
  using GeneratedResidualBlocks =
      typename Contributions::GeneratedResidualBlocks;

  using ValueBlocks =
      ConcatenateBlockListsT<StellarPhysicsValueBlocks, GeneratedValueBlocks>;
  using ResidualBlocks = ConcatenateBlockListsT<StellarPhysicsResidualBlocks,
                                                GeneratedResidualBlocks>;
  using FormType = utils::blocks::block_form<ValueBlocks, ResidualBlocks>;

  using BaseJacobianCouplings = StellarPhysicsJacobianCouplings;
  using ContributionJacobianCouplings =
      typename Contributions::ContributionJacobianCouplings;
  using IncidentJacobianCouplings = ContributionJacobianCouplings;
  using JacobianCouplings =
      UniqueConcatenateBlockListsT<BaseJacobianCouplings,
                                   ContributionJacobianCouplings>;

  // Pass two: materialize rows only after all contributed blocks are
  // present in the final form.
  using JacobianType =
      typename SynthesizeJacobianRows<ResidualBlocks, JacobianCouplings>::Type;

  static constexpr bool compilable =
      Contributions::complete &&
      utils::blocks::block_form_is_valid_v<FormType> &&
      IsJacobianCouplingList<JacobianCouplings>::value &&
      CouplingEndpointsBelongToForm<JacobianCouplings, ValueBlocks,
                                    ResidualBlocks>::value &&
      utils::blocks::jacobian_form_is_valid_v<FormType, JacobianType>;
};
} // namespace detail

template <typename Candidate>
inline constexpr bool stellarEquilibriumSystemIsCompilable =
    detail::CompileStellarEquilibriumSystem<
        std::remove_cvref_t<Candidate>>::compilable;

/*
 * This compiler proves the symbolic block topology only.  Keep the explicit
 * name available to extension authors and tests so that success here is not
 * mistaken for an assembled numerical runtime.  The established spelling is
 * retained below as a compatibility alias.
 */
template <typename Candidate>
inline constexpr bool stellarEquilibriumIsSymbolicallyCompilable =
    stellarEquilibriumSystemIsCompilable<Candidate>;

template <typename Candidate>
concept StellarEquilibriumSymbolicallyCompilable =
    stellarEquilibriumIsSymbolicallyCompilable<Candidate>;

template <typename Candidate>
concept StellarEquilibriumSystemCompilable =
    StellarEquilibriumSymbolicallyCompilable<Candidate>;

template <model::StellarModelType Model>
  requires StellarEquilibriumSystemCompilable<Model>
struct CompiledStellarEquilibriumSystem final
    : detail::CompileStellarEquilibriumSystem<std::remove_cvref_t<Model>> {
  using Base =
      detail::CompileStellarEquilibriumSystem<std::remove_cvref_t<Model>>;

  using FormType = typename Base::FormType;
  using JacobianType = typename Base::JacobianType;

  // This classification is exposed only after the complete compiler concept
  // has succeeded; model declarations intentionally do not predict it.
  static constexpr models::EquilibriumSystemCompilation compilationClass =
      models::EquilibriumSystemCompilation::complete_equilibrium_system;

  static_assert(utils::blocks::block_form_is_valid_v<FormType>);
  static_assert(utils::blocks::valid_jacobian_form<FormType, JacobianType>);
};

template <model::StellarModelType Model>
  requires StellarEquilibriumSystemCompilable<Model>
using CompiledStellarEquilibriumForm =
    typename CompiledStellarEquilibriumSystem<Model>::FormType;

template <model::StellarModelType Model>
  requires StellarEquilibriumSystemCompilable<Model>
using CompiledStellarEquilibriumJacobianForm =
    typename CompiledStellarEquilibriumSystem<Model>::JacobianType;
} // namespace mean_field::operators