recursivemover.cpp

/*
    Copyright (c) 2012 Volker Krause <vkrause@kde.org>

    This library is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public License as published by
    the Free Software Foundation; either version 2 of the License, or (at your
    option) any later version.

    This library is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
    License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "recursivemover_p.h"
#include "collectionfetchjob.h"
#include "itemfetchjob.h"
#include "itemfetchscope.h"
#include "collectionfetchscope.h"

using namespace Akonadi;

RecursiveMover::RecursiveMover(AgentBasePrivate *parent)
    : KCompositeJob(parent)
    , m_agentBase(parent)
    , m_currentAction(None)
    , m_runningJobs(0)
    , m_pendingReplay(false)
{
}

void RecursiveMover::start()
{
    Q_ASSERT(receivers(SIGNAL(result(KJob*))));

    CollectionFetchJob *job = new CollectionFetchJob(m_movedCollection, CollectionFetchJob::Recursive, this);
    connect(job, SIGNAL(finished(KJob*)), SLOT(collectionListResult(KJob*)));
    addSubjob(job);
    ++m_runningJobs;
}

void RecursiveMover::setCollection(const Collection &collection, const Collection &parentCollection)
{
    m_movedCollection = collection;
    m_collections.insert(collection.id(), m_movedCollection);
    m_collections.insert(parentCollection.id(), parentCollection);
}

void RecursiveMover::collectionListResult(KJob *job)
{
    Q_ASSERT(m_pendingCollections.isEmpty());
    --m_runningJobs;

    if (job->error()) {
        return; // error handling is in the base class
    }

    // build a parent -> children map for the following topological sorting
    // while we are iterating anyway, also fill m_collections here
    CollectionFetchJob *fetchJob = qobject_cast<CollectionFetchJob *>(job);
    QHash<Collection::Id, Collection::List> colTree;
    foreach (const Collection &col, fetchJob->collections()) {
        colTree[col.parentCollection().id()] << col;
        m_collections.insert(col.id(), col);
    }

    // topological sort; BFS traversal of the tree
    m_pendingCollections.push_back(m_movedCollection);
    QQueue<Collection> toBeProcessed;
    toBeProcessed.enqueue(m_movedCollection);
    while (!toBeProcessed.isEmpty()) {
        const Collection col = toBeProcessed.dequeue();
        const Collection::List children = colTree.value(col.id());
        if (children.isEmpty()) {
            continue;
        }
        m_pendingCollections.append(children);
        foreach (const Collection &child, children) {
            toBeProcessed.enqueue(child);
        }
    }

    replayNextCollection();
}

void RecursiveMover::collectionFetchResult(KJob *job)
{
    Q_ASSERT(m_currentCollection.isValid());
    --m_runningJobs;

    if (job->error()) {
        return; // error handling is in the base class
    }

    CollectionFetchJob *fetchJob = qobject_cast<CollectionFetchJob *>(job);
    if (fetchJob->collections().size() == 1) {
        m_currentCollection = fetchJob->collections().first();
        m_currentCollection.setParentCollection(m_collections.value(m_currentCollection.parentCollection().id()));
        m_collections.insert(m_currentCollection.id(), m_currentCollection);
    } else {
        // already deleted, move on
    }

    if (!m_runningJobs && m_pendingReplay) {
        replayNext();
    }
}

void RecursiveMover::itemListResult(KJob *job)
{
    --m_runningJobs;

    if (job->error()) {
        return; // error handling is in the base class
    }

    foreach (const Item &item, qobject_cast<ItemFetchJob *>(job)->items()) {
        if (item.remoteId().isEmpty()) {
            m_pendingItems.push_back(item);
        }
    }

    if (!m_runningJobs && m_pendingReplay) {
        replayNext();
    }
}

void RecursiveMover::itemFetchResult(KJob *job)
{
    Q_ASSERT(m_currentAction == None);
    --m_runningJobs;

    if (job->error()) {
        return; // error handling is in the base class
    }

    ItemFetchJob *fetchJob = qobject_cast<ItemFetchJob *>(job);
    if (fetchJob->items().size() == 1) {
        m_currentAction = AddItem;
        m_agentBase->itemAdded(fetchJob->items().first(), m_currentCollection);
    } else {
        // deleted since we started, skip
        m_currentItem = Item();
        replayNextItem();
    }
}

void RecursiveMover::replayNextCollection()
{
    if (!m_pendingCollections.isEmpty()) {

        m_currentCollection = m_pendingCollections.takeFirst();
        ItemFetchJob *job = new ItemFetchJob(m_currentCollection, this);
        connect(job, SIGNAL(result(KJob*)), SLOT(itemListResult(KJob*)));
        addSubjob(job);
        ++m_runningJobs;

        if (m_currentCollection.remoteId().isEmpty()) {
            Q_ASSERT(m_currentAction == None);
            m_currentAction = AddCollection;
            m_agentBase->collectionAdded(m_currentCollection, m_collections.value(m_currentCollection.parentCollection().id()));
            return;
        } else {
            //replayNextItem(); - but waiting for the fetch job to finish first
            m_pendingReplay = true;
            return;
        }
    } else {
        // nothing left to do
        emitResult();
    }
}

void RecursiveMover::replayNextItem()
{
    Q_ASSERT(m_currentCollection.isValid());
    if (m_pendingItems.isEmpty()) {
        replayNextCollection(); // all items processed here
        return;
    } else {
        Q_ASSERT(m_currentAction == None);
        m_currentItem = m_pendingItems.takeFirst();
        ItemFetchJob *job = new ItemFetchJob(m_currentItem, this);
        job->fetchScope().fetchFullPayload();
        connect(job, SIGNAL(result(KJob*)), SLOT(itemFetchResult(KJob*)));
        addSubjob(job);
        ++m_runningJobs;
    }
}

void RecursiveMover::changeProcessed()
{
    Q_ASSERT(m_currentAction != None);

    if (m_currentAction == AddCollection) {
        Q_ASSERT(m_currentCollection.isValid());
        CollectionFetchJob *job = new CollectionFetchJob(m_currentCollection, CollectionFetchJob::Base, this);
        job->fetchScope().setAncestorRetrieval(CollectionFetchScope::All);
        connect(job, SIGNAL(result(KJob*)), SLOT(collectionFetchResult(KJob*)));
        addSubjob(job);
        ++m_runningJobs;
    }

    m_currentAction = None;
}

void RecursiveMover::replayNext()
{
    // wait for runnings jobs to finish before actually doing the replay
    if (m_runningJobs) {
        m_pendingReplay = true;
        return;
    }

    m_pendingReplay = false;

    if (m_currentCollection.isValid()) {
        replayNextItem();
    } else {
        replayNextCollection();
    }
}

#include "moc_recursivemover_p.cpp"