/*
    SPDX-FileCopyrightText: 2012 Victor Dodon <dodonvictor at gmail dot com>
    SPDX-FileCopyrightText: 2012-2018 Gilles Caulier <caulier dot gilles at gmail dot com>

    SPDX-License-Identifier: GPL-2.0-or-later
*/

#include "kipitestpluginloader.h"

// Qt includes

#include <QMap>
#include <QAction>
#include <QDebug>

// KF includes

#include <KActionCategory>
#include <KXMLGUIFactory>
#include <KXmlGuiWindow>

// Local includes

#include "kipiinterface.h"
#include "kipitestmainwindow.h"

namespace KXMLKipiCmd
{

class KipiTestPluginLoader::Private
{

public:

    Private()
    {
        app                         = nullptr;
        kipipluginsActionCollection = nullptr;
        kipiPluginLoader            = nullptr;
        kipiInterface               = nullptr;
    }

    PluginLoader*               kipiPluginLoader;
    KipiInterface*              kipiInterface;
    KXmlGuiWindow*              app;

    KActionCollection*          kipipluginsActionCollection;
    QMap<int, KActionCategory*> kipiCategoryMap;
};

// -- Static values -------------------------------

KipiTestPluginLoader* KipiTestPluginLoader::m_instance = nullptr;

// -----------------------------------------------

KipiTestPluginLoader::KipiTestPluginLoader(KXmlGuiWindow* const parent, KipiInterface *const interface)
    : QObject(parent),
      d(new Private)
{
    m_instance       = this;
    d->kipiInterface = interface;
    d->app           = parent;

    loadPlugins();
}

KipiTestPluginLoader::~KipiTestPluginLoader()
{
    delete d;
    m_instance = nullptr;
}

KipiTestPluginLoader* KipiTestPluginLoader::instance()
{
    return m_instance;
}

KActionCollection* KipiTestPluginLoader::pluginsActionCollection() const
{
    return d->kipipluginsActionCollection;
}

QList<PluginLoader::Info*> KipiTestPluginLoader::pluginList()
{
    return d->kipiPluginLoader->pluginList();
}

QList<QAction*> KipiTestPluginLoader::kipiActionsByCategory(Category cat) const
{
    KActionCategory* const category = d->kipiCategoryMap[cat];

    if (category)
    {
        return category->actions();
    }

    return QList<QAction*>();
}

void KipiTestPluginLoader::loadPlugins()
{
    d->kipipluginsActionCollection = new KActionCollection(d->app, QLatin1String("kipitest"));

    QStringList ignores;

    // List of obsoletes plugins to not load

    // Comment the following two lines if you want to load the HelloWorld and
    // the KXMLHelloWorld plugins for testing purposes
    //ignores.append("HelloWorld");
    //ignores.append("KXMLHelloWorld");

    ignores.append(QString::fromLatin1("KameraKlient"));

    // These plugins have been renamed with 0.2.0-rc1
    ignores.append(QString::fromLatin1("Facebook Exporter"));
    ignores.append(QString::fromLatin1("SmugMug Exporter"));
    ignores.append(QString::fromLatin1("SlideShow"));
    ignores.append(QString::fromLatin1("PrintWizard"));
    ignores.append(QString::fromLatin1("SimpleViewer"));
    ignores.append(QString::fromLatin1("KioExport"));

    d->kipiPluginLoader = new PluginLoader(d->app);
    d->kipiPluginLoader->setInterface(d->kipiInterface);
    d->kipiPluginLoader->setIgnoredPluginsList(ignores);
    d->kipiPluginLoader->init();

    connect(d->kipiPluginLoader, &PluginLoader::replug,
            this, &KipiTestPluginLoader::slotKipiPluginsPlug);

    d->kipiPluginLoader->loadPlugins();
}

void KipiTestPluginLoader::slotKipiPluginsPlug()
{
    d->kipiCategoryMap.clear();
    d->kipipluginsActionCollection->clear();

    PluginLoader::PluginList list = d->kipiPluginLoader->pluginList();
    int cpt                       = 0;

    for (PluginLoader::PluginList::ConstIterator it = list.constBegin() ; it != list.constEnd() ; ++it)
    {
        Plugin* const plugin = (*it)->plugin();

        if (!plugin || !(*it)->shouldLoad())
        {
            continue;
        }

        d->app->guiFactory()->removeClient(plugin);
    }

    QStringList disabledActions = d->kipiPluginLoader->disabledPluginActions();

    for (PluginLoader::PluginList::ConstIterator it = list.constBegin() ; it != list.constEnd() ; ++it)
    {
        Plugin* const plugin = (*it)->plugin();

        if (!plugin || !(*it)->shouldLoad())
        {
            continue;
        }

        ++cpt;
        plugin->setup(d->app);
        plugin->rebuild();

        const auto pluginActions = plugin->actions();
        for (QAction* const action : pluginActions)
        {
            QString actionName(action->objectName());
            Category cat = plugin->category(action);

            if (cat == InvalidCategory)
            {
                qWarning() << "Plugin action '" << actionName << "' has invalid category!";
                continue;
            }

            if (!disabledActions.contains(actionName))
            {
                KActionCategory* category = d->kipiCategoryMap[cat];

                if (!category)
                {
                    category = new KActionCategory(categoryName(cat), d->kipipluginsActionCollection);
                    d->kipiCategoryMap.insert(cat, category);
                }

                category->addAction(actionName, qobject_cast<QAction*>(action));
            }
            else
            {
                qDebug() << "Plugin '" << actionName << "' is disabled.";
            }
        }
    }

    for (PluginLoader::PluginList::ConstIterator it = list.constBegin() ; it != list.constEnd() ; ++it)
    {
        Plugin* const plugin = (*it)->plugin();

        if (!plugin || !(*it)->shouldLoad())
        {
            continue;
        }

        d->app->guiFactory()->addClient(plugin);
    }

    // load KIPI actions settings
    d->kipipluginsActionCollection->readSettings();
}

void KipiTestPluginLoader::checkEmptyCategory(Category cat)
{
    KActionCategory* const category = d->kipiCategoryMap[cat];

    if (!category)
    {
        QString actionName    = QString::fromLatin1("emptyCategory") + categoryShortName(cat);
        QAction* const action = d->app->actionCollection()->addAction(actionName);
        action->setEnabled(false);
        d->kipiCategoryMap.insert(cat, new KActionCategory(categoryName(cat), d->kipipluginsActionCollection));
    }
}

QString KipiTestPluginLoader::categoryName(Category cat) const
{
    QString res;

    switch (cat)
    {
        case ExportPlugin:
            res = QLatin1String("Export Tools");
            break;

        case ImportPlugin:
            res = QLatin1String("Import Tools");
            break;

        case ImagesPlugin:
            res = QLatin1String("Images Tools");
            break;

        case ToolsPlugin:
            res = QLatin1String("Miscellaneous Tools");
            break;

        case BatchPlugin:
            res = QLatin1String("Batch Tools");
            break;

        case CollectionsPlugin:
            res = QLatin1String("Albums Tools");
            break;

        default:
            res = QLatin1String("Unknown Tools");
            break;
    }

    return res;
}

QString KipiTestPluginLoader::categoryShortName(Category cat) const
{
    QString res;

    switch (cat)
    {
        case ExportPlugin:
            res = QLatin1String("Export");
            break;

        case ImportPlugin:
            res = QLatin1String("Import");
            break;

        case ToolsPlugin:
            res = QLatin1String("Tools");
            break;

        case BatchPlugin:
            res = QLatin1String("Batch");
            break;

        case CollectionsPlugin:
            res = QLatin1String("Collections");
            break;

        default:
            res = QLatin1String("Unknown");
            break;
    }

    return res;
}

} // namespace KXMLKipiCmd

#include "moc_kipitestpluginloader.cpp"
