#include "pyjs_.h"

#include "napi_callback.hpp"

static PyObject* __pyjs_module_;

static PyObject* __py__main__module_;

std::pair<PyObject*,PyObjectType> pyjs::Js_ConvertToPython(const Napi::Env env,

}

Napi::Value pyjs::Py_ConvertToJavascript(const Napi::Env env, PyObject* obj,

}

Napi::FunctionReference

pyjs::PyjsConfigurationOptions::js_type_checking_callback_;

Napi::FunctionReference

pyjs::PyjsConfigurationOptions::serialization_filter_callback_;

Napi::FunctionReference

pyjs::PyjsConfigurationOptions::unmarshalling_filter_callback_;

std::unique_ptr<napi_ext::ThreadSafeCallback>

pyjs::PyjsConfigurationOptions::debug_messaging_callback_;

const std::unique_ptr<const std::vector<Napi::Function>>

pyjs::PyjsConfigurationOptions::GetSerializationFilters()

{

std::unique_ptr<std::vector<Napi::Function>> filters(new std::vector<Napi::Function>());

Napi::Value filter_object_ = pyjs::PyjsConfigurationOptions::serialization_filter_callback_

.Call({ });

if (!filter_object_.IsUndefined())

{

Napi::Object obj = filter_object_.As<Napi::Object>();

filters->emplace_back(obj.Get("SequenceTest").As<Napi::Function>());

filters->emplace_back(obj.Get("SequenceRegister").As<Napi::Function>());

filters->emplace_back(obj.Get("Finalize").As<Napi::Function>());

}

return filters;

}

Napi::Value pyjs::PyjsConfigurationOptions::SetJSTypeCheckingCallback(const Napi::CallbackInfo &info)

{

Napi::Env env = info.Env();

js_type_checking_callback_ = Napi::Persistent(info[0].As<Napi::Function>());

js_type_checking_callback_.SuppressDestruct();

return env.Undefined();

}

Napi::Value pyjs::PyjsConfigurationOptions::SetSerializationFiltersConstructor(const Napi::CallbackInfo &info)

{

Napi::Env env = info.Env();

//Don't set this more than once...

serialization_filter_callback_ = Napi::Persistent(info[0].As<Napi::Function>());

serialization_filter_callback_.SuppressDestruct();

return env.Undefined();

}

Napi::Object pyjs::PyjsConfigurationOptions::Init(Napi::Env env, Napi::Object exports)

{

exports.Set("$SetJSTypeCheckingCallback",

Napi::Function::New(env, pyjs::PyjsConfigurationOptions::SetJSTypeCheckingCallback));

exports.Set("$SetUnmarshallingFilter",

Napi::Function::New(env, pyjs::PyjsConfigurationOptions::SetUnmarshallingFilter));

exports.Set("$SetSerializationCallbackConstructor",

Napi::Function::New(env, NapiPyObject::SetSerializationCallBackConstructor));

exports.Set("$SetSerializationFilterConstructor",

Napi::Function::New(env, pyjs::PyjsConfigurationOptions::SetSerializationFiltersConstructor));

exports.Set("$SetDebugMessagingCallback",

Napi::Function::New(env, pyjs::PyjsConfigurationOptions::SetDebugMessagingCallback));

return exports;

}

Napi::Value pyjs::PyjsConfigurationOptions::SetUnmarshallingFilter(const Napi::CallbackInfo &info)

{

Napi::Env env = info.Env();

unmarshalling_filter_callback_ = Napi::Persistent(info[0].As<Napi::Function>());

unmarshalling_filter_callback_.SuppressDestruct();

return env.Undefined();

}

NapiPyObject* pyjs::PyjsConfigurationOptions::AttemptNapiObjectUnmarshalling(Napi::Env env, Napi::Value obj)

{

Napi::Value filter_output_ = pyjs::PyjsConfigurationOptions::unmarshalling_filter_callback_

.Call({ obj });

if (!filter_output_.IsUndefined())

{

return Napi::ObjectWrap<NapiPyObject>::Unwrap(filter_output_.As<Napi::Object>());

}

else

return NULL;

}

PyJsSpecialObjectType pyjs::PyjsConfigurationOptions::CheckJSSpecialType(const Napi::Value val)

{

return (PyJsSpecialObjectType)js_type_checking_callback_.Call({ val }).ToNumber().Int32Value();

}

Napi::Value pyjs::PyjsConfigurationOptions::SetDebugMessagingCallback(const Napi::CallbackInfo &info)

{

Napi::Env env = info.Env();

pyjs::PyjsConfigurationOptions::debug_messaging_callback_ =

std::make_unique<napi_ext::ThreadSafeCallback>(info[0].As<Napi::Function>());

debug_messaging_callback_->unref();

return env.Undefined();

}

void pyjs::PyjsConfigurationOptions::SendDebugMessage(std::vector<std::string> msg)

{

#ifdef __PY__DEBUG

pyjs::PyjsConfigurationOptions::debug_messaging_callback_->call(

[msg](Napi::Env env, std::vector<napi_value>& args)

{

std::vector<napi_value> nv (msg.size());

std::transform(msg.begin(), msg.end(), nv.begin(), [env](std::string s) {

return Napi::String::New(env, s);

});

args = nv;

});

#endif

}

#ifdef __PY__DEBUG

bool pyjs::PyjsConfigurationOptions::IsDebugEnabled()

{

return true;

}

#else

bool pyjs::PyjsConfigurationOptions::IsDebugEnabled()

{

return false;

}

#endif

static Napi::Value Import(const Napi::CallbackInfo &info)

}

