// 직렬화 대상 구조체
struct FSerializeTargetStruct
{
    FSerializeTargetStruct(){}

    FSerializeTargetStruct(int32 InOrder, const FString& InName) : Order(InOrder), Name(InName) {

    }

    int32 Order = -1;
    FString Name = TEXT("이름");

    friend FArchive& operator<<(FArchive& Ar, FSerializeTargetStruct& InDataStruct)
    {
        Ar << InDataStruct.Name;
        Ar << InDataStruct.Order;
        return Ar;
    }
};

// 직렬화 하여 객체의 상태 저장, 읽기
void Test_Serialize()
{
    FSerializeTargetStruct RawDataSrc(16, TEXT("사람인"));

    // 직렬화 하여 파일로 저장할 것이다.
    
    // 저장할 경로 설정
    const FString SaveDir = FPaths::Combine(FPaths::ProjectDir() , TEXT("Saved"));      // 저장할 폴더 경로
    const FString RawDataFileName(TEXT("RawData.bin")); // 직렬화한 데이터는 .bin 이든 .txt 든 아무 포맷으로 저장할 수 있으며, 다시 읽을 수 있다. 하지만 사람이 읽을 수 있는 언어가 아님은 똑같다.
    
    FString RawDataAbsolutePath = FPaths::Combine(*SaveDir, *RawDataFileName);			// 이것만으로는 정확하게 나오지 않는다.
    FPaths::MakeStandardFilename(RawDataAbsolutePath);									// 깔끔하고 정돈된 파일경로를 얻을 수 있다.

    {
        // 데이터 저장하기
        // 모든 Archive 클래스는 FArchive 클래스를 상속 받는다.
        FArchive* RawFileWriterAr = IFileManager::Get().CreateFileWriter(*RawDataAbsolutePath); // 아카이브 클래스 생성 ( Writer Mode )
        if (nullptr != RawFileWriterAr)
        {
            /*
            *RawFileWriterAr << RawDataSrc.Order;
            *RawFileWriterAr << RawDataSrc.Name;
            */ // 이를 아래와 같이 한번에 호출

            *RawFileWriterAr << RawDataSrc; // operator<< 을 재정의 하였음

            RawFileWriterAr->Close();
            delete RawFileWriterAr;
            RawFileWriterAr = nullptr;
        }

        // 데이터 읽어오기
        FSerializeTargetStruct RawDataDest;
        FArchive* RawFileReaderAr = IFileManager::Get().CreateFileReader(*RawDataAbsolutePath); // 아카이브 클래스 생성 ( Reader Mode )
        if (nullptr != RawFileReaderAr)
        {
            /*
            // FileReaderAr 에서 읽은 데이터를 RawDataDest 로 넘겨준다.
            // 순서가 바뀌어서는 안된다. 쓴 순서대로 꺼내 읽어야 한다.
            *RawFileReaderAr << RawDataDest.Order;
            *RawFileReaderAr << RawDataDest.Name;
            */ // 이를 아래와 같이 한번에 호출

            *RawFileReaderAr << RawDataDest; // operator<< 을 재정의 하였음

            RawFileReaderAr->Close();
            delete RawFileReaderAr;
            RawFileReaderAr = nullptr;

            UE_LOG(LogTemp, Log, TEXT(" RawData : {  Name : %s, Order : %d }"), *RawDataDest.Name, RawDataDest.Order);
        }

    }    
}
                            
                        

                            
// SerializeTargetClass.h

#pragma once

#include "CoreMinimal.h"
#include "UObject/NoExportTypes.h"
#include "SerializeTargetClass.generated.h"

/**
 * 
 */
UCLASS()
class UECPP_TUTORIAL_API USerializeTargetClass : public UObject
{
	GENERATED_BODY()
	

public:

	USerializeTargetClass();

	int32 GetOrder() const { return Order; }
	void SetOrder(int32 InOrder) { Order = InOrder; }

	const FString& GetName() const { return Name; }
	void SetName(const FString& InName) { Name = InName; }

	// UObject 에는 Serialize 라는 함수가 기본 구현되어 있다.
	virtual void Serialize(FArchive& Ar) override;

private:

	UPROPERTY()
	int32 Order;

	UPROPERTY()
	FString Name;

};

// SerializeTargetClass.cpp

#include "SerializeTargetClass.h"

