// Copyright Epic Games, Inc. All Rights Reserved.

/*=============================================================================
        UObjectBaseUtility.cpp: Unreal UObject functions that only depend on UObjectBase
=============================================================================*/

#include "UObject/UObjectBaseUtility.h"
#include "UObject/Class.h"
#include "UObject/Package.h"
#include "UObject/UObjectHash.h"
#include "Templates/Casts.h"
#include "UObject/Interface.h"
#include "Misc/StringBuilder.h"
#include "Modules/ModuleManager.h"
#include "ProfilingDebugging/MallocProfiler.h"

/***********************/
/******** Names ********/
/***********************/

/**
 * Returns the fully qualified pathname for this object, in the format:
 * 'Outermost.[Outer:]Name'
 *
 * @param	StopOuter	if specified, indicates that the output string should be relative to this object.  if StopOuter
 *						does not exist in this object's Outer chain, the result would be the same as passing NULL.
 *
 * @note	safe to call on NULL object pointers!
 */
FString UObjectBaseUtility::GetPathName(const UObject* StopOuter /*=NULL*/) const
{
    FString Result;
    GetPathName(StopOuter, Result);
    return Result;
}

/**
 * Version of GetPathName() that eliminates unnecessary copies and appends an existing string.
 */
void UObjectBaseUtility::GetPathName(const UObject* StopOuter, FString& ResultString) const
{
    TStringBuilder<256> ResultBuilder;
    GetPathName(StopOuter, ResultBuilder);
    ResultString += FStringView(ResultBuilder);
}

void UObjectBaseUtility::GetPathName(const UObject* StopOuter, FStringBuilderBase& ResultString) const
{
    if (this != StopOuter && this != NULL)
    {
        UObject* ObjOuter = GetOuter();
        if (ObjOuter && ObjOuter != StopOuter)
        {
            ObjOuter->GetPathName(StopOuter, ResultString);

            // SUBOBJECT_DELIMITER_CHAR is used to indicate that this object's outer is not a UPackage
            if (ObjOuter->GetClass() != UPackage::StaticClass() && ObjOuter->GetOuter()->GetClass() == UPackage::StaticClass())
            {
                ResultString << SUBOBJECT_DELIMITER_CHAR;
            }
            else
            {
                ResultString << TEXT('.');
            }
        }
        GetFName().AppendString(ResultString);
    }
    else
    {
        ResultString << TEXT("None");
    }
}

/**
 * Returns the fully qualified pathname for this object as well as the name of the class, in the format:
 * 'ClassName Outermost.[Outer:]Name'.
 *
 * @param	StopOuter	if specified, indicates that the output string should be relative to this object.  if StopOuter
 *						does not exist in this object's Outer chain, the result would be the same as passing NULL.
 *
 * @note	safe to call on NULL object pointers!
 */
FString UObjectBaseUtility::GetFullName(const UObject* StopOuter, EObjectFullNameFlags Flags) const
{
    FString Result;
    Result.Empty(128);
    GetFullName(StopOuter, Result, Flags);
    return Result;
}

/**
 * Version of GetFullName() that eliminates unnecessary copies and appends an existing string.
 */
void UObjectBaseUtility::GetFullName(const UObject* StopOuter, FString& ResultString, EObjectFullNameFlags Flags) const
{
    if (this != nullptr)
    {
        if (EnumHasAllFlags(Flags, EObjectFullNameFlags::IncludeClassPackage))
        {
            ResultString += GetClass()->GetPathName();
        }
        else
        {
            GetClass()->AppendName(ResultString);
        }
        ResultString += TEXT(' ');
        GetPathName(StopOuter, ResultString);
    }
    else
    {
        ResultString += TEXT("None");
    }
}

/**
 * Walks up the chain of packages until it reaches the top level, which it ignores.
 *
 * @param	bStartWithOuter		whether to include this object's name in the returned string
 * @return	string containing the path name for this object, minus the outermost-package's name
 */
FString UObjectBaseUtility::GetFullGroupName(bool bStartWithOuter) const
{
    const UObjectBaseUtility* Obj = bStartWithOuter ? GetOuter() : this;
    return Obj ? Obj->GetPathName(GetOutermost()) : TEXT("");
}

