#include <cassert>

#include <private/qobject_p.h>

#include "qtobjectmanager.h"
#include "marshallruby.h"
#include "connectruby.h"


void ConnectAny::call_ruby(int argc, const VALUE *argv)
{
 if (m_conn_type == CONN_RUBY_TO_RUBY) {
 RubyConnectRuby *r2r = (RubyConnectRuby*)this;
 VALUE rbret = rb_funcall3(r2r->m_receiver, r2r->m_slot_id, argc, argv);
 }
 else if (m_conn_type == CONN_QT_TO_RUBY) {
 QtConnectRuby *q2r = (QtConnectRuby*)this;
 VALUE rbret = rb_funcall3(q2r->m_receiver, q2r->m_slot_id, argc, argv);
 }
}

void ConnectAny::call_qt(int argc, const VALUE *argv)
{
 
}

void RubyConnectRuby::call(int argc, VALUE *argv)
{
 this->call_ruby(argc, argv);
}

bool RubyConnectRuby::eventFilter(QObject * watched, QEvent * event)
{
 if (event->type() == QEvent::MetaCall) {
 qDebug()<<"evvvvvvvvvvvvtttt"<<watched<<event;
 QMetaCallEvent *evt = (QMetaCallEvent*)event;
 qDebug()<<"meta cal evt:"<<evt<<evt->args();
 this->mcevt = evt;
 }
 return false; 
}

void RubyConnectRuby::router(int argc, VALUE *argv, VALUE obj)
{
 qDebug()<<"invoked..."<<argc<<argv<<obj;
 this->call_ruby(argc, argv);

 // cleanup
 delete [] argv;
}


void QtConnectRuby::call(int argc, VALUE *argv)
{
 this->call_ruby(argc, argv);
}

bool QtConnectRuby::eventFilter(QObject * watched, QEvent * event)
{
 if (event->type() == QEvent::MetaCall) {
 qDebug()<<"evvvvvvvvvvvvtttt"<<watched<<event;
 QMetaCallEvent *evt = (QMetaCallEvent*)event;
 qDebug()<<"meta cal evt:"<<evt<<evt->args();
 this->mcevt = evt;
 }
 return false;
}

void QtConnectRuby::router()
{
 qDebug()<<"hereeeeeeee"<<this->mcevt;
 qDebug()<<this->m_sender<<this->m_signal<<this->m_receiver<<this->m_slot;
 
 assert(this->mcevt != NULL);
 assert(this->m_sender == sender());

 // 查找sender的signature,确定参数个数
 QString rawsig = this->m_signal.right(this->m_signal.length()-1);
 QByteArray normsig = QMetaObject::normalizedSignature(rawsig.toLatin1().data());
 const QMetaObject *mo = this->m_sender->metaObject();
 int idx = mo->indexOfSignal(normsig.data());
 QMetaMethod mm = mo->method(idx);
 qDebug()<<normsig<<idx;
 qDebug()<<mm.parameterCount();

 if (idx == -1) {
 qDebug()<<"can not get a method";
 assert(idx != -1);
 return;
 }

 int argc = mm.parameterCount();
 VALUE argv[10] = {0};

 void **args = mcevt->args();
 for (int i = 1; i < argc+1; i++) {
 int pty = mm.parameterType(i-1);
 void *arg = args[i];

 argv[i-1] = MarshallRuby::Variant2VALUE(arg, pty);
 }

 //
 // qDebug()<<TYPE(this->m_slot);
 // ID call_id = rb_intern("call");
 // VALUE rbret = rb_funcall3(this->m_slot, call_id, argc, argv);
 this->call(argc, argv);
}

void RubyConnectQt::call(int argc, VALUE *argv)
{
 qDebug()<<argc<<"not impled";
 emit invoked(argc, argv, 0);
}

bool RubyConnectQt::eventFilter(QObject *watched, QEvent *event)
{
 if (event->type() == QEvent::MetaCall) {
 qDebug()<<"evvvvvvvvvvvvtttt"<<watched<<event;
 QMetaCallEvent *evt = (QMetaCallEvent*)event;
 qDebug()<<"meta cal evt:"<<evt<<evt->args();
 this->mcevt = evt;
 }
 return false;
}

void RubyConnectQt::router(int argc, VALUE *argv, VALUE obj)
{
 
 // cleanup
 delete []argv;
}

////////////// 
void QtConnectQt::call(int argc, VALUE *argv)
{
 qDebug()<<argc<<"not impled";
}

bool QtConnectQt::eventFilter(QObject * watched, QEvent * event)
{
 if (event->type() == QEvent::MetaCall) {
 qDebug()<<"evvvvvvvvvvvvtttt"<<watched<<event;
 QMetaCallEvent *evt = (QMetaCallEvent*)event;
 qDebug()<<"meta cal evt:"<<evt<<evt->args();
 this->mcevt = evt;
 }
 return false;
}

