// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2019 Luxoft Sweden AB
// Copyright (C) 2018 Pelagicore AG
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "dbuscontextadaptor.h"
#include "application.h"
#include "package.h"
#include "packagemanager.h"
#include "packagemanager_adaptor.h"
#include "applicationmanager.h"
#include "dbuspolicy.h"
#include "exception.h"
#include "logging.h"

using namespace Qt::StringLiterals;

//NOTE: The header for this class is autogenerated from the XML interface definition.
//      We are NOT using the generated cpp, but instead implement the adaptor manually.

QT_USE_NAMESPACE_AM

static bool checkPackageId(PackageManagerAdaptor *a, const QString &id)
{
    if (PackageManager::instance()->package(id))
        return true;
    DBusContextAdaptor::sendErrorReply(a, u"Unknown package id '%1'"_s.arg(id));
    return false;
}

static bool checkInstaller(PackageManagerAdaptor *a)
{
    if (PackageManager::instance()->installationEnabled())
        return true;
    DBusContextAdaptor::sendErrorReply(a, u"The application-manager was compiled without the installer part"_s);
    return false;
}

static QString taskStateToString(AsynchronousTask::TaskState state)
{
    const char *cstr = QMetaEnum::fromType<AsynchronousTask::TaskState>().valueToKey(state);
    return QString::fromUtf8(cstr);
}


PackageManagerAdaptor::PackageManagerAdaptor(QObject *parent)
    : QDBusAbstractAdaptor(parent)
{
    auto pm = PackageManager::instance();

    connect(pm, &PackageManager::countChanged,
            this, &PackageManagerAdaptor::countChanged);
    connect(pm, &PackageManager::readyChanged,
            this, &PackageManagerAdaptor::readyChanged);
    connect(pm, &PackageManager::packageAdded,
            this, &PackageManagerAdaptor::packageAdded);
    connect(pm, &PackageManager::packageChanged,
            this, &PackageManagerAdaptor::packageChanged);
    connect(pm, &PackageManager::packageAboutToBeRemoved,
            this, &PackageManagerAdaptor::packageAboutToBeRemoved);
    connect(pm, &PackageManager::taskBlockingUntilInstallationAcknowledge,
            this, &PackageManagerAdaptor::taskBlockingUntilInstallationAcknowledge);
    connect(pm, &PackageManager::taskFailed,
            this, &PackageManagerAdaptor::taskFailed);
    connect(pm, &PackageManager::taskFinished,
            this, &PackageManagerAdaptor::taskFinished);
    connect(pm, &PackageManager::taskProgressChanged,
            this, &PackageManagerAdaptor::taskProgressChanged);
    connect(pm, &PackageManager::taskRequestingInstallationAcknowledge,
            this, [this](const QString &taskId, Package *package,
                         const QVariantMap &packageExtraMetaData,
                         const QVariantMap &packageExtraSignedMetaData) {
        auto map = PackageManager::instance()->get(package);
        map.remove(u"package"_s); // cannot marshall QObject *
        map.remove(u"packageObject"_s); // cannot marshall QObject *

        const auto apps = package->applications(); // these are QObject * (legacy API)
        QVariantList appList;
        appList.reserve(apps.size());
        for (auto *app : apps) {
            QVariantMap appMap = ApplicationManager::instance()->get(app);
            appMap.remove(u"application"_s);        // cannot marshall QObject *
            appMap.remove(u"applicationObject"_s);  // cannot marshall QObject *
            appList.append(appMap);
        }
        map.insert(u"applications"_s, appList);
        map = convertToDBusVariant(map).toMap();

        emit taskRequestingInstallationAcknowledge(taskId, map, packageExtraMetaData,
                                                   packageExtraSignedMetaData);
    });
    connect(pm, &PackageManager::taskStarted,
            this, &PackageManagerAdaptor::taskStarted);
    connect(pm, &PackageManager::taskStateChanged,
            this, [this](const QString &taskId, AsynchronousTask::TaskState newState) {
        emit taskStateChanged(taskId, taskStateToString(newState));
    });
}

PackageManagerAdaptor::~PackageManagerAdaptor()
{ }

bool PackageManagerAdaptor::installationEnabled() const
{
    return PackageManager::instance()->installationEnabled();
}

bool PackageManagerAdaptor::allowInstallationOfUnsignedPackages() const
{
    return PackageManager::instance()->allowInstallationOfUnsignedPackages();
}

int PackageManagerAdaptor::count() const
{
    return PackageManager::instance()->count();
}

bool PackageManagerAdaptor::developmentMode() const
{
    return PackageManager::instance()->developmentMode();
}

QString PackageManagerAdaptor::hardwareId() const
{
    return PackageManager::instance()->hardwareId();
}

QString PackageManagerAdaptor::architecture() const
{
    return PackageManager::instance()->architecture();
}