/***********************/
/*** Outer & Package ***/
/***********************/

void UObjectBaseUtility::DetachExternalPackage()
{
    ClearFlags(RF_HasExternalPackage);
}

void UObjectBaseUtility::ReattachExternalPackage()
{
    // GetObjectExternalPackageThreadSafe doesn't check for the RF_HasExternalPackage before looking up the external package
    if (!HasAnyFlags(RF_HasExternalPackage) && GetObjectExternalPackageThreadSafe(this))
    {
        SetFlags(RF_HasExternalPackage);
    }
}

/**
 * Walks up the list of outers until it finds the top-level one that isn't a package.
 * Will return null if called on a package
 * @return outermost non-null, non-package Outer.
 */
UObject* UObjectBaseUtility::GetOutermostObject() const
{
    UObject* Top = (UObject*)(this);
    if (Top->IsA<UPackage>())
    {
        return nullptr;
    }
    for (;;)
    {
        UObject* CurrentOuter = Top->GetOuter();
        if (CurrentOuter->IsA<UPackage>())
        {
            return Top;
        }
        Top = CurrentOuter;
    }
}

/**
 * Walks up the list of outers until it finds a package directly associated with the object.
 *
 * @return the package the object is in.
 */
UPackage* UObjectBaseUtility::GetPackage() const
{
    const UObject* Top = static_cast<const UObject*>(this);
    for (;;)
    {
        // GetExternalPackage will return itself if called on a UPackage
        if (UPackage* Package = Top->GetExternalPackage())
        {
            return Package;
        }
        Top = Top->GetOuter();
    }
}

/**
 * Legacy function, has the same behavior as GetPackage
 * use GetPackage instead.
 * @return the package the object is in.
 * @see GetPackage
 */
UPackage* UObjectBaseUtility::GetOutermost() const
{
    return GetPackage();
}

/**
 * Finds the outermost package and marks it dirty
 */
bool UObjectBaseUtility::MarkPackageDirty() const
{
    // since transient objects will never be saved into a package, there is no need to mark a package dirty
    // if we're transient
    if (!HasAnyFlags(RF_Transient))
    {
        UPackage* Package = GetOutermost();

        if (Package != NULL)
        {
            // It is against policy to dirty a map or package during load in the Editor, to enforce this policy
            // we explicitly disable the ability to dirty a package or map during load.  Commandlets can still
            // set the dirty state on load.
            if (IsRunningCommandlet() ||
                (GIsEditor && !GIsEditorLoadingPackage && !GIsCookerLoadingPackage && !GIsPlayInEditorWorld && !IsInAsyncLoadingThread()
#if WITH_HOT_RELOAD
                 && !GIsHotReload
#endif  // WITH_HOT_RELOAD
#if WITH_EDITORONLY_DATA
                 && !Package->bIsCookedForEditor  // Cooked packages can't be modified nor marked as dirty
#endif
                 ))
            {
                const bool bIsDirty = Package->IsDirty();

                // We prevent needless re-dirtying as this can be an expensive operation.
                if (!bIsDirty)
                {
                    Package->SetDirtyFlag(true);
                }

                // Always call PackageMarkedDirtyEvent, even when the package is already dirty
                Package->PackageMarkedDirtyEvent.Broadcast(Package, bIsDirty);

                return true;
            }
            else
            {
                // notify the caller that the request to mark the package as dirty was suppressed
                return false;
            }
        }
    }
    return true;
}

/**
 * Determines whether this object is a template object
 *
 * @return	true if this object is a template object (owned by a UClass)
 */
bool UObjectBaseUtility::IsTemplate(EObjectFlags TemplateTypes) const
{
    for (const UObjectBaseUtility* TestOuter = this; TestOuter; TestOuter = TestOuter->GetOuter())
    {
        if (TestOuter->HasAnyFlags(TemplateTypes))
            return true;
    }

    return false;
}

/**
 * Traverses the outer chain searching for the next object of a certain type.  (T must be derived from UObject)
 *
 * @param	Target class to search for
 * @return	a pointer to the first object in this object's Outer chain which is of the correct type.
 */
