e2eefoldermanager.cpp

// SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
// SPDX-License-Identifier: GPL-2.0-or-later

#include "e2eefoldermanager.h"
#include "accountmanager.h"
#include "clientsideencryption.h"
#include "folderman.h"
#include "folder.h"

#include <QLoggingCategory>

namespace OCC {

Q_LOGGING_CATEGORY(lcE2eFolderManager, "nextcloud.gui.e2efoldermanager", QtInfoMsg)

E2EFolderManager *E2EFolderManager::_instance = nullptr;

E2EFolderManager *E2EFolderManager::instance()
{
    if (!_instance) {
        _instance = new E2EFolderManager();
    }
    return _instance;
}

E2EFolderManager::E2EFolderManager(QObject *parent)
    : QObject(parent)
{
    const auto accounts = AccountManager::instance()->accounts();
    for (const auto &accountState : accounts) {
        if (accountState && accountState->account() && accountState->account()->e2e()) {
            connectE2eSignals(accountState->account());
        }
    }

    connect(AccountManager::instance(), &AccountManager::accountAdded,
            this, &E2EFolderManager::slotAccountAdded);
}

E2EFolderManager::~E2EFolderManager()
{
    _instance = nullptr;
}

void E2EFolderManager::slotAccountAdded(AccountState *accountState)
{
    if (accountState && accountState->account() && accountState->account()->e2e()) {
        connectE2eSignals(accountState->account());
    }
}

void E2EFolderManager::connectE2eSignals(const AccountPtr &account)
{
    if (!account || !account->e2e()) {
        return;
    }

    connect(account->e2e(), &ClientSideEncryption::initializationFinished,
            this, &E2EFolderManager::slotE2eInitializationFinished, Qt::UniqueConnection);

    if (account->e2e()->isInitialized()) {
        restoreE2eFoldersForAccount(account);
    }
}

void E2EFolderManager::slotE2eInitializationFinished()
{
    qCDebug(lcE2eFolderManager) << "E2E initialization finished, restoring blacklisted E2E folders";

    auto *e2e = qobject_cast<ClientSideEncryption *>(sender());
    if (!e2e) {
        qCWarning(lcE2eFolderManager) << "slotE2eInitializationFinished called but sender is not ClientSideEncryption";
        return;
    }

    const auto accounts = AccountManager::instance()->accounts();
    for (const auto &accountState : accounts) {
        if (accountState->account()->e2e() == e2e) {
            restoreE2eFoldersForAccount(accountState->account());
            break;
        }
    }
}

void E2EFolderManager::restoreE2eFoldersForAccount(const AccountPtr &account)
{
    if (!account || !account->e2e() || !account->e2e()->isInitialized()) {
        qCDebug(lcE2eFolderManager) << "Cannot restore folders - account or E2E not ready";
        return;
    }

    qCDebug(lcE2eFolderManager) << "Restoring E2E folders for account:" << account->displayName();

    auto *folderMan = FolderMan::instance();
    const auto folders = folderMan->map();

    int foldersProcessed = 0;
    for (const auto &folder : folders) {
        if (folder->accountState()->account() != account) {
            continue;
        }

        bool ok = false;
        const auto foldersToRemoveFromBlacklist = folder->journalDb()->getSelectiveSyncList(
            SyncJournalDb::SelectiveSyncE2eFoldersToRemoveFromBlacklist, &ok);

        if (foldersToRemoveFromBlacklist.isEmpty()) {
            continue;
        }

        qCDebug(lcE2eFolderManager) << "Found E2E folders to restore for" << folder->alias()
                                   << ":" << foldersToRemoveFromBlacklist;

        auto blackList = folder->journalDb()->getSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList, &ok);
        qCDebug(lcE2eFolderManager) << "Current blacklist:" << blackList;
        const auto blackListSize = blackList.size();

        for (const auto &pathToRemoveFromBlackList : foldersToRemoveFromBlacklist) {
            blackList.removeAll(pathToRemoveFromBlackList);
        }

        if (blackList.size() != blackListSize) {
            if (folder->isSyncRunning()) {
                qCDebug(lcE2eFolderManager) << "Folder is syncing, terminating to prevent E2E folder deletion";
                folderTerminateSyncAndUpdateBlackList(blackList, folder, foldersToRemoveFromBlacklist);
                ++foldersProcessed;
                continue;
            }

            folder->journalDb()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList, blackList);
            folder->journalDb()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncE2eFoldersToRemoveFromBlacklist, {});

            for (const auto &pathToRemoteDiscover : foldersToRemoveFromBlacklist) {
                folder->journalDb()->schedulePathForRemoteDiscovery(pathToRemoteDiscover);
            }

            folderMan->scheduleFolder(folder);
            ++foldersProcessed;
        }
    }

    if (foldersProcessed > 0) {
        qCDebug(lcE2eFolderManager) << "Restored E2E folders for" << foldersProcessed << "sync folders";
    } else {
        qCDebug(lcE2eFolderManager) << "No E2E folders needed restoration";
    }
}

void E2EFolderManager::folderTerminateSyncAndUpdateBlackList(const QStringList &blackList, OCC::Folder *folder, const QStringList &foldersToRemoveFromBlacklist)
{
    if (_folderConnections.contains(folder->alias())) {
        qCWarning(lcE2eFolderManager) << "Folder " << folder->alias() << "is already terminating the sync.";
        return;
    }
    // in case sync is already running - terminate it and start a new one
    const QMetaObject::Connection syncTerminatedConnection = connect(folder, &Folder::syncFinished, this, [this, blackList, folder, foldersToRemoveFromBlacklist]() {
        const auto foundConnectionIt = _folderConnections.find(folder->alias());
        if (foundConnectionIt != _folderConnections.end()) {
            disconnect(*foundConnectionIt);
            _folderConnections.erase(foundConnectionIt);
        }
        
        folder->journalDb()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList, blackList);
        folder->journalDb()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncE2eFoldersToRemoveFromBlacklist, {});

        for (const auto &pathToRemoteDiscover : foldersToRemoveFromBlacklist) {
            folder->journalDb()->schedulePathForRemoteDiscovery(pathToRemoteDiscover);
        }

        FolderMan::instance()->scheduleFolder(folder);
    });
    _folderConnections.insert(folder->alias(), syncTerminatedConnection);
    folder->slotTerminateSync();
}

} // namespace OCC