#include "ffpython.h"


//! 获取python异常信息

int pyops_t::traceback(string& ret_)
{
    PyObject* err = PyErr_Occurred();

    if (err != NULL) {
        PyObject *ptype = NULL, *pvalue = NULL, *ptraceback = NULL;
        PyObject *pyth_module = NULL, *pyth_func = NULL;

        PyErr_Fetch(&ptype, &pvalue, &ptraceback);
        if (pvalue)
        {
            if (true == PyList_Check(pvalue))
            {
                int n = PyList_Size(pvalue);
                for (int i = 0; i < n; ++i)
                {
                    PyObject *pystr = PyObject_Str(PyList_GetItem(pvalue, i));
                    ret_ += PyString_AsString(pystr);
                    ret_ += "\n";
                    Py_DECREF(pystr);
                }
            }
            if (true == PyTuple_Check(pvalue))
            {
                int n = PyTuple_Size(pvalue);
                for (int i = 0; i < n; ++i)
                {
                    PyObject* tmp_str = PyTuple_GetItem(pvalue, i);
                    if (true == PyTuple_Check(tmp_str))
                    {
                        int m = PyTuple_Size(tmp_str);
                        for (int j = 0; j < m; ++j)
                        {
                            PyObject *pystr = PyObject_Str(PyTuple_GetItem(tmp_str, j));
                            ret_ += PyString_AsString(pystr);
                            ret_ += ",";
                            Py_DECREF(pystr);
                        }
                    }
                    else
                    {
                        PyObject *pystr = PyObject_Str(tmp_str);
                        ret_ += PyString_AsString(pystr);
                        Py_DECREF(pystr);
                    }
                    ret_ += "\n";
                }
            }
            else
            {
                PyObject *pystr = PyObject_Str(pvalue);
                if (pystr)
                {
                    ret_ += PyString_AsString(pystr);
                    ret_ += "\n";
                    Py_DECREF(pystr);
                }
            }
        }

        /* See if we can get a full traceback */
        PyObject *module_name = PyString_FromString("traceback");
        pyth_module = PyImport_Import(module_name);
        Py_DECREF(module_name);

        if (pyth_module && ptype && pvalue && ptraceback)
        {
            pyth_func = PyObject_GetAttrString(pyth_module, "format_exception");
            if (pyth_func && PyCallable_Check(pyth_func)) {
                PyObject *pyth_val = PyObject_CallFunctionObjArgs(pyth_func, ptype, pvalue, ptraceback, NULL);
                if (pyth_val && true == PyList_Check(pyth_val))
                {
                    int n = PyList_Size(pyth_val);
                    for (int i = 0; i < n; ++i)
                    {
                        PyObject* tmp_str = PyList_GetItem(pyth_val, i);
                        PyObject *pystr = PyObject_Str(tmp_str);
                        if (pystr)
                        {
                            ret_ += PyString_AsString(pystr);

                            Py_DECREF(pystr);
                        }
                        ret_ += "\n";
                    }
                }
                Py_XDECREF(pyth_val);
            }
        }
        Py_XDECREF(pyth_func);
        Py_XDECREF(pyth_module);
        Py_XDECREF(ptype);
        Py_XDECREF(pvalue);
        Py_XDECREF(ptraceback);
        PyErr_Clear();
        return 0;
    }

    return -1;
}


ffpython_t::ffpython_t()
{
    if (!Py_IsInitialized())
        Py_Initialize();
}
ffpython_t::~ffpython_t()
{
    clear_cache_pyobject();
}


int ffpython_t::init_py()
{
    Py_Initialize();
    return 0;
}
int ffpython_t::final_py()
{
    Py_Finalize();
    return 0;
}

int ffpython_t::add_path(const string& path_)
{
    char buff[1024];
    SAFE_SPRINTF(buff, sizeof(buff), "import sys\nif '%s' not in sys.path:\n\tsys.path.append('%s')\n", path_.c_str(), path_.c_str());
    PyRun_SimpleString(buff);
    return 0;
}

int ffpython_t::run_string(const string& py_)
{
    PyRun_SimpleString(py_.c_str());
    return 0;
}

