/*
    This file is part of the KDE project
    SPDX-FileCopyrightText: 1999 Matthias Hoelzer-Kluepfel <hoelzer@kde.org>
    SPDX-FileCopyrightText: 2000 Matthias Elter <elter@kde.org>
    SPDX-FileCopyrightText: 2003 Daniel Molkentin <molkentin@kde.org>
    SPDX-FileCopyrightText: 2003, 2006 Matthias Kretz <kretz@kde.org>

    SPDX-License-Identifier: LGPL-2.0-only
*/

#include "kcmoduleinfo.h"

#if KCMUTILS_BUILD_DEPRECATED_SINCE(5, 88)

#include <kcmutils_debug.h>

#include <QVariant>

#include <KDesktopFile>

#include <KLocalizedString>
#include <KPluginInfo>

class Q_DECL_HIDDEN KCModuleInfo::Private
{
public:
    Private();
    Private(const KPluginInfo &);
    Private(const KService::Ptr &);

    QStringList keywords;
    QString name, icon, lib, handle, fileName, doc, comment;
    bool allLoaded = false;
    int weight = 100;

    // For real C++ plugins
    KPluginInfo pluginInfo;

    // Can be a C++ plugin, or just a desktop file launching an executable (see autotest)
    KService::Ptr service;

    /**
     * Reads the service entries specific for KCModule from the desktop file.
     * The usual desktop entries are read in the Private ctor.
     */
    void loadAll();
};

KCModuleInfo::Private::Private()
{
}

KCModuleInfo::Private::Private(const KPluginInfo &pluginInfo)
    : allLoaded(false)
    , pluginInfo(pluginInfo)
{
    if (!pluginInfo.isValid()) {
        qCWarning(KCMUTILS_LOG) << "Invalid plugin";
        return;
    }

    // set the modules simple attributes
    name = pluginInfo.name();
    comment = pluginInfo.comment();
    icon = pluginInfo.icon();
    fileName = pluginInfo.entryPath();
    lib = pluginInfo.libraryPath();
    keywords = pluginInfo.property(QStringLiteral("Keywords")).toStringList();
}

KCModuleInfo::Private::Private(const KService::Ptr &service)
    : allLoaded(false)
    , pluginInfo()
    , service(service)
{
    if (!service) {
        return;
    }

    name = service->name();
    comment = service->comment();
    icon = service->icon();
    fileName = service->entryPath();
    lib = service->library();
    keywords = service->keywords();
}

KCModuleInfo::KCModuleInfo()
    : d(new Private)
{
}

KCModuleInfo::KCModuleInfo(const QString &desktopFile)
    : d(new Private(KService::serviceByStorageId(desktopFile)))
{
}

KCModuleInfo::KCModuleInfo(KService::Ptr service)
    : d(new Private(service))
{
}

KCModuleInfo::KCModuleInfo(const KPluginInfo &pluginInfo)
    : d(new Private(pluginInfo))
{
}

KCModuleInfo::KCModuleInfo(const KCModuleInfo &rhs)
    : d(new Private)
{
    (*this) = rhs;
}

KCModuleInfo &KCModuleInfo::operator=(const KCModuleInfo &rhs)
{
    *d = *(rhs.d);
    return *this;
}

bool KCModuleInfo::operator==(const KCModuleInfo &rhs) const
{
    return ((d->name == rhs.d->name) && (d->lib == rhs.d->lib) && (d->fileName == rhs.d->fileName));
}

bool KCModuleInfo::operator!=(const KCModuleInfo &rhs) const
{
    return !operator==(rhs);
}

KCModuleInfo::~KCModuleInfo()
{
    delete d;
}

bool KCModuleInfo::isValid() const
{
    return d->pluginInfo.isValid() || d->service;
}

void KCModuleInfo::Private::loadAll()
{
    allLoaded = true;

    if (!pluginInfo.isValid() && !service) { /* We have a bogus service. All get functions will return empty/zero values */
        return;
    }

    if (service) {
        // get the documentation path
        doc = service->property(QStringLiteral("X-DocPath"), QVariant::String).toString();
        if (doc.isEmpty()) {
            doc = service->property(QStringLiteral("DocPath"), QVariant::String).toString();
        }

        // read weight
        QVariant tmp = service->property(QStringLiteral("X-KDE-Weight"), QVariant::Int);
        weight = tmp.isValid() ? tmp.toInt() : 100;

        // factory handle
        tmp = service->property(QStringLiteral("X-KDE-FactoryName"), QVariant::String);
        handle = tmp.isValid() ? tmp.toString() : lib;
    } else {
        // get the documentation path
        doc = pluginInfo.property(QStringLiteral("X-DocPath")).toString();
        if (doc.isEmpty()) {
            doc = pluginInfo.property(QStringLiteral("DocPath")).toString();
        }

        // read weight
        QVariant tmp = pluginInfo.property(QStringLiteral("X-KDE-Weight")).toInt();
        weight = tmp.isValid() ? tmp.toInt() : 100;

        // factory handle
        tmp = pluginInfo.property(QStringLiteral("X-KDE-FactoryName"));
        handle = tmp.isValid() ? tmp.toString() : lib;
    }
}

QString KCModuleInfo::fileName() const
{
    return d->fileName;
}

QStringList KCModuleInfo::keywords() const
{
    return d->keywords;
}

QString KCModuleInfo::moduleName() const
{
    return d->name;
}

KService::Ptr KCModuleInfo::service() const
{
    if (d->service) {
        return d->service;
    }
    if (!d->pluginInfo.isValid()) {
        return {};
    }
    QT_WARNING_PUSH
    QT_WARNING_DISABLE_CLANG("-Wdeprecated-declarations")
    QT_WARNING_DISABLE_GCC("-Wdeprecated-declarations")
    return d->pluginInfo.service();
    QT_WARNING_POP
}

KPluginInfo KCModuleInfo::pluginInfo() const
{
    return d->pluginInfo;
}

QString KCModuleInfo::comment() const
{
    return d->comment;
}

QString KCModuleInfo::icon() const
{
    return d->icon;
}

QString KCModuleInfo::library() const
{
    return d->lib;
}

QString KCModuleInfo::docPath() const
{
    if (!d->allLoaded) {
        d->loadAll();
    }

    return d->doc;
}

#if KCMUTILS_BUILD_DEPRECATED_SINCE(5, 85)
QString KCModuleInfo::handle() const
{
    if (!d->allLoaded) {
        d->loadAll();
    }

    return d->handle;
}
#endif

int KCModuleInfo::weight() const
{
    if (!d->allLoaded) {
        d->loadAll();
    }

    return d->weight;
}

QVariant KCModuleInfo::property(const QString &key) const
{
    if (d->service) {
        return d->service->property(key);
    } else {
        return d->pluginInfo.property(key);
    }
}

#endif