USerializeTargetClass::USerializeTargetClass()
{
	Order = -1;
	Name = TEXT("ObjDefault");
}

void USerializeTargetClass::Serialize(FArchive& Ar)
{
	// override 를 호출했다면 Super 를 호출해준다.
	Super::Serialize(Ar); // 언리얼 오브젝트가 알아야하는 기본적인정보를 설정해준다.

	Ar << Order;
	Ar << Name;
}

// 활용 
// UObject Serailize
{
    // FilePath
    FString ObjectDataFileDir = FPaths::Combine(FPaths::ProjectDir(), TEXT("Saved"));
    FString ObjectDataFilePath = FPaths::Combine(*ObjectDataFileDir, TEXT("UObjectDataFile.bin"));
    FPaths::MakeStandardFilename(ObjectDataFilePath);

    /* # UObject 의 내용 File 로 저장하기
    
        UObject >> Memory >> File
        UObject >(FMemoryWriter)> Memory >(FArchive)> File

        FMemoryWrite Archive 를 사용
        IFileManager 로 파일 저장
    */

    // 대상이 되는 UObject 생성
    USerializeTargetClass* SerializeTargetObject_Src = NewObject<USerializeTargetClass>();
    SerializeTargetObject_Src->SetName(TEXT("UObject SerializeTarget Object"));
    SerializeTargetObject_Src->SetOrder(51);

    // UObject 로부터 메모리에 데이터 이동
    TArray<uint8> MemoryBufferToSave; // 데이터를 저장할 바이트버퍼 생성
    FMemoryWriter MemoryWriterAr(MemoryBufferToSave); // 버퍼와 연동하는 메모리라이터 선언
    SerializeTargetObject_Src->Serialize(MemoryWriterAr); // Memory << UObject , Serialize 함수에 아카이브 클래스를 인수로 넣어준다.

    // 메모리로부터 File 로 데이터 이동
    TUniquePtr<FArchive> FileWriterAr = TUniquePtr<FArchive>(IFileManager::Get().CreateFileWriter(*ObjectDataFilePath)); // ObjectDataFile.bin 을 생성하면서, 해당 파일 경로에 대한 FArchive 생성
    if (FileWriterAr)
    {
        *FileWriterAr << MemoryBufferToSave; // File << Memory
        FileWriterAr->Close();
    }


    /* # File 에서 UObject 의 내용 읽기
        
        UObject << Memory << File
        UObject <(FMemoryReader)< Memory <(FArchive)< File

        IFileManager 로 파일 불러오기
        FMemoryReader Archive 사용
    */

    // 대상이 되는 UObject 생성
    USerializeTargetClass* SerializeTargetObject_Dest = NewObject<USerializeTargetClass>();
    
    // File 로부터 데이터 읽어서 버퍼에 이동
    TUniquePtr<FArchive> FileReaderAr = TUniquePtr<FArchive>(IFileManager::Get().CreateFileReader(*ObjectDataFilePath));
    TArray<uint8> MemoryBufferToRead;
    if (FileReaderAr)
    {
        *FileReaderAr << MemoryBufferToRead; // Memory << File
        FileReaderAr->Close(); 
    }

    // 버퍼의 내용을 UObject 에 이동
    FMemoryReader MemoryReaderAr(MemoryBufferToRead);
    SerializeTargetObject_Dest->Serialize(MemoryReaderAr); // UObject << Memory
    
    // 확인
    UE_LOG(LogTemp, Log, TEXT("[UObjectSerialize] SerializeTargetObject_Dest : {Name : %s, Order : %d}"), *SerializeTargetObject_Dest->GetName(), SerializeTargetObject_Dest->GetOrder());

    // FArchive 는 연결하는 파일의 경로가 있어야 하며
    // FMemoryReader, FMemoryWriter 는 연동하는 버퍼가 있어야 한다.

}
                            
                        

                            
struct MyObj{
    FString Name = TEXT("사용자");
    int Order = 20;
}
                            
                        

                            
"MyObj" : {
    "Name":"사용자",
    "Order":20
}
                            
                        

                            
// ProjectName.Build.cs 
// Copyright Epic Games, Inc. All Rights Reserved.

using UnrealBuildTool;