UObject* UObjectBaseUtility::GetTypedOuter(UClass* Target) const
{
    UObject* Result = NULL;
    for (UObject* NextOuter = GetOuter(); Result == NULL && NextOuter != NULL; NextOuter = NextOuter->GetOuter())
    {
        if (NextOuter->IsA(Target))
        {
            Result = NextOuter;
        }
    }
    return Result;
}

/*-----------------------------------------------------------------------------
        UObject accessors that depend on UClass.
-----------------------------------------------------------------------------*/

/**
 * @return	true if the specified object appears somewhere in this object's outer chain.
 */
bool UObjectBaseUtility::IsIn(const UObject* SomeOuter) const
{
    if (SomeOuter->IsA<UPackage>())
    {
        return IsInPackage(static_cast<const UPackage*>(SomeOuter));
    }
    return IsInOuter(SomeOuter);
}

/** Overload to determine if an object is in the specified package which can now be different than its outer chain. */
bool UObjectBaseUtility::IsIn(const UPackage* SomePackage) const
{
    // uncomment the ensure to more easily find where IsIn should be changed to IsInPackage
    // ensure(0);
    return IsInPackage(SomePackage);
}

bool UObjectBaseUtility::IsInOuter(const UObject* SomeOuter) const
{
    for (UObject* It = GetOuter(); It; It = It->GetOuter())
    {
        if (It == SomeOuter)
        {
            return true;
        }
    }
    return SomeOuter == nullptr;
}

/**
 * @return	true if the object is contained in the specified package.
 */
bool UObjectBaseUtility::IsInPackage(const UPackage* SomePackage) const
{
    return SomePackage != this && GetPackage() == SomePackage;
}

/**
 * Find out if this object is inside (has an outer) that is of the specified class
 * @param SomeBaseClass	The base class to compare against
 * @return True if this object is in an object of the given type.
 */
bool UObjectBaseUtility::IsInA(const UClass* SomeBaseClass) const
{
    for (const UObjectBaseUtility* It = this; It; It = It->GetOuter())
    {
        if (It->IsA(SomeBaseClass))
        {
            return true;
        }
    }
    return SomeBaseClass == NULL;
}

/**
 * Checks whether this object's top-most package has any of the specified flags
 *
 * @param	CheckFlagMask	a bitmask of EPackageFlags values to check for
 *
 * @return	true if the PackageFlags member of this object's top-package has any bits from the mask set.
 */
bool UObjectBaseUtility::RootPackageHasAnyFlags(uint32 CheckFlagMask) const
{
    return GetOutermost()->HasAnyPackageFlags(CheckFlagMask);
}

/***********************/
/******** Class ********/
/***********************/

/**
 * Finds the most-derived class which is a parent of both TestClass and this object's class.
 *
 * @param	TestClass	the class to find the common base for
 */
const UClass* UObjectBaseUtility::FindNearestCommonBaseClass(const UClass* TestClass) const
{
    const UClass* Result = NULL;

    if (TestClass != NULL)
    {
        const UClass* CurrentClass = GetClass();

        // early out if it's the same class or one is the parent of the other
        // (the check for TestClass->IsChildOf(CurrentClass) returns true if TestClass == CurrentClass
        if (TestClass->IsChildOf(CurrentClass))
        {
            Result = CurrentClass;
        }
        else if (CurrentClass->IsChildOf(TestClass))
        {
            Result = TestClass;
        }
        else
        {
            // find the nearest parent of TestClass which is also a parent of CurrentClass
            for (UClass* Cls = TestClass->GetSuperClass(); Cls; Cls = Cls->GetSuperClass())
            {
                if (CurrentClass->IsChildOf(Cls))
                {
                    Result = Cls;
                    break;
                }
            }
        }
    }

    // at this point, Result should only be NULL if TestClass is NULL
    checkfSlow(Result != NULL || TestClass == NULL, TEXT("No common base class found for object '%s' with TestClass '%s'"), *GetFullName(), *TestClass->GetFullName());
    return Result;
}

/**
 * Returns a pointer to this object safely converted to a pointer to the specified interface class.
 *
 * @param	InterfaceClass	the interface class to use for the returned type
 *
 * @return	a pointer that can be assigned to a variable of the interface type specified, or NULL if this object's
 *			class doesn't implement the interface indicated.  Will be the same value as 'this' if the interface class
 *			isn't native.
 */
