#include <QApplication>
#include <PythonQt.h>
#include <PythonQt_QtAll.h>
#include <gui/PythonQtScriptingConsole.h>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    PythonQt::init();
    PythonQt_QtAll::init();
    
    //do something...
    PythonQtObjectPtr mainm = PythonQt::self()->getMainModule();
    PythonQtScriptingConsole console(nullptr, mainm);
    console.show();
    
    return a.exec();
}

static void PythonQt::init(int flags = IgnoreSiteModule|RedirectStdOut, const QByteArray& pythonQtModuleName = QByteArray());

static PythonQt* PythonQt::self();

PythonQtScriptingConsole(QWidget* parent, const PythonQtObjectPtr& context, Qt::WindowFlags i = 0);

PythonQtObjectPtr mainm = PythonQt::self()->getMainModule();
mainm.evalFile("example.py");

Variant ans1 = mainm.evalScript("5 + 6", Py_eval_input);

mainm.evalScript("def func(x, y):\n    return x + y", Py_single_input);
Variant ans2 =  mainm.call("func", QVariantList() << 5 << 6);

PythonQtObjectPtr func = mainm.getVariable("func");
Variant ans3 =  func.call(QVariantList() << 5 << 6);
qDebug()<< ans1 << " "<< ans2 << " " << ans3;

QVariant PythonQtObjectPtr::evalScript(const QString& script, int start = Py_file_input);
QVariant PythonQt::evalScript(PyObject* object, const QString& script, int start = Py_file_input);
QVariant PythonQt::evalScript(const QString& script, PyObject* globals, PyObject* locals, int start);

void PythonQtObjectPtr::evalFile(const QString& filename);
void PythonQt::evalFile(PyObject* object, const QString& filename);

QVariant PythonQtObjectPtr::evalCode(PyObject* pycode);
QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode);

QVariant PythonQtObjectPtr::call(const QString& callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args, const QVariantMap& kwargs)

QVariant PythonQtObjectPtr::call(const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());
QVariant PythonQt::call(PyObject* callable, const QVariantList& args, const QVariantMap& kwargs)

QVariant PythonQtObjectPtr::getVariable(const QString& name);
QVariant PythonQt::getVariable(PyObject* object, const QString& name);

void PythonQtObjectPtr::addVariable(const QString& name, const QVariant& v);
void PythonQt::addVariable(PyObject* object, const QString& name, const QVariant& v);

void PythonQtObjectPtr::removeVariable(const QString& name);
void PythonQt::removeVariable(PyObject* module, const QString& name);

class Test: public QObject{
Q_OBJECT
public:
    Q_INVOKABLE void doSomething(QString str){std::cout<<"do something! " << str.toStdString() << std::endl;}
}

int main()
{
    QApplication a(argc, argv);
    PythonQt::init();
    PythonQt_QtAll::init();
    PythonQtObjectPtr mainm = PythonQt::self()->getMainModule();
    
    Test t;
    main.addObject("test", &t);
    
    mainm.evalFile("example.py");
    return a.exec();
}

void PythonQtObjectPtr::addObject(const QString& name, QObject* object);
void PythonQt::addObject(PyObject* object, const QString& name, QObject* qObject);

class QTest: public QObject{
Q_OBJECT
public:
    Q_INVOKABLE void doSomething(){std::cout << "QTest do something." << std::endl;}
    Q_INVOKABLE static void doStatic(){std::cout << "QTest static function." << std::endl;}
}

class Test{
public:
    void doSomething(){std::cout << "Test do something." << std::endl;}
    static void doStatic(){std::cout << "Test static function." << std::endl;}
}

Q_DECLARE_METATYPE(Test);

class Warpper1: public QObject{
Q_OBJECT
public Q_SLOTS:
    QTest* new_QTest(){return new QTest;}
    void delete_QTest(QTest* obj){delete obj;}
    void static_QTest_doStatic(){QTest::doStatic();}
}

