repo_scene.h

#pragma once

#include <unordered_map>

#include "../../handler/repo_database_handler_abstract.h"
#include "../bson/repo_node.h"
#include "../bson/repo_node_revision.h"
#include "repo_graph_abstract.h"

typedef std::unordered_map<repoUUID, std::vector<repo::core::model::RepoNode*>, RepoUUIDHasher > ParentMap;

namespace repo{
    namespace core{
        namespace model{
            struct RepoUUIDHasher
            {
                std::size_t operator()(const repoUUID& uid) const
                {
                    return boost::hash<boost::uuids::uuid>()(uid);
                }
            };

            class REPO_API_EXPORT RepoScene : public AbstractGraph
            {
                //FIXME: unsure as to whether i should make the graph a differen class.. struct for now.
                struct repoGraphInstance
                {
                    RepoNodeSet cameras; 
                    RepoNodeSet meshes; 
                    RepoNodeSet materials; 
                    RepoNodeSet maps; 
                    RepoNodeSet metadata; 
                    RepoNodeSet references; 
                    RepoNodeSet textures; 
                    RepoNodeSet transformations; 
                    RepoNodeSet unknowns; 

                    RepoNode *rootNode;
                    std::unordered_map<repoUUID, RepoNode*, RepoUUIDHasher > nodesByUniqueID;
                    std::unordered_map<repoUUID, repoUUID, RepoUUIDHasher > sharedIDtoUniqueID; //** mapping of shared ID to Unique ID
                    ParentMap parentToChildren; //** mapping of shared id to its children's shared id
                    std::unordered_map<repoUUID, RepoScene*, RepoUUIDHasher > referenceToScene; //** mapping of reference ID to it's scene graph
                };

                static const std::vector<std::string> collectionsInProject;
                static const uint16_t REPO_SCENE_TEXTURE_BIT = 0x0001;
            public:

                enum class GraphType { DEFAULT, OPTIMIZED };

                RepoScene(
                    const std::string                                  &database = std::string(),
                    const std::string                                  &projectName = std::string(),
                    const std::string                                  &sceneExt = REPO_COLLECTION_SCENE,
                    const std::string                                  &revExt = REPO_COLLECTION_HISTORY,
                    const std::string                                  &stashExt = REPO_COLLECTION_STASH_REPO,
                    const std::string                                  &rawExt = REPO_COLLECTION_RAW,
                    const std::string                                  &issuesExt = REPO_COLLECTION_ISSUES,
                    const std::string                                  &srcExt = REPO_COLLECTION_STASH_SRC,
                    const std::string                                  &gltfExt = REPO_COLLECTION_STASH_GLTF,
                    const std::string                                  &x3dExt = REPO_COLLECTION_STASH_X3D,
                    const std::string                                  &jsonExt = REPO_COLLECTION_STASH_JSON);

                RepoScene(
                    const std::vector<std::string> &refFiles,
                    const RepoNodeSet              &cameras,
                    const RepoNodeSet              &meshes,
                    const RepoNodeSet              &materials,
                    const RepoNodeSet              &metadata,
                    const RepoNodeSet              &textures,
                    const RepoNodeSet              &transformations,
                    const RepoNodeSet              &references = RepoNodeSet(),
                    const RepoNodeSet              &maps = RepoNodeSet(),
                    const RepoNodeSet              &unknowns = RepoNodeSet(),
                    const std::string              &sceneExt = REPO_COLLECTION_SCENE,
                    const std::string              &revExt = REPO_COLLECTION_HISTORY,
                    const std::string              &stashExt = REPO_COLLECTION_STASH_REPO,
                    const std::string              &rawExt = REPO_COLLECTION_RAW,
                    const std::string              &issuesExt = REPO_COLLECTION_ISSUES,
                    const std::string              &srcExt = REPO_COLLECTION_STASH_SRC,
                    const std::string              &gltfExt = REPO_COLLECTION_STASH_GLTF,
                    const std::string              &x3dExt = REPO_COLLECTION_STASH_X3D,
                    const std::string              &jsonExt = REPO_COLLECTION_STASH_JSON);

                ~RepoScene();

