#include <Catalogue/CatalogueController.h>
#include <CatalogueIO.hpp>
#include <Common/containers.h>
#include <Common/debug.h>
#include <QDataStream>
#include <QDir>
#include <QMutex>
#include <QStandardPaths>
#include <QThread>

using namespace SciQLop::containers;

// class CatalogueController::CatalogueControllerPrivate
//{

// public:
//    explicit CatalogueControllerPrivate(CatalogueController* parent) : m_Q {
//    parent } {}

//    CatalogueDao m_CatalogueDao;

//    QStringList m_RepositoryList;
//    CatalogueController* m_Q;

//    QSet<QString> m_KeysWithChanges;

//    QString eventUniqueKey(const std::shared_ptr<DBEvent>& event) const;
//    QString catalogueUniqueKey(const std::shared_ptr<DBCatalogue>& catalogue)
//    const;

//    void copyDBtoDB(const QString& dbFrom, const QString& dbTo);
//    QString toWorkRepository(QString repository);
//    QString toSyncRepository(QString repository);
//    void savAllDB();

//    void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
//    void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist =
//    true);

//    std::shared_ptr<IRequestPredicate> createFinder(
//        const QUuid& uniqId, const QString& repository, DBType type);
//};

CatalogueController::CatalogueController(QObject* parent)
//: impl { spimpl::make_unique_impl<CatalogueControllerPrivate>(this) }
{}

CatalogueController::~CatalogueController() {}

QStringList CatalogueController::repositories() const
{
  QStringList repos;
  std::transform(std::begin(_currentRepos), std::end(_currentRepos),
                 std::back_inserter(repos),
                 [](auto& pair) { return pair.first; });
  return repos;
}

void CatalogueController::loadRepository(const QString& path,
                                         const QString& name)
{
  if(QFile::exists(path))
  {
    auto repo = CatalogiCpp::load_repository<time_t>(path.toStdString());
    _lastSavedRepos[name] = repo;
    _currentRepos[name]   = repo;
  }
}

void CatalogueController::saveRepository(const QString& path,
                                         const QString& name)
{
  if(contains(_currentRepos, name))
  {
    CatalogiCpp::save_repository(_currentRepos[name], path.toStdString());
    _lastSavedRepos[name] = _currentRepos[name];
  }
}

std::vector<CatalogueController::Event_ptr> CatalogueController::events()
{
  std::vector<CatalogueController::Event_ptr> e_list;
  for(auto& [_, repo] : _currentRepos)
  {
    for(auto& [_, event] : repo.events())
      e_list.push_back(event);
  }
  return e_list;
}

std::vector<CatalogueController::Event_ptr>
CatalogueController::events(const CatalogueController::Catalogue_ptr& catalogue)
{
  std::vector<CatalogueController::Event_ptr> e_list;
  for(auto& [_, event] : catalogue->events())
    e_list.push_back(event);
  return e_list;
}

std::vector<std::shared_ptr<CatalogueController::Event_t>>
CatalogueController::events(const QString& repository)
{
  std::vector<std::shared_ptr<CatalogueController::Event_t>> e_list;
  if(contains(_currentRepos, repository))
  {
    auto repo = _currentRepos[repository];
    for(auto& [_, event] : repo.events())
      e_list.push_back(event);
  }
  return e_list;
}

std::vector<CatalogueController::Catalogue_ptr>
CatalogueController::catalogues()
{
  std::vector<CatalogueController::Catalogue_ptr> c_list;
  for(auto& [_, repo] : _currentRepos)
  {
    for(auto& [_, catalogue] : repo.catalogues())
      c_list.push_back(catalogue);
  }
  return c_list;
}

std::vector<CatalogueController::Catalogue_ptr>
CatalogueController::catalogues(const QString& repository)
{
  std::vector<CatalogueController::Catalogue_ptr> c_list;
  if(contains(_currentRepos, repository))
  {
    auto repo = _currentRepos[repository];
    for(auto& [_, catalogue] : repo.catalogues())
      c_list.push_back(catalogue);
  }
  return c_list;
}

bool CatalogueController::hasUnsavedChanges(
    CatalogueController::Event_ptr event)
{
  if(auto repo = repository(event))
  {
    if(contains(_lastSavedRepos, *repo))
    { return *event != *(_lastSavedRepos[*repo].event(event->uuid)); }
  }
  return true;
}

std::optional<QString>
CatalogueController::repository(CatalogueController::Event_ptr event)
{
  for(auto& [repoName, repo] : _currentRepos)
  {
    if(repo.event(event->uuid)) return repoName;
  }
  return std::nullopt;
}

