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

**

** 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 QtDBus 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 "qdbusmetaobject_p.h"

#include <QtCore/qbytearray.h>

#include <QtCore/qhash.h>

#include <QtCore/qstring.h>

#include <QtCore/qvarlengtharray.h>

#include "qdbusutil_p.h"

#include "qdbuserror.h"

#include "qdbusmetatype.h"

#include "qdbusargument.h"

#include "qdbusintrospection_p.h"

#include "qdbusabstractinterface_p.h"

#ifndef QT_NO_DBUS

QT_BEGIN_NAMESPACE

class QDBusMetaObjectGenerator

{

public:

    QDBusMetaObjectGenerator(const QString &interface,

                             const QDBusIntrospection::Interface *parsedData);

    void write(QDBusMetaObject *obj);

    void writeWithoutXml(QDBusMetaObject *obj);

private:

    struct Method {

        QByteArray parameters;

        QByteArray typeName;

        QByteArray tag;

        QByteArray name;

        QByteArray inputSignature;

        QByteArray outputSignature;

        QVarLengthArray<int, 4> inputTypes;

        QVarLengthArray<int, 4> outputTypes;

        int flags;

    };

    struct Property {

        QByteArray typeName;

        QByteArray signature;

        int type;

        int flags;

    };

    struct Type {

        int id;

        QByteArray name;

    };

    enum PropertyFlags  {

        Invalid = 0x00000000,

        Readable = 0x00000001,

        Writable = 0x00000002,

        Resettable = 0x00000004,

        EnumOrFlag = 0x00000008,

        StdCppSet = 0x00000100,

  //    Override = 0x00000200,

        Designable = 0x00001000,

        ResolveDesignable = 0x00002000,

        Scriptable = 0x00004000,

        ResolveScriptable = 0x00008000,

        Stored = 0x00010000,

        ResolveStored = 0x00020000,

        Editable = 0x00040000,

        ResolveEditable = 0x00080000,

        User = 0x00100000,

        ResolveUser = 0x00200000

    };

    enum MethodFlags  {

        AccessPrivate = 0x00,

        AccessProtected = 0x01,

        AccessPublic = 0x02,

        AccessMask = 0x03, //mask

        MethodMethod = 0x00,

        MethodSignal = 0x04,

        MethodSlot = 0x08,

        MethodTypeMask = 0x0c,

        MethodCompatibility = 0x10,

        MethodCloned = 0x20,

        MethodScriptable = 0x40

    };

    QMap<QByteArray, Method> methods;

    QMap<QByteArray, Property> properties;

    const QDBusIntrospection::Interface *data;

    QString interface;

    Type findType(const QByteArray &signature,

                  const QDBusIntrospection::Annotations &annotations,

                  const char *direction = "Out", int id = -1);

    void parseMethods();

    void parseSignals();

    void parseProperties();

};

static const int intsPerProperty = 2;

static const int intsPerMethod = 5;

// ### from kernel/qmetaobject.cpp (Qt 4.1.2):

struct QDBusMetaObjectPrivate

{

    int revision;

    int className;

    int classInfoCount, classInfoData;

    int methodCount, methodData;

    int propertyCount, propertyData;

    int enumeratorCount, enumeratorData;

    // this is specific for QDBusMetaObject:

    int propertyDBusData;

    int methodDBusData;

};

QDBusMetaObjectGenerator::QDBusMetaObjectGenerator(const QString &interfaceName,

                                                   const QDBusIntrospection::Interface *parsedData)

    : data(parsedData), interface(interfaceName)

{

    if (data) {

        parseProperties();

        parseSignals();             // call parseSignals first so that slots override signals

        parseMethods();

    }

}

QDBusMetaObjectGenerator::Type

QDBusMetaObjectGenerator::findType(const QByteArray &signature,

                                   const QDBusIntrospection::Annotations &annotations,

                                   const char *direction, int id)

{

    Type result;

    result.id = QVariant::Invalid;

    int type = QDBusMetaType::signatureToType(signature);

    if (type == QVariant::Invalid) {

        // it's not a type normally handled by our meta type system

        // it must contain an annotation

        QString annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName");

        if (id >= 0)

            annotationName += QString::fromLatin1(".%1%2")

                              .arg(QLatin1String(direction))

                              .arg(id);

        // extract from annotations:

        QByteArray typeName = annotations.value(annotationName).toLatin1();

        // verify that it's a valid one

        if (typeName.isEmpty())

            return result;      // invalid

        type = QVariant::nameToType(typeName);

        if (type == QVariant::UserType)

            type = QMetaType::type(typeName);

        if (type == QVariant::Invalid || signature != QDBusMetaType::typeToSignature(type))

            return result;      // unknown type is invalid too

        result.name = typeName;

    } else {

        result.name = QVariant::typeToName( QVariant::Type(type) );

    }

    result.id = type;

    return result;              // success

}

void QDBusMetaObjectGenerator::parseMethods()