public class UECPP_Tutorial : ModuleRules
{
	public UECPP_Tutorial(ReadOnlyTargetRules Target) : base(Target)
	{
		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

		PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay" , "Json", "JsonUtilities" }); // "Json", "JsonUtilities" 모듈 추가
	}
}

                            
                        

                            
// Json 과 JsonUtilities 모듈을 추가해주어야 한다.
// 언리얼 오브젝트를 Json 오브젝트로 바꾸기 위한 헬퍼 라이브러리 가 들어가 있는 헤더파일. 
#include "JsonObjectConverter.h" 

{

    // 경로 설정
    FString ObjectDataFileDir = FPaths::Combine(FPaths::ProjectDir(), TEXT("Saved"));
    FString ObjectDataFilePath = FPaths::Combine(*ObjectDataFileDir, TEXT("ObjectData.txt"));
    FPaths::MakeStandardFilename(ObjectDataFilePath);

    /*  # UObject 내용 저장
    
        UObject >> FJsonObject >> FString >> File
        UObject >(FJsonObjectConverter)> FJsonObject >(FJsonSerializer)> FString >(FFileHelper)> File

        1. UObject to FJson
        2. FJson to FString
        3. FString to File
    */

    USerializeTargetClass* SerializeTargetObject_Src = NewObject<USerializeTargetClass>();
    SerializeTargetObject_Src->SetName(TEXT("Json SerailizeTarget Object"));
    SerializeTargetObject_Src->SetOrder(33);

    TSharedRef<FJsonObject> JsonObjectFromUObject = MakeShared<FJsonObject>();
    // UObject 도 결국 UStruct 를 상속한다. UObject 의 Property 를 Json 으로 변환하기 위한 함수  UStructToJsonObject 사용
    FJsonObjectConverter::UStructToJsonObject(SerializeTargetObject_Src->StaticClass(), SerializeTargetObject_Src, JsonObjectFromUObject); // UObject >> Json Object
    
    FString JsonStr_UObject_Src; // UObject_Src 의 내용을 Json 문자열로 저장할 버퍼
    TSharedRef<TJsonWriter<TCHAR>> JsonWriterAr = TJsonWriterFactory<TCHAR>::Create(&JsonStr_UObject_Src);
    if (FJsonSerializer::Serialize(JsonObjectFromUObject, JsonWriterAr)) // JsonObject >> FString
    {
        // 직렬화 성공
        // 인코딩을 신경쓰지 않아도, 운영체제에 맞게 string 을 File 로 저장할 수 있도록 하는 클래스
        FFileHelper::SaveStringToFile(JsonStr_UObject_Src, *ObjectDataFilePath); // FString >> File
    }


    /*	# UObject 내용 읽어오기

        UObject << FJsonObject << FString << File
        UObject <(FJsonObjectConverter)< FJsonObject <(FJsonSerializer)< FString <(FFileHelper)< File

        1. File to FString
        2. FString to FJson
        3. FJson to UObject

    */

    FString JsonStrFromFile;
    FFileHelper::LoadFileToString(JsonStrFromFile, *ObjectDataFilePath); // File >> FString

    // Json Data 를 담을 Object
    USerializeTargetClass* SerializeTargetObject_Dest = NewObject<USerializeTargetClass>();

    TSharedRef<TJsonReader<TCHAR>> JsonReaderAr = TJsonReaderFactory<TCHAR>::Create(JsonStrFromFile);
    TSharedPtr<FJsonObject> JsonObjectFromStr = nullptr; // 만약 문자열이 JSON 형태로 잘 적히지 않았다면, 안만들어 질 수도 있기 때문에 TSharedPtr 로 선언
    FJsonSerializer::Deserialize(JsonReaderAr, JsonObjectFromStr); // FString >> FJsonObject
    if (JsonObjectFromStr)
    {
        // 역직렬화 성공시 FJsonObject 의 내용을 UObject 로 담는다.
        FJsonObjectConverter::JsonObjectToUStruct(JsonObjectFromStr.ToSharedRef(), SerializeTargetObject_Dest->StaticClass(), SerializeTargetObject_Dest); // FJsonObject >> UObject

        UE_LOG(LogTemp, Log, TEXT("[JSON Serialize] SerializeTargetObject_Dest : { Name : %s, Order : %d }"), *SerializeTargetObject_Dest->GetName(), SerializeTargetObject_Dest->GetOrder());

    }
    else {
        UE_LOG(LogTemp, Warning, TEXT("[JSON Serialize] Serialize Failed"));
    }

}