std::optional<QString>
CatalogueController::repository(CatalogueController::Catalogue_ptr catalogue)
{
  for(auto& [repoName, repo] : _currentRepos)
  {
    if(repo.catalogue(catalogue->uuid)) return repoName;
  }
  return std::nullopt;
}

void CatalogueController::save(CatalogueController::Event_ptr event)
{
  auto repo_name = repository(event);
  if(repo_name && contains(_lastSavedRepos, *repo_name))
  {
    auto repo = _lastSavedRepos[*repo_name];
    if(contains(repo.events(), event->uuid))
    {
      auto saved_evemt = _lastSavedRepos[*repo_name].event(event->uuid);
      *saved_evemt     = *event;
    }
    else
    {
      // TODO/Question should we also take care of which catalogue has it?
      // if an event is created and added to a catalogue, what should we do if
      // the user clicks the event save button?
      //  - Only save event value in all events list?
      //  - Also save the fact that this event is added to a catalogue and save
      //    the catalogue?
      repo.add(event);
    }
  }
}

void CatalogueController::save(CatalogueController::Catalogue_ptr catalogue)
{
  auto repo_name = repository(catalogue);
  if(repo_name && contains(_lastSavedRepos, *repo_name))
  {
    auto repo = _lastSavedRepos[*repo_name];
    if(contains(repo.catalogues(), catalogue->uuid))
    {
      auto saved_catalogue = repo.catalogue(catalogue->uuid);
      *saved_catalogue     = *catalogue;
    }
    else
    {
      repo.add(catalogue);
    }
  }
}

void CatalogueController::save(const QString& repository)
{
  if(contains(_currentRepos, repository))
  { _lastSavedRepos[repository] = _currentRepos[repository]; }
  else
  {
    SCIQLOP_ERROR(CatalogueController, "Trying to save an unknown repository");
  }
}

void CatalogueController::add(const QString& repository)
{
  if(!contains(_currentRepos, repository))
  {
    _currentRepos[repository] = Repository_t{};
    emit repositoryAdded(repository);
  }
}

CatalogueController::Catalogue_ptr
CatalogueController::add(const QString& catalogue, const QString& repository)
{
  if(!contains(_currentRepos, repository)) { add(repository); }
  auto new_catalogue  = make_catalogue_ptr();
  new_catalogue->name = catalogue.toStdString();
  _currentRepos[repository].add(new_catalogue);
  emit catalogueAdded(new_catalogue, repository);
  return new_catalogue;
}

void CatalogueController::add(CatalogueController::Event_ptr event,
                              CatalogueController::Catalogue_ptr catalogue)
{
  catalogue->add(event);
  emit this->catalogueChanged(catalogue);
}

void CatalogueController::add(CatalogueController::Event_ptr event,
                              const QString& repository)
{}

// void CatalogueController::saveDB(const QString& destinationPath, const
// QString& repositoryName)
//{
//    if (!impl->m_CatalogueDao.saveDB(destinationPath, repositoryName))
//    {
//        qCCritical(LOG_CatalogueController())
//            << tr("Impossible to saveDB %1 from %2 ").arg(repositoryName,
//            destinationPath);
//    }
//}

// std::list<std::shared_ptr<DBEvent>> CatalogueController::retrieveEvents(
//    const QString& repository) const
//{
//    QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT :
//    repository;

//    auto eventsShared = std::list<std::shared_ptr<DBEvent>> {};
//    auto events =
//    impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName)); for
//    (auto event : events)
//    {
//        eventsShared.push_back(std::make_shared<DBEvent>(event));
//    }
//    return eventsShared;
//}

// std::list<std::shared_ptr<DBEvent>> CatalogueController::retrieveAllEvents()
// const
//{
//    auto eventsShared = std::list<std::shared_ptr<DBEvent>> {};
//    for (auto repository : impl->m_RepositoryList)
//    {
//        eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
//    }

//    return eventsShared;
//}

// std::list<std::shared_ptr<DBEvent>>
// CatalogueController::retrieveEventsFromCatalogue(
//    std::shared_ptr<DBCatalogue> catalogue) const
//{
//    auto eventsShared = std::list<std::shared_ptr<DBEvent>> {};
//    auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
//    for (auto event : events)
//    {
//        eventsShared.push_back(std::make_shared<DBEvent>(event));
//    }
//    return eventsShared;
//}

// void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
//{
//    event->setRepository(impl->toWorkRepository(event->getRepository()));

