/*
 *
 *  Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
 *
 *  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.1 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.
 *
 *  Further, this software is distributed without any warranty that it is
 *  free of the rightful claim of any third person regarding infringement
 *  or the like.  Any license provided herein, whether implied or
 *  otherwise, applies only to this software file.  Patent licenses, if
 *  any, provided herein do not apply to combinations of this program with
 *  other software, or any other product whatsoever.
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contact information: MeVis Research GmbH, Universitaetsallee 29,
 *  28359 Bremen, Germany or:
 *
 *  http://www.mevis.de
 *
 */

//----------------------------------------------------------------------------------
/*!
// \file    PythonQtMetaObjectWrapper.cpp
// \author  Florian Link
// \author  Last changed by $Author: florian $
// \date    2006-05
*/
//----------------------------------------------------------------------------------

#include "PythonQtMetaObjectWrapper.h"
#include <QObject>

#include "PythonQt.h"
#include "PythonQtSlot.h"
#include "PythonQtClassInfo.h"
#include "PythonQtConversion.h"

static void PythonQtMetaObjectWrapper_dealloc(PythonQtMetaObjectWrapper* self)
{
  self->ob_type->tp_free((PyObject*)self);
}

static PyObject* PythonQtMetaObjectWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
{
  PythonQtMetaObjectWrapper *self;

  self = (PythonQtMetaObjectWrapper *)type->tp_alloc(type, 0);
  if (self != NULL) {
    self->_info = NULL;
  }
  return (PyObject *)self;
}

