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

#include "Kismet2/KismetDebugUtilities.h"
#include "Engine/BlueprintGeneratedClass.h"
#include "GameFramework/Actor.h"
#include "UObject/PropertyPortFlags.h"
#include "UObject/TextProperty.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/SWidget.h"
#include "Layout/WidgetPath.h"
#include "Framework/Application/MenuStack.h"
#include "Framework/Application/SlateApplication.h"
#include "Widgets/Layout/SBorder.h"
#include "Widgets/Layout/SBox.h"
#include "Widgets/Text/SMultiLineEditableText.h"
#include "Widgets/Layout/SScrollBox.h"
#include "EditorStyleSet.h"
#include "Engine/Blueprint.h"
#include "EdGraph/EdGraph.h"
#include "Editor/UnrealEdEngine.h"
#include "Settings/EditorExperimentalSettings.h"
#include "CallStackViewer.h"
#include "WatchPointViewer.h"
#include "Animation/AnimBlueprintGeneratedClass.h"
#include "UnrealEdGlobals.h"
#include "Engine/Breakpoint.h"
#include "ActorEditorUtils.h"
#include "EdGraphSchema_K2.h"
#include "K2Node.h"
#include "K2Node_Tunnel.h"
#include "K2Node_FunctionEntry.h"
#include "K2Node_Knot.h"
#include "K2Node_MacroInstance.h"
#include "K2Node_Message.h"
#include "Kismet2/KismetEditorUtilities.h"
#include "Kismet2/BlueprintEditorUtils.h"
#include "Logging/TokenizedMessage.h"
#include "Logging/MessageLog.h"
#include "Misc/UObjectToken.h"
#include "AnimGraphNode_Base.h"
#include "UObject/UnrealType.h"
#include "AnimationGraphSchema.h"

#define LOCTEXT_NAMESPACE "BlueprintDebugging"

/** Per-thread data for use by FKismetDebugUtilities functions */
class FKismetDebugUtilitiesData: public TThreadSingleton<FKismetDebugUtilitiesData>
{
public:
    FKismetDebugUtilitiesData()
        : TargetGraphNodes(), CurrentInstructionPointer(nullptr), MostRecentBreakpointInstructionPointer(nullptr), MostRecentStoppedNode(nullptr), TargetGraphStackDepth(INDEX_NONE), MostRecentBreakpointGraphStackDepth(INDEX_NONE), MostRecentBreakpointInstructionOffset(INDEX_NONE), StackFrameAtIntraframeDebugging(nullptr), TraceStackSamples(FKismetDebugUtilities::MAX_TRACE_STACK_SAMPLES), bIsSingleStepping(false), bIsSteppingOut(false)
    {
    }

    void Reset()
    {
        TargetGraphNodes.Empty();
        CurrentInstructionPointer             = nullptr;
        MostRecentStoppedNode                 = nullptr;

        TargetGraphStackDepth                 = INDEX_NONE;
        MostRecentBreakpointGraphStackDepth   = INDEX_NONE;
        MostRecentBreakpointInstructionOffset = INDEX_NONE;
        StackFrameAtIntraframeDebugging       = nullptr;

        bIsSingleStepping                     = false;
        bIsSteppingOut                        = false;
    }

    // List of graph nodes that the user wants to stop at, at the current TargetGraphStackDepth. Used for Step Over:
    TArray<TWeakObjectPtr<class UEdGraphNode>> TargetGraphNodes;

    // Current node:
    TWeakObjectPtr<class UEdGraphNode> CurrentInstructionPointer;

    // The current instruction encountered if we are stopped at a breakpoint; NULL otherwise
    TWeakObjectPtr<class UEdGraphNode> MostRecentBreakpointInstructionPointer;

    // The last node that we decided to break on for any reason (e.g. breakpoint, exception, or step operation):
    TWeakObjectPtr<class UEdGraphNode> MostRecentStoppedNode;

    // The target graph call stack depth. INDEX_NONE if not active
    int32 TargetGraphStackDepth;

    // The graph stack depth that a breakpoint was hit at, used to ensure that breakpoints
    // can be hit multiple times in the case of recursion
    int32 MostRecentBreakpointGraphStackDepth;

    // The instruction that we hit a breakpoint at, this is used to ensure that a given node
    // can be stepped over reliably (but still break multiple times in the case of recursion):
    int32 MostRecentBreakpointInstructionOffset;

    // The last message that an exception delivered
    FText LastExceptionMessage;

    // Only valid inside intraframe debugging
    const FFrame* StackFrameAtIntraframeDebugging;

    // This data is used for the 'marching ants' display in the blueprint editor
    TSimpleRingBuffer<FKismetTraceSample> TraceStackSamples;

    // This flag controls whether we're trying to 'step in' to a function
    bool bIsSingleStepping;

    // This flag controls whether we're trying to 'step out' of a graph
    bool bIsSteppingOut;
};

//////////////////////////////////////////////////////////////////////////
// FKismetDebugUtilities

void FKismetDebugUtilities::EndOfScriptExecution(const FBlueprintContextTracker& BlueprintContext)
{
    if (BlueprintContext.GetScriptEntryTag() == 1)
    {
        // if this is our last VM frame, then clear stepping data:
        FKismetDebugUtilitiesData& Data = FKismetDebugUtilitiesData::Get();

        Data.Reset();
    }
}

void FKismetDebugUtilities::RequestSingleStepIn()
{
    FKismetDebugUtilitiesData& Data = FKismetDebugUtilitiesData::Get();

    Data.bIsSingleStepping          = true;
}