                static std::vector<RepoNode*> filterNodesByType(
                    const std::vector<RepoNode*> nodes,
                    const NodeType filter);

                bool isOK() const{
                    return !status;
                }

                bool isMissingTexture() const{
                    return status & REPO_SCENE_TEXTURE_BIT;
                }
                void setMissingTexture(){
                    status |= REPO_SCENE_TEXTURE_BIT;
                }

                void addMetadata(
                    RepoNodeSet &metadata,
                    const bool  &exactMatch,
                    const bool  &propagateData = true);

                void addStashGraph(
                    const RepoNodeSet &cameras,
                    const RepoNodeSet &meshes,
                    const RepoNodeSet &materials,
                    const RepoNodeSet &textures,
                    const RepoNodeSet &transformations);

                void clearStash();

                bool commit(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg,
                    const std::string &userName,
                    const std::string &message = std::string(),
                    const std::string &tag = std::string());

                bool commitStash(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg);

                repoUUID getBranchID() const
                {
                    return branch;
                }

                std::string getDatabaseName() const
                {
                    return databaseName;
                }

                std::string getStashExtension() const
                {
                    return stashExt;
                }

                std::string getRawExtension() const
                {
                    return rawExt;
                }

                std::string getSRCExtension() const
                {
                    return srcExt;
                }

                std::string getGLTFExtension() const
                {
                    return gltfExt;
                }

                std::string getX3DExtension() const
                {
                    return x3dExt;
                }

                std::string getJSONExtension() const
                {
                    return jsonExt;
                }

                repoUUID getRevisionID() const
                {
                    if (revNode)
                        return revNode->getUniqueID();
                    else
                        return revision;
                }

                std::string getOwner() const
                {
                    if (revNode)
                        return revNode->getAuthor();
                    else
                        return "";
                }

                static std::vector<std::string> getProjectExtensions()
                {
                    return collectionsInProject;
                }

                std::string getProjectName() const
                {
                    return projectName;
                }

                std::vector<double> getWorldOffset() const
                {
                    return worldOffset.size() ? worldOffset : std::vector<double>({ 0, 0, 0 });
                }

                bool isHeadRevision() const
                {
                    return headRevision;
                }

                bool isRevisioned() const
                {
                    return !unRevisioned;
                }

                void setDatabaseAndProjectName(std::string newDatabaseName, std::string newProjectName)
                {
                    databaseName = sanitizeName(newDatabaseName);
                    projectName = sanitizeName(newProjectName);
                }

                void setRevision(repoUUID revisionID)
                {
                    headRevision = false;
                    revision = revisionID;
                }

                void setBranch(repoUUID branchID){ branch = branchID; }

                void setCommitMessage(const std::string &msg) { commitMsg = msg; }

                void setWorldOffset(
                    const std::vector<double> &offset);

                std::string getBranchName() const;

                GraphType getViewGraph() const
                {
                    if (stashGraph.rootNode)
                        return GraphType::OPTIMIZED;
                    else
                        return GraphType::DEFAULT;
                }

                bool loadRevision(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg);

                bool loadScene(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg);

                bool loadStash(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg);

                void updateRevisionStatus(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    const RevisionNode::UploadStatus &status);

                void printStatistics(std::iostream &output);

                void abandonChild(
                    const GraphType &gType,
                    const repoUUID  &parent,
                    const repoUUID  &child,
                    const bool      &modifyParent = true,
                    const bool      &modifyChild = true)
                {
                    return abandonChild(gType, parent, getNodeBySharedID(gType, child), modifyParent, modifyChild);
                }

                void abandonChild(
                    const GraphType &gType,
                    const repoUUID  &parent,
                    RepoNode  *child,
                    const bool      &modifyParent = true,
                    const bool      &modifyChild = true);

                void addInheritance(
                    const GraphType &gType,
                    const repoUUID  &parent,
                    const repoUUID  &child,
                    const bool      &noUpdate = false)
                {
                    addInheritance(gType, getNodeByUniqueID(gType, parent), getNodeByUniqueID(gType, child), noUpdate);
                }

                void addInheritance(
                    const GraphType &gType,
                    const RepoNode  *parent,
                    RepoNode  *child,
                    const bool      &noUpdate = false);