void QtConnectQt::router()
{
 qDebug()<<"hereeeeeeee"<<this->mcevt;
 qDebug()<<this->m_sender<<this->m_signal<<this->m_receiver<<this->m_slot;
 
 assert(this->mcevt != NULL);
 assert(this->m_sender == sender());

 qDebug()<<"meta calling qt slot...";
 this->mcevt->placeMetaCall(this->m_receiver); // faild
 // int ret = QMetaObject::metacall(this->m_receiver, QMetaObject::InvokeMetaMethod, mcevt->id(), mcevt->args());
 // qDebug()<<"meta call:"<<ret;
}

////////////////////////
////
// static
ConnectAny *ConnectFactory::create(int argc, VALUE *argv, VALUE obj)
{
 ConnectAny *conn = NULL;

 QString method_name = rb_id2name(SYM2ID(argv[0]));
 qDebug()<<method_name<<argc;

 if (method_name == "qtconnectrb") {
 QObject *sender = (QObject*)Qom::inst()->getObject(argv[1]);
 QVariant vsignal = MarshallRuby::VALUE2Variant(argv[2]);
 QString signal = vsignal.toString();
 QString rsignal = QString("2%1").arg(signal); // real signal

 QtConnectRuby *xconn = NULL;
 if (argc == 4) {
 xconn = new QtConnectRuby(sender, rsignal, argv[3]);
 } else if (argc == 5) {
 xconn = new QtConnectRuby(sender, rsignal, argv[3], argv[4]);
 }
 
 QMetaObject::Connection qtconn =
 QObject::connect(sender, rsignal.toLatin1().data(), xconn, SLOT(router()), Qt::QueuedConnection);
 xconn->installEventFilter(xconn); // ahaha, niubeee

 xconn->qtconn = qtconn;
 conn = xconn;
 }

 else if (method_name == "qtconnectqt") {
 QObject *sender = (QObject*)Qom::inst()->getObject(argv[1]);
 QVariant vsignal = MarshallRuby::VALUE2Variant(argv[2]);
 QString signal = vsignal.toString();
 QString rsignal = QString("2%1").arg(signal); // real signal

 QObject *receiver = (QObject*)Qom::inst()->getObject(argv[3]);
 QVariant vslot = MarshallRuby::VALUE2Variant(argv[4]);
 QString slot = vslot.toString();
 QString rslot = QString("1%1").arg(slot);

 QtConnectQt *xconn = new QtConnectQt(sender, rsignal, receiver, rslot);
 QMetaObject::Connection qtconn =
 // QObject::connect(sender, rsignal.toLatin1().data(), xconn, SLOT(router()), Qt::QueuedConnection);
 QObject::connect(sender, rsignal.toLatin1().data(), receiver, rslot.toLatin1().data(), Qt::QueuedConnection);
 xconn->installEventFilter(xconn);

 xconn->qtconn = qtconn;
 conn = xconn;
 }

 else if (method_name == "rbconnectrb") {
 conn = ConnectFactory::create_rbconnectrb(argc, argv, obj);
 assert(conn != NULL);
 }

 else if (method_name == "rbconnectqt") {

 }
 
 /*
 // Qt5::connectrb 
 if (method_name == "connectrb") {
 qDebug()<<"got ittttttt."<<method_name;
 return x_Qt_connectrb(argc, argv, self);
 } 
 // Qt5::rbconnectrb
 else if (method_name == "rbconnectrb") {
 qDebug()<<"got ittttttt."<<method_name;
 return x_Qt_rbconnectrb(argc, argv, self);
 }
 // Qt5::rbdisconnectrb
 else if (method_name == "rbdisconnectrb") {
 qDebug()<<"got ittttttt."<<method_name;
 return x_Qt_rbdisconnectrb(argc, argv, self);
 }
 // Qt5::rbconnect 
 else if (method_name == "rbconnect") {
 qDebug()<<"got ittttttt."<<method_name;
 return x_Qt_rbconnect(argc, argv, self);
 }
 // Qt5::connect
 else if (method_name == "connect") {
 qDebug()<<"got ittttttt."<<method_name;
 return x_Qt_connect(argc, argv, self); 
 }
 */
 
 assert(conn != NULL);
 return conn;
}