//    auto uniqueId = impl->eventUniqueKey(event);
//    impl->m_KeysWithChanges.insert(uniqueId);

//    impl->m_CatalogueDao.updateEvent(*event);
//}

// void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct>
// eventProduct)
//{
//    impl->m_CatalogueDao.updateEventProduct(*eventProduct);
//}

// void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
//{
//    // Remove it from both repository and repository_work
//    event->setRepository(impl->toWorkRepository(event->getRepository()));
//    impl->m_CatalogueDao.removeEvent(*event);
//    event->setRepository(impl->toSyncRepository(event->getRepository()));
//    impl->m_CatalogueDao.removeEvent(*event);
//    impl->savAllDB();
//}

// void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
//{
//    event->setRepository(impl->toWorkRepository(event->getRepository()));

//    auto eventTemp = *event;
//    impl->m_CatalogueDao.addEvent(eventTemp);

//    // Call update is necessary at the creation of add Event if it has some
//    tags or some event
//    // products
//    if (!event->getEventProducts().empty() || !event->getTags().empty())
//    {

//        auto eventProductsTemp = eventTemp.getEventProducts();
//        auto eventProductTempUpdated = std::list<DBEventProduct> {};
//        for (auto eventProductTemp : eventProductsTemp)
//        {
//            eventProductTemp.setEvent(eventTemp);
//            eventProductTempUpdated.push_back(eventProductTemp);
//        }
//        eventTemp.setEventProducts(eventProductTempUpdated);

//        impl->m_CatalogueDao.updateEvent(eventTemp);
//    }

//    auto workPred = impl->createFinder(event->getUniqId(),
//    event->getRepository(), DBType::WORK);

//    auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
//    *event = workEvent;

//    auto uniqueId = impl->eventUniqueKey(event);
//    impl->m_KeysWithChanges.insert(uniqueId);
//}

// void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
//{
//    impl->saveEvent(event, true);
//    impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
//}

// void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event, bool&
// removed)
//{
//    auto syncPred = impl->createFinder(event->getUniqId(),
//    event->getRepository(), DBType::SYNC); auto workPred =
//    impl->createFinder(event->getUniqId(), event->getRepository(),
//    DBType::WORK);

//    auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
//    if (!syncEvent.getUniqId().isNull())
//    {
//        removed = false;
//        impl->m_CatalogueDao.copyEvent(
//            syncEvent, impl->toWorkRepository(event->getRepository()), true);

//        auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
//        *event = workEvent;
//        impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
//    }
//    else
//    {
//        removed = true;
//        // Since the element wasn't in sync repository. Discard it means
//        remove it
//        event->setRepository(impl->toWorkRepository(event->getRepository()));
//        impl->m_CatalogueDao.removeEvent(*event);
//    }
//}

// bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event)
// const
//{
//    return impl->m_KeysWithChanges.contains(impl->eventUniqueKey(event));
//}

// std::list<std::shared_ptr<DBCatalogue>>
// CatalogueController::retrieveCatalogues(
//    const QString& repository) const
//{
//    QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT :
//    repository;

//    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue>> {};
//    auto catalogues =
//    impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
//    for (auto catalogue : catalogues)
//    {
//        cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
//    }
//    return cataloguesShared;
//}

// void CatalogueController::addCatalogue(std::shared_ptr<DBCatalogue>
// catalogue)
//{
//    catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));

//    auto catalogueTemp = *catalogue;
//    impl->m_CatalogueDao.addCatalogue(catalogueTemp);

//    auto workPred
//        = impl->createFinder(catalogue->getUniqId(),
//        catalogue->getRepository(), DBType::WORK);

//    auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
//    *catalogue = workCatalogue;

//    auto uniqueId = impl->catalogueUniqueKey(catalogue);
//    impl->m_KeysWithChanges.insert(uniqueId);
//}

// void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue>
// catalogue)
//{
//    catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));

//    auto uniqueId = impl->catalogueUniqueKey(catalogue);
//    impl->m_KeysWithChanges.insert(uniqueId);

//    impl->m_CatalogueDao.updateCatalogue(*catalogue);
//}

// void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue>
// catalogue)
//{
//    // Remove it from both repository and repository_work
//    catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
//    impl->m_CatalogueDao.removeCatalogue(*catalogue);
//    catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
//    impl->m_CatalogueDao.removeCatalogue(*catalogue);
//    impl->savAllDB();
//}

// void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue>
// catalogue)
//{
//    impl->saveCatalogue(catalogue, true);
//    impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));

