#include "specialpurposepreprocessor.h"
#include "entityreader.h"
#include "query.h"
#include "applicationdomaintype.h"

using namespace Sink;

static QHash<QByteArray, QString> specialPurposeFolders()
{
    QHash<QByteArray, QString> hash;
        //FIXME localize
    hash.insert("drafts", "Drafts");
    hash.insert("trash", "Trash");
    return hash;
}

static QHash<QString, QByteArray> specialPurposeNames()
{
    QHash<QString, QByteArray> hash;
    for (const auto &value : specialPurposeFolders().values()) {
        hash.insert(value.toLower(), specialPurposeFolders().key(value));
    }
    return hash;
}

//specialpurpose, name
static QHash<QByteArray, QString> sSpecialPurposeFolders = specialPurposeFolders();
//Lowercase-name, specialpurpose
static QHash<QString, QByteArray> sSpecialPurposeNames = specialPurposeNames();

namespace SpecialPurpose {
bool isSpecialPurposeFolderName(const QString &name)
{
    return sSpecialPurposeNames.contains(name.toLower());
}

QByteArray getSpecialPurposeType(const QString &name)
{
    return sSpecialPurposeNames.value(name.toLower());
}
}

SpecialPurposeProcessor::SpecialPurposeProcessor(const QByteArray &resourceType, const QByteArray &resourceInstanceIdentifier) : mResourceType(resourceType), mResourceInstanceIdentifier(resourceInstanceIdentifier) {}

QByteArray SpecialPurposeProcessor::ensureFolder(Sink::Storage::Transaction &transaction, const QByteArray &specialPurpose)
{
    if (!mSpecialPurposeFolders.contains(specialPurpose)) {
        //Try to find an existing drafts folder
        Sink::EntityReader<ApplicationDomain::Folder> reader(mResourceType, mResourceInstanceIdentifier, transaction);
        reader.query(Sink::Query().filter<ApplicationDomain::Folder::SpecialPurpose>(Query::Comparator(specialPurpose, Query::Comparator::Contains)),
            [this, specialPurpose](const ApplicationDomain::Folder &f) -> bool{
                mSpecialPurposeFolders.insert(specialPurpose, f.identifier());
                return false;
            });
        if (!mSpecialPurposeFolders.contains(specialPurpose)) {
            Trace() << "Failed to find a drafts folder, creating a new one";
            auto folder = ApplicationDomain::Folder::create(mResourceInstanceIdentifier);
            folder.setSpecialPurpose(QByteArrayList() << specialPurpose);
            folder.setName(sSpecialPurposeFolders.value(specialPurpose));
            folder.setIcon("folder");
            //This processes the pipeline synchronously
            createEntity(folder);
            mSpecialPurposeFolders.insert(specialPurpose, folder.identifier());
        }
    }
    return mSpecialPurposeFolders.value(specialPurpose);
}

void SpecialPurposeProcessor::moveToFolder(Sink::ApplicationDomain::BufferAdaptor &newEntity, Sink::Storage::Transaction &transaction)
{
    if (newEntity.getProperty("trash").toBool()) {
        newEntity.setProperty("folder", ensureFolder(transaction, "trash"));
        return;
    }
    if (newEntity.getProperty("draft").toBool()) {
        newEntity.setProperty("folder", ensureFolder(transaction, "drafts"));
    }
}

void SpecialPurposeProcessor::newEntity(const QByteArray &uid, qint64 revision, Sink::ApplicationDomain::BufferAdaptor &newEntity, Sink::Storage::Transaction &transaction)
{
    moveToFolder(newEntity, transaction);
}

void SpecialPurposeProcessor::modifiedEntity(const QByteArray &uid, qint64 revision, const Sink::ApplicationDomain::BufferAdaptor &oldEntity, Sink::ApplicationDomain::BufferAdaptor &newEntity, Sink::Storage::Transaction &transaction)
{
    moveToFolder(newEntity, transaction);
}