                std::vector<RepoNode*>
                    getChildrenAsNodes(
                    const GraphType &g,
                    const repoUUID &parent) const;

                std::vector<RepoNode*>
                    getChildrenNodesFiltered(
                    const GraphType &g,
                    const repoUUID &parent,
                    const NodeType  &type) const;

                std::vector<RepoNode*> getParentNodesFiltered(
                    const GraphType &gType,
                    const RepoNode  *node,
                    const NodeType  &type) const;

                RepoScene* getSceneFromReference(
                    const GraphType &gType,
                    const repoUUID  &reference) const
                {
                    const repoGraphInstance &g = gType == GraphType::OPTIMIZED ? stashGraph : graph;
                    RepoScene* refScene = nullptr;

                    std::unordered_map<repoUUID, RepoScene*, boost::hash<boost::uuids::uuid> >::const_iterator it = g.referenceToScene.find(reference);
                    if (it != g.referenceToScene.end())
                        refScene = it->second;
                    return refScene;
                }

                std::string getTextureIDForMesh(
                    const GraphType &gType,
                    const repoUUID  &sharedID) const;

                RepoNodeSet getAllCameras(
                    const GraphType &gType) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.cameras : graph.cameras;
                }

                RepoNodeSet getAllMaterials(
                    const GraphType &gType) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.materials : graph.materials;
                }

                RepoNodeSet getAllMaps(
                    const GraphType &gType = GraphType::DEFAULT) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.maps : graph.maps;
                }

