repo_model_import_assimp.h

#pragma once

#include <string>

#include <assimp/Importer.hpp>
#include <assimp/cimport.h>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

#include <boost/bimap.hpp>

#include "repo_model_import_abstract.h"
#include "../../../core/model/collection/repo_scene.h"
#include "../../../core/model/bson/repo_node_camera.h"
#include "../../../core/model/bson/repo_node_material.h"
#include "../../../core/model/bson/repo_node_mesh.h"
#include "../../../core/model/bson/repo_node_metadata.h"
#include "../../../core/model/bson/repo_node_transformation.h"

namespace repo{
    namespace manipulator{
        namespace modelconvertor{
            class AssimpModelImport : public AbstractModelImport
            {
            public:
                AssimpModelImport();

                AssimpModelImport(const ModelImportConfig *settings);

                virtual ~AssimpModelImport();

                static std::string getSupportedFormats();

                repo::core::model::RepoScene* generateRepoScene();

                bool importModel(std::string filePath, std::string &errMsg);

            private:

                repo::core::model::RepoScene* convertAiSceneToRepoScene();

                repo::core::model::CameraNode* createCameraRepoNode(
                    const aiCamera *assimpCamera);
                repo::core::model::MaterialNode* createMaterialRepoNode(
                    const aiMaterial *material,
                    const std::string &name,
                    const std::unordered_map<std::string, repo::core::model::RepoNode *> &nameToTexture);

                repo::core::model::MeshNode createMeshRepoNode(
                    const aiMesh *assimpMesh,
                    const std::vector<repo::core::model::RepoNode *> &materials,
                    std::unordered_map < repo::core::model::RepoNode*, std::vector<repoUUID>> &matMap,
                    const bool hasTexture,
                    const std::vector<double> &offset);

                repo::core::model::MetadataNode* createMetadataRepoNode(
                    const aiMetadata             *assimpMeta,
                    const std::string            &metadataName,
                    const std::vector<repoUUID> &parents = std::vector<repoUUID>());

                repo::core::model::RepoNodeSet createTransformationNodesRecursive(
                    const aiNode                                                         *assimpNode,
                    const std::unordered_map<std::string, repo::core::model::RepoNode *> &cameras,
                    const std::vector<repo::core::model::RepoNode >                      &meshes,
                    const std::unordered_map<repoUUID, repo::core::model::RepoNode *, RepoUUIDHasher>    &meshToMat,
                    std::unordered_map<repo::core::model::RepoNode *, std::vector<repoUUID>> &matParents,
                    repo::core::model::RepoNodeSet                                       &newMeshes,
                    repo::core::model::RepoNodeSet                                       &metadata,
                    uint32_t                                                             &count,
                    const std::vector<double>                                            &worldOffset,
                    const std::vector<repoUUID>                                          &parent = std::vector<repoUUID>()
                    );

                repo::core::model::RepoNode* duplicateMesh(
                    repoUUID                    &newParent,
                    repo::core::model::RepoNode &mesh,
                    const std::unordered_map<repoUUID, repo::core::model::RepoNode *, RepoUUIDHasher>    &meshToMat,
                    std::unordered_map<repo::core::model::RepoNode *, std::vector<repoUUID>> &matParents);

                std::vector<std::vector<double>> getAiMeshBoundingBox(
                    const aiMesh *mesh) const;

                std::vector<std::vector<double>> getSceneBoundingBox() const;

                void getSceneBoundingBoxInternal(
                    const aiNode                     *node,
                    const aiMatrix4x4                &mat,
                    std::vector<std::vector<double>> &bbox) const;

                void loadTextures(std::string folderPath);

                void setAssimpProperties();

                uint32_t composeAssimpPostProcessingFlags(
                    uint32_t flag = 0);

                Assimp::Importer importer;  
                const aiScene *assimpScene; 
                std::string orgFile; 
            };
        } //namespace AssimpModelImport
    } //namespace manipulator
} //namespace repo