static int PythonQtMetaObjectWrapper_init(PythonQtMetaObjectWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
{
  return 0;
}

PyObject *PythonQtMetaObjectWrapper_call(PyObject *func, PyObject *args, PyObject *kw) {
  PythonQtMetaObjectWrapper* wrapper = (PythonQtMetaObjectWrapper*)func;
  PyObject* result = NULL;
  QString error;
  PyObject* err = NULL;
  if (wrapper->_info->constructors()) {
    result = PythonQtSlotFunction_CallImpl(NULL, wrapper->_info->constructors(), args, kw);
    err = PyErr_Occurred();
  }
  if (!result) {
    QObject* v = NULL;
    QListIterator<PythonQtConstructorHandler*> it(PythonQt::self()->constructorHandlers());
    while (!v && it.hasNext()) {
      v = it.next()->create(wrapper->_info->metaObject(), args, kw, error);
    }
    if (v) {
      result = PythonQt::priv()->wrapQObject(v);
    }
  }
  if (result) {
    // change ownershipflag to be owned by PythonQt
    if (result->ob_type == &PythonQtWrapper_Type) {
      ((PythonQtWrapper*)result)->_ownedByPythonQt = true;
    }
  } else {
    if (!wrapper->_info->constructors()) {
      if (!err) {
        if (error.isEmpty()) {
          error = QString("No constructors available for ") + wrapper->_info->className();
        }
        PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
      }
    }
  }
  return result;
}

static PyObject *PythonQtMetaObjectWrapper_classname(PythonQtMetaObjectWrapper* type)
{
  return PyString_FromString((QString("Meta_") + type->_info->className()).toLatin1().data());
}

static PyObject *PythonQtMetaObjectWrapper_help(PythonQtMetaObjectWrapper* type)
{
  return PythonQt::self()->helpCalled(type->_info);
}


static PyMethodDef PythonQtMetaObjectWrapper_methods[] = {
    {"className", (PyCFunction)PythonQtMetaObjectWrapper_classname, METH_NOARGS,
     "Return the classname of the object"
    },
    {"help", (PyCFunction)PythonQtMetaObjectWrapper_help, METH_NOARGS,
    "Shows the help of available methods for this class"
    },
    {NULL, NULL, 0 , NULL}  /* Sentinel */
};


static PyObject *PythonQtMetaObjectWrapper_getattro(PyObject *obj,PyObject *name)
{
  const char *attributeName;
  PythonQtMetaObjectWrapper *wt = (PythonQtMetaObjectWrapper *)obj;

  if ((attributeName = PyString_AsString(name)) == NULL) {
    return NULL;
  }

  PythonQtMemberInfo member = wt->_info->member(attributeName);
  if (member._type == PythonQtMemberInfo::EnumValue) {
    return PyInt_FromLong(member._enumValue);
  }
  if (member._type == PythonQtMemberInfo::Slot && member._slot->isClassDecorator()) {
    return PythonQtSlotFunction_New(member._slot, obj, NULL);
  }

  // look for the interal methods (className(), help())
  PyObject* internalMethod = Py_FindMethod( PythonQtMetaObjectWrapper_methods, obj, (char*)attributeName);
  if (internalMethod) {
    return internalMethod;
  }
  PyErr_Clear();

  if (qstrcmp(attributeName, "__dict__")==0) {
    QStringList l = wt->_info->memberList(true);
    PyObject* dict = PyDict_New();
    foreach (QString name, l) {
      //PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
      PyDict_SetItemString(dict, name.toLatin1().data(), Py_None);
      //Py_DECREF(o);
    }
    return dict;
  }

  QString error = QString(wt->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
  PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
  return NULL;
}

static PyObject * PythonQtMetaObjectWrapper_repr(PyObject * obj)
{
  PythonQtMetaObjectWrapper* wt = (PythonQtMetaObjectWrapper*)obj;
  if (wt->_info->isCPPWrapper()) {
    const QMetaObject* meta = wt->_info->metaObject(); 
    if (!meta) {
      QObject* decorator = wt->_info->decorator();
      if (decorator) {
        meta = decorator->metaObject();
      }
    }
    if (meta) {
      return PyString_FromFormat("%s Class (C++ wrapped by %s)", wt->_info->className(), meta->className());
    } else {
      return PyString_FromFormat("%s Class (C++ unwrapped)", wt->_info->className());
    }
  } else {
    return PyString_FromFormat("%s Class", wt->_info->className());
  }
}

static int PythonQtMetaObjectWrapper_compare(PyObject * obj1, PyObject * obj2)
{
  if (obj1->ob_type == &PythonQtMetaObjectWrapper_Type &&
    obj2->ob_type == &PythonQtMetaObjectWrapper_Type) {

    PythonQtMetaObjectWrapper* w1 = (PythonQtMetaObjectWrapper*)obj1;
    PythonQtMetaObjectWrapper* w2 = (PythonQtMetaObjectWrapper*)obj2;
    if (w1->_info == w2->_info) {
      return 0;
    } else {
      return -1;
    }
  } else {
    return -1;
  }
}

static long PythonQtMetaObjectWrapper_hash(PythonQtMetaObjectWrapper *obj)
{
  return reinterpret_cast<long>(obj->_info);
}

PyTypeObject PythonQtMetaObjectWrapper_Type = {
    PyObject_HEAD_INIT(NULL)
    0,                         /*ob_size*/
    "PythonQt.PythonQtMetaObjectWrapper",             /*tp_name*/
    sizeof(PythonQtMetaObjectWrapper),             /*tp_basicsize*/
    0,                         /*tp_itemsize*/
    (destructor)PythonQtMetaObjectWrapper_dealloc, /*tp_dealloc*/
    0,                         /*tp_print*/
    0,                         /*tp_getattr*/
    0,                         /*tp_setattr*/
    PythonQtMetaObjectWrapper_compare,         /*tp_compare*/
    PythonQtMetaObjectWrapper_repr,            /*tp_repr*/
    0,                         /*tp_as_number*/
    0,                         /*tp_as_sequence*/
    0,                         /*tp_as_mapping*/
    (hashfunc)PythonQtMetaObjectWrapper_hash,                         /*tp_hash */
    PythonQtMetaObjectWrapper_call,                         /*tp_call*/
    0,                         /*tp_str*/
    PythonQtMetaObjectWrapper_getattro,                         /*tp_getattro*/
    0,                         /*tp_setattro*/
    0,                         /*tp_as_buffer*/
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
    "PythonQtMetaObjectWrapper object",           /* tp_doc */
    0,                   /* tp_traverse */
    0,                   /* tp_clear */
    0,                   /* tp_richcompare */
    0,                   /* tp_weaklistoffset */
    0,                   /* tp_iter */
    0,                   /* tp_iternext */
    0,             /* tp_methods */
    0,             /* tp_members */
    0,                         /* tp_getset */
    0,                         /* tp_base */
    0,                         /* tp_dict */
    0,                         /* tp_descr_get */
    0,                         /* tp_descr_set */
    0,                         /* tp_dictoffset */
    (initproc)PythonQtMetaObjectWrapper_init,      /* tp_init */
    0,                         /* tp_alloc */
    PythonQtMetaObjectWrapper_new,                 /* tp_new */
};

//-------------------------------------------------------