                RepoNodeSet getAllMeshes(
                    const GraphType &gType) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.meshes : graph.meshes;
                }

                RepoNodeSet getAllMetadata(
                    const GraphType &gType) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.metadata : graph.metadata;
                }

                RepoNodeSet getAllReferences(
                    const GraphType &gType) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.references : graph.references;
                }

                RepoNodeSet getAllTextures(
                    const GraphType &gType) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.textures : graph.textures;
                }

                RepoNodeSet getAllTransformations(
                    const GraphType &gType) const
                {
                    return  gType == GraphType::OPTIMIZED ? stashGraph.transformations : graph.transformations;
                }

                std::vector<repoUUID> getAddedNodesID() const
                {
                    return std::vector<repoUUID>(newAdded.begin(), newAdded.end());
                }

                std::set<repoUUID> getAllSharedIDs(
                    const GraphType &gType) const;

                std::vector<RepoNode*> getAllDescendantsByType(
                    const GraphType &gType,
                    const repoUUID  &sharedID,
                    const NodeType  &type) const;

                std::vector<repoUUID> getModifiedNodesID() const
                {
                    return std::vector<repoUUID>(newModified.begin(), newModified.end());
                }

                std::vector<repoUUID> getRemovedNodesID() const
                {
                    return std::vector<repoUUID>(newRemoved.begin(), newRemoved.end());
                }

                std::vector<RepoNode*> getRemovedNodes() const
                {
                    return toRemove;
                }

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

                size_t getTotalNodesChanged() const
                {
                    return newRemoved.size() + newAdded.size() + newModified.size();
                }

                RepoNode* getNodeBySharedID(
                    const GraphType &gType,
                    const repoUUID &sharedID) const
                {
                    const repoGraphInstance &g = gType == GraphType::OPTIMIZED ? stashGraph : graph;
                    auto it = g.sharedIDtoUniqueID.find(sharedID);

                    if (it == g.sharedIDtoUniqueID.end()) return nullptr;

                    return getNodeByUniqueID(gType, it->second);
                }

                RepoNode* getNodeByUniqueID(
                    const GraphType &gType,
                    const repoUUID &uniqueID) const
                {
                    const repoGraphInstance &g = gType == GraphType::OPTIMIZED ? stashGraph : graph;
                    auto it = g.nodesByUniqueID.find(uniqueID);

                    if (it == g.nodesByUniqueID.end()) return nullptr;

                    return it->second;
                }

                bool hasRoot(const GraphType &gType) const {
                    const repoGraphInstance &g = gType == GraphType::OPTIMIZED ? stashGraph : graph;
                    return (bool)g.rootNode;
                }
                RepoNode* getRoot(const GraphType &gType) const {
                    const repoGraphInstance &g = gType == GraphType::OPTIMIZED ? stashGraph : graph;
                    return g.rootNode;
                }

                uint32_t getItemsInCurrentGraph(const GraphType &gType) {
                    const repoGraphInstance &g = gType == GraphType::OPTIMIZED ? stashGraph : graph;
                    return g.nodesByUniqueID.size();
                }

                std::vector<std::string> getOriginalFiles() const;

                void addNodes(const std::vector<RepoNode *> &nodes);

                void modifyNode(
                    const GraphType                   &gtype,
                    const repoUUID                    &sharedID,
                    RepoNode                          *newNode,
                    const bool                        &overwrite = false)
                {
                    modifyNode(gtype, getNodeBySharedID(gtype, sharedID), newNode, overwrite);
                }

                void modifyNode(
                    const GraphType                   &gtype,
                    RepoNode                          *node,
                    RepoNode                          *newNode,
                    const bool                       &overwrite = false);

                void removeNode(
                    const GraphType                   &gtype,
                    const repoUUID                    &sharedID);

                void reorientateDirectXModel();

            protected:
                bool addNodeToScene(
                    const GraphType &gType,
                    const RepoNodeSet nodes,
                    std::string &errMsg,
                    RepoNodeSet *collection);

                bool addNodeToMaps(
                    const GraphType &gType,
                    RepoNode *node,
                    std::string &errMsg);

                bool commitNodes(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    const std::vector<repoUUID> &nodesToCommit,
                    const GraphType &gType,
                    std::string &errMsg);

                bool commitProjectSettings(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg,
                    const std::string &userName);

                bool commitRevisionNode(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg,
                    RevisionNode *&newRevNode,
                    const std::string &userName,
                    const std::string &message,
                    const std::string &tag);

                bool commitSceneChanges(
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::string &errMsg);

                void getSceneBoundingBoxInternal(
                    const GraphType            &gType,
                    const RepoNode             *node,
                    const std::vector<float>   &mat,
                    std::vector<repo_vector_t> &bbox) const;

                bool populate(
                    const GraphType &gtype,
                    repo::core::handler::AbstractDatabaseHandler *handler,
                    std::vector<RepoBSON> nodes,
                    std::string &errMsg);

                void populateAndUpdate(
                    const GraphType &gType,
                    const RepoNodeSet &cameras,
                    const RepoNodeSet &meshes,
                    const RepoNodeSet &materials,
                    const RepoNodeSet &metadata,
                    const RepoNodeSet &textures,
                    const RepoNodeSet &transformations,
                    const RepoNodeSet &references,
                    const RepoNodeSet &maps,
                    const RepoNodeSet &unknowns);

                void shiftModel(
                    const std::vector<double> &offset);

                /*
                * ---------------- Scene Graph settings ----------------
                */

                std::string sceneExt;    
                std::string revExt;      
                std::string stashExt;      
                std::string rawExt;      
                std::string issuesExt;      
                std::string srcExt;      
                std::string gltfExt;      
                std::string x3dExt;      
                std::string jsonExt;      
                std::vector<std::string> refFiles;  //Original Files that created this scene
                std::vector<RepoNode*> toRemove;
                std::vector<double> worldOffset;
                repoUUID   revision;
                repoUUID   branch;
                std::string commitMsg;
                bool headRevision;
                bool unRevisioned;       
                RevisionNode         *revNode;

                /*
                * ---------------- Scene Graph Details ----------------
                */

                //Change trackers
                std::set<repoUUID> newCurrent; //new list of current (unique IDs)
                std::set<repoUUID> newAdded; //list of nodes added to the new revision (shared ID)
                std::set<repoUUID> newRemoved; //list of nodes removed for this revision (shared ID)
                std::set<repoUUID> newModified; // list of nodes modified during this revision  (shared ID)

                repoGraphInstance graph; //current state of the graph, given the branch/revision
                repoGraphInstance stashGraph; //current state of the optimized graph, given the branch/revision
                uint16_t status; //health of the scene, 0 denotes healthy
            };
        }//namespace graph
    }//namespace manipulator
}//namespace repo