#include "MPCookSideEffect.h"
#include "Cooker/CookWorkerClient.h"
#include "Algo/Sort.h"
#include "Algo/Unique.h"
namespace UE
{
namespace Cook
{
FCookWorkerClient* FMPCookSideEffectCollector::CookWorkerClient = nullptr;

void FMPCookSideEffectCollector::AddExport(UObject* Export)
{
    if (!CookWorkerClient)
    {
        UE_LOG(LogCook, Display, TEXT("AddExport With Null CookWorkerClient %s"), *Export->GetPathName());
        return;
    }
    FName ExportObjectPath                        = FName(*Export->GetPathName());
    FMPCookSideEffectCollectorData& CollectorData = CookWorkerClient->GetCookCollectorData();
    FScopeLock Lock(&CollectorData.CookSideEffectsLock);
    CollectorData.CookSideEffects.EdlExports.Add(ExportObjectPath);
    CookWorkerClient->MarkAssetRegistryDirty();
}

void FMPCookSideEffectCollector::AddImport(UObject* Import, UPackage* ImportingPackage)
{
    if (!CookWorkerClient)
    {
        UE_LOG(LogCook, Display, TEXT("AddImport With Null CookWorkerClient %s"), *Import->GetPathName());
        return;
    }
    FName ImportObjectPath                        = FName(*Import->GetPathName());
    FName PackageObjectPath                       = ImportingPackage->GetFName();
    FMPCookSideEffectCollectorData& CollectorData = CookWorkerClient->GetCookCollectorData();
    FScopeLock Lock(&CollectorData.CookSideEffectsLock);
    CollectorData.CookSideEffects.EdlImports.Add({ImportObjectPath, PackageObjectPath});
    CookWorkerClient->MarkAssetRegistryDirty();
}

void FMPCookSideEffectCollector::AddArc(UObject* DepObject, bool bDepIsSerialize, UObject* Export, bool bExportIsSerialize)
{
    if (!CookWorkerClient)
    {
        UE_LOG(LogCook, Display, TEXT("AddArc With Null CookWorkerClient %s"), *DepObject->GetPathName());
        return;
    }
    FName DepObjectPath                           = FName(*DepObject->GetPathName());
    FName ExportObjectPath                        = FName(*Export->GetPathName());
    FMPCookSideEffectCollectorData& CollectorData = CookWorkerClient->GetCookCollectorData();
    FScopeLock Lock(&CollectorData.CookSideEffectsLock);
    FCookEdlArc& Arc       = CollectorData.CookSideEffects.EdlArcs.Emplace_GetRef();
    Arc.DepObjectPath      = DepObjectPath;
    Arc.bDepIsSerialize    = bDepIsSerialize;
    Arc.ExportObjectPath   = ExportObjectPath;
    Arc.bExportIsSerialize = bExportIsSerialize;
    CookWorkerClient->MarkAssetRegistryDirty();
}

void FMPCookSideEffectCollector::SetCookWorkerClient(FCookWorkerClient* InCookWorkerClient)
{
    CookWorkerClient = InCookWorkerClient;
    if (InCookWorkerClient)
    {
        ICookSideEffectCollector::SetFactory(&FMPCookSideEffectCollector::NewCookSideEffectCollector);
    }
    else
    {
        ICookSideEffectCollector::SetFactory(nullptr);
    }
}

ICookSideEffectCollector* FMPCookSideEffectCollector::NewCookSideEffectCollector()
{
    return new FMPCookSideEffectCollector();
}

bool operator<(const FCookEDImport& Self, const FCookEDImport& Other)
{
    if (Self.Path != Other.Path)
        return Self.Path.LexicalLess(Other.Path);
    return Self.Package.LexicalLess(Other.Package);
}
bool operator==(const FCookEDImport& Self, const FCookEDImport& Other)
{
    return Self.Path == Other.Path &&
           Self.Package == Other.Package;
}

bool operator<(const FCookEdlArc& Self, const FCookEdlArc& Other)
{
    if (Self.bDepIsSerialize != Other.bDepIsSerialize)
        return Self.bDepIsSerialize < Other.bDepIsSerialize;
    if (Self.bExportIsSerialize != Other.bExportIsSerialize)
        return Self.bExportIsSerialize < Other.bExportIsSerialize;
    if (Self.DepObjectPath != Other.DepObjectPath)
        return Self.DepObjectPath.LexicalLess(Other.DepObjectPath);
    return Self.ExportObjectPath.LexicalLess(Other.ExportObjectPath);
}
bool operator==(const FCookEdlArc& Self, const FCookEdlArc& Other)
{
    return Self.bDepIsSerialize == Other.bDepIsSerialize &&
           Self.bExportIsSerialize == Other.bExportIsSerialize &&
           Self.DepObjectPath == Other.DepObjectPath &&
           Self.ExportObjectPath == Other.ExportObjectPath;
}

void FMPCookSideEffectCollectorData::UniqueToCookSideEffects(FCookSideEffects& Target)
{
    auto UniqueArray = [](auto& Array)
    {
        if (Array.Num() > 1)
        {
            Array.Sort([](const auto& Lhs, const auto& Rhs)
                       {
                           return Lhs < Rhs;
                       });
            int32 NewNum = Algo::Unique(Array, [](const auto& Lhs, const auto& Rhs)
                                        {
                                            return Lhs == Rhs;
                                        });

            Array.SetNum(NewNum, false);
        }
    };

    UniqueArray(CookSideEffects.EdlImports);
    UniqueArray(CookSideEffects.EdlExports);
    UniqueArray(CookSideEffects.EdlArcs);

    Target.EdlImports = MoveTemp(CookSideEffects.EdlImports);
    Target.EdlExports = MoveTemp(CookSideEffects.EdlExports);
    Target.EdlArcs    = MoveTemp(CookSideEffects.EdlArcs);
}

}  // namespace Cook
}  // namespace UE