void* UObjectBaseUtility::GetInterfaceAddress(UClass* InterfaceClass)
{
    void* Result = NULL;

    if (InterfaceClass != NULL && InterfaceClass->HasAnyClassFlags(CLASS_Interface) && InterfaceClass != UInterface::StaticClass())
    {
        // Script interface
        if (!InterfaceClass->HasAnyClassFlags(CLASS_Native))
        {
            if (GetClass()->ImplementsInterface(InterfaceClass))
            {
                // if it isn't a native interface, the address won't be different
                Result = this;
            }
        }
        // Native interface
        else
        {
            for (UClass* CurrentClass = GetClass(); Result == NULL && CurrentClass != NULL; CurrentClass = CurrentClass->GetSuperClass())
            {
                for (TArray<FImplementedInterface>::TIterator It(CurrentClass->Interfaces); It; ++It)
                {
                    // See if this is the implementation we are looking for, and it was done natively, not in K2
                    FImplementedInterface& ImplInterface = *It;
                    if (!ImplInterface.bImplementedByK2 && ImplInterface.Class->IsChildOf(InterfaceClass))
                    {
                        Result = (uint8*)this + It->PointerOffset;
                        break;
                    }
                }
            }
        }
    }

    return Result;
}

void* UObjectBaseUtility::GetNativeInterfaceAddress(UClass* InterfaceClass)
{
    check(InterfaceClass != NULL);
    check(InterfaceClass->HasAllClassFlags(CLASS_Interface | CLASS_Native));
    check(InterfaceClass != UInterface::StaticClass());

    for (UClass* CurrentClass = GetClass(); CurrentClass; CurrentClass = CurrentClass->GetSuperClass())
    {
        for (auto It = CurrentClass->Interfaces.CreateConstIterator(); It; ++It)
        {
            // See if this is the implementation we are looking for, and it was done natively, not in K2
            auto& ImplInterface = *It;
            if (!ImplInterface.bImplementedByK2 && ImplInterface.Class->IsChildOf(InterfaceClass))
            {
                if (It->PointerOffset)
                {
                    return (uint8*)this + It->PointerOffset;
                }
            }
        }
    }

    return NULL;
}

bool UObjectBaseUtility::IsDefaultSubobject() const
{
    const bool bIsInstanced = GetOuter() && (GetOuter()->HasAnyFlags(RF_ClassDefaultObject) || ((UObject*)this)->GetArchetype() != GetClass()->GetDefaultObject(false));
    return bIsInstanced;
}

UClass* GetParentNativeClass(UClass* Class)
{
    while (Class && !Class->IsNative())
    {
        Class = Class->GetSuperClass();
    }

    return Class;
}

