/****************************************************************************
**
** Copyright (C) 2018 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt VS Tools.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "vsqml.h"
#include "astvisitor.h"
#include "vsqmldebugclient.h"

#include <QtQml/private/qqmljslexer_p.h>
#include <QtQml/private/qqmljsparser_p.h>
#include <QtQml/private/qqmljsglobal_p.h>
#include <QtQml/private/qqmljsgrammar_p.h>

#include <QCoreApplication>

#include <Windows.h>

using namespace QQmlJS;
using namespace QQmlJS::AST;

QCoreApplication *app = nullptr;

BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID)
{
    switch (reason) {
    case DLL_PROCESS_DETACH:
        if (app) {
            delete app;
            app = nullptr;
        }
        break;
    default:
        break;
    }
    return TRUE;
}

QCoreApplication *GetQtApplication()
{
    if (app == nullptr) {
        static int argc = 1;
        static const char *argv[] = { "vsqml", nullptr };
        app = new QCoreApplication(argc, const_cast<char **>(argv));
    }

    return app;
}

struct State
{
    Engine *engine;
    Lexer *lexer;
    Parser *parser;
};

bool qmlGetTokens(const char *qmlText, int qmlTextLength, int **tokens, int *tokensLength)
{
    if (!qmlText || !tokens || !tokensLength)
        return false;

    Engine engine;
    Lexer lexer(&engine);
    Parser parser(&engine);

    lexer.setCode(QString::fromUtf8(qmlText, qmlTextLength), 1, true);

    QVector<int> tokenValues;
    for (lexer.lex(); lexer.tokenKind(); lexer.lex()) {
        tokenValues.append(lexer.tokenKind());
        tokenValues.append(lexer.tokenOffset());
        tokenValues.append(lexer.tokenLength());
    }
    *tokensLength = tokenValues.count() * sizeof(int);
    *tokens = new int[tokenValues.count()];
    memcpy(*tokens, tokenValues.data(), *tokensLength);

    return true;
}

bool qmlFreeTokens(int *tokens)
{
    if (!tokens)
        return false;

    delete[] tokens;
    return true;
}

bool qmlParse(
    const char *qmlText,
    int qmlTextLength,
    void **parser,
    bool *parsedCorrectly,
    int **diagnosticMessages,
    int *diagnosticMessagesLength,
    int **comments,
    int *commentsLength)
{
    if (!qmlText || !parser)
        return false;

    *parser = 0;

    if (parsedCorrectly)
        *parsedCorrectly = false;
    if (diagnosticMessages)
        *diagnosticMessages = 0;
    if (diagnosticMessagesLength)
        *diagnosticMessagesLength = 0;
    if (comments)
        *comments = 0;
    if (commentsLength)
        *commentsLength = 0;

    auto s = new State;
    s->engine = new Engine();
    s->lexer = new Lexer(s->engine);
    s->parser = new Parser(s->engine);
    *parser = s;

    s->lexer->setCode(QString::fromUtf8(qmlText, qmlTextLength), 1, true);
    bool ok = s->parser->parse();
    if (parsedCorrectly)
        *parsedCorrectly = ok;

    if (diagnosticMessages && diagnosticMessagesLength) {
        QVector<int> diagValues;
        for (auto diag : s->parser->diagnosticMessages()) {
            diagValues.append(diag.kind);
            diagValues.append(diag.loc.offset);
            diagValues.append(diag.loc.length);
        }
        *diagnosticMessagesLength = diagValues.count() * sizeof(int);
        *diagnosticMessages = new int[diagValues.count()];
        memcpy(*diagnosticMessages, diagValues.data(), *diagnosticMessagesLength);
    }

    if (comments && commentsLength) {
        QVector<int> commentValues;
        for (auto comment : s->engine->comments()) {
            commentValues.append(comment.offset);
            commentValues.append(comment.length);
        }
        *commentsLength = commentValues.count() * sizeof(int);
        *comments = new int[commentValues.count()];
        memcpy(*comments, commentValues.data(), *commentsLength);
    }

    return true;
}

bool qmlFreeParser(void *parser)
{
    if (!parser)
        return false;

    auto s = reinterpret_cast<State*>(parser);
    delete s->parser;
    delete s->lexer;
    delete s->engine;
    delete s;

    return true;
}

bool qmlFreeDiagnosticMessages(int *diagnosticMessages)
{
    if (!diagnosticMessages)
        return false;

    delete[] diagnosticMessages;
    return true;
}

bool qmlFreeComments(int *comments)
{
    if (!comments)
        return false;

    delete[] comments;
    return true;
}

void *qmlGetAstVisitor()
{
    return new AstVisitor();
}

bool qmlFreeAstVisitor(void *astVisitor)
{
    if (!astVisitor)
        return false;

    delete reinterpret_cast<AstVisitor*>(astVisitor);
    return true;
}

bool qmlSetAstVisitorCallback(void *astVisitor, int nodeKindFilter, Callback visitCallback)
{
    if (!astVisitor)
        return false;

    auto visitor = reinterpret_cast<AstVisitor*>(astVisitor);
    if (nodeKindFilter <= Node::Kind_Undefined)
        visitor->setCallback(visitCallback);
    else
        visitor->setCallback(nodeKindFilter, visitCallback);

    return true;
}

bool qmlAcceptAstVisitor(void *parser, void *node, void *astVisitor)
{
    if (!parser || !astVisitor)
        return false;

    auto s = reinterpret_cast<State*>(parser);
    auto visitor = reinterpret_cast<AstVisitor*>(astVisitor);

    Node *visitNode = 0;
    if (node)
        visitNode = reinterpret_cast<Node*>(node);
    else
        visitNode = s->parser->rootNode();

    if (!visitNode)
        return false;

    visitNode->accept(visitor->GetVisitor());

    return true;
}

bool qmlDebugClientThread(
    QmlDebugClientCreated clientCreated,
    QmlDebugClientDestroyed clientDestroyed,
    QmlDebugClientConnected clientConnected,
    QmlDebugClientDisconnected clientDisconnected,
    QmlDebugClientMessageReceived clientMessageReceived)
{
    GetQtApplication();

    QEventLoop eventLoop;
    VsQmlDebugClient client(&eventLoop);

    if (clientCreated)
        clientCreated(&client);

    QObject::connect(&client, &VsQmlDebugClient::connected, [&client, clientConnected]()
    {
        if (clientConnected)
            clientConnected(&client);
    });

    QObject::connect(&client, &VsQmlDebugClient::disconnected, [&client, clientDisconnected]()
    {
        if (clientDisconnected)
            clientDisconnected(&client);
    });

    QObject::connect(&client, &VsQmlDebugClient::messageReceived,
        [&client, clientMessageReceived](
            const QByteArray &messageType,
            const QByteArray &messageParams)
    {
        if (clientMessageReceived)
            clientMessageReceived(&client,
                messageType.constData(), messageType.size(),
                messageParams.constData(), messageParams.size());
    });

    int exitCode = eventLoop.exec();

    if (clientDestroyed)
        clientDestroyed(&client);

    return (exitCode == 0);
}

bool qmlDebugClientConnect(
    void *qmlDebugClient,
    const char *hostNameData,
    int hostNameLength,
    unsigned short hostPort)
{
    if (!qmlDebugClient)
        return false;

    auto client = reinterpret_cast<VsQmlDebugClient*>(qmlDebugClient);
    QString hostName = QString::fromUtf8(hostNameData, hostNameLength);

    return QMetaObject::invokeMethod(client, "connectToHost", Qt::QueuedConnection,
        Q_ARG(QString, hostName), Q_ARG(quint16, hostPort));
}

bool qmlDebugClientStartLocalServer(
    void *qmlDebugClient,
    const char *fileNameData,
    int fileNameLength)
{
    if (!qmlDebugClient)
        return false;

    auto client = reinterpret_cast<VsQmlDebugClient *>(qmlDebugClient);
    QString fileName = QString::fromUtf8(fileNameData, fileNameLength);

    return QMetaObject::invokeMethod(client, "startLocalServer", Qt::QueuedConnection,
        Q_ARG(QString, fileName));
}

bool qmlDebugClientDisconnect(void *qmlDebugClient)
{
    if (!qmlDebugClient)
        return false;

    auto client = reinterpret_cast<VsQmlDebugClient*>(qmlDebugClient);

    return QMetaObject::invokeMethod(client, "disconnectFromHost", Qt::QueuedConnection);
}

bool qmlDebugClientSendMessage(
    void *qmlDebugClient,
    const char *messageTypeData,
    int messageTypeLength,
    const char *messageParamsData,
    int messageParamsLength)
{
    if (!qmlDebugClient)
        return false;

    auto client = reinterpret_cast<VsQmlDebugClient*>(qmlDebugClient);
    QByteArray messageType = QByteArray::fromRawData(messageTypeData, messageTypeLength);
    QByteArray messageParams = QByteArray::fromRawData(messageParamsData, messageParamsLength);

    return QMetaObject::invokeMethod(client, "sendMessage", Qt::QueuedConnection,
        Q_ARG(QByteArray, messageType), Q_ARG(QByteArray, messageParams));
}

bool qmlDebugClientShutdown(void *qmlDebugClient)
{
    if (!qmlDebugClient)
        return false;

    auto client = reinterpret_cast<VsQmlDebugClient*>(qmlDebugClient);
    return QMetaObject::invokeMethod(client->parent(), "quit", Qt::QueuedConnection);
}