/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtSCriptTools module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qscriptdebuggerscriptedconsolecommand_p.h"

#include "qscriptdebuggerconsolecommand_p_p.h"

#include "qscriptdebuggerconsolecommandjob_p.h"

#include "qscriptdebuggerconsolecommandjob_p_p.h"

#include "qscriptmessagehandlerinterface_p.h"

#include "qscriptdebuggerconsoleglobalobject_p.h"

#include "qscriptdebuggerresponse_p.h"

#include "qscriptdebuggervalue_p.h"

#include "qscriptdebuggervalueproperty_p.h"

#include "qscriptdebuggercommandschedulerinterface_p.h"

#include <QtCore/qstring.h>

#include <QtCore/qstringlist.h>

#include <QtScript/qscriptengine.h>

#include <QtScript/qscriptvalue.h>

#include <QtScript/qscriptvalueiterator.h>

#include <QtScript/qscriptcontextinfo.h>

#include <QtCore/qdebug.h>

Q_DECLARE_METATYPE(QScriptDebuggerResponse)

Q_DECLARE_METATYPE(QScriptBreakpointData)

Q_DECLARE_METATYPE(QScriptBreakpointMap)

Q_DECLARE_METATYPE(QScriptScriptData)

Q_DECLARE_METATYPE(QScriptScriptMap)

Q_DECLARE_METATYPE(QScriptContextInfo)

Q_DECLARE_METATYPE(QScriptDebuggerValue)

Q_DECLARE_METATYPE(QScriptDebuggerValueProperty)

Q_DECLARE_METATYPE(QScriptDebuggerValuePropertyList)

Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommand*)

Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommandList)

Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommandGroupData)

Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommandGroupMap)

QT_BEGIN_NAMESPACE

static QScriptValue debuggerResponseToScriptValue(QScriptEngine *eng, const QScriptDebuggerResponse &in)

{

    QScriptValue out = eng->newObject();

    out.setProperty(QString::fromLatin1("result"), qScriptValueFromValue(eng, in.result()));

    out.setProperty(QString::fromLatin1("error"), QScriptValue(eng, in.error()));

    out.setProperty(QString::fromLatin1("async"), QScriptValue(eng, in.async()));

    return out;

}

static void debuggerResponseFromScriptValue(const QScriptValue &, QScriptDebuggerResponse &)

{

    Q_ASSERT(0);

}

static QScriptValue breakpointDataToScriptValue(QScriptEngine *eng, const QScriptBreakpointData &in)

{

    QScriptValue out = eng->newObject();

    out.setProperty(QString::fromLatin1("scriptId"), QScriptValue(eng, qsreal(in.scriptId())));

    out.setProperty(QString::fromLatin1("fileName"), QScriptValue(eng, in.fileName()));

    out.setProperty(QString::fromLatin1("lineNumber"), QScriptValue(eng, in.lineNumber()));

    out.setProperty(QString::fromLatin1("enabled"), QScriptValue(eng, in.isEnabled()));

    out.setProperty(QString::fromLatin1("singleShot"), QScriptValue(eng, in.isSingleShot()));

    out.setProperty(QString::fromLatin1("ignoreCount"), QScriptValue(eng, in.ignoreCount()));

    out.setProperty(QString::fromLatin1("condition"), QScriptValue(eng, in.condition()));

    return out;

}

static void breakpointDataFromScriptValue(const QScriptValue &in, QScriptBreakpointData &out)

{

    QScriptValue scriptId = in.property(QString::fromLatin1("scriptId"));

    if (scriptId.isValid())

        out.setScriptId((qint64)scriptId.toNumber());

    out.setFileName(in.property(QString::fromLatin1("fileName")).toString());

    out.setLineNumber(in.property(QString::fromLatin1("lineNumber")).toInt32());

    QScriptValue enabled = in.property(QString::fromLatin1("enabled"));

    if (enabled.isValid())

        out.setEnabled(enabled.toBoolean());

    QScriptValue singleShot = in.property(QString::fromLatin1("singleShot"));

    if (singleShot.isValid())

        out.setSingleShot(singleShot.toBoolean());

    out.setIgnoreCount(in.property(QString::fromLatin1("ignoreCount")).toInt32());

    out.setCondition(in.property(QString::fromLatin1("condition")).toString());

}

static QScriptValue breakpointMapToScriptValue(QScriptEngine *eng, const QScriptBreakpointMap &in)

