#include <Foundation/Foundation.h>

#include "DataWrapper.h"

#include "Helpers.h"

#include "Runtime.h"

#include "Caches.h"

#include "Constants.h"

using namespace v8;

namespace tns {

static NSOperationQueue* workers_ = nil;

__attribute__((constructor))

void staticInitMethod() {

workers_ = [[NSOperationQueue alloc] init];

workers_.maxConcurrentOperationCount = 100;

}

WorkerWrapper::WorkerWrapper(v8::Isolate* mainIsolate, std::function<void (v8::Isolate*, v8::Local<v8::Object> thiz, std::string)> onMessage)

: mainIsolate_(mainIsolate),

workerIsolate_(nullptr),

isRunning_(false),

isClosing_(false),

isTerminating_(false),

isDisposed_(false),

isWeak_(false),

onMessage_(onMessage) {

}

const WrapperType WorkerWrapper::Type() {

return WrapperType::Worker;

}

const int WorkerWrapper::Id() {

return this->workerId_;

}

const bool WorkerWrapper::IsRunning() {

return this->isRunning_;

}

const bool WorkerWrapper::IsClosing() {

return this->isClosing_;

}

const int WorkerWrapper::WorkerId() {

return this->workerId_;

}

void WorkerWrapper::PostMessage(std::string message) {

if (!this->isTerminating_) {

this->queue_.Push(message);

}

}

void WorkerWrapper::Start(std::shared_ptr<Persistent<Value>> poWorker, std::function<Isolate* ()> func) {

this->poWorker_ = poWorker;

this->workerId_ = nextId_.fetch_add(1, std::memory_order_relaxed) + 1;

[workers_ addOperationWithBlock:^{

this->BackgroundLooper(func);

}];

this->isRunning_ = true;

}

void WorkerWrapper::DrainPendingTasks() {

std::vector<std::string> messages = this->queue_.PopAll();

v8::Locker locker(this->workerIsolate_);

Isolate::Scope isolate_scope(this->workerIsolate_);

HandleScope handle_scope(this->workerIsolate_);

Local<Context> context = Caches::Get(this->workerIsolate_)->GetContext();

Local<Object> global = context->Global();

for (std::string message: messages) {

if (this->isTerminating_) {

break;

}

TryCatch tc(this->workerIsolate_);

this->onMessage_(this->workerIsolate_, global, message);

if (tc.HasCaught()) {

this->CallOnErrorHandlers(tc);

}

}

}

void WorkerWrapper::BackgroundLooper(std::function<Isolate* ()> func) {

if (!this->isTerminating_) {

CFRunLoopRef runLoop = CFRunLoopGetCurrent();

this->queue_.Initialize(runLoop, [](void* info) {

WorkerWrapper* w = static_cast<WorkerWrapper*>(info);

w->DrainPendingTasks();

}, this);

this->workerIsolate_ = func();

this->DrainPendingTasks();

// check again as it could terminate before this

if (!this->isTerminating_) {

CFRunLoopRun();

}

}

this->isDisposed_ = true;

Runtime* runtime = Runtime::GetCurrentRuntime();

delete runtime;

}

void WorkerWrapper::Close() {

this->isClosing_ = true;

}

void WorkerWrapper::Terminate() {

// set terminating to true atomically

bool wasTerminating = this->isTerminating_.exchange(true);

if (!wasTerminating) {

if (this->workerIsolate_ != nullptr) {

this->workerIsolate_->TerminateExecution();

}

this->queue_.Terminate();

this->isRunning_ = false;

}

}

void WorkerWrapper::CallOnErrorHandlers(TryCatch& tc) {

if (this->isTerminating_) {

return;

}

Local<Context> context = Caches::Get(this->workerIsolate_)->GetContext();

Local<Object> global = context->Global();

Local<Value> onErrorVal;

bool success = global->Get(context, tns::ToV8String(this->workerIsolate_, "onerror")).ToLocal(&onErrorVal);

Isolate* isolate = context->GetIsolate();

tns::Assert(success, isolate);

if (!onErrorVal.IsEmpty() && onErrorVal->IsFunction()) {

Local<v8::Function> onErrorFunc = onErrorVal.As<v8::Function>();

Local<Value> error = tc.Exception();

Local<Value> args[1] = { error };

Local<Value> result;

TryCatch innerTc(this->workerIsolate_);

success = onErrorFunc->Call(context, v8::Undefined(this->workerIsolate_), 1, args).ToLocal(&result);

if (success && !result.IsEmpty() && result->BooleanValue(this->workerIsolate_)) {

// Do nothing, exception is handled and does not need to be raised to the main thread's onerror handler

return;

}

if (!success && innerTc.HasCaught()) {

this->PassUncaughtExceptionFromWorkerToMain(context, innerTc);

}

this->PassUncaughtExceptionFromWorkerToMain(context, tc);

}

}

void WorkerWrapper::PassUncaughtExceptionFromWorkerToMain(Local<Context> context, TryCatch& tc, bool async) {

Isolate* workerIsolate = context->GetIsolate();

int lineNumber;

bool success = tc.Message()->GetLineNumber(context).To(&lineNumber);

Isolate* isolate = context->GetIsolate();

tns::Assert(success, isolate);

std::string message = tns::ToString(workerIsolate, tc.Message()->Get());

Local<Value> source;

success = tc.Message()->GetScriptResourceName()->ToString(context).ToLocal(&source);

tns::Assert(success, isolate);

std::string src = tns::ToString(workerIsolate, source);

std::string stackTrace = "";

Local<Value> stackTraceVal = tc.StackTrace(context).FromMaybe(Local<Value>());

if (!stackTraceVal.IsEmpty()) {

Local<v8::String> stackTraceStr = stackTraceVal->ToDetailString(context).FromMaybe(Local<v8::String>());

if (!stackTraceStr.IsEmpty()) {

stackTrace = tns::ToString(workerIsolate, stackTraceStr);

}

}

auto runtime = static_cast<Runtime*>(mainIsolate_->GetData(Constants::RUNTIME_SLOT));

if (runtime == nullptr) {

return;

}

tns::ExecuteOnRunLoop(runtime->RuntimeLoop(), [this, message, src, stackTrace, lineNumber]() {

v8::Locker locker(this->mainIsolate_);

Isolate::Scope isolate_scope(this->mainIsolate_);

HandleScope handle_scope(this->mainIsolate_);

Local<Object> worker = this->poWorker_->Get(this->mainIsolate_).As<Object>();

Local<Context> context = Caches::Get(this->mainIsolate_)->GetContext();

Local<Value> onErrorVal;

bool success = worker->Get(context, tns::ToV8String(this->mainIsolate_, "onerror")).ToLocal(&onErrorVal);

tns::Assert(success, this->mainIsolate_);

if (!onErrorVal.IsEmpty() && onErrorVal->IsFunction()) {

Local<v8::Function> onErrorFunc = onErrorVal.As<v8::Function>();

Local<Object> arg = this->ConstructErrorObject(context, message, src, stackTrace, lineNumber);

Local<Value> args[1] = { arg };

Local<Value> result;

TryCatch tc(this->mainIsolate_);

bool success = onErrorFunc->Call(context, v8::Undefined(this->mainIsolate_), 1, args).ToLocal(&result);

if (!success && tc.HasCaught()) {

Local<Value> error = tc.Exception();

Log(@"%s", tns::ToString(this->mainIsolate_, error).c_str());

this->mainIsolate_->ThrowException(error);

}

}

}, async);

}

Local<Object> WorkerWrapper::ConstructErrorObject(Local<Context> context, std::string message, std::string source, std::string stackTrace, int lineNumber) {

Isolate* isolate = context->GetIsolate();

Local<ObjectTemplate> objTemplate = ObjectTemplate::New(isolate);

Local<Object> obj;

bool success = objTemplate->NewInstance(context).ToLocal(&obj);

tns::Assert(success, isolate);

tns::Assert(obj->Set(context, tns::ToV8String(isolate, "message"), tns::ToV8String(isolate, message)).FromMaybe(false), isolate);

tns::Assert(obj->Set(context, tns::ToV8String(isolate, "filename"), tns::ToV8String(isolate, source)).FromMaybe(false), isolate);

tns::Assert(obj->Set(context, tns::ToV8String(isolate, "stackTrace"), tns::ToV8String(isolate, stackTrace)).FromMaybe(false), isolate);

tns::Assert(obj->Set(context, tns::ToV8String(isolate, "lineno"), Number::New(isolate, lineNumber)).FromMaybe(false), isolate);

return obj;

}

std::atomic<int> WorkerWrapper::nextId_(0);

}