/*
 * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
 */
#include "resourcefacade.h"

#include "resourceconfig.h"
#include "query.h"
#include "definitions.h"
#include "storage.h"
#include "resourceaccess.h"
#include <QDir>

using namespace Sink;

template<typename DomainType>
ConfigNotifier LocalStorageFacade<DomainType>::sConfigNotifier;

template <typename DomainType>
static typename DomainType::Ptr readFromConfig(ConfigStore &configStore, const QByteArray &id, const QByteArray &type)
{
    auto object = DomainType::Ptr::create(id);
    object->setProperty("type", type);
    const auto configurationValues = configStore.get(id);
    for (auto it = configurationValues.constBegin(); it != configurationValues.constEnd(); it++) {
        object->setProperty(it.key(), it.value());
    }
    return object;
}

static bool matchesFilter(const QHash<QByteArray, Query::Comparator> &filter, const QMap<QByteArray, QVariant> &properties)
{
    for (const auto &filterProperty : filter.keys()) {
        if (filterProperty == "type") {
            continue;
        }
        if (!filter.value(filterProperty).matches(properties.value(filterProperty))) {
            return false;
        }
    }
    return true;
}

template<typename DomainType>
LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query, const QByteArray &identifier, ConfigNotifier &configNotifier)
    : mResultProvider(new ResultProvider<typename DomainType::Ptr>), mConfigStore(identifier)
{
    QObject *guard = new QObject;
    mResultProvider->setFetcher([this, query, guard, &configNotifier](const QSharedPointer<DomainType> &) {
        const auto entries = mConfigStore.getEntries();
        for (const auto &res : entries.keys()) {
            const auto type = entries.value(res);

            if (query.propertyFilter.contains("type") && query.propertyFilter.value("type").value.toByteArray() != type) {
                Trace() << "Skipping due to type.";
                continue;
            }
            if (!query.ids.isEmpty() && !query.ids.contains(res)) {
                continue;
            }
            const auto configurationValues = mConfigStore.get(res);
            if (!matchesFilter(query.propertyFilter, configurationValues)){
                Trace() << "Skipping due to filter.";
                continue;
            }
            Trace() << "Found match " << res;
            auto entity = readFromConfig<DomainType>(mConfigStore, res, type);
            updateStatus(*entity);
            mResultProvider->add(entity);
        }
        if (query.liveQuery) {
            {
                auto ret = QObject::connect(&configNotifier, &ConfigNotifier::added, guard, [this](const ApplicationDomain::ApplicationDomainType::Ptr &entry) {
                    auto entity = entry.staticCast<DomainType>();
                    updateStatus(*entity);
                    mResultProvider->add(entity);
                });
                Q_ASSERT(ret);
            }
            {
                auto ret = QObject::connect(&configNotifier, &ConfigNotifier::modified, guard, [this](const ApplicationDomain::ApplicationDomainType::Ptr &entry) {
                    auto entity = entry.staticCast<DomainType>();
                    updateStatus(*entity);
                    mResultProvider->modify(entity);
                });
                Q_ASSERT(ret);
            }
            {
                auto ret = QObject::connect(&configNotifier, &ConfigNotifier::removed, guard, [this](const ApplicationDomain::ApplicationDomainType::Ptr &entry) {
                    mResultProvider->remove(entry.staticCast<DomainType>());
                });
                Q_ASSERT(ret);
            }
        }
        // TODO initialResultSetComplete should be implicit
        mResultProvider->initialResultSetComplete(typename DomainType::Ptr());
        mResultProvider->complete();
    });
    mResultProvider->onDone([=]() { delete guard; });
}

// QByteArrayList getMatchingEntries(const Query &query)
// {
//         const auto entries = mConfigStore.getEntries();
//         for (const auto &res : entries.keys()) {
//             const auto type = entries.value(res);
//
//             if (query.propertyFilter.contains("type") && query.propertyFilter.value("type").value.toByteArray() != type) {
//                 Trace() << "Skipping due to type.";
//                 continue;
//             }
//             if (!query.ids.isEmpty() && !query.ids.contains(res)) {
//                 continue;
//             }
//             const auto configurationValues = mConfigStore.get(res);
//             if (!matchesFilter(query.propertyFilter, configurationValues)){
//                 Trace() << "Skipping due to filter.";
//                 continue;
//             }
//             Trace() << "Found match " << res;
//             auto entity = readFromConfig<DomainType>(mConfigStore, res, type);
//             updateStatus(*entity);
//             mResultProvider->add(entity);
//         }
//
// }


template<typename DomainType>
void LocalStorageQueryRunner<DomainType>::updateStatus(DomainType &entity)
{
    if (mStatusUpdater) {
        mStatusUpdater(entity);
    }
}

template<typename DomainType>
void LocalStorageQueryRunner<DomainType>::setStatusUpdater(const std::function<void(DomainType &)> &updater)
{
    mStatusUpdater = updater;
}

template<typename DomainType>
void LocalStorageQueryRunner<DomainType>::statusChanged(const QByteArray &identifier)
{
    Trace() << "Status changed " << identifier;
    auto entity = readFromConfig<DomainType>(mConfigStore, identifier, ApplicationDomain::getTypeName<DomainType>());
    updateStatus(*entity);
    mResultProvider->modify(entity);
}

template<typename DomainType>
typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr LocalStorageQueryRunner<DomainType>::emitter()
{
    return mResultProvider->emitter();
}


template <typename DomainType>
LocalStorageFacade<DomainType>::LocalStorageFacade(const QByteArray &identifier) : StoreFacade<DomainType>(), mIdentifier(identifier), mConfigStore(identifier)
{
}

template <typename DomainType>
LocalStorageFacade<DomainType>::~LocalStorageFacade()
{
}

