#include <QObject>

#include "DynamicQMetaObjectBuilder.h"

namespace Brig {

DynamicQMetaObjectBuilder::DynamicQMetaObjectBuilder(const char *typeName)

{

_typeName = strdup(typeName);

}

DynamicQMetaObjectBuilder::~DynamicQMetaObjectBuilder()

{

// Release all signals

for (BrigMetaSignal *signal : _signals) {

delete signal;

}

_signals.clear();

// Release all methods

for (BrigMetaMethod *method : _methods) {

delete method;

}

_methods.clear();

// Release all properties

for (BrigMetaProperty *property: _properties) {

delete property;

}

_properties.clear();

delete _typeName;

delete signalListener;

}

QMetaObject *DynamicQMetaObjectBuilder::build()

{

// Initializing builder

builder.setClassName(_typeName);

builder.setSuperClass(&QObject::staticMetaObject);

builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);

// Initializing properties

int relativePropIndex = builder.propertyCount();

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

BrigMetaProperty *property = _properties[i];

QMetaPropertyBuilder propb = builder.addProperty(QMetaObject::normalizedSignature(property->signature), "QVariant", relativePropIndex);

propb.setWritable(true);

relativePropIndex++;

}

// Initializing signal hanglers

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

BrigMetaSignal *signal = _signals[i];

builder.addSignal(QMetaObject::normalizedSignature(signal->signature));

}

// Initializing method hanglers

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

BrigMetaMethod *method = _methods[i];

builder.addMethod(QMetaObject::normalizedSignature(method->signature), "QVariant");

}

return builder.toMetaObject();

}

void DynamicQMetaObjectBuilder::addSignal(const char *name, const char *signature, QList<QByteArray> arguments)

{

Nan::HandleScope scope;

BrigMetaSignal *signal = new BrigMetaSignal();

signal->name = strdup(name);

signal->signature = strdup(signature);

// signal->handler = new Nan::Callback(cb.As<Function>());

signal->arguments = arguments;

_signals.append(signal);

#if 0

// Create a new callback

Callback *callback = new Callback();

callback->signature = strdup(name);

callback->handler = new Nan::Callback(cb.As<Function>());

_signals.append(callback);

// Preparing arguments

QList<QByteArray> arguments;

for (auto argName : argumentNames) {

arguments.push_back(argName.toLatin1());

}

// Add to signal builder

builder->addSignal(signature).setParameterNames(arguments);

printf("Added signal handler: %s\n", callback->signature);

#endif

}

void DynamicQMetaObjectBuilder::addMethod(const char *name, const char *signature, QList<QByteArray> arguments, Local<Value> cb)

{

Nan::HandleScope scope;

BrigMetaMethod *method = new BrigMetaMethod();

method->name = strdup(name);

method->signature = strdup(signature);

method->arguments = arguments;

method->handler = new Nan::Callback(cb.As<Function>());

_methods.append(method);

#if 0

// Create a new callback

Callback *callback = new Callback();

callback->signature = strdup(name);

callback->handler = new Nan::Callback(cb.As<Function>());

_methods.append(callback);

// Preparing arguments

QList<QByteArray> arguments;

for (auto argName : argumentNames) {

arguments.push_back(argName.toLatin1());

}

// Add to method builder

builder->addMethod(signature).setParameterNames(arguments);

printf("Added method handler: %s\n", callback->signature);

#endif

}

void DynamicQMetaObjectBuilder::addProperty(const char *name, Local<Value> readCallback, Local<Value> writeCallback)

{

Nan::HandleScope scope;

// Signal

BrigMetaSignal *signal = new BrigMetaSignal();

std::string signalName(name);

signalName += "Changed";

signal->name = strdup(signalName.c_str());

//signalName += "(QVariant)";

signalName += "()";

signal->signature = strdup(signalName.c_str());

// Convert parameters

QList<QByteArray> arguments;

// arguments << QByteArray("QVariant");

signal->arguments = arguments;

_signals.append(signal);

// Property

BrigMetaProperty *property = new BrigMetaProperty();

property->name = strdup(name);

property->signature = strdup(name);

property->signalId = _signals.count() - 1;

property->readHandler = new Nan::Callback(readCallback.As<Function>());

property->writeHandler = new Nan::Callback(writeCallback.As<Function>());

_properties.append(property);

}

void DynamicQMetaObjectBuilder::addSignalListener(Local<Value> listener)

{

Nan::HandleScope scope;

signalListener = new Nan::Callback(listener.As<Function>());

}

}