{

    //

    // TODO:

    //  Add cloned methods when the remote object has return types

    //

    QDBusIntrospection::Methods::ConstIterator method_it = data->methods.constBegin();

    QDBusIntrospection::Methods::ConstIterator method_end = data->methods.constEnd();

    for ( ; method_it != method_end; ++method_it) {

        const QDBusIntrospection::Method &m = *method_it;

        Method mm;

        mm.name = m.name.toLatin1();

        QByteArray prototype = mm.name;

        prototype += '(';

        bool ok = true;

        // build the input argument list

        for (int i = 0; i < m.inputArgs.count(); ++i) {

            const QDBusIntrospection::Argument &arg = m.inputArgs.at(i);

            Type type = findType(arg.type.toLatin1(), m.annotations, "In", i);

            if (type.id == QVariant::Invalid) {

                ok = false;

                break;

            }

            mm.inputSignature += arg.type.toLatin1();

            mm.inputTypes.append(type.id);

            mm.parameters.append(arg.name.toLatin1());

            mm.parameters.append(',');

            prototype.append(type.name);

            prototype.append(',');

        }

        if (!ok) continue;

        // build the output argument list:

        for (int i = 0; i < m.outputArgs.count(); ++i) {

            const QDBusIntrospection::Argument &arg = m.outputArgs.at(i);

            Type type = findType(arg.type.toLatin1(), m.annotations, "Out", i);

            if (type.id == QVariant::Invalid) {

                ok = false;

                break;

            }

            mm.outputSignature += arg.type.toLatin1();

            mm.outputTypes.append(type.id);

            if (i == 0) {

                // return value

                mm.typeName = type.name;

            } else {

                // non-const ref parameter

                mm.parameters.append(arg.name.toLatin1());

                mm.parameters.append(',');

                prototype.append(type.name);

                prototype.append("&,");

            }

        }

        if (!ok) continue;

        // convert the last commas:

        if (!mm.parameters.isEmpty()) {

            mm.parameters.truncate(mm.parameters.length() - 1);

            prototype[prototype.length() - 1] = ')';

        } else {

            prototype.append(')');

        }

        // check the async tag

        if (m.annotations.value(QLatin1String(ANNOTATION_NO_WAIT)) == QLatin1String("true"))

            mm.tag = "Q_NOREPLY";

        // meta method flags

        mm.flags = AccessPublic | MethodSlot | MethodScriptable;

        // add

        methods.insert(QMetaObject::normalizedSignature(prototype), mm);

    }

}

void QDBusMetaObjectGenerator::parseSignals()

{

    QDBusIntrospection::Signals::ConstIterator signal_it = data->signals_.constBegin();

    QDBusIntrospection::Signals::ConstIterator signal_end = data->signals_.constEnd();

    for ( ; signal_it != signal_end; ++signal_it) {

        const QDBusIntrospection::Signal &s = *signal_it;

        Method mm;

        mm.name = s.name.toLatin1();

        QByteArray prototype = mm.name;

        prototype += '(';

        bool ok = true;

        // build the output argument list

        for (int i = 0; i < s.outputArgs.count(); ++i) {

            const QDBusIntrospection::Argument &arg = s.outputArgs.at(i);

            Type type = findType(arg.type.toLatin1(), s.annotations, "Out", i);

            if (type.id == QVariant::Invalid) {

                ok = false;

                break;

            }

            mm.inputSignature += arg.type.toLatin1();

            mm.inputTypes.append(type.id);

            mm.parameters.append(arg.name.toLatin1());

            mm.parameters.append(',');

            prototype.append(type.name);

            prototype.append(',');

        }

        if (!ok) continue;

        // convert the last commas:

        if (!mm.parameters.isEmpty()) {

            mm.parameters.truncate(mm.parameters.length() - 1);

            prototype[prototype.length() - 1] = ')';

        } else {

            prototype.append(')');

        }

        // meta method flags

        mm.flags = AccessProtected | MethodSignal | MethodScriptable;

        // add

        methods.insert(QMetaObject::normalizedSignature(prototype), mm);

    }

}

void QDBusMetaObjectGenerator::parseProperties()

{

    QDBusIntrospection::Properties::ConstIterator prop_it = data->properties.constBegin();

    QDBusIntrospection::Properties::ConstIterator prop_end = data->properties.constEnd();

    for ( ; prop_it != prop_end; ++prop_it) {

        const QDBusIntrospection::Property &p = *prop_it;

        Property mp;

        Type type = findType(p.type.toLatin1(), p.annotations);

        if (type.id == QVariant::Invalid)

            continue;

        QByteArray name = p.name.toLatin1();

        mp.signature = p.type.toLatin1();

        mp.type = type.id;

        mp.typeName = type.name;

        // build the flags:

        mp.flags = StdCppSet | Scriptable | Stored | Designable;

        if (p.access != QDBusIntrospection::Property::Write)

            mp.flags |= Readable;

        if (p.access != QDBusIntrospection::Property::Read)

            mp.flags |= Writable;

        if (mp.typeName == "QDBusVariant")

            mp.flags |= 0xff << 24;

        else if (mp.type < 0xff)

            // encode the type in the flags

            mp.flags |= mp.type << 24;

        // add the property:

        properties.insert(name, mp);

    }

}