{

    QScriptValue out = eng->newObject();

    QScriptBreakpointMap::const_iterator it;

    for (it = in.constBegin(); it != in.constEnd(); ++it) {

        out.setProperty(QString::number(it.key()), qScriptValueFromValue(eng, it.value()));

    }

    return out;

}

static void breakpointMapFromScriptValue(const QScriptValue &, QScriptBreakpointMap &)

{

    Q_ASSERT(0);

}

static QScriptValue scriptDataToScriptValue(QScriptEngine *eng, const QScriptScriptData &in)

{

    QScriptValue out = eng->newObject();

    out.setProperty(QString::fromLatin1("contents"), QScriptValue(eng, in.contents()));

    out.setProperty(QString::fromLatin1("fileName"), QScriptValue(eng, in.fileName()));

    out.setProperty(QString::fromLatin1("baseLineNumber"), QScriptValue(eng, in.baseLineNumber()));

    return out;

}

static void scriptDataFromScriptValue(const QScriptValue &in, QScriptScriptData &out)

{

    QString contents = in.property(QString::fromLatin1("contents")).toString();

    QString fileName = in.property(QString::fromLatin1("fileName")).toString();

    int baseLineNumber = in.property(QString::fromLatin1("baseLineNumber")).toInt32();

    QScriptScriptData tmp(contents, fileName, baseLineNumber);

    out = tmp;

}

static QScriptValue scriptMapToScriptValue(QScriptEngine *eng, const QScriptScriptMap &in)

{

    QScriptValue out = eng->newObject();

    QScriptScriptMap::const_iterator it;

    for (it = in.constBegin(); it != in.constEnd(); ++it) {

        out.setProperty(QString::number(it.key()), qScriptValueFromValue(eng, it.value()));

    }

    return out;

}

static void scriptMapFromScriptValue(const QScriptValue &, QScriptScriptMap &)

{

    Q_ASSERT(0);

}

static QScriptValue consoleCommandToScriptValue(

    QScriptEngine *eng, QScriptDebuggerConsoleCommand* const &in)

{

    if (!in)

        return eng->undefinedValue();

    QScriptValue out = eng->newObject();

    out.setProperty(QString::fromLatin1("name"), QScriptValue(eng, in->name()));

    out.setProperty(QString::fromLatin1("group"), QScriptValue(eng, in->group()));

    out.setProperty(QString::fromLatin1("shortDescription"), QScriptValue(eng, in->shortDescription()));

    out.setProperty(QString::fromLatin1("longDescription"), QScriptValue(eng, in->longDescription()));

    out.setProperty(QString::fromLatin1("aliases"), qScriptValueFromValue(eng, in->aliases()));

    out.setProperty(QString::fromLatin1("seeAlso"), qScriptValueFromValue(eng, in->seeAlso()));

    return out;

}

static void consoleCommandFromScriptValue(

    const QScriptValue &, QScriptDebuggerConsoleCommand* &)

{

    Q_ASSERT(0);

}

static QScriptValue consoleCommandGroupDataToScriptValue(

    QScriptEngine *eng, const QScriptDebuggerConsoleCommandGroupData &in)

{

    QScriptValue out = eng->newObject();

    out.setProperty(QString::fromLatin1("longDescription"), QScriptValue(eng, in.longDescription()));

    out.setProperty(QString::fromLatin1("shortDescription"), QScriptValue(eng, in.shortDescription()));

    return out;

}

static void consoleCommandGroupDataFromScriptValue(

    const QScriptValue &, QScriptDebuggerConsoleCommandGroupData &)

{

    Q_ASSERT(0);

}

static QScriptValue consoleCommandGroupMapToScriptValue(

    QScriptEngine *eng, const QScriptDebuggerConsoleCommandGroupMap &in)

{

    QScriptValue out = eng->newObject();

    QScriptDebuggerConsoleCommandGroupMap::const_iterator it;

    for (it = in.constBegin(); it != in.constEnd(); ++it) {

        out.setProperty(it.key(), qScriptValueFromValue(eng, it.value()));

    }

    return out;

}

static void consoleCommandGroupMapFromScriptValue(

    const QScriptValue &, QScriptDebuggerConsoleCommandGroupMap &)

{

    Q_ASSERT(0);

}

static QScriptValue contextInfoToScriptValue(QScriptEngine *eng, const QScriptContextInfo &in)