template <typename DomainType>
typename DomainType::Ptr LocalStorageFacade<DomainType>::readFromConfig(const QByteArray &id, const QByteArray &type)
{
    return ::readFromConfig<DomainType>(mConfigStore, id, type);
}

template <typename DomainType>
KAsync::Job<void> LocalStorageFacade<DomainType>::create(const DomainType &domainObject)
{
    return KAsync::start<void>([domainObject, this]() {
        const QByteArray type = domainObject.getProperty("type").toByteArray();
        const QByteArray providedIdentifier = domainObject.identifier().isEmpty() ? domainObject.getProperty("identifier").toByteArray() : domainObject.identifier();
        const QByteArray identifier = providedIdentifier.isEmpty() ? ResourceConfig::newIdentifier(type) : providedIdentifier;
        mConfigStore.add(identifier, type);
        auto changedProperties = domainObject.changedProperties();
        changedProperties.removeOne("identifier");
        changedProperties.removeOne("type");
        if (!changedProperties.isEmpty()) {
            // We have some configuration values
            QMap<QByteArray, QVariant> configurationValues;
            for (const auto &property : changedProperties) {
                configurationValues.insert(property, domainObject.getProperty(property));
            }
            mConfigStore.modify(identifier, configurationValues);
        }
        sConfigNotifier.add(readFromConfig(identifier, type));
    });
}

template <typename DomainType>
KAsync::Job<void> LocalStorageFacade<DomainType>::modify(const DomainType &domainObject)
{
    return KAsync::start<void>([domainObject, this]() {
        const QByteArray identifier = domainObject.identifier();
        if (identifier.isEmpty()) {
            Warning() << "We need an \"identifier\" property to identify the entity to configure.";
            return;
        }
        auto changedProperties = domainObject.changedProperties();
        changedProperties.removeOne("identifier");
        changedProperties.removeOne("type");
        if (!changedProperties.isEmpty()) {
            // We have some configuration values
            QMap<QByteArray, QVariant> configurationValues;
            for (const auto &property : changedProperties) {
                configurationValues.insert(property, domainObject.getProperty(property));
            }
            mConfigStore.modify(identifier, configurationValues);
        }

        const auto type = mConfigStore.getEntries().value(identifier);
        sConfigNotifier.modify(readFromConfig(identifier, type));
    });
}

template <typename DomainType>
KAsync::Job<void> LocalStorageFacade<DomainType>::remove(const DomainType &domainObject)
{
    return KAsync::start<void>([domainObject, this]() {
        const QByteArray identifier = domainObject.identifier();
        if (identifier.isEmpty()) {
            Warning() << "We need an \"identifier\" property to identify the entity to configure";
            return;
        }
        Trace() << "Removing: " << identifier;
        mConfigStore.remove(identifier);
        sConfigNotifier.remove(QSharedPointer<DomainType>::create(domainObject));
    });
}

template <typename DomainType>
QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> LocalStorageFacade<DomainType>::load(const Query &query)
{
    auto runner = new LocalStorageQueryRunner<DomainType>(query, mIdentifier, sConfigNotifier);
    return qMakePair(KAsync::null<void>(), runner->emitter());
}

ResourceFacade::ResourceFacade() : LocalStorageFacade<Sink::ApplicationDomain::SinkResource>("resources")
{
}

ResourceFacade::~ResourceFacade()
{
}

KAsync::Job<void> ResourceFacade::remove(const Sink::ApplicationDomain::SinkResource &resource)
{
    const auto identifier = resource.identifier();
    return LocalStorageFacade<Sink::ApplicationDomain::SinkResource>::remove(resource).then<void>([identifier]() {
        // TODO shutdown resource, or use the resource process with a --remove option to cleanup (so we can take advantage of the file locking)
        QDir dir(Sink::storageLocation());
        for (const auto &folder : dir.entryList(QStringList() << identifier + "*")) {
            Sink::Storage(Sink::storageLocation(), folder, Sink::Storage::ReadWrite).removeFromDisk();
        }
    });
}

QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain::SinkResource::Ptr>::Ptr> ResourceFacade::load(const Sink::Query &query)
{
    auto runner = new LocalStorageQueryRunner<ApplicationDomain::SinkResource>(query, mIdentifier, sConfigNotifier);
    auto monitoredResources = QSharedPointer<QSet<QByteArray>>::create();
    runner->setStatusUpdater([runner, monitoredResources](ApplicationDomain::SinkResource &resource) {
        auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource.identifier(), ResourceConfig::getResourceType(resource.identifier()));
        if (!monitoredResources->contains(resource.identifier())) {
            //TODO disconnect at some point when the runner is done
            auto ret = QObject::connect(resourceAccess.data(), &ResourceAccess::notification, [resource, runner, resourceAccess](const Notification &notification) {
                Trace() << "Received notification in facade: " << notification.type;
                if (notification.type == Notification::Status) {
                    runner->statusChanged(resource.identifier());
                }
            });
            Q_ASSERT(ret);
            monitoredResources->insert(resource.identifier());
        }
        resource.setStatusStatus(resourceAccess->getResourceStatus());
    });
    return qMakePair(KAsync::null<void>(), runner->emitter());
}


AccountFacade::AccountFacade() : LocalStorageFacade<Sink::ApplicationDomain::SinkAccount>("accounts")
{
}

AccountFacade::~AccountFacade()
{
}

IdentityFacade::IdentityFacade() : LocalStorageFacade<Sink::ApplicationDomain::Identity>("identities")
{
}

IdentityFacade::~IdentityFacade()
{
}

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wundefined-reinterpret-cast"
#include "moc_resourcefacade.cpp"
#pragma clang diagnostic pop