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

**

** 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 QtScript module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL-ONLY$

** GNU Lesser General Public License Usage

** 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.

**

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

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

** $QT_END_LICENSE$

**

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

#include "config.h"

#include "qscriptqobject_p.h"

#include <QtCore/qmetaobject.h>

#include <QtCore/qvarlengtharray.h>

#include <QtCore/qdebug.h>

#include <QtScript/qscriptable.h>

#include "../api/qscriptengine_p.h"

#include "../api/qscriptable_p.h"

#include "../api/qscriptcontext_p.h"

#include "qscriptfunction_p.h"

#include "Error.h"

#include "PrototypeFunction.h"

#include "PropertyNameArray.h"

#include "JSFunction.h"

#include "JSString.h"

#include "JSValue.h"

#include "JSArray.h"

#include "RegExpObject.h"

#include "RegExpConstructor.h"

namespace JSC

{

QT_USE_NAMESPACE

ASSERT_CLASS_FITS_IN_CELL(QScript::QObjectPrototype);

ASSERT_CLASS_FITS_IN_CELL(QScript::QMetaObjectWrapperObject);

ASSERT_CLASS_FITS_IN_CELL(QScript::QMetaObjectPrototype);

ASSERT_CLASS_FITS_IN_CELL(QScript::QtFunction);

ASSERT_CLASS_FITS_IN_CELL(QScript::QtPropertyFunction);

}

QT_BEGIN_NAMESPACE

namespace QScript

{

struct QObjectConnection

{

    int slotIndex;

    JSC::JSValue receiver;

    JSC::JSValue slot;

    JSC::JSValue senderWrapper;

    QObjectConnection(int i, JSC::JSValue r, JSC::JSValue s,

                      JSC::JSValue sw)

        : slotIndex(i), receiver(r), slot(s), senderWrapper(sw) {}

    QObjectConnection() : slotIndex(-1) {}

    bool hasTarget(JSC::JSValue r, JSC::JSValue s) const

    {

        if ((r && r.isObject()) != (receiver && receiver.isObject()))

            return false;

        if (((r && r.isObject()) && (receiver && receiver.isObject()))

            && (r != receiver)) {

            return false;

        }

        return (s == slot);

    }

    void mark(JSC::MarkStack& markStack)

    {

        if (senderWrapper) {

            // see if the sender should be marked or not;

            // if the C++ object is owned by script, we don't want

            // it to stay alive due to a script connection.

            Q_ASSERT(senderWrapper.inherits(&QScriptObject::info));

            QScriptObject *scriptObject = static_cast<QScriptObject*>(JSC::asObject(senderWrapper));

            if (!JSC::Heap::isCellMarked(scriptObject)) {

                QScriptObjectDelegate *delegate = scriptObject->delegate();

                Q_ASSERT(delegate && (delegate->type() == QScriptObjectDelegate::QtObject));

                QObjectDelegate *inst = static_cast<QObjectDelegate*>(delegate);

                if ((inst->ownership() == QScriptEngine::ScriptOwnership)

                    || ((inst->ownership() == QScriptEngine::AutoOwnership)

                        && inst->value() && !inst->value()->parent())) {

                    senderWrapper = JSC::JSValue();

                } else {

                    markStack.append(senderWrapper);

                }

            }

        }

        if (receiver)

            markStack.append(receiver);

        if (slot)

            markStack.append(slot);

    }

};

class QObjectNotifyCaller : public QObject

{

public:

    void callConnectNotify(const char *signal)

        { connectNotify(signal); }

    void callDisconnectNotify(const char *signal)

        { disconnectNotify(signal); }

};

class QObjectConnectionManager: public QObject

{

public:

    QObjectConnectionManager(QScriptEnginePrivate *engine);

    ~QObjectConnectionManager();

    bool addSignalHandler(QObject *sender, int signalIndex,

                          JSC::JSValue receiver,

                          JSC::JSValue slot,

                          JSC::JSValue senderWrapper,

                          Qt::ConnectionType type);