void FKismetDebugUtilities::RequestStepOver()
{
    FKismetDebugUtilitiesData& Data          = FKismetDebugUtilitiesData::Get();
    const TArray<const FFrame*>& ScriptStack = FBlueprintContextTracker::Get().GetScriptStack();

    if (ScriptStack.Num() > 0)
    {
        Data.TargetGraphStackDepth = ScriptStack.Num();

        // get the current graph that we're stopped at:
        const FFrame* CurrentFrame = ScriptStack.Last();
        if (CurrentFrame->Object)
        {
            if (UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(CurrentFrame->Object->GetClass()))
            {
                const int32 BreakpointOffset = CurrentFrame->Code - CurrentFrame->Node->Script.GetData() - 1;
                UEdGraphNode* BlueprintNode  = BPGC->DebugData.FindSourceNodeFromCodeLocation(CurrentFrame->Node, BreakpointOffset, true);
                if (BlueprintNode)
                {
                    // add any nodes connected via execs as TargetGraphNodes:
                    for (UEdGraphPin* Pin: BlueprintNode->Pins)
                    {
                        if (Pin->Direction == EGPD_Output && Pin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec && Pin->LinkedTo.Num() > 0)
                        {
                            for (UEdGraphPin* LinkedTo: Pin->LinkedTo)
                            {
                                UEdGraphNode* GraphNode = LinkedTo->GetOwningNode();
                                if (UK2Node_Knot* Knot = Cast<UK2Node_Knot>(GraphNode))
                                {
                                    // search the knot chain to find the actual node:
                                    GraphNode = Knot->GetExecTerminal();
                                }

                                if (GraphNode)
                                {
                                    Data.TargetGraphNodes.AddUnique(GraphNode);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void FKismetDebugUtilities::RequestStepOut()
{
    FKismetDebugUtilitiesData& Data          = FKismetDebugUtilitiesData::Get();
    const TArray<const FFrame*>& ScriptStack = FBlueprintContextTracker::Get().GetScriptStack();

    Data.bIsSingleStepping                   = false;
    if (ScriptStack.Num() > 1)
    {
        Data.bIsSteppingOut        = true;
        Data.TargetGraphStackDepth = ScriptStack.Num() - 1;
    }
}

void FKismetDebugUtilities::OnScriptException(const UObject* ActiveObject, const FFrame& StackFrame, const FBlueprintExceptionInfo& Info)
{
    FKismetDebugUtilitiesData& Data = FKismetDebugUtilitiesData::Get();

    struct Local
    {
        static void OnMessageLogLinkActivated(const class TSharedRef<IMessageToken>& Token)
        {
            if (Token->GetType() == EMessageToken::Object)
            {
                const TSharedRef<FUObjectToken> UObjectToken = StaticCastSharedRef<FUObjectToken>(Token);
                if (UObjectToken->GetObject().IsValid())
                {
                    FKismetEditorUtilities::BringKismetToFocusAttentionOnObject(UObjectToken->GetObject().Get());
                }
            }
        }
    };

    checkSlow(ActiveObject != nullptr);

    // Ignore script exceptions for preview actors
    if (FActorEditorUtils::IsAPreviewOrInactiveActor(Cast<const AActor>(ActiveObject)))
    {
        return;
    }

    UClass* ClassContainingCode = FindClassForNode(ActiveObject, StackFrame.Node);
    UBlueprint* BlueprintObj    = (ClassContainingCode ? Cast<UBlueprint>(ClassContainingCode->ClassGeneratedBy) : nullptr);
    if (BlueprintObj)
    {
        const FBlueprintExceptionInfo* ExceptionInfo = &Info;
        bool bResetObjectBeingDebuggedWhenFinished   = false;
        UObject* ObjectBeingDebugged                 = BlueprintObj->GetObjectBeingDebugged();
        UObject* SavedObjectBeingDebugged            = ObjectBeingDebugged;
        UWorld* WorldBeingDebugged                   = BlueprintObj->GetWorldBeingDebugged();
        const FString& PathToDebug                   = BlueprintObj->GetObjectPathToDebug();

        if (ObjectBeingDebugged == nullptr)
        {
            // Check if we need to update the object being debugged
            UObject* ObjectToDebug = FindObjectSafe<UObject>(nullptr, *PathToDebug);
            if (ObjectToDebug)
            {
                // If the path to debug matches a newly-spawned object, set the hard reference now
                ObjectBeingDebugged = ObjectToDebug;
                BlueprintObj->SetObjectBeingDebugged(ObjectBeingDebugged);
            }
        }

        const int32 BreakpointOffset = StackFrame.Code - StackFrame.Node->Script.GetData() - 1;

        bool bShouldBreakExecution   = false;
        bool bForceToCurrentObject   = false;
        bool bIsStepping             = Data.bIsSingleStepping || Data.TargetGraphStackDepth != INDEX_NONE;

        switch (Info.GetType())
        {
            case EBlueprintExceptionType::Breakpoint:
                bShouldBreakExecution = true;
                break;
            case EBlueprintExceptionType::Tracepoint:
                bShouldBreakExecution = bIsStepping;
                break;
            case EBlueprintExceptionType::WireTracepoint:
                break;
            case EBlueprintExceptionType::AccessViolation:
                if (GIsEditor && GIsPlayInEditorWorld)
                {
                    // declared as its own variable since it's flushed (logs pushed to std output) on destruction
                    // we want the full message constructed before it's logged
                    TSharedRef<FTokenizedMessage> Message = FTokenizedMessage::Create(EMessageSeverity::Error);
                    Message->AddToken(FTextToken::Create(FText::Format(LOCTEXT("RuntimeErrorMessageFmt", "Blueprint Runtime Error: \"{0}\"."), Info.GetDescription())));

                    Message->AddToken(FTextToken::Create(LOCTEXT("RuntimeErrorBlueprintObjectLabel", "Blueprint: ")));
                    Message->AddToken(FUObjectToken::Create(BlueprintObj, FText::FromString(BlueprintObj->GetName()))
                                          ->OnMessageTokenActivated(FOnMessageTokenActivated::CreateStatic(&Local::OnMessageLogLinkActivated)));

                    // NOTE: StackFrame.Node is not a blueprint node like you may think ("Node" has some legacy meaning)
                    Message->AddToken(FTextToken::Create(LOCTEXT("RuntimeErrorBlueprintFunctionLabel", "Function: ")));
                    Message->AddToken(FUObjectToken::Create(StackFrame.Node, StackFrame.Node->GetDisplayNameText())
                                          ->OnMessageTokenActivated(FOnMessageTokenActivated::CreateStatic(&Local::OnMessageLogLinkActivated)));

#if WITH_EDITORONLY_DATA  // to protect access to GeneratedClass->DebugData
                    UBlueprintGeneratedClass* GeneratedClass = Cast<UBlueprintGeneratedClass>(ClassContainingCode);
                    if ((GeneratedClass != nullptr) && GeneratedClass->DebugData.IsValid())
                    {
                        UEdGraphNode* BlueprintNode = GeneratedClass->DebugData.FindSourceNodeFromCodeLocation(StackFrame.Node, BreakpointOffset, true);
                        // if instead, there is a node we can point to...
                        if (BlueprintNode != nullptr)
                        {
                            Message->AddToken(FTextToken::Create(LOCTEXT("RuntimeErrorBlueprintGraphLabel", "Graph: ")));
                            Message->AddToken(FUObjectToken::Create(BlueprintNode->GetGraph(), FText::FromString(GetNameSafe(BlueprintNode->GetGraph())))
                                                  ->OnMessageTokenActivated(FOnMessageTokenActivated::CreateStatic(&Local::OnMessageLogLinkActivated)));

                            Message->AddToken(FTextToken::Create(LOCTEXT("RuntimeErrorBlueprintNodeLabel", "Node: ")));
                            Message->AddToken(FUObjectToken::Create(BlueprintNode, BlueprintNode->GetNodeTitle(ENodeTitleType::ListView))
                                                  ->OnMessageTokenActivated(FOnMessageTokenActivated::CreateStatic(&Local::OnMessageLogLinkActivated)));
                        }
                    }
#endif  // WITH_EDITORONLY_DATA
                    FMessageLog("PIE").AddMessage(Message);
                }
                bForceToCurrentObject = true;
                bShouldBreakExecution = GetDefault<UEditorExperimentalSettings>()->bBreakOnExceptions;
                break;
            case EBlueprintExceptionType::InfiniteLoop:
                bForceToCurrentObject = true;
                bShouldBreakExecution = GetDefault<UEditorExperimentalSettings>()->bBreakOnExceptions;
                break;
            default:
                bForceToCurrentObject = true;
                bShouldBreakExecution = GetDefault<UEditorExperimentalSettings>()->bBreakOnExceptions;
                break;
        }

        if (!bForceToCurrentObject && bIsStepping)
        {
            // If we're stepping, temporarily override the selected debug object so step into always works)
            bForceToCurrentObject = true;
        }

        // If we are debugging a specific world, the object needs to be in it
        if (WorldBeingDebugged != nullptr && !ActiveObject->IsIn(WorldBeingDebugged))
        {
            // Might be a streaming level case, so find the real world to see
            const UObject* ObjOuter = ActiveObject;
            const UWorld* ObjWorld  = nullptr;
            bool FailedWorldCheck   = true;
            while (ObjWorld == nullptr && ObjOuter != nullptr)
            {
                ObjOuter = ObjOuter->GetOuter();
                ObjWorld = Cast<const UWorld>(ObjOuter);
            }
            if (ObjWorld && ObjWorld->PersistentLevel)
            {
                if (ObjWorld->PersistentLevel->OwningWorld == WorldBeingDebugged)
                {
                    // Its ok, the owning world is the world being debugged
                    FailedWorldCheck = false;
                }
            }

            if (FailedWorldCheck)
            {
                bForceToCurrentObject = false;
                bShouldBreakExecution = false;
            }
        }

        if (bShouldBreakExecution)
        {
            if ((PathToDebug.IsEmpty()) || (bForceToCurrentObject))
            {
                // If there was nothing being debugged, treat this as a one-shot, temporarily set this object as being debugged,
                // and continue allowing any breakpoint to hit later on
                bResetObjectBeingDebuggedWhenFinished = true;
                ObjectBeingDebugged                   = const_cast<UObject*>(ActiveObject);
                BlueprintObj->SetObjectBeingDebugged(ObjectBeingDebugged);
            }
        }

        if (ObjectBeingDebugged == ActiveObject)
        {
            // Record into the trace log
            FKismetTraceSample& Tracer = Data.TraceStackSamples.WriteNewElementUninitialized();
            Tracer.Context             = MakeWeakObjectPtr(const_cast<UObject*>(ActiveObject));
            Tracer.Function            = StackFrame.Node;
            Tracer.Offset              = BreakpointOffset;  //@TODO: Might want to make this a parameter of Info
            Tracer.ObservationTime     = FPlatformTime::Seconds();

            // Find the node that generated the code which we hit
            UEdGraphNode* NodeStoppedAt = FindSourceNodeForCodeLocation(ActiveObject, StackFrame.Node, BreakpointOffset, /*bAllowImpreciseHit=*/true);
            if (NodeStoppedAt && (Info.GetType() == EBlueprintExceptionType::Tracepoint || Info.GetType() == EBlueprintExceptionType::Breakpoint))
            {
                // Handle Node stepping and update the stack
                CheckBreakConditions(NodeStoppedAt, Info.GetType() == EBlueprintExceptionType::Breakpoint, BreakpointOffset, bShouldBreakExecution);
            }

            // Can't do intraframe debugging when the editor is actively stopping
            if (GEditor->ShouldEndPlayMap())
            {
                bShouldBreakExecution = false;
            }

            // Handle a breakpoint or single-step
            if (bShouldBreakExecution)
            {
                AttemptToBreakExecution(BlueprintObj, ActiveObject, StackFrame, *ExceptionInfo, NodeStoppedAt, BreakpointOffset);
            }
        }

        // Reset the object being debugged if we forced it to be something different
        if (bResetObjectBeingDebuggedWhenFinished)
        {
            if (BlueprintObj->GetObjectBeingDebugged() == ObjectBeingDebugged)
            {
                // Only reset if it's still what we expected, if the user picked a new object from the UI we want to respect that
                BlueprintObj->SetObjectBeingDebugged(SavedObjectBeingDebugged);
            }
        }

        const auto ShowScriptExceptionError = [&](const FText& InExceptionErrorMsg)
        {
            if (GUnrealEd->PlayWorld != nullptr)
            {
                GEditor->RequestEndPlayMap();
                FSlateApplication::Get().LeaveDebuggingMode();
            }

            // Launch a message box notifying the user why they have been booted
            {
                // Callback to display a pop-up showing the Callstack, the user can highlight and copy this if needed
                auto DisplayCallStackLambda = [](const FText CallStack)
                {
                    TSharedPtr<SMultiLineEditableText> TextBlock;
                    TSharedRef<SWidget> DisplayWidget =
                        SNew(SBox)
                            .MaxDesiredHeight(512)
                            .MaxDesiredWidth(512)
                            .Content()
                                [SNew(SBorder)
                                     .BorderImage(FEditorStyle::GetBrush("ToolPanel.GroupBorder"))
                                         [SNew(SScrollBox) + SScrollBox::Slot()
                                                                 [SAssignNew(TextBlock, SMultiLineEditableText)
                                                                      .AutoWrapText(true)
                                                                      .IsReadOnly(true)
                                                                      .Text(CallStack)]]];

                    FSlateApplication::Get().PushMenu(
                        FSlateApplication::Get().GetActiveTopLevelWindow().ToSharedRef(),
                        FWidgetPath(),
                        DisplayWidget,
                        FSlateApplication::Get().GetCursorPos(),
                        FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup));

                    FSlateApplication::Get().SetKeyboardFocus(TextBlock);
                };

                TSharedRef<FTokenizedMessage> Message = FTokenizedMessage::Create(EMessageSeverity::Error);

                // Display the main error message
                Message->AddToken(FTextToken::Create(InExceptionErrorMsg));

                // Display a link to the UObject and the UFunction that is crashing
                {
                    // Get the name of the Blueprint
                    FString BlueprintName;
                    BlueprintObj->GetName(BlueprintName);

                    Message->AddToken(FTextToken::Create(LOCTEXT("ShowScriptExceptionError_BlueprintLabel", "Blueprint: ")));
                    Message->AddToken(FUObjectToken::Create(BlueprintObj, FText::FromString(BlueprintName)));
                }
                {
                    // If a source node is found, that's the token we want to link, otherwise settle with the UFunction
                    const int32 BreakpointOpCodeOffset = StackFrame.Code - StackFrame.Node->Script.GetData() - 1;  //@TODO: Might want to make this a parameter of Info
                    UEdGraphNode* SourceNode           = FindSourceNodeForCodeLocation(ActiveObject, StackFrame.Node, BreakpointOpCodeOffset, /*bAllowImpreciseHit=*/true);

                    Message->AddToken(FTextToken::Create(LOCTEXT("ShowScriptExceptionError_FunctionLabel", "Function: ")));
                    if (SourceNode)
                    {
                        Message->AddToken(FUObjectToken::Create(SourceNode, SourceNode->GetNodeTitle(ENodeTitleType::ListView)));
                    }
                    else
                    {
                        Message->AddToken(FUObjectToken::Create(StackFrame.Node, StackFrame.Node->GetDisplayNameText()));
                    }
                }

                // Display a pop-up that will display the complete script callstack
                Message->AddToken(FTextToken::Create(LOCTEXT("ShowScriptExceptionError_CallStackLabel", "Call Stack: ")));
                Message->AddToken(FActionToken::Create(LOCTEXT("ShowScriptExceptionError_ShowCallStack", "Show"), LOCTEXT("ShowScriptExceptionError_ShowCallStackDesc", "Displays the underlying callstack, tracing what function calls led to the assert occuring."), FOnActionTokenExecuted::CreateStatic(DisplayCallStackLambda, FText::FromString(StackFrame.GetStackTrace()))));
                FMessageLog("PIE").AddMessage(Message);
            }
        };

        // Extra cleanup after potential interactive handling
        switch (Info.GetType())
        {
            case EBlueprintExceptionType::FatalError:
                ShowScriptExceptionError(FText::Format(LOCTEXT("ShowScriptExceptionError_FatalErrorFmt", "Fatal error detected: \"{0}\"."), Info.GetDescription()));
                break;
            case EBlueprintExceptionType::InfiniteLoop:
                ShowScriptExceptionError(LOCTEXT("ShowScriptExceptionError_InfiniteLoop", "Infinite loop detected."));
                break;
            default:
                // Left empty intentionally
                break;
        }
    }
}

UClass* FKismetDebugUtilities::FindClassForNode(const UObject* Object, UFunction* Function)
{
    if (NULL != Function)
    {
        UClass* FunctionOwner = Function->GetOwnerClass();
        return FunctionOwner;
    }
    if (NULL != Object)
    {
        UClass* ObjClass = Object->GetClass();
        return ObjClass;
    }
    return NULL;
}

const TSimpleRingBuffer<FKismetTraceSample>& FKismetDebugUtilities::GetTraceStack()
{
    return FKismetDebugUtilitiesData::Get().TraceStackSamples;
}

UEdGraphNode* FKismetDebugUtilities::FindSourceNodeForCodeLocation(const UObject* Object, UFunction* Function, int32 DebugOpcodeOffset, bool bAllowImpreciseHit)
{
    if (Object != NULL)
    {
        // Find the blueprint that corresponds to the object
        if (UBlueprintGeneratedClass* Class = Cast<UBlueprintGeneratedClass>(FindClassForNode(Object, Function)))
        {
            return Class->GetDebugData().FindSourceNodeFromCodeLocation(Function, DebugOpcodeOffset, bAllowImpreciseHit);
        }
    }

    return NULL;
}

void FKismetDebugUtilities::CheckBreakConditions(UEdGraphNode* NodeStoppedAt, bool bHitBreakpoint, int32 BreakpointOffset, bool& InOutBreakExecution)
{
    FKismetDebugUtilitiesData& Data          = FKismetDebugUtilitiesData::Get();
    const TArray<const FFrame*>& ScriptStack = FBlueprintContextTracker::Get().GetScriptStack();

    if (NodeStoppedAt)
    {
        const bool bIsTryingToBreak = bHitBreakpoint ||
                                      Data.TargetGraphStackDepth != INDEX_NONE ||
                                      Data.bIsSingleStepping;

        if (bIsTryingToBreak)
        {
            // Update the TargetGraphStackDepth if we're on the same node - this handles things like
            // event nodes in the Event Graph, which will push another frame on to the stack:
            if (NodeStoppedAt == Data.MostRecentStoppedNode &&
                Data.MostRecentBreakpointGraphStackDepth < ScriptStack.Num() &&
                Data.TargetGraphStackDepth != INDEX_NONE)
            {
                // when we recurse, when a node increases stack depth itself we want to increase our
                // target depth to compensate:
                Data.TargetGraphStackDepth += 1;
            }
            else if (NodeStoppedAt != Data.MostRecentStoppedNode)
            {
                Data.MostRecentStoppedNode = nullptr;
            }

            // We should only actually break execution when we're on a new node or we've recursed to the same
            // node. We detect recursion by checking for a deeper stack and an earlier instruction:
            InOutBreakExecution =
                NodeStoppedAt != Data.MostRecentStoppedNode ||
                (Data.MostRecentBreakpointGraphStackDepth < ScriptStack.Num() &&
                 Data.MostRecentBreakpointInstructionOffset >= BreakpointOffset);

            // If we have a TargetGraphStackDepth, don't break if we haven't reached that stack depth, or if we've stepped
            // in to a collapsed graph/macro instance:
            if (InOutBreakExecution && Data.TargetGraphStackDepth != INDEX_NONE && !bHitBreakpoint)
            {
                InOutBreakExecution = Data.TargetGraphStackDepth >= ScriptStack.Num();
                if (InOutBreakExecution && Data.TargetGraphStackDepth == ScriptStack.Num())
                {
                    // we're at the same stack depth, don't break if we've entered a different graph, but do break if we left the
                    // graph that we were trying to step over..
                    const FFrame* CurrentFrame = ScriptStack.Last();
                    if (CurrentFrame->Object)
                    {
                        if (UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(CurrentFrame->Object->GetClass()))
                        {
                            UEdGraphNode* BlueprintNode = BPGC->DebugData.FindSourceNodeFromCodeLocation(CurrentFrame->Node, BreakpointOffset, true);
                            if (Data.TargetGraphNodes.Num() == 0 || Data.TargetGraphNodes.Contains(BlueprintNode))
                            {
                                InOutBreakExecution = true;
                            }
                            else
                            {
                                InOutBreakExecution = false;  // nowhere to stop
                            }
                        }
                        else
                        {
                            InOutBreakExecution = false;
                        }
                    }
                }
            }
        }
        else if (NodeStoppedAt != Data.MostRecentStoppedNode)
        {
            Data.MostRecentStoppedNode = nullptr;
        }
    }

    if (InOutBreakExecution)
    {
        Data.MostRecentStoppedNode                 = NodeStoppedAt;
        Data.MostRecentBreakpointGraphStackDepth   = ScriptStack.Num();
        Data.MostRecentBreakpointInstructionOffset = BreakpointOffset;
        Data.TargetGraphStackDepth                 = INDEX_NONE;
        Data.TargetGraphNodes.Empty();
        Data.bIsSteppingOut = false;
    }
    else if (Data.TargetGraphStackDepth != INDEX_NONE && Data.bIsSteppingOut)
    {
        UK2Node_Tunnel* AsTunnel = Cast<UK2Node_Tunnel>(NodeStoppedAt);
        if (AsTunnel)
        {
            // if we go through a tunnel entry/exit node update the target stack depth...
            if (AsTunnel->bCanHaveInputs)
            {
                Data.TargetGraphStackDepth += 1;
            }
            else if (AsTunnel->bCanHaveOutputs)
            {
                Data.TargetGraphStackDepth -= 1;
            }
        }
    }
}

void FKismetDebugUtilities::AttemptToBreakExecution(UBlueprint* BlueprintObj, const UObject* ActiveObject, const FFrame& StackFrame, const FBlueprintExceptionInfo& Info, UEdGraphNode* NodeStoppedAt, int32 DebugOpcodeOffset)
{
    checkSlow(BlueprintObj->GetObjectBeingDebugged() == ActiveObject);

    FKismetDebugUtilitiesData& Data = FKismetDebugUtilitiesData::Get();

    // Cannot have re-entrancy while processing a breakpoint; return from this call stack before resuming execution!
    check(!GIntraFrameDebuggingGameThread);

    TGuardValue<bool> SignalGameThreadBeingDebugged(GIntraFrameDebuggingGameThread, true);
    TGuardValue<const FFrame*> ResetStackFramePointer(Data.StackFrameAtIntraframeDebugging, &StackFrame);

    // Should we pump Slate messages from this callstack, allowing intra-frame debugging?
    bool bShouldInStackDebug = false;

    if (NodeStoppedAt != NULL)
    {
        bShouldInStackDebug                         = true;

        Data.CurrentInstructionPointer              = NodeStoppedAt;

        Data.MostRecentBreakpointInstructionPointer = NULL;

        // Find the breakpoint object for the node, assuming we hit one
        if (Info.GetType() == EBlueprintExceptionType::Breakpoint)
        {
            UBreakpoint* Breakpoint = FKismetDebugUtilities::FindBreakpointForNode(BlueprintObj, NodeStoppedAt);

            if (Breakpoint != NULL)
            {
                Data.MostRecentBreakpointInstructionPointer = NodeStoppedAt;
                FKismetDebugUtilities::UpdateBreakpointStateWhenHit(Breakpoint, BlueprintObj);

                //@TODO: K2: DEBUGGING: Debug print text can go eventually
                UE_LOG(LogBlueprintDebug, Warning, TEXT("Hit breakpoint on node '%s', from offset %d"), *(NodeStoppedAt->GetDescriptiveCompiledName()), DebugOpcodeOffset);
                UE_LOG(LogBlueprintDebug, Log, TEXT("\n%s"), *StackFrame.GetStackTrace());
            }
            else
            {
                UE_LOG(LogBlueprintDebug, Warning, TEXT("Unknown breakpoint hit at node %s in object %s:%04X"), *NodeStoppedAt->GetDescriptiveCompiledName(), *StackFrame.Node->GetFullName(), DebugOpcodeOffset);
            }
        }

        // Turn off single stepping; we've hit a node
        if (Data.bIsSingleStepping)
        {
            Data.bIsSingleStepping = false;
        }
    }
    else if (UEdGraphNode* PreviousNode = FKismetDebugUtilities::GetCurrentInstruction())
    {
        if (UK2Node_Message* MessageNode = Cast<UK2Node_Message>(PreviousNode))
        {
            // Looks like object not implement one of their interfaces
            UE_LOG(LogBlueprintDebug, Warning, TEXT("Can't break execution on function '%s'. Possibly interface '%s' in class '%s' was not fully implemented."),
                   *(PreviousNode->GetDocumentationExcerptName()),                    // Function name
                   *(MessageNode->GetTargetFunction()->GetOuterUClass()->GetName()),  // Interface name
                   *(ActiveObject->GetClass()->GetName()));                           // Current object class name
        }
        else
        {
            UE_LOG(LogBlueprintDebug, Warning, TEXT("Can't break execution on function '%s'. Possibly it was not implemented in class '%s'."),
                   *(PreviousNode->GetDocumentationExcerptName()),  // Function name
                   *(ActiveObject->GetClass()->GetName()));         // Current object class name
        }
    }
    else
    {
        UE_LOG(LogBlueprintDebug, Warning, TEXT("Tried to break execution in an unknown spot at object %s:%04X"), *StackFrame.Node->GetFullName(), StackFrame.Code - StackFrame.Node->Script.GetData());
    }

    // A check to !GIsAutomationTesting was removed from here as it seemed redundant.
    // Breakpoints have to be explicitly enabled by the user which shouldn't happen
    // under automation and this was preventing debugging on automation test bp's.
    if ((GUnrealEd->PlayWorld != NULL) && NodeStoppedAt)
    {
        // Pause the simulation
        GUnrealEd->PlayWorld->bDebugPauseExecution     = true;
        GUnrealEd->PlayWorld->bDebugFrameStepExecution = false;
        bShouldInStackDebug                            = true;
    }
    else
    {
        bShouldInStackDebug = false;
        //@TODO: Determine exactly what behavior we want for breakpoints hit when not in PIE/SIE
        // ensureMsgf(false, TEXT("Breakpoints placed in a function instead of the event graph are not supported yet"));
    }

    // Now enter within-the-frame debugging mode
    if (bShouldInStackDebug)
    {
        TGuardValue<int32> GuardDisablePIE(GPlayInEditorID, INDEX_NONE);
        const TArray<const FFrame*>& ScriptStack = FBlueprintContextTracker::Get().GetScriptStack();
        Data.LastExceptionMessage                = Info.GetDescription();
        FKismetEditorUtilities::BringKismetToFocusAttentionOnObject(NodeStoppedAt);
        CallStackViewer::UpdateDisplayedCallstack(ScriptStack);
        WatchViewer::UpdateInstancedWatchDisplay();
        FSlateApplication::Get().EnterDebuggingMode();
    }
}

UEdGraphNode* FKismetDebugUtilities::GetCurrentInstruction()
{
    // If paused at the end of the frame, or while not paused, there is no 'current instruction' to speak of
    // It only has meaning during intraframe debugging.
    if (GIntraFrameDebuggingGameThread)
    {
        return FKismetDebugUtilitiesData::Get().CurrentInstructionPointer.Get();
    }
    else
    {
        return NULL;
    }
}

UEdGraphNode* FKismetDebugUtilities::GetMostRecentBreakpointHit()
{
    // If paused at the end of the frame, or while not paused, there is no 'current instruction' to speak of
    // It only has meaning during intraframe debugging.
    if (GIntraFrameDebuggingGameThread)
    {
        return FKismetDebugUtilitiesData::Get().MostRecentBreakpointInstructionPointer.Get();
    }
    else
    {
        return NULL;
    }
}

// Notify the debugger of the start of the game frame
void FKismetDebugUtilities::NotifyDebuggerOfStartOfGameFrame(UWorld* CurrentWorld)
{
}

// Notify the debugger of the end of the game frame
void FKismetDebugUtilities::NotifyDebuggerOfEndOfGameFrame(UWorld* CurrentWorld)
{
    FKismetDebugUtilitiesData::Get().bIsSingleStepping = false;
}

bool FKismetDebugUtilities::IsSingleStepping()
{
    const FKismetDebugUtilitiesData& Data = FKismetDebugUtilitiesData::Get();
    return Data.bIsSingleStepping || Data.bIsSteppingOut || Data.TargetGraphStackDepth != INDEX_NONE;
}

//////////////////////////////////////////////////////////////////////////
// Breakpoint

// Is the node a valid breakpoint target? (i.e., the node is impure and ended up generating code)
bool FKismetDebugUtilities::IsBreakpointValid(UBreakpoint* Breakpoint)
{
    check(Breakpoint);

    // Breakpoints on impure nodes in a macro graph are always considered valid
    UBlueprint* Blueprint = Cast<UBlueprint>(Breakpoint->GetOuter());
    if (Blueprint && Blueprint->BlueprintType == BPTYPE_MacroLibrary)
    {
        UK2Node* K2Node = Cast<UK2Node>(Breakpoint->Node);
        if (K2Node)
        {
            return K2Node->IsA<UK2Node_MacroInstance>() || (!K2Node->IsNodePure() && !K2Node->IsA<UK2Node_Tunnel>());
        }
    }

    TArray<uint8*> InstallSites;
    FKismetDebugUtilities::GetBreakpointInstallationSites(Breakpoint, InstallSites);
    return InstallSites.Num() > 0;
}

// Set the node that the breakpoint should focus on
void FKismetDebugUtilities::SetBreakpointLocation(UBreakpoint* Breakpoint, UEdGraphNode* NewNode)
{
    if (NewNode != Breakpoint->Node)
    {
        // Uninstall it from the old site if needed
        FKismetDebugUtilities::SetBreakpointInternal(Breakpoint, false);

        // Make the new site accurate
        Breakpoint->Node = NewNode;
        FKismetDebugUtilities::SetBreakpointInternal(Breakpoint, Breakpoint->bEnabled);
    }
}

// Set or clear the enabled flag for the breakpoint
void FKismetDebugUtilities::SetBreakpointEnabled(UBreakpoint* Breakpoint, bool bIsEnabled)
{
    if (Breakpoint->bStepOnce && !bIsEnabled)
    {
        // Want to be disabled, but the single-stepping is keeping it enabled
        bIsEnabled                                  = true;
        Breakpoint->bStepOnce_WasPreviouslyDisabled = true;
    }

    Breakpoint->bEnabled = bIsEnabled;
    FKismetDebugUtilities::SetBreakpointInternal(Breakpoint, Breakpoint->bEnabled);
}

// Sets this breakpoint up as a single-step breakpoint (will disable or delete itself after one go if the breakpoint wasn't already enabled)
void FKismetDebugUtilities::SetBreakpointEnabledForSingleStep(UBreakpoint* Breakpoint, bool bDeleteAfterStep)
{
    Breakpoint->bStepOnce                       = true;
    Breakpoint->bStepOnce_RemoveAfterHit        = bDeleteAfterStep;
    Breakpoint->bStepOnce_WasPreviouslyDisabled = !Breakpoint->bEnabled;

    FKismetDebugUtilities::SetBreakpointEnabled(Breakpoint, true);
}

void FKismetDebugUtilities::ReapplyBreakpoint(UBreakpoint* Breakpoint)
{
    FKismetDebugUtilities::SetBreakpointInternal(Breakpoint, Breakpoint->IsEnabled());
}

void FKismetDebugUtilities::StartDeletingBreakpoint(UBreakpoint* Breakpoint, UBlueprint* OwnerBlueprint)
{
#if WITH_EDITORONLY_DATA
    checkSlow(OwnerBlueprint->Breakpoints.Contains(Breakpoint));
    OwnerBlueprint->Breakpoints.Remove(Breakpoint);
    OwnerBlueprint->MarkPackageDirty();

    FKismetDebugUtilities::SetBreakpointLocation(Breakpoint, NULL);
#endif  // #if WITH_EDITORONLY_DATA
}

// Update the internal state of the breakpoint when it got hit
void FKismetDebugUtilities::UpdateBreakpointStateWhenHit(UBreakpoint* Breakpoint, UBlueprint* OwnerBlueprint)
{
    // Handle single-step breakpoints
    if (Breakpoint->bStepOnce)
    {
        Breakpoint->bStepOnce = false;

        if (Breakpoint->bStepOnce_RemoveAfterHit)
        {
            FKismetDebugUtilities::StartDeletingBreakpoint(Breakpoint, OwnerBlueprint);
        }
        else if (Breakpoint->bStepOnce_WasPreviouslyDisabled)
        {
            FKismetDebugUtilities::SetBreakpointEnabled(Breakpoint, false);
        }
    }
}

// Install/uninstall the breakpoint into/from the script code for the generated class that contains the node
void FKismetDebugUtilities::SetBreakpointInternal(UBreakpoint* Breakpoint, bool bShouldBeEnabled)
{
    TArray<uint8*> InstallSites;
    FKismetDebugUtilities::GetBreakpointInstallationSites(Breakpoint, InstallSites);

    for (int i = 0; i < InstallSites.Num(); ++i)
    {
        if (uint8* InstallSite = InstallSites[i])
        {
            *InstallSite = bShouldBeEnabled ? EX_Breakpoint : EX_Tracepoint;
        }
    }
}

// Returns the installation site(s); don't cache these pointers!
void FKismetDebugUtilities::GetBreakpointInstallationSites(UBreakpoint* Breakpoint, TArray<uint8*>& InstallSites)
{
    InstallSites.Empty();

#if WITH_EDITORONLY_DATA
    if (Breakpoint->Node != NULL)
    {
        UBlueprint* Blueprint = FBlueprintEditorUtils::FindBlueprintForNode(Breakpoint->Node);

        if ((Blueprint != NULL) && (Blueprint->GeneratedClass != NULL))
        {
            if (UBlueprintGeneratedClass* Class = Cast<UBlueprintGeneratedClass>(*Blueprint->GeneratedClass))
            {
                // Find the insertion point from the debugging data
                Class->GetDebugData().FindBreakpointInjectionSites(Breakpoint->Node, InstallSites);
            }
        }
    }
#endif  // #if WITH_EDITORONLY_DATA
}

// Returns the set of valid breakpoint locations for the given macro instance node
void FKismetDebugUtilities::GetValidBreakpointLocations(const UK2Node_MacroInstance* MacroInstanceNode, TArray<const UEdGraphNode*>& BreakpointLocations)
{
    check(MacroInstanceNode);
    BreakpointLocations.Empty();

    // Gather information from the macro graph associated with the macro instance node
    bool bIsMacroPure                = false;
    UK2Node_Tunnel* MacroEntryNode   = NULL;
    UK2Node_Tunnel* MacroResultNode  = NULL;
    UEdGraph* InstanceNodeMacroGraph = MacroInstanceNode->GetMacroGraph();
    if (ensure(InstanceNodeMacroGraph != nullptr))
    {
        FKismetEditorUtilities::GetInformationOnMacro(InstanceNodeMacroGraph, MacroEntryNode, MacroResultNode, bIsMacroPure);
    }
    if (!bIsMacroPure && MacroEntryNode)
    {
        // Get the execute pin outputs on the entry node
        for (const UEdGraphPin* ExecPin: MacroEntryNode->Pins)
        {
            if (ExecPin && ExecPin->Direction == EGPD_Output && ExecPin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec)
            {
                // For each pin linked to each execute pin, collect the node that owns it
                for (const UEdGraphPin* LinkedToPin: ExecPin->LinkedTo)
                {
                    check(LinkedToPin);

                    const UEdGraphNode* LinkedToNode = LinkedToPin->GetOwningNode();
                    check(LinkedToNode);

                    if (LinkedToNode->IsA<UK2Node_MacroInstance>())
                    {
                        // Recursively descend into macro instance nodes encountered in a macro graph
                        TArray<const UEdGraphNode*> SubLocations;
                        GetValidBreakpointLocations(Cast<const UK2Node_MacroInstance>(LinkedToNode), SubLocations);
                        BreakpointLocations.Append(SubLocations);
                    }
                    else
                    {
                        BreakpointLocations.AddUnique(LinkedToNode);
                    }
                }
            }
        }
    }
}

// Finds a breakpoint for a given node if it exists, or returns NULL
UBreakpoint* FKismetDebugUtilities::FindBreakpointForNode(UBlueprint* Blueprint, const UEdGraphNode* Node, bool bCheckSubLocations)
{
    // iterate backwards so we can remove invalid breakpoints as we go
    for (int32 Index = Blueprint->Breakpoints.Num() - 1; Index >= 0; --Index)
    {
        UBreakpoint* Breakpoint = Blueprint->Breakpoints[Index];
        if (Breakpoint == nullptr)
        {
            Blueprint->Breakpoints.RemoveAtSwap(Index);
            Blueprint->MarkPackageDirty();
            UE_LOG(LogBlueprintDebug, Warning, TEXT("Encountered an invalid blueprint breakpoint in %s (this should not happen... if you know how your blueprint got in this state, then please notify the Engine-Blueprints team)"), *Blueprint->GetPathName());
            continue;
        }

        const UEdGraphNode* BreakpointLocation = Breakpoint->GetLocation();
        if (BreakpointLocation == nullptr)
        {
            Blueprint->Breakpoints.RemoveAtSwap(Index);
            Blueprint->MarkPackageDirty();
            UE_LOG(LogBlueprintDebug, Display, TEXT("Encountered a blueprint breakpoint in %s without an associated node. The blueprint breakpoint has been removed"), *Blueprint->GetPathName());
            continue;
        }

        // Return this breakpoint if the location matches the given node
        if (BreakpointLocation == Node)
        {
            return Breakpoint;
        }
        else if (bCheckSubLocations)
        {
            // If this breakpoint is set on a macro instance node, check the set of valid breakpoint locations. If we find a
            // match in the returned set, return the breakpoint that's set on the macro instance node. This allows breakpoints
            // to be set and hit on macro instance nodes contained in a macro graph that will be expanded during compile.
            const UK2Node_MacroInstance* MacroInstanceNode = Cast<UK2Node_MacroInstance>(BreakpointLocation);
            if (MacroInstanceNode)
            {
                TArray<const UEdGraphNode*> ValidBreakpointLocations;
                GetValidBreakpointLocations(MacroInstanceNode, ValidBreakpointLocations);
                if (ValidBreakpointLocations.Contains(Node))
                {
                    return Breakpoint;
                }
            }
        }
    }

    return NULL;
}

bool FKismetDebugUtilities::HasDebuggingData(const UBlueprint* Blueprint)
{
    return Cast<UBlueprintGeneratedClass>(*Blueprint->GeneratedClass)->GetDebugData().IsValid();
}

//////////////////////////////////////////////////////////////////////////
// Blueprint utils

// Looks thru the debugging data for any class variables associated with the node
FProperty* FKismetDebugUtilities::FindClassPropertyForPin(UBlueprint* Blueprint, const UEdGraphPin* Pin)
{
    FProperty* FoundProperty = nullptr;

    UClass* Class            = Blueprint->GeneratedClass;
    while (UBlueprintGeneratedClass* BlueprintClass = Cast<UBlueprintGeneratedClass>(Class))
    {
        FoundProperty = BlueprintClass->GetDebugData().FindClassPropertyForPin(Pin);
        if (FoundProperty != nullptr)
        {
            break;
        }

        Class = BlueprintClass->GetSuperClass();
    }

    return FoundProperty;
}

// Looks thru the debugging data for any class variables associated with the node (e.g., temporary variables or timelines)
FProperty* FKismetDebugUtilities::FindClassPropertyForNode(UBlueprint* Blueprint, const UEdGraphNode* Node)
{
    if (UBlueprintGeneratedClass* Class = Cast<UBlueprintGeneratedClass>(*Blueprint->GeneratedClass))
    {
        return Class->GetDebugData().FindClassPropertyForNode(Node);
    }

    return NULL;
}

void FKismetDebugUtilities::ClearBreakpoints(UBlueprint* Blueprint)
{
    for (int32 BreakpointIndex = 0; BreakpointIndex < Blueprint->Breakpoints.Num(); ++BreakpointIndex)
    {
        UBreakpoint* Breakpoint = Blueprint->Breakpoints[BreakpointIndex];
        FKismetDebugUtilities::SetBreakpointLocation(Breakpoint, NULL);
    }

    Blueprint->Breakpoints.Empty();
    Blueprint->MarkPackageDirty();
}

FKismetDebugUtilities::FOnWatchedPinsListChanged FKismetDebugUtilities::WatchedPinsListChangedEvent;

bool FKismetDebugUtilities::CanWatchPin(const UBlueprint* Blueprint, const UEdGraphPin* Pin)
{
    // Forward to schema
    if (const UEdGraphNode* Node = Pin->GetOwningNode())
    {
        if (const UAnimationGraphSchema* AnimationGraphSchema = Cast<UAnimationGraphSchema>(Node->GetSchema()))
        {
            // Anim graphs need to respect whether they have a binding as they are effectively unlinked
            bool bHasBinding = false;

            if (UAnimGraphNode_Base* AnimGraphNode = Cast<UAnimGraphNode_Base>(Pin->GetOwningNode()))
            {
                // Compare FName without number to make sure we catch array properties that are split into multiple pins
                FName ComparisonName = Pin->GetFName();
                ComparisonName.SetNumber(0);

                if (FAnimGraphNodePropertyBinding* BindingPtr = AnimGraphNode->PropertyBindings.Find(ComparisonName))
                {
                    bHasBinding = true;
                }
            }

            UEdGraph* Graph = Pin->GetOwningNode()->GetGraph();

            // We allow input pins to be watched only if they have bindings, otherwise we need to follow to output pins
            const bool bNotAnInputOrBound = (Pin->Direction != EGPD_Input) || bHasBinding;

            return !AnimationGraphSchema->IsMetaPin(*Pin) && bNotAnInputOrBound && !IsPinBeingWatched(Blueprint, Pin);
        }
        else if (const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(Node->GetSchema()))
        {
            UEdGraph* Graph = Pin->GetOwningNode()->GetGraph();

            // Inputs should always be followed to their corresponding output in the world above
            const bool bNotAnInput = (Pin->Direction != EGPD_Input);

            //@TODO: Make watching a schema-allowable/denyable thing
            const bool bCanWatchThisGraph = true;

            return bCanWatchThisGraph && !K2Schema->IsMetaPin(*Pin) && bNotAnInput && !IsPinBeingWatched(Blueprint, Pin);
        }
    }

    return false;
}

bool FKismetDebugUtilities::IsPinBeingWatched(const UBlueprint* Blueprint, const UEdGraphPin* Pin)
{
    return Blueprint->WatchedPins.Contains(const_cast<UEdGraphPin*>(Pin));
}

void FKismetDebugUtilities::RemovePinWatch(UBlueprint* Blueprint, const UEdGraphPin* Pin)
{
    UEdGraphPin* NonConstPin = const_cast<UEdGraphPin*>(Pin);
    Blueprint->WatchedPins.Remove(NonConstPin);
    Blueprint->MarkPackageDirty();
    Blueprint->PostEditChange();
    WatchedPinsListChangedEvent.Broadcast(Blueprint);
}

void FKismetDebugUtilities::TogglePinWatch(UBlueprint* Blueprint, const UEdGraphPin* Pin)
{
    int32 ExistingWatchIndex = Blueprint->WatchedPins.Find(const_cast<UEdGraphPin*>(Pin));

    if (ExistingWatchIndex != INDEX_NONE)
    {
        FKismetDebugUtilities::RemovePinWatch(Blueprint, Pin);
    }
    else
    {
        Blueprint->WatchedPins.Add(const_cast<UEdGraphPin*>(Pin));
        Blueprint->MarkPackageDirty();
        Blueprint->PostEditChange();
    }

    WatchedPinsListChangedEvent.Broadcast(Blueprint);
}

void FKismetDebugUtilities::ClearPinWatches(UBlueprint* Blueprint)
{
    Blueprint->WatchedPins.Empty();
    Blueprint->MarkPackageDirty();
    Blueprint->PostEditChange();

    WatchedPinsListChangedEvent.Broadcast(Blueprint);
}

// Gets the watched tooltip for a specified site
FKismetDebugUtilities::EWatchTextResult FKismetDebugUtilities::GetWatchText(FString& OutWatchText, UBlueprint* Blueprint, UObject* ActiveObject, const UEdGraphPin* WatchPin)
{
    FProperty* PropertyToDebug     = nullptr;
    void* DataPtr                  = nullptr;
    void* DeltaPtr                 = nullptr;
    UObject* ParentObj             = nullptr;
    bool bShouldUseContainerOffset = false;
    TArray<UObject*> SeenObjects;
    FKismetDebugUtilities::EWatchTextResult Result = FindDebuggingData(Blueprint, ActiveObject, WatchPin, PropertyToDebug, DataPtr, DeltaPtr, ParentObj, SeenObjects, &bShouldUseContainerOffset);

    if (Result == FKismetDebugUtilities::EWatchTextResult::EWTR_Valid)
    {
        // If this came from an array property we need to avoid using ExportText_InContainer in order to properly
        // calculate the internal offset
        if (bShouldUseContainerOffset)
        {
            PropertyToDebug->ExportText_Direct(/*inout*/ OutWatchText, DataPtr, DeltaPtr, ParentObj, PPF_PropertyWindow | PPF_BlueprintDebugView);
        }
        else
        {
            PropertyToDebug->ExportText_InContainer(/*ArrayElement=*/0, /*inout*/ OutWatchText, DataPtr, DeltaPtr, /*Parent=*/ParentObj, PPF_PropertyWindow | PPF_BlueprintDebugView);
        }
    }

    return Result;
}

FKismetDebugUtilities::EWatchTextResult FKismetDebugUtilities::GetDebugInfo(FDebugInfo& OutDebugInfo, UBlueprint* Blueprint, UObject* ActiveObject, const UEdGraphPin* WatchPin)
{
    FProperty* PropertyToDebug = nullptr;
    void* DataPtr              = nullptr;
    void* DeltaPtr             = nullptr;
    UObject* ParentObj         = nullptr;
    TArray<UObject*> SeenObjects;
    FKismetDebugUtilities::EWatchTextResult Result = FindDebuggingData(Blueprint, ActiveObject, WatchPin, PropertyToDebug, DataPtr, DeltaPtr, ParentObj, SeenObjects);

    if (Result == FKismetDebugUtilities::EWatchTextResult::EWTR_Valid)
    {
        GetDebugInfo_InContainer(0, OutDebugInfo, PropertyToDebug, DataPtr);
    }

    return Result;
}

FKismetDebugUtilities::EWatchTextResult FKismetDebugUtilities::FindDebuggingData(UBlueprint* Blueprint, UObject* ActiveObject, const UEdGraphPin* WatchPin, FProperty*& OutProperty, void*& OutData, void*& OutDelta, UObject*& OutParent, TArray<UObject*>& SeenObjects, bool* OutbShouldUseContainerOffset /* = nullptr */)
{
    FKismetDebugUtilitiesData& Data = FKismetDebugUtilitiesData::Get();

    if (FProperty* Property = FKismetDebugUtilities::FindClassPropertyForPin(Blueprint, WatchPin))
    {
        if (!Property->IsValidLowLevel())
        {
            //@TODO: Temporary checks to attempt to determine intermittent unreproducable crashes in this function
            static bool bErrorOnce = true;
            if (bErrorOnce)
            {
                ensureMsgf(false, TEXT("Error: Invalid (but non-null) property associated with pin; cannot get variable value"));
                bErrorOnce = false;
            }
            return EWTR_NoProperty;
        }

        if (ActiveObject != nullptr)
        {
            if (!ActiveObject->IsValidLowLevel())
            {
                //@TODO: Temporary checks to attempt to determine intermittent unreproducable crashes in this function
                static bool bErrorOnce = true;
                if (bErrorOnce)
                {
                    ensureMsgf(false, TEXT("Error: Invalid (but non-null) active object being debugged; cannot get variable value for property %s"), *Property->GetPathName());
                    bErrorOnce = false;
                }
                return EWTR_NoDebugObject;
            }

            void* PropertyBase = nullptr;

            // Walk up the stack frame to see if we can find a function scope that contains the property as a local
            for (const FFrame* TestFrame = Data.StackFrameAtIntraframeDebugging; TestFrame != NULL; TestFrame = TestFrame->PreviousFrame)
            {
                if (Property->IsIn(TestFrame->Node))
                {
                    // output parameters need special handling
                    for (FOutParmRec* OutParmRec = TestFrame->OutParms; OutParmRec != nullptr; OutParmRec = OutParmRec->NextOutParm)
                    {
                        if (OutParmRec->Property == Property)
                        {
                            if (WatchPin->Direction == EEdGraphPinDirection::EGPD_Input)
                            {
                                // try to use the output pin we're linked to
                                // otherwise the output param won't show any data since the return node hasn't executed when we stop here
                                if (WatchPin->LinkedTo.Num() == 1)
                                {
                                    return FindDebuggingData(Blueprint, ActiveObject, WatchPin->LinkedTo[0], OutProperty, OutData, OutDelta, OutParent, SeenObjects, OutbShouldUseContainerOffset);
                                }
                                else if (!WatchPin->LinkedTo.Num())
                                {
                                    // If this is an output pin with no links, then we have no debug data
                                    // so fallback to the local stack frame
                                    PropertyBase = TestFrame->Locals;
                                }
                            }

                            // If this is an out container property then a different offset must be used when exporting this property
                            // to text. Only container properties are effected by this because ExportText_InContainer adds an extra
                            // 8 byte offset, which  would point to the container's first element, not the container itself.
                            const bool bIsContainer = OutParmRec->Property->IsA<FArrayProperty>() || OutParmRec->Property->IsA<FSetProperty>() || OutParmRec->Property->IsA<FMapProperty>();
                            if (PropertyBase == nullptr && OutbShouldUseContainerOffset && bIsContainer)
                            {
                                *OutbShouldUseContainerOffset = true;
                                PropertyBase                  = OutParmRec->PropAddr;
                            }
                            break;
                        }
                    }

                    // Fallback to the local variables if we couldn't find one
                    if (PropertyBase == nullptr)
                    {
                        PropertyBase = TestFrame->Locals;
                    }
                    break;
                }
            }

            // Try at member scope if it wasn't part of a current function scope
            UClass* PropertyClass = Property->GetOwner<UClass>();
            if (!PropertyBase && PropertyClass)
            {
                if (ActiveObject->GetClass()->IsChildOf(PropertyClass))
                {
                    PropertyBase = ActiveObject;
                }
                else if (AActor* Actor = Cast<AActor>(ActiveObject))
                {
                    // Try and locate the propertybase in the actor components
                    for (UActorComponent* ComponentIter: Actor->GetComponents())
                    {
                        if (ComponentIter->GetClass()->IsChildOf(PropertyClass))
                        {
                            PropertyBase = ComponentIter;
                            break;
                        }
                    }
                }
            }
#if USE_UBER_GRAPH_PERSISTENT_FRAME
            // Try find the propertybase in the persistent ubergraph frame
            UFunction* OuterFunction = Property->GetOwner<UFunction>();
            if (!PropertyBase && OuterFunction)
            {
                UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(Blueprint->GeneratedClass);
                if (BPGC && ActiveObject->IsA(BPGC))
                {
                    PropertyBase = BPGC->GetPersistentUberGraphFrame(ActiveObject, OuterFunction);
                }
            }
#endif  // USE_UBER_GRAPH_PERSISTENT_FRAME

            // see if our WatchPin is on a animation node & if so try to get its property info
            UAnimBlueprintGeneratedClass* AnimBlueprintGeneratedClass = Cast<UAnimBlueprintGeneratedClass>(Blueprint->GeneratedClass);
            if (!PropertyBase && AnimBlueprintGeneratedClass)
            {
                // are we linked to an anim graph node?
                FProperty* LinkedProperty       = Property;
                const UAnimGraphNode_Base* Node = Cast<UAnimGraphNode_Base>(WatchPin->GetOuter());
                if (Node == nullptr && WatchPin->LinkedTo.Num() > 0)
                {
                    const UEdGraphPin* LinkedPin = WatchPin->LinkedTo[0];
                    // When we change Node we *must* change Property, so it's still a sub-element of that.
                    LinkedProperty = FKismetDebugUtilities::FindClassPropertyForPin(Blueprint, LinkedPin);
                    Node           = Cast<UAnimGraphNode_Base>(LinkedPin->GetOuter());
                }

                if (Node && LinkedProperty)
                {
                    FStructProperty* NodeStructProperty = CastField<FStructProperty>(FKismetDebugUtilities::FindClassPropertyForNode(Blueprint, Node));
                    if (NodeStructProperty)
                    {
                        for (const FStructPropertyPath& NodeProperty: AnimBlueprintGeneratedClass->GetAnimNodeProperties())
                        {
                            if (NodeProperty.Get() == NodeStructProperty)
                            {
                                void* NodePtr = NodeProperty->ContainerPtrToValuePtr<void>(ActiveObject);
                                OutProperty   = LinkedProperty;
                                OutData       = NodePtr;
                                OutDelta      = NodePtr;
                                OutParent     = ActiveObject;
                                return EWTR_Valid;
                            }
                        }
                    }
                }
            }

            // If we still haven't found a result, try changing the active object to whatever is passed into the self pin.
            if (!PropertyBase)
            {
                UEdGraphNode* WatchNode = WatchPin->GetOwningNode();

                if (WatchNode)
                {
                    UEdGraphPin* SelfPin = WatchNode->FindPin(TEXT("self"));
                    if (SelfPin && SelfPin != WatchPin)
                    {
                        FProperty* SelfPinProperty = nullptr;
                        void* SelfPinData          = nullptr;
                        void* SelfPinDelta         = nullptr;
                        UObject* SelfPinParent     = nullptr;
                        SeenObjects.AddUnique(ActiveObject);
                        FKismetDebugUtilities::EWatchTextResult Result = FindDebuggingData(Blueprint, ActiveObject, SelfPin, SelfPinProperty, SelfPinData, SelfPinDelta, SelfPinParent, SeenObjects);
                        FObjectPropertyBase* SelfPinPropertyBase       = CastField<FObjectPropertyBase>(SelfPinProperty);
                        if (Result == EWTR_Valid && SelfPinPropertyBase != nullptr)
                        {
                            void* PropertyValue       = SelfPinProperty->ContainerPtrToValuePtr<void>(SelfPinData);
                            UObject* TempActiveObject = SelfPinPropertyBase->GetObjectPropertyValue(PropertyValue);
                            if (TempActiveObject && TempActiveObject != ActiveObject)
                            {
                                if (!SeenObjects.Contains(TempActiveObject))
                                {
                                    return FindDebuggingData(Blueprint, TempActiveObject, WatchPin, OutProperty, OutData, OutDelta, OutParent, SeenObjects);
                                }
                            }
                        }
                    }
                }
            }

            // Now either print out the variable value, or that it was out-of-scope
            if (PropertyBase != nullptr)
            {
                OutProperty = Property;
                OutData     = PropertyBase;
                OutDelta    = PropertyBase;
                OutParent   = ActiveObject;
                return EWTR_Valid;
            }
            else
            {
                return EWTR_NotInScope;
            }
        }
        else
        {
            return EWTR_NoDebugObject;
        }
    }
    else
    {
        return EWTR_NoProperty;
    }
}

void FKismetDebugUtilities::GetDebugInfo_InContainer(int32 Index, FDebugInfo& DebugInfo, FProperty* Property, const void* Data)
{
    GetDebugInfoInternal(DebugInfo, Property, Property->ContainerPtrToValuePtr<void>(Data, Index));
}

void FKismetDebugUtilities::GetDebugInfoInternal(FDebugInfo& DebugInfo, FProperty* Property, const void* PropertyValue)
{
    if (Property == nullptr)
    {
        return;
    }

    DebugInfo.Type              = UEdGraphSchema_K2::TypeToText(Property);
    DebugInfo.DisplayName       = Property->GetDisplayNameText();

    FByteProperty* ByteProperty = CastField<FByteProperty>(Property);
    if (ByteProperty)
    {
        UEnum* Enum = ByteProperty->GetIntPropertyEnum();
        if (Enum)
        {
            if (Enum->IsValidEnumValue(*(const uint8*)PropertyValue))
            {
                DebugInfo.Value = Enum->GetDisplayNameTextByValue(*(const uint8*)PropertyValue);
            }
            else
            {
                DebugInfo.Value = FText::FromString(TEXT("(INVALID)"));
            }

            return;
        }

        // if there is no Enum we need to fall through and treat this as a FNumericProperty
    }

    FNumericProperty* NumericProperty = CastField<FNumericProperty>(Property);
    if (NumericProperty)
    {
        DebugInfo.Value = FText::FromString(NumericProperty->GetNumericPropertyValueToString(PropertyValue));
        return;
    }

    FBoolProperty* BoolProperty = CastField<FBoolProperty>(Property);
    if (BoolProperty)
    {
        const FCoreTexts& CoreTexts = FCoreTexts::Get();

        DebugInfo.Value             = BoolProperty->GetPropertyValue(PropertyValue) ? CoreTexts.True : CoreTexts.False;
        return;
    }

    FNameProperty* NameProperty = CastField<FNameProperty>(Property);
    if (NameProperty)
    {
        DebugInfo.Value = FText::FromName(*(FName*)PropertyValue);
        return;
    }

    FTextProperty* TextProperty = CastField<FTextProperty>(Property);
    if (TextProperty)
    {
        DebugInfo.Value = TextProperty->GetPropertyValue(PropertyValue);
        return;
    }

    FStrProperty* StringProperty = CastField<FStrProperty>(Property);
    if (StringProperty)
    {
        DebugInfo.Value = FText::FromString(StringProperty->GetPropertyValue(PropertyValue));
        return;
    }

    FArrayProperty* ArrayProperty = CastField<FArrayProperty>(Property);
    if (ArrayProperty)
    {
        checkSlow(ArrayProperty->Inner);

        FScriptArrayHelper ArrayHelper(ArrayProperty, PropertyValue);

        DebugInfo.Value = FText::Format(LOCTEXT("ArraySize", "Num={0}"), FText::AsNumber(ArrayHelper.Num()));

        for (int32 i = 0; i < ArrayHelper.Num(); i++)
        {
            FDebugInfo ArrayDebugInfo;

            uint8* PropData = ArrayHelper.GetRawPtr(i);
            GetDebugInfoInternal(ArrayDebugInfo, ArrayProperty->Inner, PropData);
            // overwrite the display name with the array index for the current element
            ArrayDebugInfo.DisplayName = FText::Format(LOCTEXT("ArrayIndexName", "[{0}]"), FText::AsNumber(i));
            DebugInfo.Children.Add(ArrayDebugInfo);
        }

        return;
    }

    FStructProperty* StructProperty = CastField<FStructProperty>(Property);
    if (StructProperty)
    {
        FString WatchText;
        StructProperty->ExportTextItem(WatchText, PropertyValue, PropertyValue, nullptr, PPF_PropertyWindow | PPF_BlueprintDebugView, nullptr);
        DebugInfo.Value = FText::FromString(WatchText);

        for (TFieldIterator<FProperty> It(StructProperty->Struct); It; ++It)
        {
            FDebugInfo StructDebugInfo;
            GetDebugInfoInternal(StructDebugInfo, *It, It->ContainerPtrToValuePtr<void>(PropertyValue, 0));

            DebugInfo.Children.Add(StructDebugInfo);
        }

        return;
    }

    FEnumProperty* EnumProperty = CastField<FEnumProperty>(Property);
    if (EnumProperty)
    {
        FNumericProperty* LocalUnderlyingProp = EnumProperty->GetUnderlyingProperty();
        UEnum* Enum                           = EnumProperty->GetEnum();

        int64 Value                           = LocalUnderlyingProp->GetSignedIntPropertyValue(PropertyValue);

        // if the value is the max value (the autogenerated *_MAX value), export as "INVALID", unless we're exporting text for copy/paste (for copy/paste,
        // the property text value must actually match an entry in the enum's names array)
        if (Enum)
        {
            if (Enum->IsValidEnumValue(Value))
            {
                DebugInfo.Value = Enum->GetDisplayNameTextByValue(Value);
            }
            else
            {
                DebugInfo.Value = LOCTEXT("Invalid", "(INVALID)");
            }
        }
        else
        {
            DebugInfo.Value = FText::AsNumber(Value);
        }

        return;
    }

    FMapProperty* MapProperty = CastField<FMapProperty>(Property);
    if (MapProperty)
    {
        FScriptMapHelper MapHelper(MapProperty, PropertyValue);
        DebugInfo.Value = FText::Format(LOCTEXT("MapSize", "Num={0}"), FText::AsNumber(MapHelper.Num()));
        uint8* PropData = MapHelper.GetPairPtr(0);

        int32 Index     = 0;
        for (int32 Count = MapHelper.Num(); Count; PropData += MapProperty->MapLayout.SetLayout.Size, ++Index)
        {
            if (MapHelper.IsValidIndex(Index))
            {
                FDebugInfo ChildInfo;

                GetDebugInfoInternal(ChildInfo, MapProperty->ValueProp, PropData + MapProperty->MapLayout.ValueOffset);

                // use the info from the ValueProp and then overwrite the name with the KeyProp data
                FString NameStr = TEXT("[");
                MapProperty->KeyProp->ExportTextItem(NameStr, PropData, nullptr, nullptr, PPF_PropertyWindow | PPF_BlueprintDebugView | PPF_Delimited, nullptr);
                NameStr += TEXT("] ");

                ChildInfo.DisplayName = FText::FromString(NameStr);

                DebugInfo.Children.Add(ChildInfo);

                --Count;
            }
        }

        return;
    }

    FSetProperty* SetProperty = CastField<FSetProperty>(Property);
    if (SetProperty)
    {
        FScriptSetHelper SetHelper(SetProperty, PropertyValue);
        DebugInfo.Value = FText::Format(LOCTEXT("SetSize", "Num={0}"), FText::AsNumber(SetHelper.Num()));
        uint8* PropData = SetHelper.GetElementPtr(0);

        int32 Index     = 0;
        for (int32 Count = SetHelper.Num(); Count; PropData += SetProperty->SetLayout.Size, ++Index)
        {
            if (SetHelper.IsValidIndex(Index))
            {
                FDebugInfo ChildInfo;
                GetDebugInfoInternal(ChildInfo, SetProperty->ElementProp, PropData);

                // members of sets don't have their own names
                ChildInfo.DisplayName = FText::GetEmpty();

                DebugInfo.Children.Add(ChildInfo);

                --Count;
            }
        }

        return;
    }

    FObjectPropertyBase* ObjectPropertyBase = CastField<FObjectPropertyBase>(Property);
    if (ObjectPropertyBase)
    {
        UObject* Obj = ObjectPropertyBase->GetObjectPropertyValue(PropertyValue);
        if (Obj != nullptr)
        {
            DebugInfo.Value = FText::FromString(Obj->GetFullName());
        }
        else
        {
            DebugInfo.Value = FText::FromString(TEXT("None"));
        }

        return;
    }

    FDelegateProperty* DelegateProperty = CastField<FDelegateProperty>(Property);
    if (DelegateProperty)
    {
        if (DelegateProperty->SignatureFunction)
        {
            DebugInfo.Value = DelegateProperty->SignatureFunction->GetDisplayNameText();
        }
        else
        {
            DebugInfo.Value = LOCTEXT("NoFunc", "(No bound function)");
        }

        return;
    }

    FMulticastDelegateProperty* MulticastDelegateProperty = CastField<FMulticastDelegateProperty>(Property);
    if (MulticastDelegateProperty)
    {
        if (MulticastDelegateProperty->SignatureFunction)
        {
            DebugInfo.Value = MulticastDelegateProperty->SignatureFunction->GetDisplayNameText();
        }
        else
        {
            DebugInfo.Value = LOCTEXT("NoFunc", "(No bound function)");
        }

        return;
    }

    ensure(false);
}

FText FKismetDebugUtilities::GetAndClearLastExceptionMessage()
{
    FKismetDebugUtilitiesData& Data = FKismetDebugUtilitiesData::Get();
    const FText Result              = Data.LastExceptionMessage;
    Data.LastExceptionMessage       = FText();
    return Result;
}

#undef LOCTEXT_NAMESPACE