repo_controller.h

#pragma once

#include <map>
#include <memory>
#include <string>

#include "core/model/bson/repo_bson_project_settings.h"
#include "core/model/bson/repo_bson_role.h"
#include "core/model/bson/repo_bson_role_settings.h"
#include "core/model/bson/repo_bson_user.h"
#include "core/model/bson/repo_node_transformation.h"
#include "core/model/bson/repo_node_reference.h"
#include "core/model/bson/repo_node_map.h"
#include "core/model/collection/repo_scene.h"
#include "lib/datastructure/repo_structs.h"
#include "lib/repo_listener_abstract.h"
#include "manipulator/modelconvertor/import/repo_model_import_config.h"
#include "repo_bouncer_global.h"

namespace repo{
    class REPO_API_EXPORT RepoController
    {
    public:

        class RepoToken;

        RepoController(
            std::vector<lib::RepoAbstractListener*> listeners = std::vector<lib::RepoAbstractListener *>(),
            const uint32_t &numConcurrentOps = 1,
            const uint32_t &numDbConn = 1);

        ~RepoController();

        /*
            *   ------------- Database Connection & Authentication --------------
            */

        RepoToken* authenticateMongo(
            std::string       &errMsg,
            const std::string &address,
            const uint32_t    &port,
            const std::string &dbName,
            const std::string &username,
            const std::string &password,
            const bool        &pwDigested = false
            );

        bool authenticateMongo(
            std::string       &errMsg,
            const RepoToken   *token
            );

        RepoToken* authenticateToAdminDatabaseMongo(
            std::string       &errMsg,
            const std::string &address,
            const int         &port,
            const std::string &username,
            const std::string &password,
            const bool        &pwDigested = false
            );

        void disconnectFromDatabase(const RepoToken* token);

        bool testConnection(const RepoToken *token);

        /*
        *   ------------- Token operations --------------
        */

        void addAlias(
            RepoToken         *token,
            const std::string &alias);

        RepoToken* createToken(
            const std::string &alias,
            const std::string &address,
            const int         &port,
            const std::string &dbName,
            const std::string &username,
            const std::string &password
            );

        RepoToken* createToken(
            const std::string &alias,
            const std::string &address,
            const int         &port,
            const std::string &dbName,
            const RepoController::RepoToken *token
            );

        RepoToken* createTokenFromSerialised(
            const std::string &data) const;

        void destroyToken(RepoToken* token);

        void getInfoFromToken(
            const RepoToken *token,
            std::string     &alias,
            std::string     &host,
            uint32_t        &port,
            std::string     &username,
            std::string     &authDB
            ) const;

        std::string serialiseToken(
            const RepoToken* token) const;

        /*
        *   ------------- Database info lookup --------------
        */

        uint64_t countItemsInCollection(
            const RepoToken            *token,
            const std::string    &database,
            const std::string    &collection);

        std::vector < repo::core::model::RepoBSON >
            getAllFromCollectionContinuous(
            const RepoToken      *token,
            const std::string    &database,
            const std::string    &collection,
            const uint64_t       &skip = 0,
            const uint32_t       &limit = 0);

        std::vector < repo::core::model::RepoBSON >
            getAllFromCollectionContinuous(
            const RepoToken              *token,
            const std::string            &database,
            const std::string            &collection,
            const std::list<std::string> &fields,
            const std::string            &sortField,
            const int                    &sortOrder = -1,
            const uint64_t               &skip = 0,
            const uint32_t               &limit = 0);

        std::vector < repo::core::model::RepoRole >
            getRolesFromDatabase(
            const RepoToken              *token,
            const std::string            &database,
            const uint64_t               &skip = 0,
            const uint32_t               &limit = 0);

        std::vector < repo::core::model::RepoRoleSettings >
            getRoleSettingsFromDatabase(
            const RepoToken              *token,
            const std::string            &database,
            const uint64_t               &skip = 0,
            const uint32_t               &limit = 0);

        repo::core::model::RepoRoleSettings getRoleSettings(
            const RepoToken *token,
            const repo::core::model::RepoRole &role);

        repo::core::model::RepoRoleSettings getRoleSettings(
            const RepoToken *token,
            const std::string &database,
            const std::string &uniqueRoleName
            );