#if STATS && USE_MALLOC_PROFILER
void FScopeCycleCounterUObject::TrackObjectForMallocProfiling(const UObjectBaseUtility* InObject)
{
    // Get the package name from the outermost item (if available - can't use GetOutermost here)
    FName PackageName;
    if (InObject->GetOuter())
    {
        UObjectBaseUtility* Top = InObject->GetOuter();
        for (;;)
        {
            UObjectBaseUtility* CurrentOuter = Top->GetOuter();
            if (!CurrentOuter)
            {
                PackageName = Top->GetFName();
                break;
            }
            Top = CurrentOuter;
        }
    }

    // Get the class name (if available)
    FName ClassName;
    if (InObject->GetClass())
    {
        ClassName = InObject->GetClass()->GetFName();
    }

    TrackObjectForMallocProfiling(PackageName, ClassName, InObject->GetFName());
}
void FScopeCycleCounterUObject::TrackObjectForMallocProfiling(const FName InPackageName, const FName InClassName, const FName InObjectName)
{
    static const TCHAR PackageTagCategory[] = TEXT("Package:");
    static const TCHAR ObjectTagCategory[]  = TEXT("Object:");
    static const TCHAR ClassTagCategory[]   = TEXT("Class:");

    // We use an array rather than an FString to try and minimize heap allocations
    TArray<TCHAR, TInlineAllocator<256>> ScratchSpaceBuffer;

    auto AppendNameToBuffer = [&](const FName InName)
    {
        const FNameEntry* NameEntry = InName.GetDisplayNameEntry();
        if (NameEntry->IsWide())
        {
            WIDECHAR WideName[NAME_SIZE];
            NameEntry->GetWideName(WideName);
            const WIDECHAR* NameCharPtr = WideName;
            while (*NameCharPtr != 0)
            {
                ScratchSpaceBuffer.Add((TCHAR)*NameCharPtr++);
            }
        }
        else
        {
            ANSICHAR AnsiName[NAME_SIZE];
            NameEntry->GetAnsiName(AnsiName);
            const ANSICHAR* NameCharPtr = AnsiName;
            while (*NameCharPtr != 0)
            {
                ScratchSpaceBuffer.Add((TCHAR)*NameCharPtr++);
            }
        }
    };

    if (!InPackageName.IsNone())
    {
        // "Package:/Path/To/Package"
        ScratchSpaceBuffer.Reset();
        ScratchSpaceBuffer.Append(PackageTagCategory, UE_ARRAY_COUNT(PackageTagCategory) - 1);
        AppendNameToBuffer(InPackageName);
        ScratchSpaceBuffer.Add(0);
        PackageTag = FName(ScratchSpaceBuffer.GetData());
        GMallocProfiler->AddTag(PackageTag);

        // "Object:/Path/To/Package/ObjectName"
        ScratchSpaceBuffer.Reset();
        ScratchSpaceBuffer.Append(ObjectTagCategory, UE_ARRAY_COUNT(ObjectTagCategory) - 1);
        AppendNameToBuffer(InPackageName);
        ScratchSpaceBuffer.Add(TEXT('/'));
        AppendNameToBuffer(InObjectName);
        ScratchSpaceBuffer.Add(0);
        ObjectTag = FName(ScratchSpaceBuffer.GetData());
        GMallocProfiler->AddTag(ObjectTag);
    }

    if (!InClassName.IsNone())
    {
        // "Class:ClassName"
        ScratchSpaceBuffer.Reset();
        ScratchSpaceBuffer.Append(ClassTagCategory, UE_ARRAY_COUNT(ClassTagCategory) - 1);
        AppendNameToBuffer(InClassName);
        ScratchSpaceBuffer.Add(0);
        ClassTag = FName(ScratchSpaceBuffer.GetData());
        GMallocProfiler->AddTag(ClassTag);
    }
}
void FScopeCycleCounterUObject::UntrackObjectForMallocProfiling()
{
    if (!PackageTag.IsNone())
    {
        GMallocProfiler->RemoveTag(PackageTag);
    }

    if (!ClassTag.IsNone())
    {
        GMallocProfiler->RemoveTag(ClassTag);
    }

    if (!ObjectTag.IsNone())
    {
        GMallocProfiler->RemoveTag(ObjectTag);
    }
}
#endif

#if !STATS && !ENABLE_STATNAMEDEVENTS && USE_LIGHTWEIGHT_STATS_FOR_HITCH_DETECTION && USE_HITCH_DETECTION && USE_LIGHTWEIGHT_UOBJECT_STATS_FOR_HITCH_DETECTION
#include "HAL/ThreadHeartBeat.h"
#include "HAL/ThreadManager.h"

void FScopeCycleCounterUObject::ReportHitch()
{
    float Delta                  = float(FGameThreadHitchHeartBeat::Get().GetCurrentTime() - FGameThreadHitchHeartBeat::Get().GetFrameStartTime()) * 1000.0f;
    const uint32 CurrentThreadId = FPlatformTLS::GetCurrentThreadId();
    const FString& ThreadString  = FThreadManager::GetThreadName(CurrentThreadId);
    FString StackString;
    if (CurrentThreadId == GGameThreadId)
    {
        if (StatObject->IsValidLowLevel() && StatObject->IsValidLowLevelFast())
        {
            StackString = GetFullNameSafe(StatObject);
        }
        else
        {
            StackString = FString(TEXT("[UObject was invalid]"));
        }
    }
    else
    {
        StackString = FString(TEXT("[Not grabbing UObject name from other threads]"));
    }
    UE_LOG(LogCore, Error, TEXT("Leaving UObject scope on hitch (+%8.2fms) [%s] %s"), Delta, *ThreadString, *StackString);
}
#endif