{

    QScriptValue out = eng->newObject();

    out.setProperty(QString::fromLatin1("scriptId"), QScriptValue(eng, qsreal(in.scriptId())));

    out.setProperty(QString::fromLatin1("fileName"), QScriptValue(eng, in.fileName()));

    out.setProperty(QString::fromLatin1("lineNumber"), QScriptValue(eng, in.lineNumber()));

    out.setProperty(QString::fromLatin1("columnNumber"), QScriptValue(eng, in.columnNumber()));

    out.setProperty(QString::fromLatin1("functionName"), QScriptValue(eng, in.functionName()));

    return out;

}

static void contextInfoFromScriptValue(const QScriptValue &, QScriptContextInfo &)

{

    Q_ASSERT(0);

}

static QScriptValue debuggerScriptValuePropertyToScriptValue(QScriptEngine *eng, const QScriptDebuggerValueProperty &in)

{

    QScriptValue out = eng->newObject();

    out.setProperty(QString::fromLatin1("name"), QScriptValue(eng, in.name()));

    out.setProperty(QString::fromLatin1("value"), qScriptValueFromValue(eng, in.value()));

    out.setProperty(QString::fromLatin1("valueAsString"), QScriptValue(eng, in.valueAsString()));

    out.setProperty(QString::fromLatin1("flags"), QScriptValue(eng, static_cast<int>(in.flags())));

    return out;

}

static void debuggerScriptValuePropertyFromScriptValue(const QScriptValue &in, QScriptDebuggerValueProperty &out)

{

    QString name = in.property(QString::fromLatin1("name")).toString();

    QScriptDebuggerValue value = qscriptvalue_cast<QScriptDebuggerValue>(in.property(QString::fromLatin1("value")));

    QString valueAsString = in.property(QString::fromLatin1("valueAsString")).toString();

    int flags = in.property(QString::fromLatin1("flags")).toInt32();

    QScriptDebuggerValueProperty tmp(name, value, valueAsString, QScriptValue::PropertyFlags(flags));

    out = tmp;

}

/*!

  \since 4.5

  \class QScriptDebuggerScriptedConsoleCommand

  \internal

  \brief The QScriptDebuggerScriptedConsoleCommand class encapsulates a command defined in a script.

*/

class QScriptDebuggerScriptedConsoleCommandPrivate

    : public QScriptDebuggerConsoleCommandPrivate

{

    Q_DECLARE_PUBLIC(QScriptDebuggerScriptedConsoleCommand)

public:

    QScriptDebuggerScriptedConsoleCommandPrivate();

    ~QScriptDebuggerScriptedConsoleCommandPrivate();

    QString name;

    QString group;

    QString shortDescription;

    QString longDescription;

    QStringList aliases;

    QStringList seeAlso;

    QStringList argumentTypes;

    QStringList subCommands;

    QScriptEngine *engine;

    QScriptValue execFunction;

    QScriptValue responseFunction;

};

QScriptDebuggerScriptedConsoleCommandPrivate::QScriptDebuggerScriptedConsoleCommandPrivate()

{

    engine = 0;

}

QScriptDebuggerScriptedConsoleCommandPrivate::~QScriptDebuggerScriptedConsoleCommandPrivate()

{

    delete engine;

}

QScriptDebuggerScriptedConsoleCommand::QScriptDebuggerScriptedConsoleCommand(

    const QString &name, const QString &group,

    const QString &shortDescription, const QString &longDescription,

    const QStringList &aliases, const QStringList &seeAlso,

    const QStringList &argumentTypes, const QStringList &subCommands,

    const QScriptValue &execFunction, const QScriptValue &responseFunction)

    : QScriptDebuggerConsoleCommand(*new QScriptDebuggerScriptedConsoleCommandPrivate)