    bool removeSignalHandler(QObject *sender, int signalIndex,

                             JSC::JSValue receiver,

                             JSC::JSValue slot);

    static const QMetaObject staticMetaObject;

    virtual const QMetaObject *metaObject() const;

    virtual void *qt_metacast(const char *);

    virtual int qt_metacall(QMetaObject::Call, int, void **argv);

    void execute(int slotIndex, void **argv);

    void mark(JSC::MarkStack&);

private:

    QScriptEnginePrivate *engine;

    int slotCounter;

    QVector<QVector<QObjectConnection> > connections;

};

static bool hasMethodAccess(const QMetaMethod &method, int index, const QScriptEngine::QObjectWrapOptions &opt)

{

    return (method.access() != QMetaMethod::Private)

        && ((index != 2) || !(opt & QScriptEngine::ExcludeDeleteLater));

}

static bool isEnumerableMetaProperty(const QMetaProperty &prop,

                                     const QMetaObject *mo, int index)

{

    return prop.isScriptable() && prop.isValid()

        // the following lookup is to ensure that we have the

        // "most derived" occurrence of the property with this name

        && (mo->indexOfProperty(prop.name()) == index);

}

static inline QByteArray methodName(const QMetaMethod &method)

{

    QByteArray signature = method.signature();

    return signature.left(signature.indexOf('('));

}

static QVariant variantFromValue(QScriptEnginePrivate *eng,

                                 int targetType, const QScriptValue &value)

{

    QVariant v(targetType, (void *)0);

    Q_ASSERT(eng);

    if (QScriptEnginePrivate::convert(value, targetType, v.data(), eng))

        return v;

    if (uint(targetType) == QVariant::LastType)

        return value.toVariant();

    if (value.isVariant()) {

        v = value.toVariant();

        if (v.canConvert(QVariant::Type(targetType))) {

            v.convert(QVariant::Type(targetType));

            return v;

        }

        QByteArray typeName = v.typeName();

        if (typeName.endsWith('*')

            && (QMetaType::type(typeName.left(typeName.size()-1)) == targetType)) {

            return QVariant(targetType, *reinterpret_cast<void* *>(v.data()));

        }

    }

    return QVariant();

}

static const bool GeneratePropertyFunctions = true;

static unsigned flagsForMetaProperty(const QMetaProperty &prop)

{

    return (JSC::DontDelete

            | (!prop.isWritable() ? unsigned(JSC::ReadOnly) : unsigned(0))

            | (GeneratePropertyFunctions

               ? unsigned(JSC::Getter | JSC::Setter)

                  : unsigned(0))

            | QObjectMemberAttribute);

}

static int indexOfMetaEnum(const QMetaObject *meta, const QByteArray &str)

{

    QByteArray scope;

    QByteArray name;

    int scopeIdx = str.lastIndexOf("::");

    if (scopeIdx != -1) {

        scope = str.left(scopeIdx);

        name = str.mid(scopeIdx + 2);

    } else {

        name = str;

    }

    for (int i = meta->enumeratorCount() - 1; i >= 0; --i) {

        QMetaEnum m = meta->enumerator(i);

        if ((m.name() == name) && (scope.isEmpty() || (m.scope() == scope)))

            return i;

    }

    return -1;

}

static inline QScriptable *scriptableFromQObject(QObject *qobj)

{

    void *ptr = qobj->qt_metacast("QScriptable");

    return reinterpret_cast<QScriptable*>(ptr);

}

QtFunction::QtFunction(JSC::JSValue object, int initialIndex, bool maybeOverloaded,

                       JSC::JSGlobalData *data, WTF::PassRefPtr<JSC::Structure> sid,

                       const JSC::Identifier &ident)

    : JSC::InternalFunction(data, sid, ident),

