Made some more changes

include/verify/Initialization.h

@@ -1,22 +1,114 @@
 #ifndef INITIALIZATION_H_
 #define INITIALIZATION_H_
 
+#include <iostream>
+#include <filesystem>
 #include <string>
+#include <vector>
+#include <utility>
 
+#include "database/BaseRepository.h"
+#include "manager/DirectoryManager.h"
+#include "manager/TokenManager.h"
 #include "model/Models.h"
+#include "type/PathType.h"
 
-namespace verify {
-    class Initialization {
+namespace fs = std::filesystem;
+
+namespace verify
+{
+    template<typename Config = model::BinaryPath>
+    class Initialization
+    {
     public:
-        static bool skipVerification(const std::string&);
+        static bool skipVerification(const std::string &argument) noexcept
+        {
+            return argument.compare("--noverify") == 0;
+        }
 
-        static void checkIcarus(const model::BinaryPath&);
+        static void checkIcarus(const Config &bConf)
+        {
+            auto auth = confirmConfigAuth(bConf);
+            auto database = confirmConfigDatabase(bConf);
+            auto path = confirmConfigPaths(bConf);
+
+            if ((!auth) && (!database) && (!path)) {
+                failedConfirmation();
+            }
+
+            std::cout << "icarus check passed\n";
+        }
     private:
-        static bool confirmConfigAuth(const model::BinaryPath&);
-        static bool confirmConfigDatabase(const model::BinaryPath&);
-        static bool confirmConfigPaths(const model::BinaryPath&);
+        static bool confirmConfigAuth(const Config &bConf)
+        {
+            manager::TokenManager tokMgr;
 
-        static void failedConfirmation();
+            return tokMgr.testAuth(bConf);
+        }
+
+        static bool confirmConfigDatabase(const Config &bConf)
+        {
+            database::BaseRepository baseRepo(bConf);
+
+            return baseRepo.testConnection();
+        }
+        static bool confirmConfigPaths(const Config &bConf)
+        {
+            using manager::DirectoryManager;
+            using namespace type;
+
+            auto pathConfig = DirectoryManager::pathConfigContent(bConf);
+            const auto musicType = PathType::music;
+            const auto archiveType = PathType::archive;
+            const auto tempRootType = PathType::temp;
+            const auto coverArtType = PathType::coverArt;
+
+            auto rootMusicPath = 
+                pathConfig[DirectoryManager::retrievePathType(musicType)];
+            auto archiveRootPath = 
+                pathConfig
+                [DirectoryManager::retrievePathType(archiveType)];
+            auto tempRootPath = 
+                pathConfig
+                [DirectoryManager::retrievePathType(tempRootType)];
+
+            auto coverRootPath = 
+                pathConfig
+                [DirectoryManager::retrievePathType(coverArtType)];
+
+            std::vector<std::string> paths;
+            paths.reserve(4);
+            paths.emplace_back(std::move(rootMusicPath));
+            paths.emplace_back(std::move(archiveRootPath));
+            paths.emplace_back(std::move(tempRootPath));
+            paths.emplace_back(std::move(coverRootPath));
+
+            return confirmMultiplePaths(paths);
+        }
+
+        static void failedConfirmation()
+        {
+            std::cout << "configuration confirmation failed. check your settings\n";
+            std::exit(-1);
+        }
+
+        template<typename Obj = std::string, typename Container = std::vector<Obj>>
+        static bool confirmMultiplePaths(const Container &con)
+        {
+            auto result = true;
+
+            for (auto &path : con)
+            {
+                if (!fs::exists(path))
+                {
+                    std::cout << path << " is not properly configured\n";
+                    return false;
+                }
+            }
+
+
+            return result;
+        }
     };
 }