int ffpython_t::reload(const string& py_name_)
{
    PyObject *pName = NULL, *pModule = NULL;
    string err_msg;

    pName   = PyString_FromString(py_name_.c_str());
    pModule = PyImport_Import(pName);
    Py_DECREF(pName);
    if (NULL == pModule)
    {
        pyops_t::traceback(err_msg);
        throw runtime_error(err_msg.c_str());
        return -1;
    }

    PyObject *pNewMod = PyImport_ReloadModule(pModule);
    Py_DECREF(pModule);
    if (NULL == pNewMod)
    {
        pyops_t::traceback(err_msg);
        throw runtime_error(err_msg.c_str());
        return -1;
    }
    Py_DECREF(pNewMod);   
    return 0;
}
int ffpython_t::load(const string& py_name_)
{
    PyObject *pName = NULL, *pModule = NULL;
    string err_msg;

    pName   = PyString_FromString(py_name_.c_str());
    pModule = PyImport_Import(pName);
    Py_DECREF(pName);
    if (NULL == pModule)
    {
        pyops_t::traceback(err_msg);
        throw runtime_error(err_msg.c_str());
        return -1;
    }

    Py_DECREF(pModule);
    return 0;
}

int ffpython_t::init(const string& mod_name_, string doc_)
{
    m_mod_name = mod_name_;
    m_mod_doc  = doc_;
    PyObject* m = init_method();
    init_pyclass(m);
    return 0;
}

PyObject* ffpython_t::init_method()
{
    string mod_name_ = m_mod_name;
    string doc_      = m_mod_doc;

    if (m_pymethod_defs.empty())
    {
        m_pymethod_defs.reserve(m_func_info.size() + 1);

        for (size_t i = 0; i < m_func_info.size(); ++i)
        {
            PyMethodDef tmp = {m_func_info[i].func_impl_name.c_str(), m_func_info[i].func,
                METH_VARARGS, m_func_info[i].doc_impl.c_str()};
            m_pymethod_defs.push_back(tmp);
        }
        PyMethodDef tmp = {NULL};
        m_pymethod_defs.push_back(tmp);
    }

    PyObject* m = Py_InitModule3(m_mod_name.c_str(), &(m_pymethod_defs.front()), doc_.c_str());

    for (size_t i = 0; i < m_func_info.size(); ++i)
    {
        string pystr_args;
        string pystr_args_only_name;
        for (int j = 0; j < m_func_info[i].args_num; ++j)
        {
            stringstream ss;
            if (pystr_args.empty())
            {
                ss << "a" << (j+1);
                pystr_args += ss.str();
            }
            else
            {
                ss << ", a" << (j+1);
                pystr_args += ss.str();
            }
        }
        pystr_args_only_name = pystr_args;
        for (int j = 0; j < m_func_info[i].option_args_num; ++j)
        {
            stringstream ss;
            if (pystr_args.empty())
            {
                ss << "a" << (m_func_info[i].args_num + j+1);
                string tmp =  ss.str();
                pystr_args_only_name += tmp;
                pystr_args += tmp + " = None";
            }
            else
            {
                ss << ", a" << (m_func_info[i].args_num + j+1);
                string tmp =  ss.str();
                pystr_args_only_name += tmp;
                pystr_args += tmp + " = None";
            }
        }
        if (!pystr_args_only_name.empty())
            pystr_args_only_name += ",";

        char buff[1024];
        SAFE_SPRINTF(buff, sizeof(buff), 
            "_tmp_ff_ = None\nif '%s' in globals():\n\t_tmp_ff_ = globals()['%s']\n"
            "def %s(%s):\n"
            "\t'''%s'''\n"
            "\treturn %s.%s(%ld,(%s))\n"
            "import %s\n"
            "%s.%s = %s\n"
            "%s = None\n"
            "if _tmp_ff_:\n\tglobals()['%s'] = _tmp_ff_\n_tmp_ff_ = None\n",
            m_func_info[i].func_name.c_str(), m_func_info[i].func_name.c_str(), 
            m_func_info[i].func_name.c_str(), pystr_args.c_str(),
            m_func_info[i].doc.c_str(), 
            m_mod_name.c_str(), m_func_info[i].func_impl_name.c_str(), m_func_info[i].func_addr, pystr_args_only_name.c_str(),
            m_mod_name.c_str(),
            m_mod_name.c_str(), m_func_info[i].func_name.c_str(), m_func_info[i].func_name.c_str(),
            m_func_info[i].func_name.c_str(),
            m_func_info[i].func_name.c_str()
            );

        //printf(buff);
        PyRun_SimpleString(buff);
    }

    return m;
}