// for rb signal ==> rb slot
// signature1 Qt5::rbconnectrb(sobj, signal, robj, slot);
// signature2 Qt5::rbconnectrb(sobj, signal, Proc|Block|Lambda)
// TODO signature3 robj.rbconnectrb(sobj, signal, slot)
ConnectAny *ConnectFactory::create_rbconnectrb(int argc, VALUE *argv, VALUE obj)
{
 ConnectAny *conn = NULL;

 QString method_name = rb_id2name(SYM2ID(argv[0]));
 qDebug()<<method_name<<argc;

 // QString klass_name = get_rb_class(argv[1]);
 QString method_signature = RSTRING_PTR(argv[2]);
 QString signal_name = method_signature.split('(').at(0);

 if (argc < 3 || argc > 5) {
 qDebug()<<rb_block_given_p();
 qDebug()<<"parameter not match. need 3 to 5, given:"<<argc;
 return NULL;
 }

 // signature 2, block
 if (argc == 3 && rb_block_given_p()) {
 VALUE pblk = rb_block_proc(); // ok 
 VALUE lblk = rb_block_lambda(); // ok

 RubyConnectRuby *xconn = new RubyConnectRuby(argv[1], argv[2], lblk);
 QMetaObject::Connection qtconn =
 QObject::connect(xconn, SIGNAL(invoked(int, VALUE*, VALUE)), xconn, SLOT(route(int, VALUE*, VALUE)), Qt::QueuedConnection);
 xconn->qtconn = qtconn;
 xconn->installEventFilter(xconn);
 conn = xconn;
 } else if (argc == 3 && !rb_block_given_p()) {
 qDebug()<<"need a block here.";
 return NULL;
 }
 
 // signature 2, proc,lambda
 // qDebug()<<argc<<TYPE(argv[3])<<(TYPE(argv[3]) == T_DATA);
 // qDebug()<<RTYPEDDATA_P(argv[3])<<(RBASIC_CLASS(argv[3]) == rb_cProc);
 else if (argc == 4 && RBASIC_CLASS(argv[3]) == rb_cProc) {
 RubyConnectRuby *xconn = new RubyConnectRuby(argv[1], argv[2], argv[3]);
 QMetaObject::Connection qtconn =
 QObject::connect(xconn, SIGNAL(invoked(int, VALUE*, VALUE)), xconn, SLOT(route(int, VALUE*, VALUE)), Qt::QueuedConnection);
 xconn->qtconn = qtconn;
 xconn->installEventFilter(xconn);
 conn = xconn;
 } else if (argc == 4 && RBASIC_CLASS(argv[3]) != rb_cProc) {
 qDebug()<<"need a proc or lambda here.";
 return NULL;
 }

 // else, standard signature 1
 else if (argc == 5) {
 RubyConnectRuby *xconn = new RubyConnectRuby(argv[1], argv[2], argv[3], argv[4]);
 QMetaObject::Connection qtconn =
 QObject::connect(xconn, SIGNAL(invoked(int, VALUE*, VALUE)), xconn, SLOT(route(int, VALUE*, VALUE)), Qt::QueuedConnection);
 xconn->qtconn = qtconn;
 xconn->installEventFilter(xconn);
 conn = xconn;
 }

 else {
 qDebug()<<"error, invalid call.";
 }
 
 if (conn) {
 Qom::inst()->addConnection(argv[1], signal_name, (RubyConnectRuby*)conn);
 }

 return conn;
}

// for rb signal ==> qt slot
// signature1 Qt5::rbconnectqt(sobj, signal, robj, slot);
ConnectAny *ConnectFactory::create_rbconnectqt(int argc, VALUE *argv, VALUE obj)
{
 ConnectAny *conn = NULL;

 QString method_name = rb_id2name(SYM2ID(argv[0]));
 qDebug()<<method_name<<argc;

 // QString klass_name = get_rb_class(argv[1]);
 QString method_signature = RSTRING_PTR(argv[2]);
 QString signal_name = method_signature.split('(').at(0);

 if (argc != 5) {
 qDebug()<<"Invalid params count.need 5 params.";
 assert(argc == 5); 
 return NULL;
 }

 QObject *receiver = (QObject*)Qom::inst()->getObject(argv[3]);
 QVariant vslot = MarshallRuby::VALUE2Variant(argv[4]);
 QString slot = vslot.toString();
 QString rslot = QString("1%1").arg(slot);

 RubyConnectQt *xconn = new RubyConnectQt(argv[1], argv[2], receiver, rslot);
 QMetaObject::Connection qtconn =
 QObject::connect(xconn, SIGNAL(invoked(int, VALUE *, VALUE)),
 xconn, SLOT(router(int, VALUE *, VALUE)), Qt::QueuedConnection);
 xconn->installEventFilter(xconn);
 xconn->qtconn = qtconn;
 conn = xconn;
 Qom::inst()->addConnection(argv[1], signal_name, xconn);

 return conn;
 return NULL;
}