{

    Q_D(QScriptDebuggerScriptedConsoleCommand);

    d->name = name;

    d->group = group;

    d->shortDescription = shortDescription;

    d->longDescription = longDescription;

    d->aliases = aliases;

    d->seeAlso = seeAlso;

    d->argumentTypes = argumentTypes;

    d->subCommands = subCommands;

    d->execFunction = execFunction;

    d->responseFunction = responseFunction;

    d->engine = execFunction.engine();

    qScriptRegisterMetaType<QScriptBreakpointData>(d->engine, breakpointDataToScriptValue, breakpointDataFromScriptValue);

    qScriptRegisterMetaType<QScriptBreakpointMap>(d->engine, breakpointMapToScriptValue, breakpointMapFromScriptValue);

    qScriptRegisterMetaType<QScriptScriptData>(d->engine, scriptDataToScriptValue, scriptDataFromScriptValue);

    qScriptRegisterMetaType<QScriptScriptMap>(d->engine, scriptMapToScriptValue, scriptMapFromScriptValue);

    qScriptRegisterMetaType<QScriptContextInfo>(d->engine, contextInfoToScriptValue, contextInfoFromScriptValue);

    qScriptRegisterMetaType<QScriptDebuggerValueProperty>(d->engine, debuggerScriptValuePropertyToScriptValue, debuggerScriptValuePropertyFromScriptValue);

    qScriptRegisterSequenceMetaType<QScriptDebuggerValuePropertyList>(d->engine);

    qScriptRegisterMetaType<QScriptDebuggerResponse>(d->engine, debuggerResponseToScriptValue, debuggerResponseFromScriptValue);

    qScriptRegisterMetaType<QScriptDebuggerConsoleCommand*>(d->engine, consoleCommandToScriptValue, consoleCommandFromScriptValue);

    qScriptRegisterSequenceMetaType<QScriptDebuggerConsoleCommandList>(d->engine);

    qScriptRegisterMetaType<QScriptDebuggerConsoleCommandGroupData>(d->engine, consoleCommandGroupDataToScriptValue, consoleCommandGroupDataFromScriptValue);

    qScriptRegisterMetaType<QScriptDebuggerConsoleCommandGroupMap>(d->engine, consoleCommandGroupMapToScriptValue, consoleCommandGroupMapFromScriptValue);

// ### can't do this, if it's an object ID the conversion will be incorrect since

// ### the object ID refers to an object in a different engine!

//    qScriptRegisterMetaType(d->engine, debuggerScriptValueToScriptValue, debuggerScriptValueFromScriptValue);

}

QScriptDebuggerScriptedConsoleCommand::~QScriptDebuggerScriptedConsoleCommand()

{

}

class QScriptDebuggerScriptedConsoleCommandJobPrivate;

class QScriptDebuggerScriptedConsoleCommandJob

    : public QScriptDebuggerConsoleCommandJob,

      public QScriptDebuggerCommandSchedulerInterface

{

public:

    QScriptDebuggerScriptedConsoleCommandJob(

        QScriptDebuggerScriptedConsoleCommandPrivate *command,

        const QStringList &arguments,

        QScriptDebuggerConsole *console,

        QScriptMessageHandlerInterface *messageHandler,

        QScriptDebuggerCommandSchedulerInterface *commandScheduler);

    ~QScriptDebuggerScriptedConsoleCommandJob();

    int scheduleCommand(

        const QScriptDebuggerCommand &command,

        QScriptDebuggerResponseHandlerInterface *responseHandler);

    void start();

    void handleResponse(const QScriptDebuggerResponse &response,

                        int commandId);

private:

    Q_DECLARE_PRIVATE(QScriptDebuggerScriptedConsoleCommandJob)

    Q_DISABLE_COPY(QScriptDebuggerScriptedConsoleCommandJob)

};

class QScriptDebuggerScriptedConsoleCommandJobPrivate

    : public QScriptDebuggerConsoleCommandJobPrivate

{

public:

    QScriptDebuggerScriptedConsoleCommandJobPrivate() : command(0), commandCount(0) {}

    ~QScriptDebuggerScriptedConsoleCommandJobPrivate() {}

    QScriptDebuggerScriptedConsoleCommandPrivate *command;

    QStringList arguments;

    int commandCount;

};

QScriptDebuggerScriptedConsoleCommandJob::QScriptDebuggerScriptedConsoleCommandJob(

    QScriptDebuggerScriptedConsoleCommandPrivate *command,

    const QStringList &arguments,

    QScriptDebuggerConsole *console,

    QScriptMessageHandlerInterface *messageHandler,

    QScriptDebuggerCommandSchedulerInterface *commandScheduler)

    : QScriptDebuggerConsoleCommandJob(*new QScriptDebuggerScriptedConsoleCommandJobPrivate,

                                       console, messageHandler, commandScheduler)

{

    Q_D(QScriptDebuggerScriptedConsoleCommandJob);

    d->command = command;

    d->arguments = arguments;

}