        std::list<std::string> getCollections(
            const RepoToken             *token,
            const std::string     &databaseName
            );

        repo::core::model::CollectionStats getCollectionStats(
            const RepoToken            *token,
            const std::string    &database,
            const std::string    &collection);

        std::list<std::string> getDatabases(
            const RepoToken *token);
        //FIXME: vectors are much better than list for traversal efficiency...
        // (but they also require large continuos memory allocation should they be massive)

        std::map<std::string, std::list<std::string>>
            getDatabasesWithProjects(
            const RepoToken *token,
            const std::list<std::string> &databases);

        std::string getHostAndPort(const RepoToken *token);
        std::list<std::string> getAdminDatabaseRoles(const RepoToken *token);

        std::string getNameOfAdminDatabase(const RepoToken *token);

        std::list<std::string> getStandardDatabaseRoles(const RepoToken *token);

        /*
            *   ---------------- Database Retrieval -----------------------
            */

        void cleanUp(
            const RepoToken                        *token,
            const std::string                      &dbName,
            const std::string                      &projectName
            );

        repo::core::model::RepoScene* fetchScene(
            const RepoToken      *token,
            const std::string    &database,
            const std::string    &project,
            const std::string    &uuid = REPO_HISTORY_MASTER_BRANCH,
            const bool           &headRevision = true,
            const bool           &lightFetch = false);

        void saveOriginalFiles(
            const RepoToken                    *token,
            const repo::core::model::RepoScene *scene,
            const std::string                   &directory);

        void saveOriginalFiles(
            const RepoToken                    *token,
            const std::string                   &database,
            const std::string                   &project,
            const std::string                   &directory);

        /*
            *   ------- Database Operations (insert/delete/update) ---------
            */

        bool commitScene(
            const RepoToken                     *token,
            repo::core::model::RepoScene        *scene,
            const std::string                   &owner = "",
            const std::string                      &tag = "",
            const std::string                      &desc = "");

        void insertBinaryFileToDatabase(
            const RepoToken            *token,
            const std::string          &database,
            const std::string          &collection,
            const std::string          &name,
            const std::vector<uint8_t> &rawData,
            const std::string          &mimeType = "");
        void insertRole(
            const RepoToken                     *token,
            const repo::core::model::RepoRole   &role);

        void insertUser(
            const RepoToken                    *token,
            const repo::core::model::RepoUser  &user);

        bool removeCollection(
            const RepoToken             *token,
            const std::string     &databaseName,
            const std::string     &collectionName,
            std::string           &errMsg
            );

        bool removeDatabase(
            const RepoToken             *token,
            const std::string           &databaseName,
            std::string                 &errMsg
            );

        void removeDocument(
            const RepoToken                          *token,
            const std::string                        &databaseName,
            const std::string                        &collectionName,
            const repo::core::model::RepoBSON  &bson);

        bool removeProject(
            const RepoToken                          *token,
            const std::string                        &databaseName,
            const std::string                        &projectName,
            std::string                              &errMsg);

        void removeProjectSettings(
            const RepoToken *token,
            const std::string &database,
            const repo::core::model::RepoProjectSettings &projectSettings)
        {
            removeDocument(token, database, REPO_COLLECTION_SETTINGS_PROJECTS, projectSettings);
        }

        void removeRoleSettings(
            const RepoToken *token,
            const std::string &database,
            const repo::core::model::RepoRoleSettings &roleSettings)
        {
            removeDocument(token, database, REPO_COLLECTION_SETTINGS_ROLES, roleSettings);
        }

        void removeRoleSettings(
            const RepoToken *token,
            const repo::core::model::RepoRole &role,
            const repo::core::model::RepoRoleSettings &settings)
        {
            removeRoleSettings(token, role.getDatabase(), settings);
        }

        void removeRole(
            const RepoToken                          *token,
            const repo::core::model::RepoRole  &role);

        void removeUser(
            const RepoToken                          *token,
            const repo::core::model::RepoUser  &user);

        void updateRole(
            const RepoToken                          *token,
            const repo::core::model::RepoRole        &role);

        void updateUser(
            const RepoToken                          *token,
            const repo::core::model::RepoUser  &user);

        void upsertDocument(
            const RepoToken                          *token,
            const std::string                        &databaseName,
            const std::string                        &collectionName,
            const repo::core::model::RepoBSON  &bson);

