FESADev/include/fesa/model/domain.h

#ifndef FESA_MODEL_DOMAIN_H_
#define FESA_MODEL_DOMAIN_H_

#include <cstddef>
#include <filesystem>
#include <memory>
#include <string>
#include <vector>

#include "fesa/core/status.h"
#include "fesa/loads/concentrated_nodal_load.h"
#include "fesa/loads/load.h"
#include "fesa/model/model_types.h"

namespace fesa {

class StepDefinition;

/// @brief Exposes immutable references without transferring Domain ownership.
/// @tparam T Base or concrete semantic type stored by the Domain.
template <class T>
class DomainCollectionView {
 public:
  /// @brief Returns the number of stable collection positions.
  std::size_t Size() const noexcept { return entries_.size(); }

  /// @brief Reports whether the collection has no entries.
  bool Empty() const noexcept { return entries_.empty(); }

  /// @brief Returns one immutable entry without bounds checking.
  const T& operator[](const std::size_t index) const noexcept {
    return *entries_[index];
  }

  /// @brief Returns one immutable entry with bounds checking.
  const T& At(const std::size_t index) const { return *entries_.at(index); }

 private:
  friend class Domain;
  friend class StepDefinition;

  /// @brief Adds one reference while the owning Domain candidate is built.
  void Add(const T& entry) { entries_.push_back(&entry); }

  std::vector<const T*> entries_;
};

/// @brief Owns one immutable static-step semantic definition.
/// @note Loads retain source order and are owned polymorphically by unique
/// pointers.
class StepDefinition {
 public:
  StepDefinition(const StepDefinition&) = delete;
  StepDefinition& operator=(const StepDefinition&) = delete;
  StepDefinition(StepDefinition&&) noexcept = default;
  StepDefinition& operator=(StepDefinition&&) noexcept = default;

  /// @brief Returns the source step name.
  const std::string& Name() const noexcept;

  /// @brief Returns current boundary records in declaration order.
  const std::vector<BoundaryCondition>& Boundaries() const noexcept;

  /// @brief Returns polymorphic loads in stable source order.
  const LoadView& Loads() const noexcept;

  /// @brief Returns current concentrated loads in stable source order.
  const DomainCollectionView<ConcentratedNodalLoad>& ConcentratedLoads()
      const noexcept;

  /// @brief Returns the static initial increment provenance value.
  double InitialIncrement() const noexcept;

  /// @brief Returns the static time-period provenance value.
  double TimePeriod() const noexcept;

  /// @brief Returns the static minimum-increment provenance value.
  double MinimumIncrement() const noexcept;

  /// @brief Returns the static maximum-increment provenance value.
  double MaximumIncrement() const noexcept;

  /// @brief Returns the source location of the step declaration.
  const SourceLocation& Location() const noexcept;

 private:
  friend class Domain;

  /// @brief Converts one parsed static-step record to owned semantic objects.
  explicit StepDefinition(StaticStepDefinition definition);

  std::string name_;
  std::vector<BoundaryCondition> boundaries_;
  std::vector<std::unique_ptr<Load>> loads_;
  LoadView loads_view_;
  DomainCollectionView<ConcentratedNodalLoad> concentrated_loads_view_;
  double initial_increment_;
  double time_period_;
  double minimum_increment_;
  double maximum_increment_;
  SourceLocation location_;
};

/// @brief Owns the complete immutable semantic model definition.
/// @note Collection positions remain stable internal indices after
/// construction.
class Domain {
 public:
  /// @brief Creates a Domain that owns a copy or moved model definition.
  /// @param definition Complete parsed semantic records in declaration order.
  /// @return A successful owning Domain.
  static Result<Domain> Create(ModelDefinition definition);

  Domain(const Domain&) = delete;
  Domain& operator=(const Domain&) = delete;
  Domain(Domain&&) noexcept = default;
  Domain& operator=(Domain&&) noexcept = default;

  /// @brief Returns nodes in stable declaration order.
  const std::vector<Node>& Nodes() const noexcept;

  /// @brief Returns all element definitions in stable Domain index order.
  const DomainCollectionView<ElementDefinition>& Elements() const noexcept;

  /// @brief Returns B33 definitions in their stable concrete order.
  const DomainCollectionView<EulerBeam3DDefinition>& BeamElements()
      const noexcept;

  /// @brief Returns MITC4 shell definitions in stable declaration order.
  const DomainCollectionView<Mitc4ShellDefinition>& ShellElements()
      const noexcept;

  /// @brief Returns all materials in stable Domain index order.
  const DomainCollectionView<Material>& Materials() const noexcept;

  /// @brief Returns current isotropic materials in stable concrete order.
  const DomainCollectionView<LinearElasticMaterial>& LinearElasticMaterials()
      const noexcept;

  /// @brief Returns all properties in stable Domain index order.
  const DomainCollectionView<ElementProperty>& Properties() const noexcept;

  /// @brief Returns beam sections in stable declaration order.
  const DomainCollectionView<GeneralBeamSection>& Sections() const noexcept;

  /// @brief Returns shell sections in stable declaration order.
  const DomainCollectionView<ShellSection>& ShellSections() const noexcept;

  /// @brief Returns preprocessed shell-node frames in stable node order.
  const std::vector<ShellNodeInitialFrame>& ShellNodeInitialFrames()
      const noexcept;

  /// @brief Returns node sets in stable declaration order.
  const std::vector<NodeSet>& NodeSets() const noexcept;

  /// @brief Returns element sets in stable declaration order.
  const std::vector<ElementSet>& ElementSets() const noexcept;

  /// @brief Returns static steps in stable declaration order.
  const DomainCollectionView<StepDefinition>& Steps() const noexcept;

  /// @brief Returns sorted nonfatal mapping diagnostics.
  const std::vector<Diagnostic>& Warnings() const noexcept;

  /// @brief Returns the source input path associated with this model.
  const std::filesystem::path& SourcePath() const noexcept;

  /// @brief Returns the deterministic source-content identity.
  const std::string& SourceContentIdentity() const noexcept;

 private:
  /// @brief Takes ownership of an already constructed model definition.
  explicit Domain(ModelDefinition definition);

  ModelDefinition definition_;
  std::vector<std::unique_ptr<ElementDefinition>> element_definitions_;
  std::vector<std::unique_ptr<ElementProperty>> element_properties_;
  std::vector<std::unique_ptr<Material>> materials_;
  std::vector<std::unique_ptr<StepDefinition>> step_definitions_;
  DomainCollectionView<ElementDefinition> elements_view_;
  DomainCollectionView<EulerBeam3DDefinition> beam_elements_view_;
  DomainCollectionView<Mitc4ShellDefinition> shell_elements_view_;
  DomainCollectionView<ElementProperty> properties_view_;
  DomainCollectionView<GeneralBeamSection> sections_view_;
  DomainCollectionView<ShellSection> shell_sections_view_;
  DomainCollectionView<Material> materials_view_;
  DomainCollectionView<LinearElasticMaterial> linear_materials_view_;
  DomainCollectionView<StepDefinition> steps_view_;
};

}  // namespace fesa

#endif  // FESA_MODEL_DOMAIN_H_