filewatcher

#include "pfw/FileSystemWatcher.h"

#include <bitset>
#include <chrono>
#include <filesystem>
#include <memory>

class Listener
{
public:
    Listener(std::filesystem::path path):
            path(path)
    {
        _watcher = std::make_unique<pfw::FileSystemWatcher>(
                path, std::chrono::milliseconds(10),
                std::bind(&Listener::listenerFunction, this,
                          std::placeholders::_1));
    }
    void listenerFunction(std::vector<pfw::EventPtr> events)
    {
        if (events.at(0)->relativePath == ".files.json") {
            // blacklist delle modifiche alla lista dei file
            return;
        }

        if (events.size() == 2 && events.at(0)->type == (pfw::EventType::DELETED | pfw::EventType::RENAMED)
            && events.at(1)->type == (pfw::EventType::CREATED | pfw::EventType::RENAMED)
                ) {
            // move/rename in linux
            std::cout << events.at(0)->relativePath << " has been moved/renamed to "
                      << events.at(1)->relativePath << std::endl;
            // gestione dell'evento
            return;
        }

        if (events.size() == 3 && events.at(0)->type == pfw::EventType::DELETED
            && events.at(1)->type == pfw::EventType::CREATED
            && events.at(2)->type == pfw::EventType::MODIFIED
                ) {
            // move/rename in windows
            std::cout << events.at(0)->relativePath << " has been moved/renamed to "
                      << events.at(1)->relativePath << std::endl;
            // gestione dell'evento
            return;
        }

        for (const auto &event : events) {

            if (event->type == pfw::EventType::DELETED) {
                std::cout << event->relativePath << " has been deleted." << std::endl;
                // gestione dell'evento
            } else if (event->type == pfw::EventType::MODIFIED) {
                // gestione dell'evento
                auto p = this->path / event->relativePath;
                if (std::filesystem::is_regular_file(p)) {
                    auto size = std::filesystem::file_size(p);
                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
                    if (size == std::filesystem::file_size(p) ) {
                        std::cout << "finished! size is " << size << std::endl;
                    } else {
                        std::cout << event->relativePath << " is being modified." << std::endl;
                        //std::cout << "file size is: " << std::filesystem::file_size(p) << std::endl;
                    }

                }
            } else if (event->type == pfw::EventType::CREATED) {
                std::cout << event->relativePath << " has been created." << std::endl;
                // gestione dell'evento
                auto p = this->path / event->relativePath;
                if (std::filesystem::is_regular_file(p)) {
                    auto size = std::filesystem::file_size(p);
                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
                    if (size == std::filesystem::file_size(p) ) {
                        std::cout << "finished! size is " << size << std::endl;
                    } else {
                        std::cout << "file is being created, current size is: " << std::filesystem::file_size(p) << std::endl;
                    }

                }
            }
            if (event->type == (pfw::EventType::CREATED | pfw::EventType::MODIFIED)) {
                std::cout << event->relativePath << " has been created/copied." << std::endl;
                // gestione dell'evento
                auto p = this->path / event->relativePath;
                if (std::filesystem::is_regular_file(p)) {
                    auto size = std::filesystem::file_size(p);
                    std::this_thread::sleep_for(std::chrono::milliseconds(10));
                    if (size == std::filesystem::file_size(p) ) {
                        std::cout << "finished! size is " << size << std::endl;
                    } else {
                        std::cout << "file size is: " << std::filesystem::file_size(p) << std::endl;
                    }

                }
            }
        }
    }

private:
    std::filesystem::path path;
    std::unique_ptr<pfw::FileSystemWatcher> _watcher;
};

int main(int argc, char *argv[])
{
    if (argc < 2) {
        std::cout << "one input parameter is needed" << std::endl;
    }

    const auto path = std::filesystem::path(argv[1]);

    std::cout << "observed path is '" << path.string() << "'" << std::endl;

    auto listenerInstance = Listener(path);

    std::cout << "Press any key to finish the observation!" << std::endl;
    std::cin.ignore();

    return 0;
}