/*
    Copyright (c) 2008 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 "firstrun_p.h"
#include "dbusconnectionpool.h"
#include "servermanager.h"

#include <akonadi/agentinstance.h>
#include <akonadi/agentinstancecreatejob.h>
#include <akonadi/agentmanager.h>
#include <akonadi/agenttype.h>

#include <KConfig>
#include <KConfigGroup>
#include <KDebug>
#include <KGlobal>
#include <KProcess>
#include <KStandardDirs>

#include <QtDBus/QDBusConnection>
#include <QtDBus/QDBusInterface>
#include <QtDBus/QDBusReply>
#include <QtCore/QDir>
#include <QtCore/QMetaMethod>
#include <QtCore/QMetaObject>

static char FIRSTRUN_DBUSLOCK[] = "org.kde.Akonadi.Firstrun.lock";

using namespace Akonadi;

Firstrun::Firstrun(QObject *parent)
    : QObject(parent)
    , mConfig(new KConfig(ServerManager::addNamespace(QLatin1String("akonadi-firstrunrc"))))
    , mCurrentDefault(0)
    , mProcess(0)
{
    //The code in firstrun is not safe in multi-instance mode
    Q_ASSERT(!ServerManager::hasInstanceIdentifier());
    if (ServerManager::hasInstanceIdentifier()) {
        deleteLater();
        return;
    }
    kDebug();
    if (DBusConnectionPool::threadConnection().registerService(QLatin1String(FIRSTRUN_DBUSLOCK))) {
        findPendingDefaults();
        kDebug() << mPendingDefaults;
        setupNext();
    } else {
        kDebug() << "D-Bus lock found, so someone else does the work for us already.";
        deleteLater();
    }
}

Firstrun::~Firstrun()
{
    DBusConnectionPool::threadConnection().unregisterService(QLatin1String(FIRSTRUN_DBUSLOCK));
    delete mConfig;
    kDebug() << "done";
}

void Firstrun::findPendingDefaults()
{
    const KConfigGroup cfg(mConfig, "ProcessedDefaults");
    foreach (const QString &dirName, KGlobal::dirs()->findDirs("data", QLatin1String("akonadi/firstrun"))) {
        const QStringList files = QDir(dirName).entryList(QDir::Files | QDir::Readable);
        foreach (const QString &fileName, files) {
            const QString fullName = dirName + fileName;
            KConfig c(fullName);
            const QString id = KConfigGroup(&c, "Agent").readEntry("Id", QString());
            if (id.isEmpty()) {
                kWarning() << "Found invalid default configuration in " << fullName;
                continue;
            }
            if (cfg.hasKey(id)) {
                continue;
            }
            mPendingDefaults << dirName + fileName;
        }
    }

#ifndef KDEPIM_NO_KRESOURCES
    // always check legacy kres for migration, their migrator might have changed again
    mPendingKres << QLatin1String("contact") << QLatin1String("calendar");
#endif
}

#ifndef KDEPIM_NO_KRESOURCES
static QString resourceTypeForMimetype(const QStringList &mimeTypes)
{
    if (mimeTypes.contains(QLatin1String("text/directory"))) {
        return QString::fromLatin1("contact");
    }
    if (mimeTypes.contains(QLatin1String("text/calendar"))) {
        return QString::fromLatin1("calendar");
    }
    // TODO notes
    return QString();
}

void Firstrun::migrateKresType(const QString &resourceFamily)
{
    mResourceFamily = resourceFamily;
    KConfig config(QLatin1String("kres-migratorrc"));
    KConfigGroup migrationCfg(&config, "Migration");
    const bool enabled = migrationCfg.readEntry("Enabled", false);
    const bool setupClientBridge = migrationCfg.readEntry("SetupClientBridge", true);
    const int currentVersion = migrationCfg.readEntry(QString::fromLatin1("Version-%1").arg(resourceFamily), 0);
    const int targetVersion = migrationCfg.readEntry("TargetVersion", 0);
    if (enabled && currentVersion < targetVersion) {
        kDebug() << "Performing migration of legacy KResource settings. Good luck!";
        mProcess = new KProcess(this);
        connect(mProcess, SIGNAL(finished(int)), SLOT(migrationFinished(int)));
        QStringList args = QStringList() << QLatin1String("--interactive-on-change")
                           << QLatin1String("--type") << resourceFamily;
        if (!setupClientBridge) {
            args << QLatin1String("--omit-client-bridge");
        }
        mProcess->setProgram(QLatin1String("kres-migrator"), args);
        mProcess->start();
        if (!mProcess->waitForStarted()) {
            migrationFinished(-1);
        }
    } else {
        // nothing to do
        setupNext();
    }
}

void Firstrun::migrationFinished(int exitCode)
{
    Q_ASSERT(mProcess);
    if (exitCode == 0) {
        kDebug() << "KResource -> Akonadi migration has been successful";
        KConfig config(QLatin1String("kres-migratorrc"));
        KConfigGroup migrationCfg(&config, "Migration");
        const int targetVersion = migrationCfg.readEntry("TargetVersion", 0);
        migrationCfg.writeEntry(QString::fromLatin1("Version-%1").arg(mResourceFamily), targetVersion);
        migrationCfg.sync();
    } else if (exitCode != 1) {
        // exit code 1 means it is already running, so we are probably called by a migrator instance
        kError() << "KResource -> Akonadi migration failed!";
        kError() << "command was: " << mProcess->program();
        kError() << "exit code: " << mProcess->exitCode();
        kError() << "stdout: " << mProcess->readAllStandardOutput();
        kError() << "stderr: " << mProcess->readAllStandardError();
    }

    setupNext();
}
#endif

void Firstrun::setupNext()
{
    delete mCurrentDefault;
    mCurrentDefault = 0;

    if (mPendingDefaults.isEmpty()) {
#ifndef KDEPIM_NO_KRESOURCES
        if (!mPendingKres.isEmpty()) {
            migrateKresType(mPendingKres.takeFirst());
            return;
        }
#endif
        deleteLater();
        return;
    }

    mCurrentDefault = new KConfig(mPendingDefaults.takeFirst());
    const KConfigGroup agentCfg = KConfigGroup(mCurrentDefault, "Agent");

    AgentType type = AgentManager::self()->type(agentCfg.readEntry("Type", QString()));
    if (!type.isValid()) {
        kError() << "Unable to obtain agent type for default resource agent configuration " << mCurrentDefault->name();
        setupNext();
        return;
    }

#ifndef KDEPIM_NO_KRESOURCES
    // KDE5: remove me
    // check if there is a kresource setup for this type already
    const QString kresType = resourceTypeForMimetype(type.mimeTypes());
    if (!kresType.isEmpty()) {
        const QString kresCfgFile = KStandardDirs::locateLocal("config", QString::fromLatin1("kresources/%1/stdrc").arg(kresType));
        KConfig resCfg(kresCfgFile);
        const KConfigGroup resGroup(&resCfg, "General");
        bool legacyResourceFound = false;
        const QStringList kresResources = resGroup.readEntry("ResourceKeys", QStringList())
                                          + resGroup.readEntry("PassiveResourceKeys", QStringList());
        foreach (const QString &kresResource, kresResources) {
            const KConfigGroup cfg(&resCfg, QString::fromLatin1("Resource_%1").arg(kresResource));
            if (cfg.readEntry("ResourceType", QString()) != QLatin1String("akonadi")) {       // not a bridge
                legacyResourceFound = true;
                break;
            }
        }
        if (legacyResourceFound) {
            kDebug() << "ignoring " << mCurrentDefault->name() << " as there is a KResource setup for its type already.";
            KConfigGroup cfg(mConfig, "ProcessedDefaults");
            cfg.writeEntry(agentCfg.readEntry("Id", QString()), QString::fromLatin1("kres"));
            cfg.sync();
            setupNext();
            return;
        }
    }
#endif

    AgentInstanceCreateJob *job = new AgentInstanceCreateJob(type);
    connect(job, SIGNAL(result(KJob*)), SLOT(instanceCreated(KJob*)));
    job->start();
}

void Firstrun::instanceCreated(KJob *job)
{
    Q_ASSERT(mCurrentDefault);

    if (job->error()) {
        kError() << "Creating agent instance failed for " << mCurrentDefault->name();
        setupNext();
        return;
    }

    AgentInstance instance = static_cast<AgentInstanceCreateJob *>(job)->instance();
    const KConfigGroup agentCfg = KConfigGroup(mCurrentDefault, "Agent");
    const QString agentName = agentCfg.readEntry("Name", QString());
    if (!agentName.isEmpty()) {
        instance.setName(agentName);
    }

    // agent specific settings, using the D-Bus <-> KConfigXT bridge
    const KConfigGroup settings = KConfigGroup(mCurrentDefault, "Settings");

    QDBusInterface *iface = new QDBusInterface(QString::fromLatin1("org.freedesktop.Akonadi.Agent.%1").arg(instance.identifier()),
                                               QLatin1String("/Settings"), QString(),
                                               DBusConnectionPool::threadConnection(), this);
    if (!iface->isValid()) {
        kError() << "Unable to obtain the KConfigXT D-Bus interface of " << instance.identifier();
        setupNext();
        delete iface;
        return;
    }

    foreach (const QString &setting, settings.keyList()) {
        kDebug() << "Setting up " << setting << " for agent " << instance.identifier();
        const QString methodName = QString::fromLatin1("set%1").arg(setting);
        const QVariant::Type argType = argumentType(iface->metaObject(), methodName);
        if (argType == QVariant::Invalid) {
            kError() << "Setting " << setting << " not found in agent configuration interface of " << instance.identifier();
            continue;
        }

        QVariant arg;
        if (argType == QVariant::String) {
            // Since a string could be a path we always use readPathEntry here,
            // that shouldn't harm any normal string settings
            arg = settings.readPathEntry(setting, QString());
        } else {
            arg = settings.readEntry(setting, QVariant(argType));
        }

        const QDBusReply<void> reply = iface->call(methodName, arg);
        if (!reply.isValid()) {
            kError() << "Setting " << setting << " failed for agent " << instance.identifier();
        }
    }

    iface->call(QLatin1String("writeConfig"));

    instance.reconfigure();
    instance.synchronize();
    delete iface;

    // remember we set this one up already
    KConfigGroup cfg(mConfig, "ProcessedDefaults");
    cfg.writeEntry(agentCfg.readEntry("Id", QString()), instance.identifier());
    cfg.sync();

    setupNext();
}

QVariant::Type Firstrun::argumentType(const QMetaObject *mo, const QString &method)
{
    QMetaMethod m;
    for (int i = 0; i < mo->methodCount(); ++i) {
        const QString signature = QString::fromLatin1(mo->method(i).signature());
        if (signature.startsWith(method)) {
            m = mo->method(i);
        }
    }

    if (!m.signature()) {
        return QVariant::Invalid;
    }

    const QList<QByteArray> argTypes = m.parameterTypes();
    if (argTypes.count() != 1) {
        return QVariant::Invalid;
    }

    return QVariant::nameToType(argTypes.first());
}

#include "moc_firstrun_p.cpp"