#ifndef _PYTHONQTMETHODINFO_H

#define _PYTHONQTMETHODINFO_H

#include "PythonQtPythonInclude.h"

#include "PythonQtSystem.h"

#include <QByteArray>

#include <QHash>

#include <QList>

#include <QMetaMethod>

class PythonQtClassInfo;

struct _object;

typedef struct _object PyObject;

class PYTHONQT_EXPORT PythonQtMethodInfo

{

enum ParameterType {

Unknown = -1,

Variant = -2

};

//! stores various informations about a parameter/type name

struct ParameterInfo {

};

PythonQtMethodInfo() {

_shouldAllowThreads = true;

};

~PythonQtMethodInfo() {};

PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo);

PythonQtMethodInfo(const QByteArray& typeName, const QList<QByteArray>& args);

PythonQtMethodInfo(const PythonQtMethodInfo& other) {

_parameters = other._parameters;

_shouldAllowThreads = other._shouldAllowThreads;

}

//! returns the method info of the signature, uses a cache internally to speed up

//! multiple requests for the same method, classInfo is passed to allow local enum resolution (if NULL is passed, no local enums are recognized)

static const PythonQtMethodInfo* getCachedMethodInfo(const QMetaMethod& method, PythonQtClassInfo* classInfo);

//! get the cached method info using the passed in list of return value and arguments, return value needs to be passed as first arg

static const PythonQtMethodInfo* getCachedMethodInfoFromArgumentList(int numArgs, const char** args);

//! cleanup the cache

static void cleanupCachedMethodInfos();

//! returns the number of parameters including the return value

int parameterCount() const { return _parameters.size(); };

//! returns the id for the given type (using an internal dictionary)

static int nameToType(const char* name);

//! get the parameter infos

const QList<ParameterInfo>& parameters() const { return _parameters; }

//! add an alias for a typename, e.g. QObjectList and QList<QObject*>.

static void addParameterTypeAlias(const QByteArray& alias, const QByteArray& name);

//! fill the parameter info for the given type name

static void fillParameterInfo(ParameterInfo& type, const QByteArray& name, PythonQtClassInfo* classInfo = nullptr);

//! returns a parameter info for the given metatype (and creates and caches one if it is not yet present)

static const ParameterInfo& getParameterInfoForMetaType(int type);

//! returns the inner type id of a simple template of the form SomeObject<InnerType>

static int getInnerTemplateMetaType(const QByteArray& typeName);

//! returns the inner type name of a simple template of the form SomeObject<InnerType>

static QByteArray getInnerTemplateTypeName(const QByteArray& typeName);

//! returns the inner type name of a simple template or the typename without appended "List".

static QByteArray getInnerListTypeName(const QByteArray& typeName);

//! returns if the GIL should be released when calling this method.

//! This is the default, but it will return false if any of the

//! parameters is a PythonQtObjectPtr or PyObject*.

bool shouldAllowThreads() const { return _shouldAllowThreads; }

void setupAllowThreads();

static QHash<QByteArray, int> _parameterTypeDict;

static QHash<QByteArray, QByteArray> _parameterNameAliases;

//! stores the cached signatures of methods to speedup mapping from Qt to Python types

static QHash<QByteArray, PythonQtMethodInfo*> _cachedSignatures;

static QHash<int, ParameterInfo> _cachedParameterInfos;

QList<ParameterInfo> _parameters;

bool _shouldAllowThreads;

};

class PYTHONQT_EXPORT PythonQtSlotInfo : public PythonQtMethodInfo

{

enum Type {

MemberSlot, InstanceDecorator, ClassDecorator

};

PythonQtSlotInfo(const PythonQtSlotInfo& info):PythonQtMethodInfo() {

}

PythonQtSlotInfo(PythonQtClassInfo* classInfo, const QMetaMethod& meta, int slotIndex, QObject* decorator = nullptr, Type type = MemberSlot ):PythonQtMethodInfo()

}

//! get the parameter infos for the arguments, without return type and instance decorator.

QList<ParameterInfo> arguments() const;

void deleteOverloadsAndThis();

const QMetaMethod* metaMethod() const { return &_meta; }

void setUpcastingOffset(int upcastingOffset) { _upcastingOffset = upcastingOffset; }

int upcastingOffset() const { return _upcastingOffset; }

//! get the index of the slot (needed for qt_metacall)

int slotIndex() const { return _slotIndex; }

//! get next overloaded slot (which has the same name)

PythonQtSlotInfo* nextInfo() const { return _next; }

//! set the next overloaded slot

void setNextInfo(PythonQtSlotInfo* next) { _next = next; }

//! returns if the slot is a decorator slot

bool isInstanceDecorator() const { return _decorator!=nullptr && _type == InstanceDecorator; }

//! returns if the slot is a constructor slot

bool isClassDecorator() const { return _decorator!=nullptr && _type == ClassDecorator; }

QObject* decorator() const { return _decorator; }

//! get the full signature including return type

QString fullSignature(bool skipReturnValue = false, int optionalArgsIndex = -1) const;

//! get the Qt signature of the slot

QByteArray signature() const;

//! get the short slot name

QByteArray slotName(bool removeDecorators = false) const;

//! gets a list of all overload signatures. Signatures

//! which only differ because of default values are joined using "[]" to

//! indicate the optional arguments.

QStringList overloads(bool skipReturnValue = false) const;

//! Returns the class name that originally implements this method,

//! regardless where the wrapper is located/implemented.

QByteArray getImplementingClassName() const;

//! Invoke the given slot on obj, save/restore thread state if needed.

static void invokeQtMethod(QObject* obj, PythonQtSlotInfo* slot, void** argList);

//! Sets if calling slots should release the GIL to allow other Python threads while being inside of C++

static void setGlobalShouldAllowThreads(bool flag);

//! Returns if calling slots should release the GIL to allow Python threads while being inside of C++

static bool getGlobalShouldAllowThreads();

int _slotIndex;

PythonQtSlotInfo* _next;

QObject* _decorator;

Type _type;

QMetaMethod _meta;

int _upcastingOffset;

static bool _globalShouldAllowThreads;

};

#endif