/*

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

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License as published by the Free Software Foundation; either

 *  version 2 of the License, or (at your option) any later version.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include "config.h"

#include "qt_instance.h"

#include "Error.h"

#include "JSDOMBinding.h"

#include "JSGlobalObject.h"

#include "JSLock.h"

#include "ObjectPrototype.h"

#include "PropertyNameArray.h"

#include "qt_class.h"

#include "qt_runtime.h"

#include "runtime_object.h"

#include <qdebug.h>

#include <qhash.h>

#include <qmetaobject.h>

#include <qmetatype.h>

namespace JSC {

namespace Bindings {

// Cache QtInstances

typedef QMultiHash<void*, QtInstance*> QObjectInstanceMap;

static QObjectInstanceMap cachedInstances;

// Derived RuntimeObject

class QtRuntimeObject : public RuntimeObject {

public:

    QtRuntimeObject(ExecState*, JSGlobalObject*, PassRefPtr<Instance>);

    static const ClassInfo s_info;

    virtual void markChildren(MarkStack& markStack)

    {

        RuntimeObject::markChildren(markStack);

        QtInstance* instance = static_cast<QtInstance*>(getInternalInstance());

        if (instance)

            instance->markAggregate(markStack);

    }

    static PassRefPtr<Structure> createStructure(JSValue prototype)

    {

        return Structure::create(prototype, TypeInfo(ObjectType,  StructureFlags), AnonymousSlotCount);

    }

protected:

    static const unsigned StructureFlags = RuntimeObject::StructureFlags | OverridesMarkChildren;

private:

    virtual const ClassInfo* classInfo() const { return &s_info; }

};

const ClassInfo QtRuntimeObject::s_info = { "QtRuntimeObject", &RuntimeObject::s_info, 0, 0 };

QtRuntimeObject::QtRuntimeObject(ExecState* exec, JSGlobalObject* globalObject, PassRefPtr<Instance> instance)

    : RuntimeObject(exec, globalObject, WebCore::deprecatedGetDOMStructure<QtRuntimeObject>(exec), instance)

{

}

// QtInstance

QtInstance::QtInstance(QObject* o, PassRefPtr<RootObject> rootObject, QScriptEngine::ValueOwnership ownership)

    : Instance(rootObject)

    , m_class(0)

    , m_object(o)

    , m_hashkey(o)

    , m_defaultMethod(0)

    , m_ownership(ownership)

{

}

QtInstance::~QtInstance()

{

    JSLock lock(SilenceAssertionsOnly);

    cachedInstances.remove(m_hashkey);

    // clean up (unprotect from gc) the JSValues we've created

    m_methods.clear();

    qDeleteAll(m_fields);

    m_fields.clear();

    if (m_object) {

        switch (m_ownership) {

        case QScriptEngine::QtOwnership:

            break;

        case QScriptEngine::AutoOwnership:

            if (m_object->parent())

                break;

            // fall through!

        case QScriptEngine::ScriptOwnership:

            delete m_object;

            break;

        }

    }

}

PassRefPtr<QtInstance> QtInstance::getQtInstance(QObject* o, PassRefPtr<RootObject> rootObject, QScriptEngine::ValueOwnership ownership)

{

    JSLock lock(SilenceAssertionsOnly);

    foreach (QtInstance* instance, cachedInstances.values(o))

        if (instance->rootObject() == rootObject) {

            // The garbage collector removes instances, but it may happen that the wrapped

            // QObject dies before the gc kicks in. To handle that case we have to do an additional

            // check if to see if the instance's wrapped object is still alive. If it isn't, then

            // we have to create a new wrapper.

            if (!instance->getObject())

                cachedInstances.remove(instance->hashKey());

            else

                return instance;

        }

    RefPtr<QtInstance> ret = QtInstance::create(o, rootObject, ownership);

    cachedInstances.insert(o, ret.get());

    return ret.release();

}

bool QtInstance::getOwnPropertySlot(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

{

    return object->JSObject::getOwnPropertySlot(exec, propertyName, slot);

}

void QtInstance::put(JSObject* object, ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)

{

    object->JSObject::put(exec, propertyName, value, slot);

}

void QtInstance::removeCachedMethod(JSObject* method)

{

    if (m_defaultMethod == method)

        m_defaultMethod = 0;

    for (QHash<QByteArray, JSObject*>::Iterator it = m_methods.begin(),

        end = m_methods.end(); it != end; ++it)

        if (it.value() == method) {

            m_methods.erase(it);

            return;

        }

}

QtInstance* QtInstance::getInstance(JSObject* object)

{

    if (!object)

        return 0;

    if (!object->inherits(&QtRuntimeObject::s_info))

        return 0;

    return static_cast<QtInstance*>(static_cast<RuntimeObject*>(object)->getInternalInstance());

}

Class* QtInstance::getClass() const

{

    if (!m_class) {

        if (!m_object)

            return 0;

        m_class = QtClass::classForObject(m_object);

    }

    return m_class;

}

RuntimeObject* QtInstance::newRuntimeObject(ExecState* exec)

{

    JSLock lock(SilenceAssertionsOnly);

    return new (exec) QtRuntimeObject(exec, exec->lexicalGlobalObject(), this);

}

void QtInstance::markAggregate(MarkStack& markStack)

{

    if (m_defaultMethod)

        markStack.append(m_defaultMethod);

    foreach (JSObject* val, m_methods.values()) {

        if (val)

            markStack.append(val);

    }

}

void QtInstance::begin()

{

    // Do nothing.

}

void QtInstance::end()

{

    // Do nothing.

}

void QtInstance::getPropertyNames(ExecState* exec, PropertyNameArray& array)

{

    // This is the enumerable properties, so put:

    // properties

    // dynamic properties

    // slots

    QObject* obj = getObject();

    if (obj) {

        const QMetaObject* meta = obj->metaObject();

        int i;

        for (i = 0; i < meta->propertyCount(); i++) {

            QMetaProperty prop = meta->property(i);

            if (prop.isScriptable())

                array.add(Identifier(exec, prop.name()));

        }

#ifndef QT_NO_PROPERTIES

        QList<QByteArray> dynProps = obj->dynamicPropertyNames();

        foreach (const QByteArray& ba, dynProps)

            array.add(Identifier(exec, ba.constData()));

#endif

        const int methodCount = meta->methodCount();

        for (i = 0; i < methodCount; i++) {

            QMetaMethod method = meta->method(i);

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

                array.add(Identifier(exec, method.signature()));

        }

    }

}

JSValue QtInstance::getMethod(ExecState* exec, const Identifier& propertyName)

{

    if (!getClass())

        return jsNull();

    MethodList methodList = m_class->methodsNamed(propertyName, this);

    return new (exec) RuntimeMethod(exec, exec->lexicalGlobalObject(), propertyName, methodList);

}

JSValue QtInstance::invokeMethod(ExecState*, RuntimeMethod*)

{

    // Implemented via fallbackMethod & QtRuntimeMetaMethod::callAsFunction

    return jsUndefined();

}

JSValue QtInstance::defaultValue(ExecState* exec, PreferredPrimitiveType hint) const

{

    if (hint == PreferString)

        return stringValue(exec);

    if (hint == PreferNumber)

        return numberValue(exec);

    return valueOf(exec);

}

JSValue QtInstance::stringValue(ExecState* exec) const

{

    QObject* obj = getObject();

    if (!obj)

        return jsNull();

    // Hmm.. see if there is a toString defined

    QByteArray buf;

    bool useDefault = true;

    getClass();

    if (m_class) {

        // Cheat and don't use the full name resolution

        int index = obj->metaObject()->indexOfMethod("toString()");

        if (index >= 0) {

            QMetaMethod m = obj->metaObject()->method(index);

            // Check to see how much we can call it

            if (m.access() != QMetaMethod::Private

                && m.methodType() != QMetaMethod::Signal

                && m.parameterTypes().isEmpty()) {

                const char* retsig = m.typeName();

                if (retsig && *retsig) {

                    QVariant ret(QMetaType::type(retsig), (void*)0);

                    void * qargs[1];

                    qargs[0] = ret.data();

                    if (QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, index, qargs) < 0) {

                        if (ret.isValid() && ret.canConvert(QVariant::String)) {

                            buf = ret.toString().toLatin1().constData(); // ### Latin 1? Ascii?

                            useDefault = false;

                        }

                    }

                }

            }

        }

    }

    if (useDefault) {

        const QMetaObject* meta = obj ? obj->metaObject() : &QObject::staticMetaObject;

        QString name = obj ? obj->objectName() : QString::fromUtf8("unnamed");

        QString str = QString::fromUtf8("%0(name = \"%1\")")

                      .arg(QLatin1String(meta->className())).arg(name);

        buf = str.toLatin1();

    }

    return jsString(exec, buf.constData());

}

JSValue QtInstance::numberValue(ExecState* exec) const

{

    return jsNumber(exec, 0);

}

JSValue QtInstance::booleanValue() const

{

    // ECMA 9.2

    return jsBoolean(getObject());

}

JSValue QtInstance::valueOf(ExecState* exec) const

{

    return stringValue(exec);

}

// In qt_runtime.cpp

JSValue convertQVariantToValue(ExecState*, PassRefPtr<RootObject> root, const QVariant& variant);

QVariant convertValueToQVariant(ExecState*, JSValue, QMetaType::Type hint, int *distance);

QByteArray QtField::name() const

{

    if (m_type == MetaProperty)

        return m_property.name();

    if (m_type == ChildObject && m_childObject)

        return m_childObject->objectName().toLatin1();

#ifndef QT_NO_PROPERTIES

    if (m_type == DynamicProperty)

        return m_dynamicProperty;

#endif

    return QByteArray(); // deleted child object

}

JSValue QtField::valueFromInstance(ExecState* exec, const Instance* inst) const

{

    const QtInstance* instance = static_cast<const QtInstance*>(inst);

    QObject* obj = instance->getObject();

    if (obj) {

        QVariant val;

        if (m_type == MetaProperty) {

            if (m_property.isReadable())

                val = m_property.read(obj);

            else

                return jsUndefined();

        } else if (m_type == ChildObject)

            val = QVariant::fromValue((QObject*) m_childObject);

#ifndef QT_NO_PROPERTIES

        else if (m_type == DynamicProperty)

            val = obj->property(m_dynamicProperty);

#endif

        return convertQVariantToValue(exec, inst->rootObject(), val);

    }

    QString msg = QString(QLatin1String("cannot access member `%1' of deleted QObject")).arg(QLatin1String(name()));

    return throwError(exec, createError(exec, msg.toLatin1().constData()));

}

void QtField::setValueToInstance(ExecState* exec, const Instance* inst, JSValue aValue) const

{

    if (m_type == ChildObject) // QtScript doesn't allow setting to a named child

        return;

    const QtInstance* instance = static_cast<const QtInstance*>(inst);

    QObject* obj = instance->getObject();

    if (obj) {

        QMetaType::Type argtype = QMetaType::Void;

        if (m_type == MetaProperty)

            argtype = (QMetaType::Type) QMetaType::type(m_property.typeName());

        // dynamic properties just get any QVariant

        QVariant val = convertValueToQVariant(exec, aValue, argtype, 0);

        if (m_type == MetaProperty) {

            if (m_property.isWritable())

                m_property.write(obj, val);

        }

#ifndef QT_NO_PROPERTIES

        else if (m_type == DynamicProperty)

            obj->setProperty(m_dynamicProperty.constData(), val);

#endif

    } else {

        QString msg = QString(QLatin1String("cannot access member `%1' of deleted QObject")).arg(QLatin1String(name()));

        throwError(exec, createError(exec, msg.toLatin1().constData()));

    }

}

}

}