      data(new Data(object, initialIndex, maybeOverloaded))

{

}

QtFunction::~QtFunction()

{

    delete data;

}

JSC::CallType QtFunction::getCallData(JSC::CallData &callData)

{

    callData.native.function = call;

    return JSC::CallTypeHost;

}

void QtFunction::markChildren(JSC::MarkStack& markStack)

{

    if (data->object)

        markStack.append(data->object);

    JSC::InternalFunction::markChildren(markStack);

}

QScriptObject *QtFunction::wrapperObject() const

{

    Q_ASSERT(JSC::asObject(data->object)->inherits(&QScriptObject::info));

    return static_cast<QScriptObject*>(JSC::asObject(data->object));

}

QObject *QtFunction::qobject() const

{

    QScriptObject *scriptObject = wrapperObject();

    QScriptObjectDelegate *delegate = scriptObject->delegate();

    Q_ASSERT(delegate && (delegate->type() == QScriptObjectDelegate::QtObject));

    return static_cast<QScript::QObjectDelegate*>(delegate)->value();

}

const QMetaObject *QtFunction::metaObject() const

{

    QObject *qobj = qobject();

    if (!qobj)

        return 0;

    return qobj->metaObject();

}

int QtFunction::initialIndex() const

{

    return data->initialIndex;

}

bool QtFunction::maybeOverloaded() const

{

    return data->maybeOverloaded;

}

int QtFunction::mostGeneralMethod(QMetaMethod *out) const

{

    const QMetaObject *meta = metaObject();

    if (!meta)

        return -1;

    int index = initialIndex();

    QMetaMethod method = meta->method(index);

    if (maybeOverloaded() && (method.attributes() & QMetaMethod::Cloned)) {

        // find the most general method

        do {

            method = meta->method(--index);

        } while (method.attributes() & QMetaMethod::Cloned);

    }

    if (out)

        *out = method;

    return index;

}

QList<int> QScript::QtFunction::overloadedIndexes() const

{

    if (!maybeOverloaded())

        return QList<int>();

    QList<int> result;

    QString name = functionName();

    const QMetaObject *meta = metaObject();

    for (int index = mostGeneralMethod() - 1; index >= 0; --index) {

        QString otherName = QString::fromLatin1(methodName(meta->method(index)));

        if (otherName == name)

            result.append(index);

    }

    return result;

}

QString QtFunction::functionName() const

{

    const QMetaObject *meta = metaObject();

    if (!meta)

        return QString();

    QMetaMethod method = meta->method(initialIndex());

    return QLatin1String(methodName(method));

}

class QScriptMetaType

{

public:

    enum Kind {

        Invalid,

        Variant,

        MetaType,

        Unresolved,

        MetaEnum

    };

    inline QScriptMetaType()

        : m_kind(Invalid) { }

    inline Kind kind() const

    { return m_kind; }

    int typeId() const;

    inline bool isValid() const

    { return (m_kind != Invalid); }

    inline bool isVariant() const

    { return (m_kind == Variant); }

    inline bool isMetaType() const

    { return (m_kind == MetaType); }

    inline bool isUnresolved() const

    { return (m_kind == Unresolved); }

    inline bool isMetaEnum() const

    { return (m_kind == MetaEnum); }

    QByteArray name() const;

    inline int enumeratorIndex() const

    { Q_ASSERT(isMetaEnum()); return m_typeId; }

    inline bool operator==(const QScriptMetaType &other) const

    {

        return (m_kind == other.m_kind) && (m_typeId == other.m_typeId);

    }

    static inline QScriptMetaType variant()

    { return QScriptMetaType(Variant); }

    static inline QScriptMetaType metaType(int typeId, const QByteArray &name)

    { return QScriptMetaType(MetaType, typeId, name); }

    static inline QScriptMetaType metaEnum(int enumIndex, const QByteArray &name)

    { return QScriptMetaType(MetaEnum, enumIndex, name); }

    static inline QScriptMetaType unresolved(const QByteArray &name)

    { return QScriptMetaType(Unresolved, /*typeId=*/0, name); }

private:

    inline QScriptMetaType(Kind kind, int typeId = 0, const QByteArray &name = QByteArray())