QScriptDebuggerScriptedConsoleCommandJob::~QScriptDebuggerScriptedConsoleCommandJob()

{

}

int QScriptDebuggerScriptedConsoleCommandJob::scheduleCommand(

    const QScriptDebuggerCommand &command,

    QScriptDebuggerResponseHandlerInterface *responseHandler)

{

    Q_D(QScriptDebuggerScriptedConsoleCommandJob);

    ++d->commandCount;

    return commandScheduler()->scheduleCommand(command, responseHandler);

}

void QScriptDebuggerScriptedConsoleCommandJob::start()

{

    Q_D(QScriptDebuggerScriptedConsoleCommandJob);

    QScriptEngine *engine = d->command->engine;

    QScriptValueList args;

    for (int i = 0; i < d->arguments.size(); ++i)

        args.append(QScriptValue(engine, d->arguments.at(i)));

    QScriptDebuggerConsoleGlobalObject *global;

    global = qobject_cast<QScriptDebuggerConsoleGlobalObject*>(engine->globalObject().toQObject());

    Q_ASSERT(global != 0);

    global->setScheduler(this);

    global->setResponseHandler(this);

    global->setMessageHandler(d->messageHandler);

    global->setConsole(d->console);

    d->commandCount = 0;

    QScriptValue ret = d->command->execFunction.call(QScriptValue(), args);

    global->setScheduler(0);

    global->setResponseHandler(0);

    global->setMessageHandler(0);

    global->setConsole(0);

    if (ret.isError()) {

        qWarning("*** internal error: %s", qPrintable(ret.toString()));

    }

    if (d->commandCount == 0)

        finish();

}

void QScriptDebuggerScriptedConsoleCommandJob::handleResponse(

    const QScriptDebuggerResponse &response,

    int commandId)

{

    Q_D(QScriptDebuggerScriptedConsoleCommandJob);

    // ### generalize

    QScriptEngine *engine = d->command->engine;

    QScriptValueList args;

    args.append(qScriptValueFromValue(engine, response));

    args.append(QScriptValue(engine, commandId));

    QScriptDebuggerConsoleGlobalObject *global;

    global = qobject_cast<QScriptDebuggerConsoleGlobalObject*>(engine->globalObject().toQObject());

    Q_ASSERT(global != 0);

    global->setScheduler(this);

    global->setResponseHandler(this);

    global->setMessageHandler(d->messageHandler);

    global->setConsole(d->console);

    d->commandCount = 0;

    QScriptValue ret = d->command->responseFunction.call(QScriptValue(), args);

    global->setScheduler(0);

    global->setResponseHandler(0);

    global->setMessageHandler(0);

    global->setConsole(0);

    if (ret.isError()) {

        qWarning("*** internal error: %s", qPrintable(ret.toString()));

    }

    if (d->commandCount == 0)

        finish();

}

/*!

  \internal

*/

QString QScriptDebuggerScriptedConsoleCommand::name() const

{

    Q_D(const QScriptDebuggerScriptedConsoleCommand);

    return d->name;

}

/*!

  \internal

*/

QString QScriptDebuggerScriptedConsoleCommand::group() const

{

    Q_D(const QScriptDebuggerScriptedConsoleCommand);

    return d->group;

}

/*!

  \internal

*/

QString QScriptDebuggerScriptedConsoleCommand::shortDescription() const

{

    Q_D(const QScriptDebuggerScriptedConsoleCommand);

    return d->shortDescription;

}

/*!

  \internal

*/

QString QScriptDebuggerScriptedConsoleCommand::longDescription() const

{

    Q_D(const QScriptDebuggerScriptedConsoleCommand);

    return d->longDescription;

}

/*!

  \internal

*/

QStringList QScriptDebuggerScriptedConsoleCommand::aliases() const

{

    Q_D(const QScriptDebuggerScriptedConsoleCommand);

    return d->aliases;

}

/*!

  \internal

*/

QStringList QScriptDebuggerScriptedConsoleCommand::seeAlso() const

{

    Q_D(const QScriptDebuggerScriptedConsoleCommand);

    return d->seeAlso;

}

/*!

  \internal

*/

QStringList QScriptDebuggerScriptedConsoleCommand::argumentTypes() const

{

    Q_D(const QScriptDebuggerScriptedConsoleCommand);

    return d->argumentTypes;

}

/*!

  \internal

*/

QStringList QScriptDebuggerScriptedConsoleCommand::subCommands() const