static Napi::Value EvalHelper(const Napi::CallbackInfo &info, int type)

}

static Napi::Value Eval(const Napi::CallbackInfo &info)

{

return EvalHelper(info, Py_eval_input);

}

static Napi::Value EvalAsFile(const Napi::CallbackInfo &info)

{

return EvalHelper(info, Py_file_input);

}

static Napi::Value Global(const Napi::CallbackInfo &info)

}

Napi::Object InstanceInformation(const Napi::CallbackInfo &info)

}

PyObject* pyjs::FunctionBridgeRegisterCallback(const Napi::Env& env, Napi::Function f)

{

lock_gil lock_me;

napi_ext::ThreadSafeCallback* callback = new napi_ext::ThreadSafeCallback(f);

callback->unref();

//and into integer for long-term Python storage...

auto tmp = PyLong_FromSsize_t((Py_ssize_t)callback);

return tmp;

}

static PyObject* PyCapsuleNodeJSInterfaceFunctionCall(PyObject* self, PyObject* args)

{

PyObject* ptr_obj;

PyObject* cb_args;

napi_ext::ThreadSafeCallback* callback;

{

lock_gil lock_me;

ptr_obj = PyTuple_GET_ITEM(args, 0); //PyTuple_GET_ITEM (Borrowed)

cb_args = PyTuple_GET_ITEM(args, 1); //PyTuple_GET_ITEM (Borrowed)

Py_INCREF(cb_args); //Keep until we're done with async callback.

Py_ssize_t ptr = PyLong_AsSsize_t(ptr_obj);

callback = (napi_ext::ThreadSafeCallback*)ptr;

}

PyObject* res;

{

//Release GIL so we don't deadlock during async.

Py_BEGIN_ALLOW_THREADS

//The following lambdas run on the main loop.

auto future =

callback->call<PyObject*>([cb_args](Napi::Env env, std::vector<napi_value>& args)

{

auto map = std::unique_ptr<std::unordered_map<PyObject*,napi_value>>

(new std::unordered_map<PyObject*,napi_value>());

auto js = pyjs::Py_ConvertToJavascript(env, cb_args,

pyjs::PyjsConfigurationOptions::GetSerializationFilters(),

map, pyjs::MarshallingOptions());

Py_DECREF(cb_args); //We can get rid of args now.

args = { js };

}, [](const Napi::Value &napiValue)

{

Napi::Env env = napiValue.Env();

Napi::HandleScope scope(env);

const std::unique_ptr<const std::vector<Napi::Function>>&

serialization_filters = pyjs::PyjsConfigurationOptions::GetSerializationFilters();

std::pair<PyObject*,PyObjectType> conv = pyjs::Js_ConvertToPython(env, napiValue,

serialization_filters);

return conv.first;

});

//Block Python async thread (python_loop_thread) while waiting for result.

res = future.get();

Py_END_ALLOW_THREADS

}

return res;

}

static PyObject* PyCapsuleNodeJSInterfaceDestroyFunction(PyObject* self, PyObject* args)

{

Py_ssize_t ptr;

{

lock_gil lock_me;

PyObject* ptr_obj = PyTuple_GET_ITEM(args, 0); //PyTuple_GET_ITEM (Borrowed)

//TODO queue this, might be in the middle of processing, will have to tag

ptr = PyLong_AsSsize_t(ptr_obj);

}

napi_ext::ThreadSafeCallback* callback = (napi_ext::ThreadSafeCallback*)ptr;

delete callback;

Py_RETURN_TRUE;

}

static PyObject* PyCapsuleNodeJSInterfaceGetCurrentThreadID(PyObject* self, PyObject* args)

{

PyObject* ret;

{

lock_gil lock_me;

std::thread::id this_id = std::this_thread::get_id();

std::stringstream ss;

ss << this_id;

//PyUnicode_FromString (New)

ret = PyUnicode_FromString(ss.str().c_str());

}

return ret;

}

static PyObject* PyCapsuleNodeJSInterfaceDebugEnabled(PyObject* self, PyObject* args)

{

if (pyjs::PyjsConfigurationOptions::IsDebugEnabled())

{

Py_RETURN_TRUE;

}

else

{

Py_RETURN_FALSE;

}

}

static PyObject* PyCapsuleNodeJSInterfaceSendDebugMessage(PyObject* self, PyObject* args)

{

std::vector<std::string> d;

Py_ssize_t length = PyTuple_GET_SIZE(args);

for (Py_ssize_t i = 0; i < length; i++)

{

PyObject* obj = PyTuple_GET_ITEM(args, i);

if (PyUnicode_CheckExact(obj))

{

d.emplace_back(PyUnicode_AsUTF8(obj));

}

}

if (d.size() > 0)

{

d.emplace_back(pyjs_utils::GetCurrentThreadID());

d.emplace_back(std::to_string(pyjs_utils::GetCurrentTimeTicks()));

pyjs::PyjsConfigurationOptions::SendDebugMessage(d);

}

Py_RETURN_NONE;

}

static PyMethodDef PyCapsuleNodeJsMethods[] =

{

{

"_callback",

PyCapsuleNodeJSInterfaceFunctionCall,

METH_VARARGS,

"calls the node.js/python bridge."

},

{

"_callback_destroy",

PyCapsuleNodeJSInterfaceDestroyFunction,

METH_VARARGS,

"destroys a registered function on the node.js/python bridge."

},

{

"_get_current_thread_id",

PyCapsuleNodeJSInterfaceGetCurrentThreadID,

METH_VARARGS,

"gets the current thread id from the node.js/python interface."

},

{