class Warpper2: public QObject{
Q_OBJECT
public Q_SLOTS:
    Test* new_Test(){return new QTest;}
    void delete_Test(Test* obj){delete obj;}
    void doSomething(Test* obj){obj->doSomething();}
    void static_Test_doStatic(){Test::doStatic();}
}

int main()
{
    QApplication a(argc, argv);
    PythonQt::init();
    
    PythonQt::self()->registerClass(&QTest::staticMetaObject, "TestModule", PythonQtCreateObject<Warpper1>);
    PythonQt::self()->registerCPPClass("Test", "", "TestModule", PythonQtCreateObject<Warpper2>);
    
    PythonQtObjectPtr mainm = PythonQt::self()->getMainModule();
    mainm.evalFile("example.py");
    return a.exec();
}

void PythonQt::registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
void PythonQt::registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);

class YourCPPObject {
public:
  YourCPPObject(int arg1, float arg2) { a = arg1; b = arg2; }
  float doSomething(int arg1) { return arg1*a*b; };
  private:
  int a;
  float b;
};

class ExampleDecorator : public QObject
{
Q_OBJECT
public slots:
  // 添加一个从QPoint构造QSize的构造函数
  QSize* new_QSize(const QPoint& p) { return new QSize(p.x(), p.y()); }
  // 添加一个新的QPushButton的构造函数
  QPushButton* new_QPushButton(const QString& text, QWidget* parent=NULL) { return new QPushButton(text, parent); }
  // 为C++类添加一个构造函数
  YourCPPObject* new_YourCPPObject(int arg1, float arg2) { return new YourCPPObject(arg1, arg2); }
  // 为C++类添加一个析构函数
  void delete_YourCPPObject(YourCPPObject* obj) { delete obj; }
  // 为QWidget添加一个静态函数
  QWidget* static_QWidget_mouseGrabber() { return QWidget::mouseGrabber(); }
  // 为QWidget添加一个move槽函数
  void move(QWidget* w, const QPoint& p) { w->move(p); }
  // 为QWidget添加一个重载的槽函数
  void move(QWidget* w, int x, int y) { w->move(x,y); }
  // 为C++对象添加一个成员函数
  int doSomething(YourCPPObject* obj, int arg1) { return obj->doSomething(arg1); }
};

PythonQt::self()->addDecorators(new ExampleDecorator()); //添加这个新的装饰器
PythonQt::self()->registerCPPClass("YourCPPObject"); //注册新的类型名称

template<class T>
class PythonQtPassOwnershipToCPP; //所有权由Python转换到C++

template<class T>
class PythonQtPassOwnershipToPython; //所有权由C++转换到Python

template<class T>
class PythonQtNewOwnerOfThis; //当对象由Python管理时， 为当前环境使对象的引用计数加一。

PythonQtObjectPtr PythonQt::getMainModule(); //获取主模块
PythonQtObjectPtr importModule(const QString& name); //获取某个Python模块 例如 sys、os等
PythonQtObjectPtr PythonQt::createModuleFromFile(const QString& name, const QString& filename); //由某个文件创建模块
PythonQtObjectPtr PythonQt::createModuleFromScript(const QString& name, const QString& script = QString()); //由某段代码创建模块
PythonQtObjectPtr PythonQt::createUniqueModule(); //创建一个匿名模块
PyObject* PythonQtPrivate::packageByName(const char* name); //创建一个挂载在主模块下名字为name的模块

static PythonQtPrivate* PythonQt::priv();

static void PythonQt::setEnableThreadSupport(bool flag); //传入true时启用多线程支持，传入false则关闭支持。

#include <PythonQtThreadSupport.h> //线程相关宏被定义在这个头文件中，也包括下面将介绍的宏
void threadFunction()
{
    PYTHONQT_GIL_SCOPE;
    // do something
}