        : m_kind(kind), m_typeId(typeId), m_name(name) { }

    Kind m_kind;

    int m_typeId;

    QByteArray m_name;

};

int QScriptMetaType::typeId() const

{

    if (isVariant())

        return QMetaType::type("QVariant");

    return isMetaEnum() ? 2/*int*/ : m_typeId;

}

QByteArray QScriptMetaType::name() const

{

    if (!m_name.isEmpty())

        return m_name;

    else if (m_kind == Variant)

        return "QVariant";

    return QMetaType::typeName(typeId());

}

class QScriptMetaMethod

{

public:

    inline QScriptMetaMethod()

        { }

    inline QScriptMetaMethod(const QByteArray &name, const QVector<QScriptMetaType> &types)

        : m_name(name), m_types(types), m_firstUnresolvedIndex(-1)

    {

        QVector<QScriptMetaType>::const_iterator it;

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

            if ((*it).kind() == QScriptMetaType::Unresolved) {

                m_firstUnresolvedIndex = it - m_types.constBegin();

                break;

            }

        }

    }

    inline bool isValid() const

    { return !m_types.isEmpty(); }

    QByteArray name() const

    { return m_name; }

    inline QScriptMetaType returnType() const

    { return m_types.at(0); }

    inline int argumentCount() const

    { return m_types.count() - 1; }

    inline QScriptMetaType argumentType(int arg) const

    { return m_types.at(arg + 1); }

    inline bool fullyResolved() const

    { return m_firstUnresolvedIndex == -1; }

    inline bool hasUnresolvedReturnType() const

    { return (m_firstUnresolvedIndex == 0); }

    inline int firstUnresolvedIndex() const

    { return m_firstUnresolvedIndex; }

    inline int count() const

    { return m_types.count(); }

    inline QScriptMetaType type(int index) const

    { return m_types.at(index); }

    inline QVector<QScriptMetaType> types() const

    { return m_types; }

private:

    QByteArray m_name;

    QVector<QScriptMetaType> m_types;

    int m_firstUnresolvedIndex;

};

struct QScriptMetaArguments

{

    int matchDistance;

    int index;

    QScriptMetaMethod method;

    QVarLengthArray<QVariant, 9> args;

    inline QScriptMetaArguments(int dist, int idx, const QScriptMetaMethod &mtd,

                                const QVarLengthArray<QVariant, 9> &as)

        : matchDistance(dist), index(idx), method(mtd), args(as) { }

    inline QScriptMetaArguments()

        : index(-1) { }

    inline bool isValid() const

    { return (index != -1); }

};

static QMetaMethod metaMethod(const QMetaObject *meta,

                              QMetaMethod::MethodType type,

                              int index)

{

    if (type != QMetaMethod::Constructor)

        return meta->method(index);

    else

        return meta->constructor(index);

}

static JSC::JSValue callQtMethod(JSC::ExecState *exec, QMetaMethod::MethodType callType,

                                 QObject *thisQObject, const JSC::ArgList &scriptArgs,

                                 const QMetaObject *meta, int initialIndex,

                                 bool maybeOverloaded)

{

    QByteArray funName;

    QScriptMetaMethod chosenMethod;

    int chosenIndex = -1;

    QVarLengthArray<QVariant, 9> args;

    QVector<QScriptMetaArguments> candidates;

    QVector<QScriptMetaArguments> unresolved;

    QVector<int> tooFewArgs;

    QVector<int> conversionFailed;

    int index;

    exec->clearException();

    QScriptEnginePrivate *engine = QScript::scriptEngineFromExec(exec);

    for (index = initialIndex; index >= 0; --index) {

        QMetaMethod method = metaMethod(meta, callType, index);

        if (index == initialIndex)

            funName = methodName(method);

        else {

            if (methodName(method) != funName)

                continue;

        }

        QVector<QScriptMetaType> types;

        // resolve return type

        QByteArray returnTypeName = method.typeName();

        int rtype = QMetaType::type(returnTypeName);