QVariantMap PackageManagerAdaptor::installationLocation() const
{
    return PackageManager::instance()->installationLocation();
}

bool PackageManagerAdaptor::ready() const
{
    return PackageManager::instance()->isReady();
}

QVariantMap PackageManagerAdaptor::documentLocation() const
{
    return PackageManager::instance()->documentLocation();
}

void PackageManagerAdaptor::acknowledgePackageInstallation(const QString &taskId)
{
    QT_AM_AUTHENTICATE_DBUS(void)
    if (checkInstaller(this))
        PackageManager::instance()->acknowledgePackageInstallation(taskId);
}

bool PackageManagerAdaptor::cancelTask(const QString &taskId)
{
    QT_AM_AUTHENTICATE_DBUS(bool)
    if (checkInstaller(this))
        return PackageManager::instance()->cancelTask(taskId);
    else
        return { };
}

int PackageManagerAdaptor::compareVersions(const QString &version1, const QString &version2)
{
    QT_AM_AUTHENTICATE_DBUS(int)
    return PackageManager::instance()->compareVersions(version1, version2);
}

QStringList PackageManagerAdaptor::packageIds()
{
    QT_AM_AUTHENTICATE_DBUS(QStringList)
    return PackageManager::instance()->packageIds();
}

QVariantMap PackageManagerAdaptor::get(const QString &id)
{
    QT_AM_AUTHENTICATE_DBUS(QVariantMap)
    if (checkPackageId(this, id)) {
        auto map = PackageManager::instance()->get(id);
        map.remove(u"package"_s);       // cannot marshall QObject *
        map.remove(u"packageObject"_s); // cannot marshall QObject *
        return convertToDBusVariant(map).toMap();
    } else {
        return { };
    }
}

qlonglong PackageManagerAdaptor::installedPackageSize(const QString &packageId)
{
    QT_AM_AUTHENTICATE_DBUS(qlonglong)
    if (checkInstaller(this) && checkPackageId(this, packageId))
        return PackageManager::instance()->installedPackageSize(packageId);
    else
        return { };
}

QVariantMap PackageManagerAdaptor::installedPackageExtraMetaData(const QString &packageId)
{
    QT_AM_AUTHENTICATE_DBUS(QVariantMap)
    if (checkInstaller(this) && checkPackageId(this, packageId)) {
        const auto map = PackageManager::instance()->installedPackageExtraMetaData(packageId);
        return convertToDBusVariant(map).toMap();
    } else {
        return { };
    }
}

QVariantMap PackageManagerAdaptor::installedPackageExtraSignedMetaData(const QString &packageId)
{
    QT_AM_AUTHENTICATE_DBUS(QVariantMap)
    if (checkInstaller(this) && checkPackageId(this, packageId)) {
        const auto map = PackageManager::instance()->installedPackageExtraSignedMetaData(packageId);
        return convertToDBusVariant(map).toMap();
    } else {
        return { };
    }
}

QString PackageManagerAdaptor::removePackage(const QString &packageId, bool keepDocuments)
{
    return removePackage(packageId, keepDocuments, false);
}

QString PackageManagerAdaptor::removePackage(const QString &packageId, bool keepDocuments, bool force)
{
    QT_AM_AUTHENTICATE_DBUS(QString)
    if (checkInstaller(this) && checkPackageId(this, packageId))
        return PackageManager::instance()->removePackage(packageId, keepDocuments, force);
    else
        return { };
}

QString PackageManagerAdaptor::startPackageInstallation(const QString &sourceUrl)
{
    QT_AM_AUTHENTICATE_DBUS(QString)
    if (checkInstaller(this))
        return PackageManager::instance()->startPackageInstallation(sourceUrl);
    else
        return { };
}

QString PackageManagerAdaptor::taskState(const QString &taskId)
{
    QT_AM_AUTHENTICATE_DBUS(QString)
    if (checkInstaller(this))
        return taskStateToString(PackageManager::instance()->taskState(taskId));
    else
        return { };
}

QString PackageManagerAdaptor::taskPackageId(const QString &taskId)
{
    QT_AM_AUTHENTICATE_DBUS(QString)
    if (checkInstaller(this))
        return PackageManager::instance()->taskPackageId(taskId);
    else
        return { };
}

QStringList PackageManagerAdaptor::activeTaskIds()
{
    QT_AM_AUTHENTICATE_DBUS(QStringList)
    if (checkInstaller(this))
        return PackageManager::instance()->activeTaskIds();
    else
        return { };
}

bool PackageManagerAdaptor::validateDnsName(const QString &name)
{
    QT_AM_AUTHENTICATE_DBUS(bool)
    return PackageManager::instance()->validateDnsName(name);
}

bool PackageManagerAdaptor::validateDnsName(const QString &name, int minimumParts)
{
    QT_AM_AUTHENTICATE_DBUS(bool)
    return PackageManager::instance()->validateDnsName(name, minimumParts);
}