int ffpython_t::init_pyclass(PyObject* m)
{
    for (size_t i = 0; i < m_all_pyclass.size(); ++i)
    {
        m_all_pyclass[i].static_pytype_info->mod_name = m_mod_name;
        if (false == m_all_pyclass[i].inherit_name.empty())
        {
            pyclass_regigster_tool_t* inherit_class = get_pyclass_info_by_name(m_all_pyclass[i].inherit_name);
            assert(inherit_class && "base class must be registed");
            for (size_t n = 0; n < inherit_class->methods_info.size(); ++n)
            {
                const string& method_name = inherit_class->methods_info[n].func_name;
                if (false == is_method_exist(m_all_pyclass[i].methods_info, method_name))
                {
                    m_all_pyclass[i].methods_info.push_back(inherit_class->methods_info[n]);
                }
            }
            for (size_t n = 0; n < inherit_class->propertys_info.size(); ++n)
            {
                const string& property_name = inherit_class->propertys_info[n].property_name;
                if (false == is_property_exist(m_all_pyclass[i].propertys_info, property_name))
                {
                    m_all_pyclass[i].propertys_info.push_back(inherit_class->propertys_info[n]);
                }
            }
        }
        //! init class property
        for (size_t j = 0; j < m_all_pyclass[i].propertys_info.size(); ++j)
        {
            PyGetSetDef tmp = {(char*)m_all_pyclass[i].propertys_info[j].property_name.c_str(),
                m_all_pyclass[i].propertys_info[j].getter_func, 
                m_all_pyclass[i].propertys_info[j].setter_func,
                (char*)m_all_pyclass[i].propertys_info[j].doc.c_str(),
                m_all_pyclass[i].propertys_info[j].ptr
            };
            m_all_pyclass[i].pyproperty_def.push_back(tmp);
        }
        PyGetSetDef tmp_property_def = {NULL};
        m_all_pyclass[i].pyproperty_def.push_back(tmp_property_def);
        //! init class method
        for (size_t j = 0; j < m_all_pyclass[i].methods_info.size(); ++j)
        {
            PyMethodDef tmp = {m_all_pyclass[i].methods_info[j].func_real_name.c_str(),
                m_all_pyclass[i].methods_info[j].func, 
                METH_VARARGS,
                m_all_pyclass[i].methods_info[j].doc.c_str()
            };
            m_all_pyclass[i].pymethod_def.push_back(tmp);

        }
        PyMethodDef tmp_del = {"delete",
            m_all_pyclass[i].delete_func,
            METH_VARARGS,
            "delete obj"
        };
        m_all_pyclass[i].pymethod_def.push_back(tmp_del);
        PyMethodDef tmp_method_def = {NULL};
        m_all_pyclass[i].pymethod_def.push_back(tmp_method_def);

        m_all_pyclass[i].class_name_with_mod = m_mod_name + "." + m_all_pyclass[i].class_name;
        m_all_pyclass[i].class_reel_name_with_mod = m_mod_name + "." + m_all_pyclass[i].class_real_name;

        PyTypeObject tmp_pytype_def = 
        {
            PyObject_HEAD_INIT(NULL)
            0,                         /*ob_size*/
            m_all_pyclass[i].class_reel_name_with_mod.c_str(),             /*tp_name*/
            m_all_pyclass[i].type_size,             /*tp_size*/
            0,                         /*tp_itemsize*/
            (destructor)m_all_pyclass[i].dector, /*tp_dealloc*/
            0,                         /*tp_print*/
            0,                         /*tp_getattr*/
            0,                         /*tp_setattr*/
            0,                         /*tp_compare*/
            0,                         /*tp_repr*/
            0,                         /*tp_as_number*/
            0,                         /*tp_as_sequence*/
            0,                         /*tp_as_mapping*/
            0,                         /*tp_hash */
            0,                         /*tp_call*/
            0,                         /*tp_str*/
            0,                         /*tp_getattro*/
            0,                         /*tp_setattro*/
            0,                         /*tp_as_buffer*/
            Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
            m_all_pyclass[i].doc.c_str(),           /* tp_doc */
            0,                               /* tp_traverse */
            0,                               /* tp_clear */
            0,                               /* tp_richcompare */
            0,                               /* tp_weaklistoffset */
            0,                               /* tp_iter */
            0,                               /* tp_iternext */
            &(m_all_pyclass[i].pymethod_def.front()),//Noddy_methods,             /* tp_methods */
            0,//Noddy_members,             /* tp_members */
            &(m_all_pyclass[i].pyproperty_def.front()),//Noddy_getseters,           /* tp_getset */
            0,                         /* tp_base */
            0,                         /* tp_dict */
            0,                         /* tp_descr_get */
            0,                         /* tp_descr_set */
            0,                         /* tp_dictoffset */
            (initproc)m_all_pyclass[i].init,      /* tp_init */
            0,                         /* tp_alloc */
            m_all_pyclass[i].ctor,                 /* tp_new */
        };
        m_all_pyclass[i].pytype_def = tmp_pytype_def;
        m_all_pyclass[i].static_pytype_info->pytype_def = &m_all_pyclass[i].pytype_def;
        cpp_to_pyclass_reg_info_t::add(m_all_pyclass[i].class_name, m_all_pyclass[i].inherit_name, &m_all_pyclass[i].pytype_def);

        if (PyType_Ready(&m_all_pyclass[i].pytype_def) < 0)
            return -1;
        Py_INCREF(&m_all_pyclass[i].pytype_def);
        PyModule_AddObject(m, m_all_pyclass[i].class_real_name.c_str(), (PyObject *)&m_all_pyclass[i].pytype_def);

        stringstream str_def_args;
        stringstream str_init_args;
        for (int a = 0; a < m_all_pyclass[i].args_num; ++a)
        {
            str_def_args << "a"<<(a+1)<<",";
            str_init_args << "a"<<(a+1)<<",";
        }
        for (int b = 0; b < m_all_pyclass[b].option_args_num; ++b)
        {
            str_def_args << "a"<<(m_all_pyclass[i].args_num+ b+1)<<" = None,";
            str_init_args << "a"<<(m_all_pyclass[i].args_num+ b+1)<<",";
        }

        char buff[1024];
        SAFE_SPRINTF(buff, sizeof(buff),
            "_tmp_ff_ = None\nif '%s' in globals():\n\t_tmp_ff_ = globals()['%s']\n"
            "import %s\n"
            "class %s(object):\n"
            "\t'''%s'''\n"
            "\tdef __init__(self, %s assign_obj_ = 0):\n"//! ����init����
            "\t\t'''%s'''\n"
            "\t\tif True == isinstance(assign_obj_, %s):\n"
            "\t\t\tself.obj = assign_obj_\n"
            "\t\t\treturn\n"
            "\t\tself.obj = %s(0,(%s))\n",
            m_all_pyclass[i].class_name.c_str(), m_all_pyclass[i].class_name.c_str(),
            m_mod_name.c_str(),
            m_all_pyclass[i].class_name.c_str(),
            m_all_pyclass[i].doc.c_str(),
            str_def_args.str().c_str(),
            "init class",
            m_all_pyclass[i].class_reel_name_with_mod.c_str(),
            m_all_pyclass[i].class_reel_name_with_mod.c_str(), str_init_args.str().c_str()
            );

        string gen_class_str = buff;
        SAFE_SPRINTF(buff, sizeof(buff),
            "\tdef delete(self):\n"
            "\t\t'''delete obj'''\n"
            "\t\tself.obj.delete()\n");
        gen_class_str += buff;
        //! 增加析构函数
        //! 增加属性
        for (size_t c = 0; c < m_all_pyclass[i].propertys_info.size(); ++c)
        {
            SAFE_SPRINTF(buff, sizeof(buff), 
                "\tdef get_%s(self):\n"
                "\t\treturn self.obj.%s\n"
                "\tdef set_%s(self, v):\n"
                "\t\tself.obj.%s = v\n"
                "\t@property\n"
                "\tdef %s(self):\n"
                "\t\treturn self.obj.%s\n"
                "\t@%s.setter\n"
                "\tdef %s(self, v):\n"
                "\t\tself.obj.%s = v\n",
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str(),
                m_all_pyclass[i].propertys_info[c].property_name.c_str()
                );
            gen_class_str += buff;
        }

        for (size_t m = 0; m < m_all_pyclass[i].methods_info.size(); ++m)
        {
            string pystr_args;
            string pystr_args_only_name;
            for (int j = 0; j < m_all_pyclass[i].methods_info[m].args_num; ++j)
            {
                stringstream ss;
                if (pystr_args.empty())
                {
                    ss << "a" << (j+1);
                    pystr_args += ss.str();
                }
                else
                {
                    ss << ", a" << (j+1);
                    pystr_args += ss.str();
                }
            }
            pystr_args_only_name = pystr_args;
            for (int j = 0; j < m_all_pyclass[i].methods_info[m].option_args_num; ++j)
            {
                stringstream ss;
                if (pystr_args.empty())
                {
                    ss << "a" << (m_all_pyclass[i].methods_info[m].args_num + j+1);
                    string tmp =  ss.str();
                    pystr_args_only_name += tmp;
                    pystr_args += tmp + " = None";
                }
                else
                {
                    ss << ", a" << (m_all_pyclass[i].methods_info[m].args_num + j+1);
                    string tmp =  ss.str();
                    pystr_args_only_name += tmp;
                    pystr_args += tmp + " = None";
                }
            }
            if (!pystr_args_only_name.empty())
                pystr_args_only_name += ",";

            SAFE_SPRINTF(buff, sizeof(buff), 
                "\tdef %s(self,%s):\n"
                "\t\t'''%s'''\n"
                "\t\treturn self.obj.%s(%ld,(%s))\n"
                ,m_all_pyclass[i].methods_info[m].func_name.c_str(), pystr_args.c_str(),
                m_all_pyclass[i].methods_info[m].doc.c_str(),
                m_all_pyclass[i].methods_info[m].func_real_name.c_str(), m_all_pyclass[i].methods_info[m].func_addr, pystr_args_only_name.c_str()
                );
            gen_class_str += buff;
        }
        SAFE_SPRINTF(buff, sizeof(buff), 
            "%s.%s = %s\n"
            "%s = None\n"
            "if _tmp_ff_:\n\tglobals()['%s'] = _tmp_ff_\n_tmp_ff_ = None\n",
            m_mod_name.c_str(), m_all_pyclass[i].class_name.c_str(), m_all_pyclass[i].class_name.c_str(),
            m_all_pyclass[i].class_name.c_str(),
            m_all_pyclass[i].class_name.c_str()
            );
        gen_class_str += buff;
        //printf(gen_class_str.c_str());
        PyRun_SimpleString(gen_class_str.c_str());
    }
    return 0;
}


bool ffpython_t::is_method_exist(const vector<pyclass_regigster_tool_t::method_info_t>& src_, const string& new_)
{
    for (size_t i = 0; i < src_.size(); ++i)
    {
        if (new_ == src_[i].func_name)
        {
            return true;
        }
    }
    return false;
}
bool ffpython_t::is_property_exist(const vector<pyclass_regigster_tool_t::property_info_t>& src_, const string& new_)
{
    for (size_t i = 0; i < src_.size(); ++i)
    {
        if (new_ == src_[i].property_name)
        {
            return true;
        }
    }
    return false;
}
pyclass_regigster_tool_t* ffpython_t::get_pyclass_info_by_name(const string& name_)
{
    for (size_t i = 0; i < m_all_pyclass.size(); ++i)
    {
        if (m_all_pyclass[i].class_name == name_)
        {
            return &(m_all_pyclass[i]);
        }
    }
    return NULL;
}