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


#include "API/Operations/ReceiveOperation.h"

#include "Dom/JsonObject.h"
#include "Transports/Transport.h"
#include "API/SpeckleSerializer.h"
#include "LogSpeckle.h"
#include "Objects/Base.h"
#include "Mixpanel.h"

// ReceiveOperation
UReceiveOperation* UReceiveOperation::ReceiveOperation(UObject* WorldContextObject,
													   const FString& ObjectId,
							                           TScriptInterface<ITransport> RemoteTransport,
							                           TScriptInterface<ITransport> LocalTransport)
{
    UReceiveOperation* Node = NewObject<UReceiveOperation>();
    Node->ObjectId = ObjectId;
    Node->RemoteTransport = RemoteTransport;
    Node->LocalTransport = LocalTransport;

	Node->RegisterWithGameInstance(WorldContextObject);
    return Node;
}

// Activate
void UReceiveOperation::Activate()
{
	FAnalytics::TrackEvent("unknown",
		"unknown", "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});

	//Async(EAsyncExecution::Thread, [this]{Receive();});
	Receive();
}

void UReceiveOperation::Receive()
{
	check(LocalTransport != nullptr);
	
	// 1. Try and get object from local transport
	auto Obj = LocalTransport->GetSpeckleObject(ObjectId);

	if (Obj != nullptr )
	{
		HandleReceive(Obj);
		return;
	}

	// 2. Try and get object from remote transport
	if(RemoteTransport == nullptr)
	{
		FString ErrorMessage = TEXT(
			"Could not find specified object using the local transport, and you didn't provide a fallback remote from which to pull it.");

		HandleError(ErrorMessage);
		return;
	}

	FTransportCopyObjectCompleteDelegate CompleteDelegate;
	CompleteDelegate.BindUObject(this, &UReceiveOperation::HandleReceive);

	FTransportErrorDelegate ErrorDelegate;
	ErrorDelegate.BindUObject(this, &UReceiveOperation::HandleError);
	
	RemoteTransport->CopyObjectAndChildren(ObjectId, LocalTransport, CompleteDelegate, ErrorDelegate);
}

void UReceiveOperation::HandleReceive(TSharedPtr<FJsonObject> Object)
{
	check(IsInGameThread())

	// FString OutputString;
	// TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&OutputString);
	// FJsonSerializer::Serialize(Object.ToSharedRef(), Writer);

	//UE_LOG(LogSpeckle, Log, TEXT("JSoN: %s"), *OutputString);

	
	FEditorScriptExecutionGuard ScriptGuard;
	if(Object == nullptr)
	{
		OnError.Broadcast(nullptr,
			           FString::Printf(TEXT("Failed to get object %s from transport"), *ObjectId),
			           TArray<FString>(),
			           TArray<FString>()
			             );
	}
	else
	{
		UBase* Res = USpeckleSerializer::DeserializeBase(Object, LocalTransport);
		TMap<FString, TSharedPtr<FJsonValue>> jsonMap = Object->Values;

		TArray<FString> Ids = TArray<FString>();
		TArray<FString> LayerNames = TArray<FString>();
		
		//UE_LOG(LogSpeckle, Log, TEXT("JSoN: %s"), *OutputString);
		for (auto &currJsonValue: jsonMap)
		{
			// Get the json key name
			FString Key = currJsonValue.Key;

			// Get the json value
			TSharedPtr<FJsonValue> Value = currJsonValue.Value;
			
			UE_LOG(LogTemp, Warning, TEXT("KEY NAME: %s "), *Key);

			if (Key.Contains("::"))
			{
				const TArray<TSharedPtr<FJsonValue>>* SubArrayPtr;
				if (Value->TryGetArray(SubArrayPtr))
				{
					for (const TSharedPtr<FJsonValue>& ArrayElement : *SubArrayPtr)
					{
						const TSharedPtr<FJsonObject>* ArraySubObjPtr;

						if (ArrayElement->TryGetObject(ArraySubObjPtr))
						{
							// TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&id_mesh);
							// FJsonSerializer::Serialize((*ArraySubObjPtr).ToSharedRef(), Writer);

							FString MeshId = (*ArraySubObjPtr)->GetStringField("referencedId");
							Ids.Add(*MeshId);
							LayerNames.Add(*Key);
							//UE_LOG(LogTemp, Warning, TEXT("KEY VAL 2: %s - %s"), *id_mesh, *id_Layer );
						}
					}
				}
			}
		}
		
		if(IsValid(Res))
		{
			OnReceiveSuccessfully.Broadcast(Res, "", Ids, LayerNames);
		}
		else
		{
			OnError.Broadcast(nullptr,
							  FString::Printf(TEXT("Root Speckle Object %s failed to deserialize"),*ObjectId),
							  TArray<FString>(),
							  TArray<FString>()
							  );
		}
	}
	
	SetReadyToDestroy();
}

void UReceiveOperation::HandleError(FString& Message)
{
	FEditorScriptExecutionGuard ScriptGuard;
	OnError.Broadcast(nullptr, Message, TArray<FString>(), TArray<FString>());
	SetReadyToDestroy();
}