FileManager.h

#pragma once
 
#include <filesystem>
#include <unordered_map>
#include <map>
#include <thread>
#include <mutex>
#include <fstream>
#include <functional>
#include <variant>
#include <queue>
#include <sstream>
#include <future>
 
#include "Cache.h"
 
#include "Handlers/FileHandle.h"
#include "Handlers/ReadFileHandle.h"
#include "Handlers/WriteFileHandle.h"
 
namespace file_manager
{
    class FILE_MANAGER_API FileManager
    {
    private:
        enum class RequestType
        {
            read,
            write
        };
 
        enum class RequestFileHandleType
        {
            read,
            write,
            readBinary,
            writeBinary,
            append,
            appendBinary
        };
 
    private:
        using FileCallback = std::variant<std::function<void(std::unique_ptr<ReadFileHandle>&&)>, std::function<void(std::unique_ptr<WriteFileHandle>&&)>>;
 
        struct RequestStruct
        {
            FileCallback callback;
            std::promise<void> requestPromise;
            RequestFileHandleType handleType;
 
            RequestStruct(FileCallback&& callback, std::promise<void>&& requestPromise, RequestFileHandleType handleType);
        };
 
        friend bool operator == (const RequestStruct& request, RequestType type);
 
    private:
        class FileNode
        {
        private:
            struct FilePathState
            {
                std::atomic_size_t readRequests;
                std::atomic_bool isWriteRequest;
 
                FilePathState();
            };
 
        private:
            std::queue<RequestStruct> requests;
            std::mutex requestsMutex;
 
        public:
            FilePathState state;
 
        public:
            FileNode() = default;
 
            void addRequest(FileCallback&& callback, std::promise<void>&& requestPromise, RequestFileHandleType handleType);
 
            void processQueue(const std::filesystem::path& filePath);
 
            ~FileNode() = default;
        };
 
        class FILE_MANAGER_API NodesContainer
        {
        private:
            std::unordered_map<std::filesystem::path, FileNode*, utility::pathHash> data;
            mutable std::mutex readWriteMutex;
 
        public:
            NodesContainer() = default;
 
            void addNode(const std::filesystem::path& filePath);
            
            FileNode* operator [](const std::filesystem::path& filePath) const;
 
            inline ~NodesContainer()
            {
                for (const auto& [_, value] : data)
                {
                    delete value;
                }
 
                data.clear();
            }
        };
 
    private:
        Cache cache;
        NodesContainer nodes;
        std::shared_ptr<threading::ThreadPool> threadPool;
 
    private:
        static void threadPoolCallback(std::promise<void>&& requestPromise);
 
    public:
        FileHandle* createHandle(const std::filesystem::path& filePath, RequestFileHandleType handleType);
 
        void notify(std::filesystem::path&& filePath);
 
        void addRequest(const std::filesystem::path& filePath, FileCallback&& callback, std::promise<void>&& requestPromise, RequestFileHandleType handleType);
 
        void decreaseReadRequests(const std::filesystem::path& filePath);
 
        void completeWriteRequest(const std::filesystem::path& filePath);
 
    private:
        FileManager();
 
        FileManager(size_t threadsNumber);
 
        FileManager(std::shared_ptr<threading::ThreadPool> threadPool);
 
        FileManager(const FileManager&) = delete;
 
        FileManager(FileManager&&) noexcept = delete;
 
        FileManager& operator = (const FileManager&) = delete;
 
        FileManager& operator = (FileManager&&) noexcept = delete;
 
        ~FileManager() = default;
 
    private:
        std::future<void> addReadRequest(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<ReadFileHandle>&&)>& callback, RequestFileHandleType handleType, bool isWait);
 
        std::future<void> addWriteRequest(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<WriteFileHandle>&&)>& callback, RequestFileHandleType handleType, bool isWait);
 
    public:
        static FileManager& getInstance();
 
        static FileManager& getInstance(size_t threadsNumber);
 
        static FileManager& getInstance(std::shared_ptr<threading::ThreadPool> threadPool);
 
        static std::string getVersion();
 
        void addFile(const std::filesystem::path& filePath, bool isFileAlreadyExist = true);
 
        std::future<void> readFile(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<ReadFileHandle>&&)>& callback, bool isWait = true);
 
        std::future<void> readBinaryFile(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<ReadFileHandle>&&)>& callback, bool isWait = true);
 
        std::future<void> writeFile(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<WriteFileHandle>&&)>& callback, bool isWait = true);
 
        std::future<void> appendFile(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<WriteFileHandle>&&)>& callback, bool isWait = true);
 
        std::future<void> writeBinaryFile(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<WriteFileHandle>&&)>& callback, bool isWait = true);
 
        std::future<void> appendBinaryFile(const std::filesystem::path& filePath, const std::function<void(std::unique_ptr<WriteFileHandle>&&)>& callback, bool isWait = true);
 
        Cache& getCache();
 
        const Cache& getCache() const;
 
        friend class FileHandle;
        friend class ReadFileHandle;
        friend class WriteFileHandle;
        friend class Cache;
        friend struct std::default_delete<FileManager>;
    };
}