/*
    SPDX-FileCopyrightText: 2012 Milian Wolff <mail@milianw.de>

    SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/

#include "phpdocsplugin.h"
#include "phpdocsmodel.h"
#include "phpdocsconfig.h"

#include <KPluginFactory>
#include <KAboutData>

#include <interfaces/idocumentation.h>
#include <interfaces/icore.h>
#include <interfaces/idocumentationcontroller.h>

#include <language/duchain/duchain.h>
#include <language/duchain/declaration.h>
#include <language/duchain/duchainlock.h>

#include <language/duchain/classdeclaration.h>
#include <language/duchain/functiondeclaration.h>
#include <language/duchain/classmemberdeclaration.h>
#include <language/duchain/classfunctiondeclaration.h>

#include <QFile>

#include "phpdocsdebug.h"
#include "phpdocumentation.h"
#include "phpdocssettings.h"

using namespace KDevelop;

K_PLUGIN_FACTORY_WITH_JSON(PhpDocsFactory, "kdevphpdocs.json", registerPlugin<PhpDocsPlugin>();)

PhpDocsPlugin::PhpDocsPlugin(QObject* parent, const KPluginMetaData& metaData, const QVariantList& args)
    : IPlugin(QStringLiteral("kdevphpdocs"), parent, metaData)
    , m_model(new PhpDocsModel(this))
{
    Q_UNUSED(args);
}

PhpDocsPlugin::~PhpDocsPlugin()
{
}

QString PhpDocsPlugin::name() const
{
    return QStringLiteral("PHP");
}

QIcon PhpDocsPlugin::icon() const
{
    static QIcon icon = QIcon::fromTheme(QStringLiteral("application-x-php"));
    return icon;
}

KDevelop::ConfigPage* PhpDocsPlugin::configPage(int number, QWidget* parent)
{
    if (number == 0) {
        return new PhpDocsConfig(this, parent);
    }
    return nullptr;
}

int PhpDocsPlugin::configPages() const
{
    return 1;
}

///TODO: possibly return multiple filenames (i.e. fallbacks) when doing local lookups
QString PhpDocsPlugin::getDocumentationFilename( KDevelop::Declaration* dec, const bool& isLocal ) const
{
    QString fname;

    //TODO: most of the SPL stuff is not found for me in the deb package php-doc
    //      => check newer documentation or give a fallback to ref.spl.html
    if ( ClassFunctionDeclaration* fdec = dynamic_cast<ClassFunctionDeclaration*>( dec ) ) {
        // class methods -> php.net/CLASS.METHOD
        // local: either CLASS.METHOD.html or function.CLASS-METHOD.html... really sucks :-/
        //        for now, use the latter...
        if ( dec->context() && dec->context()->type() == DUContext::Class && dec->context()->owner() ) {
            QString className = dec->context()->owner()->identifier().toString();

            if ( !isLocal ) {
                fname = className + '.' + fdec->identifier().toString();
            } else {
                if ( fdec->isConstructor() ) {
                    fname = QStringLiteral("construct");
                } else if ( fdec->isDestructor() ) {
                    fname = QStringLiteral("destruct");
                } else {
                    fname = fdec->identifier().toString();
                }
                //TODO: CLASS.METHOD.html e.g. for xmlreader etc. pp.
                fname = "function." + className + '-' + fname;
            }
        }
    } else if ( dynamic_cast<ClassDeclaration*>(dec) ) {
        fname = "class." + dec->identifier().toString();
    } else if ( dynamic_cast<FunctionDeclaration*>(dec) ) {
        fname = "function." + dec->identifier().toString();
    }
    // check for superglobals / reserved variables
    else if ( dec->identifier() == Identifier(QStringLiteral("GLOBALS")) ||
                dec->identifier() == Identifier(QStringLiteral("php_errormsg")) ||
                dec->identifier() == Identifier(QStringLiteral("HTTP_RAW_POST_DATA")) ||
                dec->identifier() == Identifier(QStringLiteral("http_response_header")) ||
                dec->identifier() == Identifier(QStringLiteral("argc")) ||
                dec->identifier() == Identifier(QStringLiteral("argv")) ||
                dec->identifier() == Identifier(QStringLiteral("_GET")) ||
                dec->identifier() == Identifier(QStringLiteral("_POST")) ||
                dec->identifier() == Identifier(QStringLiteral("_FILES")) ||
                dec->identifier() == Identifier(QStringLiteral("_REQUEST")) ||
                dec->identifier() == Identifier(QStringLiteral("_SESSION")) ||
                dec->identifier() == Identifier(QStringLiteral("_ENV")) ||
                dec->identifier() == Identifier(QStringLiteral("_COOKIE")) ) {
        if ( isLocal ) {
            fname = QStringLiteral("reserved.variables.") + dec->identifier().toString().remove('_');
        } else {
            fname = dec->identifier().toString();
        }
    }

    qCDebug(DOCS) << fname;

    if ( !fname.isEmpty() && isLocal ) {
        fname = fname.toLower();
        fname.replace('_', '-');
        fname.append(".html");
    }

    return fname;
}

IDocumentation::Ptr PhpDocsPlugin::documentationForDeclaration( Declaration* dec ) const
{
    if ( dec ) {
        DUChainReadLocker lock( DUChain::lock() );

        // filter non global or non-php declarations
        if ( dec->topContext()->url() != m_model->internalFunctionFile() ) {
            return {};
        }

        QUrl url = PhpDocsSettings::phpDocLocation();
        qCDebug(DOCS) << url;

        QString file = getDocumentationFilename( dec, url.isLocalFile() );
        if ( file.isEmpty() ) {
            qCDebug(DOCS) << "no documentation pattern found for" << dec->toString();
            return {};
        }

        url.setPath( url.path() + '/' + file);
        if ( url.isLocalFile() && !QFile::exists( url.toLocalFile() ) ) {
            qCDebug(DOCS) << "bad path" << url << "for documentation of" << dec->toString() << " - aborting";
            return {};
        }

        qCDebug(DOCS) << "php documentation located at " << url << "for" << dec->toString();
        return documentationForUrl(url, dec->qualifiedIdentifier().toString());
    }

    return {};
}

IDocumentation::Ptr PhpDocsPlugin::documentation(const QUrl& url) const
{
    if (url.toString().startsWith(PhpDocsSettings::phpDocLocation().toString())) {
        return documentationForUrl(url, QString());
    }
    return {};
}


QAbstractListModel* PhpDocsPlugin::indexModel() const
{
    return m_model;
}

IDocumentation::Ptr PhpDocsPlugin::documentationForIndex(const QModelIndex& index) const
{
    return documentationForDeclaration(static_cast<Declaration*>(
        index.data(PhpDocsModel::DeclarationRole).value<DeclarationPointer>().data()
    ));
}

void PhpDocsPlugin::loadUrl(const QUrl& url) const
{
    qCDebug(DOCS) << "loading URL" << url;
    auto doc = documentationForUrl(url, QString());
    ICore::self()->documentationController()->showDocumentation(doc);
}

void PhpDocsPlugin::showDocumentation(const QUrl& url)
{
    auto doc = documentationForUrl(url, url.toString());
    ICore::self()->documentationController()->showDocumentation(doc);
}

IDocumentation::Ptr PhpDocsPlugin::documentationForUrl(const QUrl& url, const QString& name, const QByteArray& description) const
{
    return IDocumentation::Ptr(new PhpDocumentation( url, name, description, const_cast<PhpDocsPlugin*>(this)));
}

IDocumentation::Ptr PhpDocsPlugin::homePage() const
{
    QUrl url = PhpDocsSettings::phpDocLocation();
    if ( url.isLocalFile() ) {
        url.setPath(url.path() + "/index.html");
    } else {
        url.setPath(url.path() + "/manual");
    }
    return documentationForUrl(url, i18n("PHP Documentation"));
}

#include "phpdocsplugin.moc"

#include "moc_phpdocsplugin.cpp"