//    // remove key of events of the catalogue
//    if (catalogue->getType() == CatalogueType::STATIC)
//    {
//        auto events = this->retrieveEventsFromCatalogue(catalogue);
//        for (auto event : events)
//        {
//            impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
//        }
//    }
//}

// void CatalogueController::discardCatalogue(std::shared_ptr<DBCatalogue>
// catalogue, bool& removed)
//{
//    auto syncPred
//        = impl->createFinder(catalogue->getUniqId(),
//        catalogue->getRepository(), DBType::SYNC);
//    auto workPred
//        = impl->createFinder(catalogue->getUniqId(),
//        catalogue->getRepository(), DBType::WORK);

//    auto syncCatalogue = impl->m_CatalogueDao.getCatalogue(syncPred);
//    if (!syncCatalogue.getUniqId().isNull())
//    {
//        removed = false;
//        impl->m_CatalogueDao.copyCatalogue(
//            syncCatalogue, impl->toWorkRepository(catalogue->getRepository()),
//            true);

//        auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
//        *catalogue = workCatalogue;
//        impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));
//    }
//    else
//    {
//        removed = true;
//        // Since the element wasn't in sync repository. Discard it means
//        remove it
//        catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
//        impl->m_CatalogueDao.removeCatalogue(*catalogue);
//    }
//}

// void CatalogueController::saveAll()
//{
//    for (auto repository : impl->m_RepositoryList)
//    {
//        // Save Event
//        auto events = this->retrieveEvents(repository);
//        for (auto event : events)
//        {
//            impl->saveEvent(event, false);
//        }

//        // Save Catalogue
//        auto catalogues = this->retrieveCatalogues(repository);
//        for (auto catalogue : catalogues)
//        {
//            impl->saveCatalogue(catalogue, false);
//        }
//    }

//    impl->savAllDB();
//    impl->m_KeysWithChanges.clear();
//}

// bool CatalogueController::hasChanges() const
//{
//    return !impl->m_KeysWithChanges.isEmpty();
//}

// QByteArray CatalogueController::mimeDataForEvents(
//    const QVector<std::shared_ptr<DBEvent>>& events) const
//{
//    auto encodedData = QByteArray {};

//    QMap<QString, QVariantList> idsPerRepository;
//    for (auto event : events)
//    {
//        idsPerRepository[event->getRepository()] << event->getUniqId();
//    }

//    QDataStream stream { &encodedData, QIODevice::WriteOnly };
//    stream << idsPerRepository;

//    return encodedData;
//}

// QVector<std::shared_ptr<DBEvent>> CatalogueController::eventsForMimeData(
//    const QByteArray& mimeData) const
//{
//    auto events = QVector<std::shared_ptr<DBEvent>> {};
//    QDataStream stream { mimeData };

//    QMap<QString, QVariantList> idsPerRepository;
//    stream >> idsPerRepository;

//    for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend();
//    ++it)
//    {
//        auto repository = it.key();
//        auto allRepositoryEvent = retrieveEvents(repository);
//        for (auto uuid : it.value())
//        {
//            for (auto repositoryEvent : allRepositoryEvent)
//            {
//                if (uuid.toUuid() == repositoryEvent->getUniqId())
//                {
//                    events << repositoryEvent;
//                }
//            }
//        }
//    }

//    return events;
//}

// QByteArray CatalogueController::mimeDataForCatalogues(
//    const QVector<std::shared_ptr<DBCatalogue>>& catalogues) const
//{
//    auto encodedData = QByteArray {};

//    QMap<QString, QVariantList> idsPerRepository;
//    for (auto catalogue : catalogues)
//    {
//        idsPerRepository[catalogue->getRepository()] <<
//        catalogue->getUniqId();
//    }

//    QDataStream stream { &encodedData, QIODevice::WriteOnly };
//    stream << idsPerRepository;

//    return encodedData;
//}

// QVector<std::shared_ptr<DBCatalogue>>
// CatalogueController::cataloguesForMimeData(
//    const QByteArray& mimeData) const
//{
//    auto catalogues = QVector<std::shared_ptr<DBCatalogue>> {};
//    QDataStream stream { mimeData };

//    QMap<QString, QVariantList> idsPerRepository;
//    stream >> idsPerRepository;

//    for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend();
//    ++it)
//    {
//        auto repository = it.key();
//        auto allRepositoryCatalogues = retrieveCatalogues(repository);
//        for (auto uuid : it.value())
//        {
//            for (auto repositoryCatalogues : allRepositoryCatalogues)
//            {
//                if (uuid.toUuid() == repositoryCatalogues->getUniqId())
//                {
//                    catalogues << repositoryCatalogues;
//                }
//            }
//        }
//    }