void QDBusMetaObjectGenerator::write(QDBusMetaObject *obj)

{

    // this code here is mostly copied from qaxbase.cpp

    // with a few modifications to make it cleaner

    QString className = interface;

    className.replace(QLatin1Char('.'), QLatin1String("::"));

    if (className.isEmpty())

        className = QLatin1String("QDBusInterface");

    QVarLengthArray<int> idata;

    idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(int));

    QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data());

    header->revision = 1;

    header->className = 0;

    header->classInfoCount = 0;

    header->classInfoData = 0;

    header->methodCount = methods.count();

    header->methodData = idata.size();

    header->propertyCount = properties.count();

    header->propertyData = header->methodData + header->methodCount * 5;

    header->enumeratorCount = 0;

    header->enumeratorData = 0;

    header->propertyDBusData = header->propertyData + header->propertyCount * 3;

    header->methodDBusData = header->propertyDBusData + header->propertyCount * intsPerProperty;

    int data_size = idata.size() +

                    (header->methodCount * (5+intsPerMethod)) +

                    (header->propertyCount * (3+intsPerProperty));

    foreach (const Method &mm, methods)

        data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count();

    idata.resize(data_size + 1);

    char null('\0');

    QByteArray stringdata = className.toLatin1();

    stringdata += null;

    stringdata.reserve(8192);

    int offset = header->methodData;

    int signatureOffset = header->methodDBusData;

    int typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod;

    idata[typeidOffset++] = 0;                           // eod

    // add each method:

    for (QMap<QByteArray, Method>::ConstIterator it = methods.constBegin();

         it != methods.constEnd(); ++it) {

        // form "prototype\0parameters\0typeName\0tag\0methodname\0inputSignature\0outputSignature"

        const Method &mm = it.value();

        idata[offset++] = stringdata.length();

        stringdata += it.key();                 // prototype

        stringdata += null;

        idata[offset++] = stringdata.length();

        stringdata += mm.parameters;

        stringdata += null;

        idata[offset++] = stringdata.length();

        stringdata += mm.typeName;

        stringdata += null;

        idata[offset++] = stringdata.length();

        stringdata += mm.tag;

        stringdata += null;

        idata[offset++] = mm.flags;

        idata[signatureOffset++] = stringdata.length();

        stringdata += mm.name;

        stringdata += null;

        idata[signatureOffset++] = stringdata.length();

        stringdata += mm.inputSignature;

        stringdata += null;

        idata[signatureOffset++] = stringdata.length();

        stringdata += mm.outputSignature;

        stringdata += null;

        idata[signatureOffset++] = typeidOffset;

        idata[typeidOffset++] = mm.inputTypes.count();

        memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.count() * sizeof(int));

        typeidOffset += mm.inputTypes.count();

        idata[signatureOffset++] = typeidOffset;

        idata[typeidOffset++] = mm.outputTypes.count();

        memcpy(idata.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.count() * sizeof(int));

        typeidOffset += mm.outputTypes.count();

    }

    Q_ASSERT(offset == header->propertyData);

    Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod);

    Q_ASSERT(typeidOffset == idata.size());

    // add each property

    signatureOffset = header->propertyDBusData;

    for (QMap<QByteArray, Property>::ConstIterator it = properties.constBegin();

         it != properties.constEnd(); ++it) {

        const Property &mp = it.value();

        // form is "name\0typeName\0signature\0"

        idata[offset++] = stringdata.length();

        stringdata += it.key();                 // name

        stringdata += null;

        idata[offset++] = stringdata.length();

        stringdata += mp.typeName;

        stringdata += null;

        idata[offset++] = mp.flags;

        idata[signatureOffset++] = stringdata.length();

        stringdata += mp.signature;

        stringdata += null;

        idata[signatureOffset++] = mp.type;

    }

    Q_ASSERT(offset == header->propertyDBusData);

    Q_ASSERT(signatureOffset == header->methodDBusData);

    char *string_data = new char[stringdata.length()];

    memcpy(string_data, stringdata, stringdata.length());

    uint *uint_data = new uint[idata.size()];

    memcpy(uint_data, idata.data(), idata.size() * sizeof(int));

    // put the metaobject together

    obj->d.data = uint_data;

    obj->d.extradata = 0;

    obj->d.stringdata = string_data;

    obj->d.superdata = &QDBusAbstractInterface::staticMetaObject;

}

#if 0

void QDBusMetaObjectGenerator::writeWithoutXml(const QString &interface)

{

    // no XML definition

    QString tmp(interface);

    tmp.replace(QLatin1Char('.'), QLatin1String("::"));

    QByteArray name(tmp.toLatin1());

    QDBusMetaObjectPrivate *header = new QDBusMetaObjectPrivate;

    memset(header, 0, sizeof *header);

    header->revision = 1;

    // leave the rest with 0

    char *stringdata = new char[name.length() + 1];

    stringdata[name.length()] = '\0';

    d.data = reinterpret_cast<uint*>(header);

    d.extradata = 0;

    d.stringdata = stringdata;