// 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 "exception.h"
#include "signature.h"
#include "logging.h"
#include "adaptorchecks_dbus.h"

//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
using namespace QT_PREPEND_NAMESPACE_AM(DBusAdaptorChecks);
using namespace Qt::StringLiterals;


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

static QString developmentModeToString(PackageManager::DevelopmentMode mode)
{
    const char *cstr = QMetaEnum::fromType<PackageManager::DevelopmentMode>().valueToKey(quint64(mode));
    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();
}

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

QDBusVariant PackageManagerAdaptor::developerCertificate() const
{
    return QDBusVariant(convertToDBusVariant(PackageManager::instance()->developerCertificate().toVariant()));
}

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();
}

QStringList PackageManagerAdaptor::packageIds()
{
    try {
        checkDBusAccess();

        return filterPackageListByAccess(this, PackageManager::instance()->packageIds());

    } catchExceptionAsDBusError({})
}

QVariantMap PackageManagerAdaptor::get(const QString &packageId)
{
    try {
        checkDBusAccess();
        checkPackageAccess(packageId);

        auto map = PackageManager::instance()->get(packageId);
        map.remove(u"package"_s);       // cannot marshall QObject *
        map.remove(u"packageObject"_s); // cannot marshall QObject *
        return convertToDBusVariant(map).toMap();

    } catchExceptionAsDBusError({})
}

qlonglong PackageManagerAdaptor::installedPackageSize(const QString &packageId)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkPackageAccess(packageId);

        return PackageManager::instance()->installedPackageSize(packageId);

    } catchExceptionAsDBusError({})
}

QVariantMap PackageManagerAdaptor::installedPackageExtraMetaData(const QString &packageId)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkPackageAccess(packageId);

        const auto map = PackageManager::instance()->installedPackageExtraMetaData(packageId);
        return convertToDBusVariant(map).toMap();

    } catchExceptionAsDBusError({})
}

QVariantMap PackageManagerAdaptor::installedPackageExtraSignedMetaData(const QString &packageId)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkPackageAccess(packageId);

        const auto map = PackageManager::instance()->installedPackageExtraSignedMetaData(packageId);
        return convertToDBusVariant(map).toMap();

    } catchExceptionAsDBusError({})
}

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

QString PackageManagerAdaptor::removePackage(const QString &packageId, bool keepDocuments, bool force)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkPackageAccess(packageId);

        bool fromApplicationDeveloper = isDevelopmentModeBus(this)
                                        && (PackageManager::instance()->developmentMode()
                                            == PackageManager::DevelopmentMode::Application);

        return PackageManager::instance()->removePackageInternal(packageId, keepDocuments, force,
                                                                 fromApplicationDeveloper);
    } catchExceptionAsDBusError({})
}

QString PackageManagerAdaptor::startPackageInstallation(const QString &sourceUrl)
{
    try {
        checkDBusAccess();
        checkInstaller();

        bool fromApplicationDeveloper = isDevelopmentModeBus(this)
                                        && (PackageManager::instance()->developmentMode()
                                            == PackageManager::DevelopmentMode::Application);

        return PackageManager::instance()->startPackageInstallationInternal(QUrl::fromUserInput(sourceUrl),
                                                                            fromApplicationDeveloper);
    } catchExceptionAsDBusError({})
}

void PackageManagerAdaptor::acknowledgePackageInstallation(const QString &taskId)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkDevelopmentModeSystem();

        PackageManager::instance()->acknowledgePackageInstallation(taskId);

    } catchExceptionAsDBusError()
}

bool PackageManagerAdaptor::cancelTask(const QString &taskId)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkTaskAccess(taskId);

        return PackageManager::instance()->cancelTask(taskId);

    } catchExceptionAsDBusError({})
}

QString PackageManagerAdaptor::taskState(const QString &taskId)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkTaskAccess(taskId);

        return taskStateToString(PackageManager::instance()->taskState(taskId));

    } catchExceptionAsDBusError({})
}

QString PackageManagerAdaptor::taskPackageId(const QString &taskId)
{
    try {
        checkDBusAccess();
        checkInstaller();
        checkTaskAccess(taskId);

        return PackageManager::instance()->taskPackageId(taskId);

    } catchExceptionAsDBusError({})
}

QStringList PackageManagerAdaptor::activeTaskIds()
{
    try {
        checkDBusAccess();
        checkInstaller();

        return filterTaskListByAccess(this, PackageManager::instance()->activeTaskIds());

    } catchExceptionAsDBusError({})
}

bool PackageManagerAdaptor::setDeveloperCertificate(const QByteArray &pkcs12Data, const QByteArray &pkcs12Password)
{
    try {
        checkDBusAccessNoCertificateNeeded();

        try {
            PackageManager::instance()->setDeveloperCertificate(pkcs12Data, pkcs12Password);
            return true;
        } catch (const Exception &e) {
            throw Exception("Failed to set developer certificate: %1").arg(e.errorString());
        }
    } catchExceptionAsDBusError({})
}

bool PackageManagerAdaptor::validateDnsName(const QString &name)
{
    try {
        checkDBusAccess();

        return PackageManager::instance()->validateDnsName(name);

    } catchExceptionAsDBusError({})
}

bool PackageManagerAdaptor::validateDnsName(const QString &name, int minimumParts)
{
    try {
        checkDBusAccess();

        return PackageManager::instance()->validateDnsName(name, minimumParts);

    } catchExceptionAsDBusError({})
}

int PackageManagerAdaptor::compareVersions(const QString &version1, const QString &version2)
{
    try {
        checkDBusAccess();

        return PackageManager::instance()->compareVersions(version1, version2);

    } catchExceptionAsDBusError({})
}