#include "trust_db.h"
#include <QXmppConfiguration.h>
#include <QXmppFutureUtils_p.h>
#include <QXmppPromise.h>
#include <qt5keychain/keychain.h>
#include <QEventLoop>
#include <QtConcurrent>
#include <iostream>

TrustDb::TrustDb(const QString &jid) :
    jid(jid)
{
}

static QString toString(const QXmpp::TrustSecurityPolicy securityPolicy)
{
    switch (securityPolicy)
    {
        case QXmpp::NoSecurityPolicy:
            return "NoSecurityPolicy";

        case QXmpp::Toakafa:
            return "Toakafa";
    }

    return "unknown";
}

static int toSecurityPolicy(const QString &s,
    QXmpp::TrustSecurityPolicy &securityPolicy)
{
    if (s == "NoSecurityPolicy")
    {
        securityPolicy = QXmpp::NoSecurityPolicy;
        return 0;
    }
    else if (s == "Toakafa")
    {
        securityPolicy = QXmpp::Toakafa;
        return 0;
    }

    return -1;
}

QString TrustDb::service() const
{
    return "xxcc/trust/" + jid;
}

QXmppTask<void> TrustDb::setSecurityPolicy(const QString &encryption,
    const QXmpp::TrustSecurityPolicy securityPolicy)
{
    QKeychain::WritePasswordJob job(service());
    QEventLoop loop;

    job.setKey("securityPolicy/" + encryption);
    job.setTextData(toString(securityPolicy));
    job.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
    job.start();
    loop.exec();

    if (job.error())
        std::cerr << "Failed to store security policy: "
            << qPrintable(job.errorString()) << std::endl;

    return QXmpp::Private::makeReadyTask();
}

QXmppTask<void> TrustDb::resetSecurityPolicy(const QString &encryption)
{
    QKeychain::DeletePasswordJob job(service());
    QEventLoop loop;

    job.setKey("securityPolicy/" + encryption);
    job.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
    job.start();
    loop.exec();

    if (job.error())
        std::cerr << "Failed to reset security policy: "
            << qPrintable(job.errorString()) << std::endl;

    return QXmpp::Private::makeReadyTask();
}

QXmppTask<QXmpp::TrustSecurityPolicy> TrustDb::securityPolicy(
        const QString &encryption)
{
    QKeychain::ReadPasswordJob job(service());
    QEventLoop loop;

    job.setKey("securityPolicy/" + encryption);
    job.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
    job.start();
    loop.exec();

    if (job.error())
        std::cerr << "Failed to read security policy: "
            << qPrintable(job.errorString()) << std::endl;

    QXmpp::TrustSecurityPolicy policy = QXmpp::Toakafa;
    const QString data = job.textData();

    if (toSecurityPolicy(data, policy))
        std::cerr << "Invalid security policy " << qPrintable(data)
            << std::endl;

    return QXmpp::Private::makeReadyTask(QXmpp::TrustSecurityPolicy(policy));
}

QXmppTask<void> TrustDb::setOwnKey(const QString &encryption,
    const QByteArray &keyId)
{
    QKeychain::WritePasswordJob job(service());
    QEventLoop loop;

    job.setKey("key/" + encryption);
    job.setBinaryData(keyId);
    job.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
    job.start();
    loop.exec();

    if (job.error())
        std::cerr << "Failed to store own key: "
            << qPrintable(job.errorString()) << std::endl;

    return QXmpp::Private::makeReadyTask();
}

QXmppTask<void> TrustDb::resetOwnKey(const QString &encryption)
{
    QKeychain::DeletePasswordJob job(service());
    QEventLoop loop;

    job.setKey("key/" + encryption);
    job.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
    job.start();
    loop.exec();

    if (job.error())
        std::cerr << "Failed to reset own key: "
            << qPrintable(job.errorString()) << std::endl;

    return QXmpp::Private::makeReadyTask();
}

QXmppTask<QByteArray> TrustDb::ownKey(const QString &encryption)
{
    QKeychain::ReadPasswordJob job(service());
    QEventLoop loop;

    job.setKey("key/" + encryption);
    job.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
    job.start();
    loop.exec();

    QByteArray ret;

    if (job.error())
        std::cerr << "Failed to read own key: "
            << qPrintable(job.errorString()) << std::endl;
    else
        ret = job.binaryData();

    return QXmpp::Private::makeReadyTask(QByteArray(ret));
}

QXmppTask<void> TrustDb::addKeys(const QString &encryption,
    const QString &keyOwnerJid, const QList<QByteArray> &keyIds,
    const QXmpp::TrustLevel trustLevel)
{
    return QXmpp::Private::makeReadyTask();
}

QXmppTask<void> TrustDb::removeKeys(const QString &encryption,
    const QList<QByteArray> &keyIds)
{
    return QXmpp::Private::makeReadyTask();
}

QXmppTask<void> TrustDb::removeKeys(const QString &encryption,
    const QString &keyOwnerJid)
{
    return QXmpp::Private::makeReadyTask();
}

QXmppTask<void> TrustDb::removeKeys(const QString &encryption)
{
    return QXmpp::Private::makeReadyTask();
}

QXmppTask<QHash<QXmpp::TrustLevel,
    QMultiHash<QString, QByteArray>>> TrustDb::keys(const QString &encryption,
        const QXmpp::TrustLevels trustLevels)
{
    return QXmpp::Private::makeReadyTask(QHash<QXmpp::TrustLevel,
        QMultiHash<QString, QByteArray>>());
}

QXmppTask<QHash<QString,
        QHash<QByteArray, QXmpp::TrustLevel>>> TrustDb::keys(const QString &encryption,
        const QList<QString> &keyOwnerJids,
        const QXmpp::TrustLevels trustLevels)
{
    return QXmpp::Private::makeReadyTask(QHash<QString,
        QHash<QByteArray, QXmpp::TrustLevel>>());
}

QXmppTask<bool> TrustDb::hasKey(const QString &encryption,
    const QString &keyOwnerJid, QXmpp::TrustLevels trustLevels)
{
    return QXmpp::Private::makeReadyTask(bool());
}

QXmppTask<QHash<QString,
    QMultiHash<QString, QByteArray>>> TrustDb::setTrustLevel(
        const QString &encryption,
        const QMultiHash<QString, QByteArray> &keyIds,
        const QXmpp::TrustLevel trustLevel)
{
    return QXmpp::Private::makeReadyTask(QHash<QString,
        QMultiHash<QString, QByteArray>>());
}

QXmppTask<QHash<QString,
    QMultiHash<QString, QByteArray>>> TrustDb::setTrustLevel(
            const QString &encryption,
            const QList<QString> &keyOwnerJids,
            const QXmpp::TrustLevel oldTrustLevel,
            const QXmpp::TrustLevel newTrustLevel)
{
    return QXmpp::Private::makeReadyTask(QHash<QString,
        QMultiHash<QString, QByteArray>>());
}

QXmppTask<QXmpp::TrustLevel> TrustDb::trustLevel(const QString &encryption,
    const QString &keyOwnerJid, const QByteArray &keyId)
{
    return QXmpp::Private::makeReadyTask(QXmpp::TrustLevel());
}

QXmppTask<void> TrustDb::resetAll(const QString &encryption)
{
    return QXmpp::Private::makeReadyTask();
}