UJavascriptIsolate* Isolate = nullptr;
Isolate = NewObject<UJavascriptIsolate>();
Isolate->Init(false);
Isolate->AddToRoot();
auto* Context = Isolate->CreateContext();

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "JavascriptIsolate.h"
#include "JavascriptComponent.h"
#include "IV8.h"
#include "Spell.generated.h"


UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class SPELLCRAFT_API USpell : public UActorComponent
{
	GENERATED_BODY()

public:	
	// Sets default values for this component's properties
	USpell();

	FAsyncTask<class JavascriptIsolateGeneratorTask>* LoadJSEngineAsyncTask;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool Main_Thread;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	UJavascriptContext *Source_Context;

	UFUNCTION()
	void CatchEngineIsolates(UJavascriptContext* SourceContext);

protected:
	// Called when the game starts
	virtual void BeginPlay() override;

public:	
	// Called every frame
	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

	UFUNCTION(BlueprintCallable, Category = "Components")
	void LoadJSIsolate();
};

//==========================
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLoadJSEngine_IsolatePass, class UJavascriptContext*, SourceContext);
class JavascriptIsolateGeneratorTask : public FNonAbandonableTask {
private:

public:
	JavascriptIsolateGeneratorTask();
	~JavascriptIsolateGeneratorTask();

	FLoadJSEngine_IsolatePass IsolatePass;

	// required by UE4
	FORCEINLINE TStatId GetStatId() const {
		RETURN_QUICK_DECLARE_CYCLE_STAT(JavascriptIsolateGeneratorTask, STATGROUP_ThreadPoolAsyncTasks);
	}

	void DoWork();
};

// Fill out your copyright notice in the Description page of Project Settings.

#include "Spell.h"
#include "JavascriptIsolate.h"
#include "JavascriptContext.h"
#include "IV8.h"

// Sets default values for this component's properties
USpell::USpell()
{
	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
	// off to improve performance if you don't need them.
	PrimaryComponentTick.bCanEverTick = true;

	Main_Thread = true;
	// ...
}

// Called when the game starts
void USpell::BeginPlay()
{
	Super::BeginPlay();

	// ...
	
}


// Called every frame
void USpell::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	// ...
}

void USpell::CatchEngineIsolates(UJavascriptContext* SourceContext) {
	this->Source_Context = SourceContext;

	UE_LOG(LogTemp, Warning, TEXT("Secondary Thread JS Context Done"));
}

void USpell::LoadJSIsolate() {
	if (Main_Thread) {
		UJavascriptIsolate* Isolate = nullptr;
		Isolate = NewObject<UJavascriptIsolate>();
		Isolate->Init(false);
		auto* Context = Isolate->CreateContext();
		UE_LOG(LogTemp, Warning, TEXT("Main Thread JS Context Done"));
	} else {
		LoadJSEngineAsyncTask = new FAsyncTask<JavascriptIsolateGeneratorTask>();
		LoadJSEngineAsyncTask->GetTask().IsolatePass.AddDynamic(this, &USpell::CatchEngineIsolates);
		LoadJSEngineAsyncTask->StartBackgroundTask();
		UE_LOG(LogTemp, Warning, TEXT("Task Started"));
	}
}

//==========================

JavascriptIsolateGeneratorTask::JavascriptIsolateGeneratorTask() {
}

JavascriptIsolateGeneratorTask::~JavascriptIsolateGeneratorTask() {
	UE_LOG(LogTemp, Warning, TEXT("Task Finished"));
}

void JavascriptIsolateGeneratorTask::DoWork() {

	UE_LOG(LogTemp, Warning, TEXT("Do Work - Start"));

	UJavascriptIsolate* Isolate = nullptr;
	Isolate = NewObject<UJavascriptIsolate>();
	Isolate->Init(false);
	UJavascriptContext* Context = nullptr;
	Context = Isolate->CreateContext();
	
	UE_LOG(LogTemp, Warning, TEXT("Do Work - End"));

	// Broadcast Delegate
	IsolatePass.Broadcast(Context);
}