//    return catalogues;
//}

// void CatalogueController::initialize()
//{
//    qCDebug(LOG_CatalogueController())
//        << tr("CatalogueController init") << QThread::currentThread();

//    impl->m_CatalogueDao.initialize();
//    auto defaultRepositoryLocation
//        = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

//    QDir defaultRepositoryLocationDir;
//    if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation))
//    {
//        defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
//        auto defaultRepository =
//        defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);

//        qCInfo(LOG_CatalogueController())
//            << tr("Persistant data loading from: ") << defaultRepository;

//        QDir dbDir(defaultRepository);
//        impl->m_RepositoryList << REPOSITORY_DEFAULT;
//        if (dbDir.exists())
//        {
//            auto dirName = dbDir.dirName();

//            if (impl->m_CatalogueDao.addDB(defaultRepository, dirName))
//            {
//                impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
//            }
//        }
//        else
//        {
//            qCInfo(LOG_CatalogueController())
//                << tr("Initialisation of Default repository detected") <<
//                defaultRepository;
//        }
//    }
//    else
//    {
//        qCWarning(LOG_CatalogueController())
//            << tr("Cannot load the persistent default repository from ")
//            << defaultRepositoryLocation;
//    }

//    qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
//}

// QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
//    const std::shared_ptr<DBEvent>& event) const
//{
//    return event->getUniqId().toString().append(event->getRepository());
//}

// QString CatalogueController::CatalogueControllerPrivate::catalogueUniqueKey(
//    const std::shared_ptr<DBCatalogue>& catalogue) const
//{
//    return
//    catalogue->getUniqId().toString().append(catalogue->getRepository());
//}

// void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(
//    const QString& dbFrom, const QString& dbTo)
//{
//    //    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
//    auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
//    auto events = m_CatalogueDao.getEvents(dbFrom);
//    for (auto catalogue : catalogues)
//    {
//        m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
//    }

//    for (auto event : events)
//    {
//        m_CatalogueDao.copyEvent(event, dbTo, true);
//    }
//}

// QString
// CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString
// repository)
//{
//    auto syncRepository = toSyncRepository(repository);

//    return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
//}

// QString
// CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString
// repository)
//{
//    auto syncRepository = repository;
//    if (repository.endsWith(REPOSITORY_WORK_SUFFIX))
//    {
//        syncRepository.remove(REPOSITORY_WORK_SUFFIX);
//    }
//    else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX))
//    {
//        syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
//    }
//    return syncRepository;
//}

// void CatalogueController::CatalogueControllerPrivate::savAllDB()
//{
//    for (auto repository : m_RepositoryList)
//    {
//        auto defaultRepositoryLocation
//            =
//            QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
//        m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
//    }
//}

// void CatalogueController::CatalogueControllerPrivate::saveEvent(
//    std::shared_ptr<DBEvent> event, bool persist)
//{
//    m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()),
//    true); if (persist)
//    {
//        savAllDB();
//    }
//}

// void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
//    std::shared_ptr<DBCatalogue> catalogue, bool persist)
//{
//    m_CatalogueDao.copyCatalogue(*catalogue,
//    toSyncRepository(catalogue->getRepository()), true); if (persist)
//    {
//        savAllDB();
//    }
//}

// std::shared_ptr<IRequestPredicate>
// CatalogueController::CatalogueControllerPrivate::createFinder(
//    const QUuid& uniqId, const QString& repository, DBType type)
//{
//    // update catalogue parameter
//    auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
//        QString { "uniqId" }, uniqId, ComparaisonOperation::EQUALEQUAL);

//    auto repositoryType = repository;
//    switch (type)
//    {
//        case DBType::SYNC:
//            repositoryType = toSyncRepository(repositoryType);
//            break;
//        case DBType::WORK:
//            repositoryType = toWorkRepository(repositoryType);
//            break;
//        case DBType::TRASH:
//        default:
//            break;
//    }

//    auto repositoryPredicate = std::make_shared<ComparaisonPredicate>(
//        QString { "repository" }, repositoryType,
//        ComparaisonOperation::EQUALEQUAL);

//    auto finderPred =
//    std::make_shared<CompoundPredicate>(CompoundOperation::AND);
//    finderPred->AddRequestPredicate(uniqIdPredicate);
//    finderPred->AddRequestPredicate(repositoryPredicate);

//    return finderPred;
//}