//PYTHONQT_GIL_SCOPE 的实际定义为
#define PYTHONQT_GIL_SCOPE PythonQtGILScope internal_pythonqt_gilscope;
//当这个对象存在时，我们认为进入了GIL作用域

// 相关操作宏定义如下
#define PYTHONQT_ALLOW_THREADS_SCOPE PythonQtThreadStateSaver internal_pythonqt_savethread;
// 当这个对象存在时，我们认为进入了允许Python运行的域，此时所有Python线程会被唤醒，并运行，直到离开这个域。
// 应当格外注意，这个宏不能使用在GIL域下，如果在GIL域下使用，可能会引发程序崩溃。

class MyEnum: public QObject
{
Q_OBJECT
public:
	explicit MyEnum(QObject* parent = NULL):QObject(parent){};
    enum Priority{
        High = 1,
        Middle = 2,
        Low = 4
    }
    Q_ENUM(Priority);
    Q_DECLARE_FLAGS(PriorityFlags, Priority);
    Q_FLAG(PriorityFlags);
}
Q_DECLARE_OPERATORS_FOR_FLAGS(MyEnum::PriorityFlags);

PythonQt::self()->registerClass(MyEnum::staticMetaObject, "Test");

class InfoTest: public QObject{
Q_OBJECT
public:
   	Q_PROPERTY(QString name WRITE setName READ getName);
    void setName(const QString& name){this->name = name;}
    QString getName(){return name;}
private:
    QString name = "default";
};

PythonQt::self()->registerClass(InfoTest::staticMetaObject, "Test", PythonQtCreateObject<Warpper>);

PythonQtObjectPtr object = PythonQtPassOwnershipToCPP<PythonQtObjectPtr>(mainm.evalScript("call()", Py_single_input));

mainm.evalScript("temp = createSomething()", Py_single_input);
Something* sth = PythonQtPassOwnershipToCPP<Something*>(mainm.getVariable("temp").value<Something*>());
mainm.evalScript("del temp", Py_eval_input);

class A:public QObject{
Q_OBJECT
public:
    void dosth(){std::cout<<"A do sth!"<<std::endl;}
}
class Warpper:public QObject{
Q_OBJECT
public:
	A* new_A(){return new A;}
    void delete_A(A* obj){delete A;}
}

PythonQt::self()->registerClass(A::staticMetaObject, "Test", PythonQtCreateObject<Warpper>);

mainm.evalFile("example.py");
A* obj = main.getVariable("obj").value<A*>();
obj->dosth();
PythonQtObjectPtr type_B = main.getVariable("B");
type_B.call("dosth", QVariantList() << QVariant::fromValue(obj)); // 等价于Python中的 B.dosth(obj)

PythonQtObjectPtr parseFile(const QString& filename); \\这个函数将使用PythonQt库的导入机制进行加载和编译，返回PyCodeObject对象。
PythonQtObjectPtr parseFileWithPythonLoaders(const QString& filename);\\这个函数使用Python的机制进行导入，支持有源和无源代码的加载。

void PythonQt::overwriteSysPath(const QStringList& paths); //重写系统查询路径
void PythonQt::addSysPath(const QString& path); //添加系统查询路径
void PythonQt::setModuleImportPath(PyObject* module, const QStringList& paths); //设置模块导入的路径
PythonQtObjectPtr PythonQt::lookupCallable(PyObject* object, const QString& name); //查询一个对象中的某个可调用对象
QString PythonQt::getReturnTypeOfWrappedMethod(PyObject* module, const QString& objectname); //
QString PythonQt::getReturnTypeOfWrappedMethod(const QString& typeName, const QString& methodName); //
PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap()); //调用一个函数，并且以PyObject*的形式返回其返回值
bool PythonQt::hadError()const; //判断是否存在异常
void PythonQt::clearError(); //清除异常
PythonQtObjectPtr PythonQt::lookupObject(PyObject* module, const QString& name); //查询模块中是否存在某个变量