#pragma once

#include "fesa/core/BoundaryCondition.hpp"
#include "fesa/core/ElementDefinition.hpp"
#include "fesa/core/LoadDefinition.hpp"
#include "fesa/core/MaterialDefinition.hpp"
#include "fesa/core/ModelTypes.hpp"
#include "fesa/core/Node.hpp"
#include "fesa/core/PropertyDefinition.hpp"
#include "fesa/core/StepDefinition.hpp"

#include <cstddef>
#include <string>
#include <unordered_map>
#include <vector>

namespace fesa::core {

class Domain {
public:
    void addNode(Node node);
    void addElement(ElementDefinition element);
    void addMaterial(LinearElasticMaterialDefinition material);
    void addShellProperty(ShellPropertyDefinition property);
    void addNodeSet(std::string name, std::vector<NodeId> node_ids);
    void addElementSet(std::string name, std::vector<ElementId> element_ids);
    std::size_t addBoundaryCondition(BoundaryCondition condition);
    std::size_t addNodalLoad(NodalLoadDefinition load);
    void addStep(LinearStaticStepDefinition step);

    const Node* findNode(NodeId id) const noexcept;
    const Node& node(NodeId id) const;
    std::size_t nodeCount() const noexcept;

    const ElementDefinition* findElement(ElementId id) const noexcept;
    const ElementDefinition& element(ElementId id) const;
    std::size_t elementCount() const noexcept;

    const LinearElasticMaterialDefinition* findMaterial(MaterialId id) const noexcept;
    const LinearElasticMaterialDefinition& material(MaterialId id) const;
    std::size_t materialCount() const noexcept;

    const ShellPropertyDefinition* findShellProperty(PropertyId id) const noexcept;
    const ShellPropertyDefinition& shellProperty(PropertyId id) const;
    std::size_t shellPropertyCount() const noexcept;

    const std::vector<NodeId>* findNodeSet(const std::string& name) const noexcept;
    const std::vector<NodeId>& nodeSet(const std::string& name) const;
    std::size_t nodeSetCount() const noexcept;

    const std::vector<ElementId>* findElementSet(const std::string& name) const noexcept;
    const std::vector<ElementId>& elementSet(const std::string& name) const;
    std::size_t elementSetCount() const noexcept;

    const BoundaryCondition& boundaryCondition(std::size_t index) const;
    std::size_t boundaryConditionCount() const noexcept;

    const NodalLoadDefinition& nodalLoad(std::size_t index) const;
    std::size_t nodalLoadCount() const noexcept;

    const LinearStaticStepDefinition* findStep(StepId id) const noexcept;
    const LinearStaticStepDefinition& step(StepId id) const;
    std::size_t stepCount() const noexcept;

private:
    std::unordered_map<NodeId, Node> nodes_;
    std::unordered_map<ElementId, ElementDefinition> elements_;
    std::unordered_map<MaterialId, LinearElasticMaterialDefinition> materials_;
    std::unordered_map<PropertyId, ShellPropertyDefinition> shell_properties_;
    std::unordered_map<std::string, std::vector<NodeId>> node_sets_;
    std::unordered_map<std::string, std::vector<ElementId>> element_sets_;
    std::vector<BoundaryCondition> boundary_conditions_;
    std::vector<NodalLoadDefinition> nodal_loads_;
    std::unordered_map<StepId, LinearStaticStepDefinition> steps_;
};

} // namespace fesa::core