        void upsertRoleSettings(
            const RepoToken *token,
            const std::string &database,
            const repo::core::model::RepoRoleSettings &roleSettings)
        {
            upsertDocument(token, database, REPO_COLLECTION_SETTINGS_ROLES, roleSettings);
        }

        void upsertRoleSettings(
            const RepoToken *token,
            const repo::core::model::RepoRole &role,
            const repo::core::model::RepoRoleSettings &settings)
        {
            upsertRoleSettings(token, role.getDatabase(), settings);
        }

        void upsertProjectSettings(
            const RepoToken *token,
            const std::string &database,
            const repo::core::model::RepoProjectSettings &projectSettings)
        {
            upsertDocument(token, database, REPO_COLLECTION_SETTINGS, projectSettings);
        }

        /*
            *   ------------- Logging --------------
            */

        void setLoggingLevel(const repo::lib::RepoLog::RepoLogLevel &level);

        void logToFile(const std::string &filePath);

        /*
            *   ------------- Import/ Export --------------
            */

        repo::core::model::RepoScene* createFederatedScene(
            const std::map<repo::core::model::TransformationNode, repo::core::model::ReferenceNode> &fedMap);

        repo::core::model::RepoScene* createMapScene(
            const repo::core::model::MapNode &mapNode);

        bool generateAndCommitGLTFBuffer(
            const RepoToken                               *token,
            repo::core::model::RepoScene            *scene);

        bool generateAndCommitSRCBuffer(
            const RepoToken                               *token,
            repo::core::model::RepoScene            *scene);

        repo_web_buffers_t generateGLTFBuffer(
            repo::core::model::RepoScene *scene);

        bool generateAndCommitSelectionTree(
            const RepoToken                               *token,
            repo::core::model::RepoScene            *scene);

        repo_web_buffers_t generateSRCBuffer(
            repo::core::model::RepoScene *scene);

        std::string getSupportedExportFormats();

        std::string getSupportedImportFormats();

        repo::core::model::RepoScene* loadSceneFromFile(
            const std::string &filePath,
            const bool &applyReduction = true,
            const bool &rotateModel = false,
            const repo::manipulator::modelconvertor::ModelImportConfig *config
            = nullptr);

        repo::core::model::RepoNodeSet loadMetadataFromFile(
            const std::string &filePath,
            const char        &delimiter = ',');

        bool saveSceneToFile(
            const std::string &filePath,
            const repo::core::model::RepoScene* scene);

        /*
            *   ------------- Optimizations --------------
            */

        bool generateAndCommitStashGraph(
            const RepoToken              *token,
            repo::core::model::RepoScene* scene
            );

        std::shared_ptr<repo_partitioning_tree_t>
            getScenePartitioning(
            const repo::core::model::RepoScene *scene,
            const uint32_t                     &maxDepth = 8
            );

        void reduceTransformations(
            const RepoToken              *token,
            repo::core::model::RepoScene *scene);

        /*
        *   ------------- 3D Diff --------------
        */

        void compareScenes(
            const RepoToken                     *token,
            repo::core::model::RepoScene        *base,
            repo::core::model::RepoScene        *compare,
            repo_diff_result_t &baseResults,
            repo_diff_result_t &compResults,
            const repo::DiffMode       &diffMode
            );

        void compareScenesByIDs(
            const RepoToken                     *token,
            repo::core::model::RepoScene        *base,
            repo::core::model::RepoScene        *compare,
            repo_diff_result_t                          &baseResults,
            repo_diff_result_t                          &compResults
            )
        {
            compareScenes(token, base, compare, baseResults, compResults, repo::DiffMode::DIFF_BY_ID);
        }

        void compareScenesByNames(
            const RepoToken                     *token,
            repo::core::model::RepoScene        *base,
            repo::core::model::RepoScene        *compare,
            repo_diff_result_t &baseResults,
            repo_diff_result_t &compResults
            )
        {
            compareScenes(token, base, compare, baseResults, compResults, repo::DiffMode::DIFF_BY_NAME);
        }

        /*
        *   ------------- Versioning --------------
        */
        std::string getVersion();

    private:
        class _RepoControllerImpl;
        _RepoControllerImpl *impl;
    };
}