NodeGraphPanel.cpp

Go to the documentation of this file.

/*
 * Olympe Blueprint Editor - Node Graph Panel Implementation
 */
 
#include "NodeGraphPanel.h"
#include "BlueprintEditor.h"
#include "InspectorPanel.h"
#include "AtomicTaskUIRegistry.h"
#include "Clipboard.h"
#include "EditorContext.h"
#include "EntityInspectorManager.h"
#include "BTNodeGraphManager.h"
#include "EnumCatalogManager.h"
#include "BPCommandSystem.h"
#include "NodeStyleRegistry.h"
#include "../system/system_consts.h"
#include "../TaskSystem/AtomicTaskRegistry.h"
#include "../TaskSystem/TaskGraphTypes.h"
#include "../third_party/imgui/imgui.h"
#include "../third_party/imnodes/imnodes.h"
#include <iostream>
#include <vector>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <cctype>
#include <memory>
#include "../NodeGraphShared/BlueprintAdapter.h"
 
// Use Blueprint namespace for command classes
using namespace Olympe::Blueprint;
 
namespace
{
    // UID generation constants for ImNodes
    // These ensure unique IDs across multiple open graphs
    constexpr int GRAPH_ID_MULTIPLIER = 10000;     // Multiplier for graph ID in node UID calculation
    constexpr int ATTR_ID_MULTIPLIER = 100;        // Multiplier for node UID in attribute UID calculation
    constexpr int LINK_ID_MULTIPLIER = 100000;     // Multiplier for graph ID in link UID calculation
 
    // Helper function to convert screen space coordinates to grid space coordinates
    // Screen space: origin at upper-left corner of the window
    // Grid space: origin at upper-left corner of the node editor, adjusted by panning
    ImVec2 ScreenSpaceToGridSpace(const ImVec2& screenPos)
    {
        // Get the editor's screen space position
        ImVec2 editorPos = ImGui::GetCursorScreenPos();
        
        // Get the current panning offset
        ImVec2 panning = ImNodes::EditorContextGetPanning();
        
        // Convert: subtract editor position to get editor space, then subtract panning to get grid space
        return ImVec2(screenPos.x - editorPos.x - panning.x, 
                      screenPos.y - editorPos.y - panning.y);
    }
}
 
namespace Olympe
{
 
// ============================================================================
// Static member definitions
// ============================================================================
 
int NodeGraphPanel::s_ActiveDebugNodeId = -1;
 
// ============================================================================
// SetActiveDebugNode
// ============================================================================
 
void NodeGraphPanel::SetActiveDebugNode(int localNodeId)
{
    s_ActiveDebugNodeId = localNodeId;
}
 
    NodeGraphPanel::NodeGraphPanel()
    {
        m_NodeNameBuffer[0] = '\0';
        m_ContextMenuSearch[0] = '\0';
        m_NewSubgraphNameBuffer[0] = '\0';
 
        // Phase 8: seed the tab list with the root graph tab.
        m_SubgraphTabs.emplace_back("root", "Root", "root");
        m_ActiveSubgraphTabIndex = 0;
    }
 
    NodeGraphPanel::~NodeGraphPanel()
    {
    }
 
    void NodeGraphPanel::Initialize()
     {
         std::cout << "[NodeGraphPanel] Initialized\n";
 
         // Phase 35.0: Create dedicated imnodes context for this panel instance
         m_imnodesContext = ImNodes::EditorContextCreate();
 
         // Phase 36: Canvas editor created lazily in RenderGraph() when canvas size is known
 
         // Set up autosave timing only.  The per-save lambda overload of
         // ScheduleSave() is used at each change site so that serialization
         // happens on the UI thread and the background task only does I/O.
         m_autosave.Init(nullptr, 1.5f, 60.0f);
     }
 
    void NodeGraphPanel::Shutdown()
     {
         // Phase 35.0: Free imnodes context
         if (m_imnodesContext)
         {
             ImNodes::EditorContextFree(m_imnodesContext);
             m_imnodesContext = nullptr;
         }
 
         m_autosave.Flush();
         std::cout << "[NodeGraphPanel] Shutdown\n";
     }
 
    void NodeGraphPanel::Render()
    {
        ImGui::Begin("Node Graph Editor");
        RenderContent();
        ImGui::End();
    }
 
    void NodeGraphPanel::RenderContent()
    {
        // Advance autosave timers each frame.
        m_autosave.Tick(static_cast<double>(ImGui::GetTime()));
 
        // Handle keyboard shortcuts
        HandleKeyboardShortcuts();
 
        // View toggles: Snap-to-grid and Minimap
        ImGui::Checkbox("Snap", &m_SnapToGrid);
        if (ImGui::IsItemHovered())
            ImGui::SetTooltip("Snap-to-grid (Ctrl+G)");
        ImGui::SameLine();
        ImGui::SetNextItemWidth(60.0f);
        ImGui::DragFloat("Grid", &m_SnapGridSize, 1.0f, 4.0f, 128.0f, "%.0f");
        if (ImGui::IsItemHovered())
            ImGui::SetTooltip("Grid cell size");
        ImGui::SameLine();
 
        // Phase 36: Minimap toggle through canvas editor
        bool minimapVisible = m_canvasEditor ? m_canvasEditor->IsMinimapVisible() : false;
        if (ImGui::Checkbox("Map", &minimapVisible))
        {
            if (m_canvasEditor)
                m_canvasEditor->SetMinimapVisible(minimapVisible);
        }
        if (ImGui::IsItemHovered())
            ImGui::SetTooltip("Minimap (Ctrl+M)");
        ImGui::SameLine();
 
        // Phase 36: Minimap size control (Step 8)
        if (m_canvasEditor && minimapVisible)
        {
            ImGui::SetNextItemWidth(50.0f);
            float minimapSize = m_canvasEditor->GetMinimapSize();
            if (ImGui::DragFloat("##mmsize", &minimapSize, 0.01f, 0.05f, 0.5f, "%.2f"))
            {
                m_canvasEditor->SetMinimapSize(minimapSize);
            }
            if (ImGui::IsItemHovered())
                ImGui::SetTooltip("Minimap scale (0.05-0.5)");
            ImGui::SameLine();
 
            // Phase 36: Minimap position control (Step 9)
            ImGui::SetNextItemWidth(80.0f);
            int minimapPosition = m_canvasEditor->GetMinimapPosition();
            const char* positionNames[] = {"TopLeft", "TopRight", "BottomLeft", "BottomRight"};
            if (ImGui::Combo("##mmpos", &minimapPosition, positionNames, IM_ARRAYSIZE(positionNames)))
            {
                m_canvasEditor->SetMinimapPosition(minimapPosition);
            }
            if (ImGui::IsItemHovered())
                ImGui::SetTooltip("Minimap position");
            ImGui::SameLine();
        }
        ImGui::SameLine();
 
        // Debug info when runtime overlay is active
        if (s_ActiveDebugNodeId >= 0)
        {
            ImGui::TextColored(ImVec4(1.0f, 0.9f, 0.2f, 1.0f), "  [DBG node %d]", s_ActiveDebugNodeId);
        }
 
        //ImGui::Separator();
        ImGui::SameLine();
        
        // Toolbar with Save/Save As buttons
        NodeGraph* activeGraph = NodeGraphManager::Get().GetActiveGraph();
        if (activeGraph)
        {
            // Save button
            bool canSave = activeGraph->HasFilepath();
            if (!canSave)
                ImGui::BeginDisabled();
                
            if (ImGui::Button("Save"))
            {
                // Validate before saving
                std::string validationError;
                if (!activeGraph->ValidateGraph(validationError))
                {
                    // Show validation error popup
                    ImGui::OpenPopup("ValidationError");
                }
                else
                {
                    int graphId = NodeGraphManager::Get().GetActiveGraphId();
                    // Sync node positions from ImNodes before saving
                    SyncNodePositionsFromImNodes(graphId);
                    const std::string& filepath = activeGraph->GetFilepath();
                    if (NodeGraphManager::Get().SaveGraph(graphId, filepath))
                    {
                        std::cout << "[NodeGraphPanel] Saved graph to: " << filepath << std::endl;
                    }
                    else
                    {
                        std::cout << "[NodeGraphPanel] Failed to save graph!" << std::endl;
                    }
                }
            }
            
            if (!canSave)
                ImGui::EndDisabled();
                
            if (!canSave && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
            {
                ImGui::SetTooltip("No filepath set. Use 'Save As...' first.");
            }
            
            ImGui::SameLine();
            
            // Save As button
            if (ImGui::Button("Save As..."))
            {
                // TODO: Open file dialog to select save location
                // For now, show popup to enter filename
                ImGui::OpenPopup("SaveAsPopup");
            }
            
            // Show dirty indicator
            ImGui::SameLine();
            if (activeGraph->IsDirty())
            {
                ImGui::TextColored(ImVec4(1.0f, 0.7f, 0.2f, 1.0f), "*");
                if (ImGui::IsItemHovered())
                {
                    ImGui::SetTooltip("Unsaved changes");
                }
            }
            
            // Show currently selected entity at the top (informational only, doesn't block rendering)
            uint64_t selectedEntity = BlueprintEditor::Get().GetSelectedEntity();
            if (selectedEntity != 0)
            {
                EntityInfo info = EntityInspectorManager::Get().GetEntityInfo(selectedEntity);
                ImGui::TextColored(ImVec4(0.5f, 1.0f, 0.5f, 1.0f),
                    "Editing for Entity: %s (ID: %llu)", info.name.c_str(), selectedEntity);
            }
            else
            {
                ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.9f, 1.0f),
                    "Editing BehaviorTree Asset (no entity context)");
            }
 
 
            // Save As popup (simple text input for now)
            static bool saveAsPopupOpen = false;
            static char filepathBuffer[512] = "";
            
            if (ImGui::BeginPopup("SaveAsPopup"))
            {
                // Clear buffer when popup first opens
                if (!saveAsPopupOpen)
                {
                    filepathBuffer[0] = '\0';
                    saveAsPopupOpen = true;
                }
                
                ImGui::Text("Save graph as:");
                ImGui::InputText("Filepath", filepathBuffer, sizeof(filepathBuffer));
                
                if (ImGui::Button("Save", ImVec2(120, 0)))
                {
                    std::string filepath(filepathBuffer);
                    if (!filepath.empty())
                    {
                        // Validate before saving
                        std::string validationError;
                        if (!activeGraph->ValidateGraph(validationError))
                        {
                            // Show validation error
                            saveAsPopupOpen = false;
                            ImGui::CloseCurrentPopup();
                            ImGui::OpenPopup("ValidationError");
                        }
                        else
                        {
                            // Ensure .json extension (check that it ends with .json)
                            if (filepath.size() < 5 || filepath.substr(filepath.size() - 5) != ".json")
                                filepath += ".json";
 
                            int graphId = NodeGraphManager::Get().GetActiveGraphId();
                            // Sync node positions from ImNodes before saving
                            SyncNodePositionsFromImNodes(graphId);
                            if (NodeGraphManager::Get().SaveGraph(graphId, filepath))
                            {
                                std::cout << "[NodeGraphPanel] Saved graph as: " << filepath << std::endl;
                                saveAsPopupOpen = false;
                                ImGui::CloseCurrentPopup();
                            }
                            else
                            {
                                std::cout << "[NodeGraphPanel] Failed to save graph!" << std::endl;
                            }
                        }
                    }
                }
                ImGui::SameLine();
                if (ImGui::Button("Cancel", ImVec2(120, 0)))
                {
                    saveAsPopupOpen = false;
                    ImGui::CloseCurrentPopup();
                }
                ImGui::EndPopup();
            }
            else
            {
                saveAsPopupOpen = false;
            }
            
            // Validation error popup
            if (ImGui::BeginPopupModal("ValidationError", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
            {
                ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Cannot save: Graph validation failed!");
                ImGui::Separator();
                
                std::string validationError;
                if (!activeGraph->ValidateGraph(validationError))
                {
                    ImGui::TextWrapped("%s", validationError.c_str());
                }
                
                ImGui::Separator();
                if (ImGui::Button("OK", ImVec2(120, 0)))
                {
                    ImGui::CloseCurrentPopup();
                }
                ImGui::EndPopup();
            }
            
            ImGui::Separator();
        }
 
        // Render graph tabs (unless suppressed by external renderer like BehaviorTreeRenderer)
        if (!m_SuppressGraphTabs)
        {
            RenderGraphTabs();
            ImGui::Separator();
        }
 
        // Render the active graph
        activeGraph = NodeGraphManager::Get().GetActiveGraph();
        if (activeGraph)
        {
            RenderGraph();
        }
        else
        {
            // Legacy UI disabled - BehaviorTreeRenderer and other editors should ensure
            // a graph is set active before rendering begins.
            ImGui::TextDisabled("No graph active. Create a new graph from the menu or load an existing one.");
        }
 
        // Render node edit modal
        RenderNodeEditModal();
    }
 
    void NodeGraphPanel::RenderGraphTabs()
    {
        auto graphIds = NodeGraphManager::Get().GetAllGraphIds();
        int currentActiveId = NodeGraphManager::Get().GetActiveGraphId();
        
        // Track which graph was requested to close
        // Using static but ensuring cleanup to prevent issues with multiple rapid closes
        static int graphToClose = -1;
        static bool confirmationOpen = false;
 
        if (ImGui::BeginTabBar("GraphTabs"))
        {
            for (int graphId : graphIds)
            {
                std::string graphName = NodeGraphManager::Get().GetGraphName(graphId);
                
                // Add dirty indicator to tab name
                NodeGraph* graph = NodeGraphManager::Get().GetGraph(graphId);
                if (graph && graph->IsDirty())
                    graphName += " *";
 
                // Only set ImGuiTabItemFlags_SetSelected if this is the active graph
                // This ensures the tab is selected visually without forcing re-selection each frame
                ImGuiTabItemFlags flags = ImGuiTabItemFlags_None;
                if (graphId == currentActiveId)
                {
                    flags = ImGuiTabItemFlags_SetSelected;
                }
                
                // Enable close button for tabs
                bool tabOpen = true;
                if (ImGui::BeginTabItem(graphName.c_str(), &tabOpen, flags))
                {
                    // Only change active graph if user clicked this tab (and it's not already active)
                    // BeginTabItem returns true when the tab content should be shown
                    if (currentActiveId != graphId)
                    {
                        NodeGraphManager::Get().SetActiveGraph(graphId);
                    }
                    ImGui::EndTabItem();
                }
                
                // If tab was closed (X button clicked)
                if (!tabOpen)
                {
                    // Only process if no confirmation dialog is currently open
                    if (!confirmationOpen)
                    {
                        // Check if graph has unsaved changes
                        if (graph && graph->IsDirty())
                        {
                            graphToClose = graphId;
                            confirmationOpen = true;
                            ImGui::OpenPopup("ConfirmCloseUnsaved");
                        }
                        else
                        {
                            // Close immediately if no unsaved changes
                            NodeGraphManager::Get().CloseGraph(graphId);
                        }
                    }
                }
            }
 
            // Add "+" button for new graph
            if (ImGui::TabItemButton("+", ImGuiTabItemFlags_Trailing))
            {
                ImGui::OpenPopup("CreateGraphPopup");
            }
 
            ImGui::EndTabBar();
        }
        
        // Confirmation popup for closing unsaved graph
        if (ImGui::BeginPopupModal("ConfirmCloseUnsaved", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
        {
            ImGui::TextColored(ImVec4(1.0f, 0.7f, 0.2f, 1.0f), "Warning: Unsaved Changes!");
            ImGui::Separator();
            
            std::string graphName = NodeGraphManager::Get().GetGraphName(graphToClose);
            ImGui::TextWrapped("The graph '%s' has unsaved changes.", graphName.c_str());
            ImGui::TextWrapped("Do you want to save before closing?");
            
            ImGui::Separator();
            
            // Save and Close button
            if (ImGui::Button("Save and Close", ImVec2(120, 0)))
            {
                NodeGraph* graph = NodeGraphManager::Get().GetGraph(graphToClose);
                if (graph && graph->HasFilepath())
                {
                    // Validate before saving
                    std::string validationError;
                    if (!graph->ValidateGraph(validationError))
                    {
                        // Show validation error
                        ImGui::CloseCurrentPopup();
                        ImGui::OpenPopup("ValidationError");
                    }
                    else
                    {
                        // Save and close
                        if (NodeGraphManager::Get().SaveGraph(graphToClose, graph->GetFilepath()))
                        {
                            NodeGraphManager::Get().CloseGraph(graphToClose);
                            graphToClose = -1;
                            confirmationOpen = false;
                            ImGui::CloseCurrentPopup();
                        }
                    }
                }
                else
                {
                    // No filepath - need Save As
                    confirmationOpen = false;
                    ImGui::CloseCurrentPopup();
                    ImGui::OpenPopup("SaveAsPopup");
                }
            }
            
            ImGui::SameLine();
            
            // Close without saving button
            if (ImGui::Button("Close Without Saving", ImVec2(150, 0)))
            {
                NodeGraphManager::Get().CloseGraph(graphToClose);
                graphToClose = -1;
                confirmationOpen = false;
                ImGui::CloseCurrentPopup();
            }
            
            ImGui::SameLine();
            
            // Cancel button
            if (ImGui::Button("Cancel", ImVec2(120, 0)))
            {
                graphToClose = -1;
                confirmationOpen = false;
                ImGui::CloseCurrentPopup();
            }
            
            ImGui::EndPopup();
        }
        else
        {
            // Popup closed without action - reset state
            if (confirmationOpen && graphToClose >= 0)
            {
                confirmationOpen = false;
                graphToClose = -1;
            }
        }
 
        // Create graph popup
        if (ImGui::BeginPopup("CreateGraphPopup"))
        {
            if (ImGui::MenuItem("New Behavior Tree"))
            {
                NodeGraphManager::Get().CreateGraph("New Behavior Tree", "BehaviorTree");
            }
            if (ImGui::MenuItem("New HFSM"))
            {
                NodeGraphManager::Get().CreateGraph("New HFSM", "HFSM");
            }
            ImGui::EndPopup();
        }
    }
 
    void NodeGraphPanel::RenderGraph()
    {
        NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
        if (!graph)
            return;
 
        // Get the Graph ID for creating unique UIDs
        int graphID = NodeGraphManager::Get().GetActiveGraphId();
        if (graphID < 0)
        {
            std::cerr << "[NodeGraphPanel] Invalid graph ID" << std::endl;
            return;
        }
 
        // Ensure canvas has valid size (minimum 1px to render)
        constexpr float MIN_CANVAS_SIZE = 1.0f;
        ImVec2 canvasSize = ImGui::GetContentRegionAvail();
        if (canvasSize.x < MIN_CANVAS_SIZE || canvasSize.y < MIN_CANVAS_SIZE)
        {
            ImGui::Text("Canvas too small to render graph");
            return;
        }
 
        // Phase 36: Initialize or update canvas editor for minimap support
        if (!m_canvasEditor)
        {
            ImVec2 canvasScreenPos = ImGui::GetCursorScreenPos();
            m_canvasEditor = std::make_unique<ImNodesCanvasEditor>(
                "BehaviorTreeEditor",
                canvasScreenPos,
                canvasSize,
                m_imnodesContext
            );
        }
 
        // Phase 35.0: Set this panel's imnodes context active before rendering
        // Prevents viewport state collision with other graph renderers (e.g., VisualScriptEditorPanel)
        if (m_imnodesContext)
        {
            ImNodes::EditorContextSet(m_imnodesContext);
        }
 
        ImNodes::BeginNodeEditor();
 
        // Render all nodes
        auto nodes = graph->GetAllNodes();
 
        // Clear positioned-nodes tracking when the active graph changes so that
        // the initial positions of a newly-opened graph are applied correctly.
        if (graphID != m_lastActiveGraphId)
        {
            m_positionedNodes.clear();
            m_lastActiveGraphId = graphID;
        }
 
        // Build set of connected attribute IDs from all graph links so that
        // connected pins render filled and unconnected pins render outlined.
        std::unordered_set<int> connectedAttrIDs;
        {
            auto allLinks = graph->GetAllLinks();
            for (size_t li = 0; li < allLinks.size(); ++li)
            {
                int fromUID = (graphID * GRAPH_ID_MULTIPLIER) + allLinks[li].fromNode;
                int toUID   = (graphID * GRAPH_ID_MULTIPLIER) + allLinks[li].toNode;
                connectedAttrIDs.insert(fromUID * ATTR_ID_MULTIPLIER + 2); // output attr
                connectedAttrIDs.insert(toUID   * ATTR_ID_MULTIPLIER + 1); // input attr
            }
        }
 
        for (GraphNode* node : nodes)
        {
            // Generate a global unique UID for ImNodes
            // Format: graphID * GRAPH_ID_MULTIPLIER + nodeID
            // This ensures no node from different graphs has the same UID
            int globalNodeUID = (graphID * GRAPH_ID_MULTIPLIER) + node->id;
 
            // Set node position BEFORE rendering (ImNodes requirement), but only
            // once per node so that subsequent user drags are not overridden.
            if (m_positionedNodes.find(globalNodeUID) == m_positionedNodes.end())
            {
                ImNodes::SetNodeGridSpacePos(globalNodeUID, ImVec2(node->posX, node->posY));
                m_positionedNodes.insert(globalNodeUID);
            }
 
            // Apply per-type title-bar colours from NodeStyleRegistry
            const NodeStyle& style = NodeStyleRegistry::Get().GetStyle(node->type);
 
            // Debug overlay: tint the active node bright yellow
            ImU32 headerColor         = style.headerColor;
            ImU32 headerHoveredColor  = style.headerHoveredColor;
            ImU32 headerSelectedColor = style.headerSelectedColor;
 
            // Phase 38b: Visual distinction for OnEvent and Root nodes
            // Check if this is a Root node or OnEvent node based on eventType field
            bool isRootNode = (node->id == graph->GetRootNodeId());
            bool isOnEventNode = (node->type == NodeType::BT_OnEvent);
 
            if (isRootNode)
            {
                // Root node: green color (from BT_ROOT_NODE_COLOR)
                headerColor         = Olympe::SystemColors::ToImU32_ABGR(Olympe::SystemColors::BT_ROOT_NODE_COLOR);
                headerHoveredColor  = IM_COL32(100, 255, 100, 255);  // Lighter green
                headerSelectedColor = IM_COL32(150, 255, 150, 255);  // Even lighter green
            }
 
            if (s_ActiveDebugNodeId == node->id)
            {
                headerColor         = IM_COL32(200, 180, 20, 255);
                headerHoveredColor  = IM_COL32(220, 200, 40, 255);
                headerSelectedColor = IM_COL32(240, 220, 60, 255);
            }
 
            ImNodes::PushColorStyle(ImNodesCol_TitleBar,         headerColor);
            ImNodes::PushColorStyle(ImNodesCol_TitleBarHovered,  headerHoveredColor);
            ImNodes::PushColorStyle(ImNodesCol_TitleBarSelected, headerSelectedColor);
 
            ImNodes::BeginNode(globalNodeUID);
 
            RenderNodePinsAndContent(node, globalNodeUID, graphID, connectedAttrIDs);
 
            ImNodes::EndNode();
 
            ImNodes::PopColorStyle();
            ImNodes::PopColorStyle();
            ImNodes::PopColorStyle();
        }
 
        // Render all links with global UIDs.
        // Pass 1: draw only inactive links (baseline blue).
        // Active links are skipped here; RenderActiveLinks() draws them with glow.
        auto links = graph->GetAllLinks();
        for (size_t i = 0; i < links.size(); ++i)
        {
            const GraphLink& link = links[i];
            
            // Generate global UIDs for the attributes
            int fromNodeUID = (graphID * GRAPH_ID_MULTIPLIER) + link.fromNode;
            int toNodeUID = (graphID * GRAPH_ID_MULTIPLIER) + link.toNode;
            
            int fromAttrUID = fromNodeUID * ATTR_ID_MULTIPLIER + 2;  // Output attribute
            int toAttrUID = toNodeUID * ATTR_ID_MULTIPLIER + 1;      // Input attribute
            
            // Link ID must also be unique globally
            int globalLinkUID = (graphID * LINK_ID_MULTIPLIER) + (int)i + 1;
 
            // Skip active links in this baseline pass to avoid double-draw;
            // RenderActiveLinks() will overlay the glow for them.
            bool isActive = (s_ActiveDebugNodeId >= 0 &&
                             (link.fromNode == s_ActiveDebugNodeId ||
                              link.toNode   == s_ActiveDebugNodeId));
            if (isActive)
                continue;
 
                ImNodes::Link(globalLinkUID, fromAttrUID, toAttrUID);
            }
 
            // Phase 36: Render minimap through canvas editor interface
            if (m_canvasEditor)
            {
                m_canvasEditor->RenderMinimap();
            }
 
            ImNodes::EndNodeEditor();
 
        // Overlay Bezier glow for links connected to the active debug node.
        // Must be called after EndNodeEditor() so screen-space positions are valid.
        RenderActiveLinks(graph, graphID);
 
        // Phase 38: Render execution indices on connections for Sequence/Selector children
        RenderConnectionIndices(graph, graphID);
 
        // Handle node interactions with UID mapping
        HandleNodeInteractions(graphID);
 
        // Handle link selection
        int numSelectedLinks = ImNodes::NumSelectedLinks();
        if (numSelectedLinks > 0)
        {
            std::vector<int> selectedLinks(numSelectedLinks);
            ImNodes::GetSelectedLinks(selectedLinks.data());
            if (selectedLinks.size() > 0)
                m_SelectedLinkId = selectedLinks[0];
        }
 
        // Handle Delete key for nodes and links (only if canDelete)
        if (ImGui::IsKeyPressed(ImGuiKey_Delete) && EditorContext::Get().CanDelete())
        {
            if (m_SelectedNodeId != -1)
            {
                // Delete selected node
                std::string graphId = std::to_string(NodeGraphManager::Get().GetActiveGraphId());
                auto cmd = std::make_unique<DeleteNodeCommand>(graphId, m_SelectedNodeId);
                BlueprintEditor::Get().GetCommandStack()->ExecuteCommand(std::move(cmd));
                m_SelectedNodeId = -1;
            }
            else if (m_SelectedLinkId != -1)
            {
                // Delete selected link
                // Extract the link index from the global link UID
                int linkIndex = (m_SelectedLinkId - (graphID * LINK_ID_MULTIPLIER)) - 1;
                
                auto links = graph->GetAllLinks();
                if (linkIndex >= 0 && linkIndex < (int)links.size())
                {
                    const GraphLink& link = links[linkIndex];
                    std::string graphId = std::to_string(NodeGraphManager::Get().GetActiveGraphId());
                    auto cmd = std::make_unique<UnlinkNodesCommand>(graphId, link.fromNode, link.toNode);
                    BlueprintEditor::Get().GetCommandStack()->ExecuteCommand(std::move(cmd));
                    m_SelectedLinkId = -1;
                }
            }
        }
 
        // Check for node hover (for property panel selection)
        int hoveredNodeUID = -1;
        if (ImNodes::IsNodeHovered(&hoveredNodeUID))
        {
            // Node hover detection - used for selection
            // (Legacy double-click modal removed - now use property panel instead)
        }
 
        // Right-click context menu on node
        if (ImGui::IsMouseReleased(ImGuiMouseButton_Right) && hoveredNodeUID != -1)
        {
            // Convert global UID to local node ID
            m_SelectedNodeId = GlobalUIDToLocalNodeID(hoveredNodeUID, graphID);
            ImGui::OpenPopup("NodeContextMenu");
        }
 
        // Handle right-click on canvas for node creation menu (only if canCreate)
        if (EditorContext::Get().CanCreate() &&
            ImGui::IsMouseReleased(ImGuiMouseButton_Right) &&
            ImNodes::IsEditorHovered() &&
            !ImNodes::IsNodeHovered(&hoveredNodeUID))
        {
            ImGui::OpenPopup("NodeCreationMenu");
            ImVec2 mousePos = ImGui::GetMousePos();
            m_ContextMenuPosX = mousePos.x;
            m_ContextMenuPosY = mousePos.y;
        }
 
        // Context menu on node
        if (ImGui::BeginPopup("NodeContextMenu"))
        {
            GraphNode* selectedNode = graph->GetNode(m_SelectedNodeId);
            if (selectedNode)
            {
                ImGui::Text("Node: %s (ID: %d)", selectedNode->name.c_str(), m_SelectedNodeId);
            }
            else
            {
                ImGui::Text("Node: %d", m_SelectedNodeId);
            }
            ImGui::Separator();
 
            // Edit menu item removed - now use right-panel property editor instead
            // if (ImGui::MenuItem("Edit Properties", "Double-click"))
 
            // Duplicate only shown if allowed
            if (EditorContext::Get().CanEdit() && EditorContext::Get().CanCreate())
            {
                if (ImGui::MenuItem("Duplicate", "Ctrl+D"))
                {
                    Blueprint::CommandStack* stack = BlueprintEditor::Get().GetCommandStack();
                    int graphId = NodeGraphManager::Get().GetActiveGraphId();
                    NodeGraphShared::BlueprintAdapter adapter(stack, graphId);
                    adapter.DuplicateNode(m_SelectedNodeId);
                    ImGui::CloseCurrentPopup();
                }
            }
 
            ImGui::Separator();
 
            // Phase 38b: Delete only shown if allowed AND node is not the Root
            if (EditorContext::Get().CanDelete())
            {
                bool isRootNode = (m_SelectedNodeId == graph->rootNodeId);
 
                if (isRootNode)
                {
                    // Root node cannot be deleted - show disabled item with tooltip
                    ImGui::BeginDisabled(true);
                    ImGui::MenuItem("Delete", "Del");
                    ImGui::EndDisabled();
                    if (ImGui::IsItemHovered())
                    {
                        ImGui::SetTooltip("Root node cannot be deleted");
                    }
                }
                else if (ImGui::MenuItem("Delete", "Del"))
                {
                    std::string graphId = std::to_string(NodeGraphManager::Get().GetActiveGraphId());
                    auto cmd = std::make_unique<DeleteNodeCommand>(graphId, m_SelectedNodeId);
                    BlueprintEditor::Get().GetCommandStack()->ExecuteCommand(std::move(cmd));
                    m_SelectedNodeId = -1;
                    ImGui::CloseCurrentPopup();
                }
            }
 
            ImGui::EndPopup();
        }
 
        // Right-click context menu on link
        int hoveredLinkUID = -1;
        if (ImNodes::IsLinkHovered(&hoveredLinkUID))
        {
            if (ImGui::IsMouseReleased(ImGuiMouseButton_Right))
            {
                m_SelectedLinkId = hoveredLinkUID;
                ImGui::OpenPopup("LinkContextMenu");
            }
        }
 
        // Context menu on link
        if (ImGui::BeginPopup("LinkContextMenu"))
        {
            // Extract link information
            int linkIndex = (m_SelectedLinkId - (graphID * LINK_ID_MULTIPLIER)) - 1;
            auto links = graph->GetAllLinks();
 
            if (linkIndex >= 0 && linkIndex < (int)links.size())
            {
                const GraphLink& link = links[linkIndex];
                GraphNode* fromNode = graph->GetNode(link.fromNode);
                GraphNode* toNode = graph->GetNode(link.toNode);
 
                if (fromNode && toNode)
                {
                    ImGui::Text("Link: %s -> %s", fromNode->name.c_str(), toNode->name.c_str());
                }
                else
                {
                    ImGui::Text("Link: %d -> %d", link.fromNode, link.toNode);
                }
                ImGui::Separator();
 
                // Delete link
                if (EditorContext::Get().CanDelete())
                {
                    if (ImGui::MenuItem("Delete Link", "Del"))
                    {
                        std::string graphId = std::to_string(NodeGraphManager::Get().GetActiveGraphId());
                        auto cmd = std::make_unique<UnlinkNodesCommand>(graphId, link.fromNode, link.toNode);
                        BlueprintEditor::Get().GetCommandStack()->ExecuteCommand(std::move(cmd));
                        m_SelectedLinkId = -1;
                        ImGui::CloseCurrentPopup();
                    }
                }
            }
            else
            {
                ImGui::Text("Invalid link");
            }
 
            ImGui::EndPopup();
        }
 
        // Handle drag & drop from node palette
        if (ImGui::BeginDragDropTarget())
        {
            // Handle BT node palette payload (NODE_TYPE = string-based type)
            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("NODE_TYPE"))
            {
                if (!payload->Data || payload->DataSize == 0)
                {
                    std::cerr << "[NodeGraphPanel] ERROR: NODE_TYPE payload has null or empty data\n";
                }
                else
                {
                    // Copy payload data to local string with bounds checking
                    size_t maxSize = 256;  // Reasonable max for node type strings
                    size_t dataSize = (payload->DataSize < maxSize) ? payload->DataSize : maxSize;
 
                    std::string nodeTypeData;
                    nodeTypeData.resize(dataSize);
                    std::memcpy(&nodeTypeData[0], payload->Data, dataSize);
 
                    // Ensure NUL-termination
                    if (nodeTypeData.find('\0') == std::string::npos)
                    {
                        // Truncate at first non-printable or add terminator
                        size_t validLen = 0;
                        for (size_t i = 0; i < nodeTypeData.size(); ++i)
                        {
                            if (nodeTypeData[i] == '\0' || nodeTypeData[i] < 32)
                                break;
                            validLen = i + 1;
                        }
                        nodeTypeData.resize(validLen);
                    }
 
                    // Remove any trailing null bytes
                    while (!nodeTypeData.empty() && nodeTypeData.back() == '\0')
                        nodeTypeData.pop_back();
 
                    std::cout << "[NodeGraphPanel] Received NODE_TYPE payload: " << nodeTypeData << "\n";
 
                    // Convert screen space coordinates to grid space
                    ImVec2 mouseScreenPos = ImGui::GetMousePos();
                    ImVec2 canvasPos = ScreenSpaceToGridSpace(mouseScreenPos);
 
                    bool validNode = false;
 
                    // Parse the type and create appropriate node
                    if (nodeTypeData.find("Action:") == 0)
                    {
                        std::string actionType = nodeTypeData.substr(7);
 
                        // Validate action type exists in catalog
                        if (EnumCatalogManager::Get().IsValidActionType(actionType))
                        {
                            int nodeId = graph->CreateNode(NodeType::BT_Action, canvasPos.x, canvasPos.y, actionType);
                            GraphNode* node = graph->GetNode(nodeId);
                            if (node)
                            {
                                node->actionType = actionType;
                                validNode = true;
                                std::cout << "[NodeGraphPanel] Created Action node: " << actionType
                                    << " at canvas pos (" << canvasPos.x << ", " << canvasPos.y << ")\n";
                            }
                        }
                        else
                        {
                            std::cerr << "[NodeGraphPanel] ERROR: Invalid ActionType: " << actionType << "\n";
                            ImGui::SetTooltip("Invalid ActionType: %s", actionType.c_str());
                        }
                    }
                    else if (nodeTypeData.find("Condition:") == 0)
                    {
                        std::string conditionType = nodeTypeData.substr(10);
 
                        // Validate condition type exists in catalog
                        if (EnumCatalogManager::Get().IsValidConditionType(conditionType))
                        {
                            int nodeId = graph->CreateNode(NodeType::BT_Condition, canvasPos.x, canvasPos.y, conditionType);
                            GraphNode* node = graph->GetNode(nodeId);
                            if (node)
                            {
                                node->conditionType = conditionType;
                                validNode = true;
                                std::cout << "[NodeGraphPanel] Created Condition node: " << conditionType
                                    << " at canvas pos (" << canvasPos.x << ", " << canvasPos.y << ")\n";
                            }
                        }
                        else
                        {
                            std::cerr << "[NodeGraphPanel] ERROR: Invalid ConditionType: " << conditionType << "\n";
                            ImGui::SetTooltip("Invalid ConditionType: %s", conditionType.c_str());
                        }
                    }
                    else if (nodeTypeData.find("Decorator:") == 0)
                    {
                        std::string decoratorType = nodeTypeData.substr(10);
 
                        // Validate decorator type exists in catalog
                        if (EnumCatalogManager::Get().IsValidDecoratorType(decoratorType))
                        {
                            int nodeId = graph->CreateNode(NodeType::BT_Decorator, canvasPos.x, canvasPos.y, decoratorType);
                            GraphNode* node = graph->GetNode(nodeId);
                            if (node)
                            {
                                node->decoratorType = decoratorType;
                                validNode = true;
                                std::cout << "[NodeGraphPanel] Created Decorator node: " << decoratorType
                                    << " at canvas pos (" << canvasPos.x << ", " << canvasPos.y << ")\n";
                            }
                        }
                        else
                        {
                            std::cerr << "[NodeGraphPanel] ERROR: Invalid DecoratorType: " << decoratorType << "\n";
                            ImGui::SetTooltip("Invalid DecoratorType: %s", decoratorType.c_str());
                        }
                    }
                    else if (nodeTypeData == "Sequence" || nodeTypeData == "Selector")
                    {
                        NodeType type = (nodeTypeData == "Sequence") ? NodeType::BT_Sequence : NodeType::BT_Selector;
                        int nodeId = graph->CreateNode(type, canvasPos.x, canvasPos.y, nodeTypeData);
                        if (nodeId > 0)
                        {
                            validNode = true;
                            std::cout << "[NodeGraphPanel] Created " << nodeTypeData << " node"
                                << " at canvas pos (" << canvasPos.x << ", " << canvasPos.y << ")\n";
                        }
                    }
                    else
                    {
                        std::cerr << "[NodeGraphPanel] ERROR: Unknown node type: " << nodeTypeData << "\n";
                        ImGui::SetTooltip("Unknown node type: %s", nodeTypeData.c_str());
                    }
 
                    if (!validNode)
                    {
                        std::cerr << "[NodeGraphPanel] Failed to create node from DnD payload\n";
                    }
                }
            }
            // Handle VS node palette payload (VS_NODE_TYPE_ENUM = TaskNodeType enum as uint8_t)
            else if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("VS_NODE_TYPE_ENUM"))
            {
                if (payload->Data && payload->DataSize == sizeof(uint8_t))
                {
                    uint8_t enumValue = *static_cast<const uint8_t*>(payload->Data);
                    TaskNodeType nodeType = static_cast<TaskNodeType>(enumValue);
 
                    std::cout << "[NodeGraphPanel] Received VS_NODE_TYPE_ENUM payload: "
                              << static_cast<int>(enumValue) << "\n";
 
                    std::string nodeTypeName;
                    switch (nodeType)
                    {
                        case TaskNodeType::EntryPoint:  nodeTypeName = "EntryPoint";  break;
                        case TaskNodeType::Branch:      nodeTypeName = "Branch";      break;
                        case TaskNodeType::VSSequence:  nodeTypeName = "Sequence";    break;
                        case TaskNodeType::While:       nodeTypeName = "While";       break;
                        case TaskNodeType::ForEach:     nodeTypeName = "ForEach";     break;
                        case TaskNodeType::DoOnce:      nodeTypeName = "DoOnce";      break;
                        case TaskNodeType::Delay:       nodeTypeName = "Delay";       break;
                        case TaskNodeType::Switch:      nodeTypeName = "Switch";      break;
                        case TaskNodeType::AtomicTask:  nodeTypeName = "AtomicTask";  break;
                        case TaskNodeType::GetBBValue:  nodeTypeName = "GetBBValue";  break;
                        case TaskNodeType::SetBBValue:  nodeTypeName = "SetBBValue";  break;
                        case TaskNodeType::MathOp:      nodeTypeName = "MathOp";      break;
                        case TaskNodeType::SubGraph:    nodeTypeName = "SubGraph";    break;
                        default:
                            std::cerr << "[NodeGraphPanel] ERROR: Unhandled TaskNodeType enum: "
                                      << static_cast<int>(enumValue) << "\n";
                            break;
                    }
 
                    if (!nodeTypeName.empty())
                    {
                        ImVec2 mousePos = ImGui::GetMousePos();
                        // CreateNewNode expects screen coordinates; it converts to canvas space internally
                        CreateNewNode(nodeTypeName.c_str(), mousePos.x, mousePos.y);
                        std::cout << "[NodeGraphPanel] Created VS node from palette: " << nodeTypeName << "\n";
                    }
                    else
                    {
                        std::cerr << "[NodeGraphPanel] Failed to create node from VS_NODE_TYPE_ENUM payload\n";
                    }
                }
                else
                {
                    std::cerr << "[NodeGraphPanel] ERROR: Invalid VS_NODE_TYPE_ENUM payload - ";
                    if (!payload->Data)
                        std::cerr << "null data\n";
                    else
                        std::cerr << "wrong size (expected " << sizeof(uint8_t)
                                  << ", got " << payload->DataSize << ")\n";
                }
            }
 
            ImGui::EndDragDropTarget();
        }
 
        // Update node positions using global UIDs
        for (GraphNode* node : nodes)
        {
                int globalNodeUID = (graphID * GRAPH_ID_MULTIPLIER) + node->id;
                ImVec2 pos = ImNodes::GetNodeGridSpacePos(globalNodeUID);
 
                // Apply snap-to-grid when enabled.
                if (m_SnapToGrid && m_SnapGridSize > 0.0f)
                {
                    pos.x = std::roundf(pos.x / m_SnapGridSize) * m_SnapGridSize;
                    pos.y = std::roundf(pos.y / m_SnapGridSize) * m_SnapGridSize;
                    // Push snapped position back so the node visually snaps.
                    ImNodes::SetNodeGridSpacePos(globalNodeUID, pos);
                }
                
                // Check if position changed
                if (node->posX != pos.x || node->posY != pos.y)
                {
                    node->posX = pos.x;
                    node->posY = pos.y;
                    
                    // Mark graph as dirty when node is moved
                    if (graph)
                        graph->MarkDirty();
 
                    // Schedule an autosave.  Serialization runs on the UI thread
                    // inside Tick(); the background task only writes the file.
                    {
                        int capturedGid    = graphID;
                        std::string fp     = (graph && graph->HasFilepath())
                                                 ? graph->GetFilepath() : "";
                        m_autosave.ScheduleSave(
                            static_cast<double>(ImGui::GetTime()),
                            [capturedGid]() -> std::string
                            {
                                NodeGraph* g = NodeGraphManager::Get().GetGraph(capturedGid);
                                if (g && g->IsDirty())
                                    return g->ToJson().dump(2);
                                return std::string();
                            },
                            fp,
                            "GameData/AI/autosave_");
                    }
                }
                    }
                }
            
                void NodeGraphPanel::SyncNodePositionsFromImNodes(int graphID)
    {
        NodeGraph* graph = NodeGraphManager::Get().GetGraph(graphID);
        if (!graph)
            return;
 
        std::vector<GraphNode*> nodes = graph->GetAllNodes();
 
        // Update all node positions from ImNodes
        for (GraphNode* node : nodes)
        {
            int globalNodeUID = (graphID * GRAPH_ID_MULTIPLIER) + node->id;
            ImVec2 pos = ImNodes::GetNodeGridSpacePos(globalNodeUID);
 
            // Update the node's position in the graph data
            if (node->posX != pos.x || node->posY != pos.y)
            {
                node->posX = pos.x;
                node->posY = pos.y;
            }
        }
    }
 
    void NodeGraphPanel::HandleNodeInteractions(int graphID)
    {
        NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
        if (!graph)
            return;
 
        // Handle node selection
        int numSelected = ImNodes::NumSelectedNodes();
        if (numSelected > 0)
        {
            std::vector<int> selectedUIDs(numSelected);
            ImNodes::GetSelectedNodes(selectedUIDs.data());
 
            // Convert the first global UID to local Node ID
            if (!selectedUIDs.empty())
            {
                int selectedLocalNodeID = GlobalUIDToLocalNodeID(selectedUIDs[0], graphID);
                m_SelectedNodeId = selectedLocalNodeID;
 
                // NEW: If this is an AtomicTask node, display its parameters in the inspector
                GraphNode* selectedNode = graph->GetNode(selectedLocalNodeID);
                if (selectedNode && selectedNode->type == NodeType::BT_Action)
                {
                    // Get the task registry to find the task display name
                    const TaskSpec* taskSpec = AtomicTaskUIRegistry::Get().GetTaskSpec(selectedNode->actionType);
                    std::string displayName = (taskSpec) ? taskSpec->displayName : selectedNode->actionType;
 
                    // Build empty parameters map (can be extended to read from node data)
                    std::unordered_map<std::string, std::string> params;
 
                    // Display in the inspector panel via singleton
                    InspectorPanel* inspector = InspectorPanel::GetInstance();
                    if (inspector)
                    {
                        inspector->SetSelectedActionNode(selectedNode->actionType, displayName, params);
                    }
                }
                else
                {
                    // Not an action node - clear the action panel
                    InspectorPanel* inspector = InspectorPanel::GetInstance();
                    if (inspector)
                    {
                        inspector->ClearSelectedActionNode();
                    }
                }
            }
        }
 
        // Handle link creation (only if canLink)
        int startAttrUID, endAttrUID;
        if (EditorContext::Get().CanLink() && ImNodes::IsLinkCreated(&startAttrUID, &endAttrUID))
        {
            // Extract the global UIDs of nodes
            int startNodeGlobalUID = startAttrUID / ATTR_ID_MULTIPLIER;
            int endNodeGlobalUID = endAttrUID / ATTR_ID_MULTIPLIER;
 
            // Convert to local IDs
            int startNodeLocalID = GlobalUIDToLocalNodeID(startNodeGlobalUID, graphID);
            int endNodeLocalID = GlobalUIDToLocalNodeID(endNodeGlobalUID, graphID);
 
            // Create the link with local IDs via adapter
            Blueprint::CommandStack* stack = BlueprintEditor::Get().GetCommandStack();
            NodeGraphShared::BlueprintAdapter adapter(stack, graphID);
            adapter.ConnectNodes(startNodeLocalID, endNodeLocalID);
        }
    }
 
    // =========================================================================
    // RenderTypedPin
    // =========================================================================
 
    void NodeGraphPanel::RenderTypedPin(int attrId, const char* label,
                                        bool isInput, bool isExec,
                                        const std::unordered_set<int>& connectedAttrIDs)
    {
        bool connected = connectedAttrIDs.count(attrId) > 0;
        // Filled when connected, outlined when not.
        ImNodesPinShape shape = isExec
            ? (connected ? ImNodesPinShape_TriangleFilled : ImNodesPinShape_Triangle)
            : (connected ? ImNodesPinShape_CircleFilled   : ImNodesPinShape_Circle);
 
        if (isInput)
        {
            ImNodes::BeginInputAttribute(attrId, shape);
            ImGui::TextUnformatted(label);
            ImNodes::EndInputAttribute();
        }
        else
        {
            ImNodes::BeginOutputAttribute(attrId, shape);
            ImGui::TextUnformatted(label);
            ImNodes::EndOutputAttribute();
        }
    }
 
    // =========================================================================
    // RenderNodePinsAndContent
    // =========================================================================
 
    void NodeGraphPanel::RenderNodePinsAndContent(GraphNode* node, int globalNodeUID,
                                                  int graphID,
                                                  const std::unordered_set<int>& connectedAttrIDs)
    {
        // ----- Title bar (icon + name) --------------------------------------
        const NodeStyle& style = NodeStyleRegistry::Get().GetStyle(node->type);
 
        ImNodes::BeginNodeTitleBar();
        if (style.icon[0] != '\0')
            ImGui::Text("[%s] %s", style.icon, node->name.c_str());
        else
            ImGui::TextUnformatted(node->name.c_str());
        ImNodes::EndNodeTitleBar();
 
        // ---- Comment box: no pins, just an editable text area -------------
        if (node->type == NodeType::Comment)
        {
            // Provide a fixed-size text display; the text is stored in parameters["text"].
            auto it = node->parameters.find("text");
            std::string commentText = (it != node->parameters.end()) ? it->second : "";
            ImGui::SetNextItemWidth(180.0f);
            char commentBuf[1024];
            strncpy_s(commentBuf, commentText.c_str(), sizeof(commentBuf) - 1);
            commentBuf[sizeof(commentBuf) - 1] = '\0';
            std::string inputId = std::string("##comment") + std::to_string(node->id);
            if (ImGui::InputTextMultiline(inputId.c_str(), commentBuf, sizeof(commentBuf),
                                          ImVec2(180.0f, 60.0f)))
            {
                node->parameters["text"] = commentBuf;
                NodeGraph* g = NodeGraphManager::Get().GetActiveGraph();
                if (g) g->MarkDirty();
            }
            // Comment boxes have no exec/data pins.
            return;
        }
 
        // ----- Exec pins: triangle shape -----------------------------------
        // Sequence and Selector are "composite" flow-control nodes -> exec pins.
        // All others use data (circle) pins.
        bool isExec = (node->type == NodeType::BT_Sequence ||
                       node->type == NodeType::BT_Selector);
 
        int inputAttrUID  = globalNodeUID * ATTR_ID_MULTIPLIER + 1;
        int outputAttrUID = globalNodeUID * ATTR_ID_MULTIPLIER + 2;
 
        // Root and OnEvent are entry points - they should NOT have input pins
        bool hasInputPin = (node->type != NodeType::BT_Root &&
                           node->type != NodeType::BT_OnEvent);
 
        // Use 2-column layout to align input pins (left) with output pins (right) on the same Y
        ImGui::Columns(3, "node_pins", false);
        ImGui::SetColumnWidth(0, 60.0f);   // Left column: input pin
        ImGui::SetColumnWidth(1, 100.0f);  // Center column: node content
 
        // ---- LEFT COLUMN: Input Pin ----
        if (hasInputPin)
            RenderTypedPin(inputAttrUID,  "In",  true,  isExec, connectedAttrIDs);
 
        // ---- CENTER COLUMN: Node content ----
        ImGui::NextColumn();
        if (node->type == NodeType::BT_Action && !node->actionType.empty())
            ImGui::Text("%s", node->actionType.c_str());
        else if (node->type == NodeType::BT_Condition && !node->conditionType.empty())
            ImGui::Text("%s", node->conditionType.c_str());
        else if (node->type == NodeType::BT_Decorator && !node->decoratorType.empty())
            ImGui::Text("%s", node->decoratorType.c_str());
        else
            ImGui::Text("%s", NodeTypeToString(node->type));
 
        // ---- RIGHT COLUMN: Output Pin ----
        ImGui::NextColumn();
        RenderTypedPin(outputAttrUID, "Out", false, isExec, connectedAttrIDs);
 
        ImGui::Columns(1);  // End columns
    }
 
    // =========================================================================
    // RenderActiveLinks
    // =========================================================================
 
    void NodeGraphPanel::RenderActiveLinks(NodeGraph* graph, int graphID)
    {
        if (s_ActiveDebugNodeId < 0 || graph == nullptr)
            return;
 
        ImDrawList* drawList = ImGui::GetWindowDrawList();
        if (drawList == nullptr)
            return;
 
        // Pulsing amber/yellow: oscillate alpha and colour over time.
        float t = 0.5f + 0.5f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f);
        float alpha = 0.6f + 0.4f * t;
 
        ImU32 glowWide = IM_COL32(255, 200, 50, static_cast<int>(alpha * 80.0f));
        ImU32 glowCore = IM_COL32(
            static_cast<int>(180.0f + t * 75.0f),
            static_cast<int>(140.0f + t * 115.0f),
            10,
            static_cast<int>(alpha * 255.0f));
 
        auto links = graph->GetAllLinks();
        for (size_t i = 0; i < links.size(); ++i)
        {
            const GraphLink& link = links[i];
            bool isActive = (link.fromNode == s_ActiveDebugNodeId ||
                             link.toNode   == s_ActiveDebugNodeId);
            if (!isActive)
                continue;
 
            int fromUID = graphID * GRAPH_ID_MULTIPLIER + link.fromNode;
            int toUID   = graphID * GRAPH_ID_MULTIPLIER + link.toNode;
 
            ImVec2 fromPos = ImNodes::GetNodeScreenSpacePos(fromUID);
            ImVec2 fromDim = ImNodes::GetNodeDimensions(fromUID);
            ImVec2 toPos   = ImNodes::GetNodeScreenSpacePos(toUID);
            ImVec2 toDim   = ImNodes::GetNodeDimensions(toUID);
 
            // Pin-center anchors: output pin is at the right edge + PinOffset,
            // input pin is at the left edge - PinOffset.  Both at centre height.
            const float po = ImNodes::GetStyle().PinOffset;
            ImVec2 p1 = ImVec2(fromPos.x + fromDim.x + po, fromPos.y + fromDim.y * 0.5f);
            ImVec2 p4 = ImVec2(toPos.x             - po, toPos.y   + toDim.y   * 0.5f);
 
            // Horizontal tangents give the classic node-graph S-curve shape.
            float curve = (p4.x - p1.x) * 0.4f;
            if (curve < 50.0f) curve = 50.0f;
            ImVec2 p2 = ImVec2(p1.x + curve, p1.y);
            ImVec2 p3 = ImVec2(p4.x - curve, p4.y);
 
            // Wide transparent halo + narrow bright core.
            drawList->AddBezierCubic(p1, p2, p3, p4, glowWide, 6.0f);
            drawList->AddBezierCubic(p1, p2, p3, p4, glowCore, 2.0f);
        }
    }
 
    // =========================================================================
    // RenderConnectionIndices - Phase 38: Y-Axis Positional Execution Order
    // =========================================================================
 
    void NodeGraphPanel::RenderConnectionIndices(NodeGraph* graph, int graphID)
    {
        if (graph == nullptr)
            return;
 
        ImDrawList* drawList = ImGui::GetWindowDrawList();
        if (drawList == nullptr)
            return;
 
        // Get all nodes (returns vector of const GraphNode*)
        auto graphNodes = graph->GetAllNodes();
 
        // Iterate through all nodes, find Sequence/Selector nodes
        for (size_t i = 0; i < graphNodes.size(); ++i)
        {
            const GraphNode* parentNode = graphNodes[i];
            if (parentNode == nullptr)
                continue;
 
            // Check if this node is a Sequence or Selector (NodeType enum comparison)
            if (parentNode->type != NodeType::BT_Sequence && parentNode->type != NodeType::BT_Selector)
                continue;
 
            // Get the parent node's screen position
            int parentUID = graphID * GRAPH_ID_MULTIPLIER + parentNode->id;
            ImVec2 parentPos = ImNodes::GetNodeScreenSpacePos(parentUID);
            ImVec2 parentDim = ImNodes::GetNodeDimensions(parentUID);
 
            // Phase 38: Sort children by Y-position to determine execution order
            std::vector<std::pair<float, int>> childrenWithY;
            for (size_t j = 0; j < parentNode->childIds.size(); ++j)
            {
                int childId = parentNode->childIds[j];
 
                // Find child node to get its Y position
                const GraphNode* childNode = graph->GetNode(childId);
                if (childNode != nullptr)
                {
                    childrenWithY.push_back(std::make_pair(childNode->posY, childId));
                }
            }
 
            // Sort by Y-coordinate (ascending: top node = first to execute)
            std::sort(childrenWithY.begin(), childrenWithY.end());
 
            // Render index for each child connection
            for (size_t i = 0; i < childrenWithY.size(); ++i)
            {
                int childId = childrenWithY[i].second;
                uint32_t executionIndex = static_cast<uint32_t>(i + 1);  // 1-based indexing
 
                // Find the child node in the graph
                const GraphNode* childNode = graph->GetNode(childId);
                if (childNode == nullptr)
                    continue;
 
                // Get child node's screen position
                int childUID = graphID * GRAPH_ID_MULTIPLIER + childNode->id;
                ImVec2 childPos = ImNodes::GetNodeScreenSpacePos(childUID);
                ImVec2 childDim = ImNodes::GetNodeDimensions(childUID);
 
                // Calculate connection curve (same as RenderActiveLinks)
                const float po = ImNodes::GetStyle().PinOffset;
                ImVec2 p1 = ImVec2(parentPos.x + parentDim.x + po, parentPos.y + parentDim.y * 0.5f);
                ImVec2 p4 = ImVec2(childPos.x - po, childPos.y + childDim.y * 0.5f);
 
                // Horizontal tangents for S-curve
                float curve = (p4.x - p1.x) * 0.4f;
                if (curve < 50.0f) curve = 50.0f;
                ImVec2 p2 = ImVec2(p1.x + curve, p1.y);
                ImVec2 p3 = ImVec2(p4.x - curve, p4.y);
 
                // Calculate midpoint of the Bezier curve for label placement
                // Use t=0.5 for cubic Bezier: B(0.5) = 0.125*p1 + 0.375*p2 + 0.375*p3 + 0.125*p4
                ImVec2 midpoint = ImVec2(
                    0.125f * p1.x + 0.375f * p2.x + 0.375f * p3.x + 0.125f * p4.x,
                    0.125f * p1.y + 0.375f * p2.y + 0.375f * p3.y + 0.125f * p4.y
                );
 
                // Format index text
                char indexText[16];
                snprintf(indexText, sizeof(indexText), "%u", executionIndex);
 
                // Render index label with background
                ImVec2 textSize = ImGui::CalcTextSize(indexText);
                ImVec2 padding = ImVec2(4.0f, 2.0f);
                ImVec2 bgMin = ImVec2(midpoint.x - textSize.x * 0.5f - padding.x, 
                                      midpoint.y - textSize.y * 0.5f - padding.y);
                ImVec2 bgMax = ImVec2(midpoint.x + textSize.x * 0.5f + padding.x,
                                      midpoint.y + textSize.y * 0.5f + padding.y);
 
                // Background: Dark with border
                ImU32 bgColor = IM_COL32(40, 40, 50, 220);
                ImU32 borderColor = IM_COL32(100, 150, 200, 255);
                ImU32 textColor = IM_COL32(200, 220, 255, 255);
 
                drawList->AddRectFilled(bgMin, bgMax, bgColor, 3.0f);
                drawList->AddRect(bgMin, bgMax, borderColor, 3.0f, 0, 1.0f);
 
                // Text: White/light blue
                drawList->AddText(ImVec2(midpoint.x - textSize.x * 0.5f, midpoint.y - textSize.y * 0.5f),
                                 textColor, indexText);
            }
        }
    }
 
    void NodeGraphPanel::RenderContextMenu()
    {
        if (ImGui::BeginPopup("NodeCreationMenu"))
        {
            // Reset search buffer when popup first opens
            ImGui::Text("Create Node");
            ImGui::Separator();
 
            // Fuzzy search filter
            ImGui::SetNextItemWidth(-1.0f);
            ImGui::InputText("##search", m_ContextMenuSearch, sizeof(m_ContextMenuSearch));
            ImGui::SameLine(0.0f, 0.0f);
            ImGui::TextDisabled(" (search)");
            ImGui::Separator();
 
            // Build lowercase search string for case-insensitive matching
            std::string searchLower(m_ContextMenuSearch);
            for (size_t i = 0; i < searchLower.size(); ++i)
                searchLower[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(searchLower[i])));
 
            // Helper: returns true when item matches the search filter (empty = show all)
            auto matchesFilter = [&](const std::string& name) -> bool
            {
                if (searchLower.empty())
                    return true;
                std::string nameLower = name;
                for (size_t i = 0; i < nameLower.size(); ++i)
                    nameLower[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(nameLower[i])));
                return nameLower.find(searchLower) != std::string::npos;
            };
 
            // ----- Built-in BT composite nodes ----------------------------
            if (searchLower.empty())
            {
                if (ImGui::BeginMenu("Composite"))
                {
                    if (ImGui::MenuItem("Sequence"))
                        CreateNewNode("Sequence", m_ContextMenuPosX, m_ContextMenuPosY);
                    if (ImGui::MenuItem("Selector"))
                        CreateNewNode("Selector", m_ContextMenuPosX, m_ContextMenuPosY);
                    ImGui::EndMenu();
                }
 
                if (ImGui::BeginMenu("Action"))
                {
                    auto actionTypes = EnumCatalogManager::Get().GetActionTypes();
                    for (const auto& actionType : actionTypes)
                    {
                        if (ImGui::MenuItem(actionType.c_str()))
                        {
                            CreateNewNode("Action", m_ContextMenuPosX, m_ContextMenuPosY);
                            NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
                            if (graph)
                            {
                                auto allNodes = graph->GetAllNodes();
                                if (!allNodes.empty())
                                    allNodes.back()->actionType = actionType;
                            }
                        }
                    }
                    ImGui::EndMenu();
                }
 
                if (ImGui::BeginMenu("Condition"))
                {
                    auto conditionTypes = EnumCatalogManager::Get().GetConditionTypes();
                    for (const auto& conditionType : conditionTypes)
                    {
                        if (ImGui::MenuItem(conditionType.c_str()))
                        {
                            CreateNewNode("Condition", m_ContextMenuPosX, m_ContextMenuPosY);
                            NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
                            if (graph)
                            {
                                auto allNodes = graph->GetAllNodes();
                                if (!allNodes.empty())
                                    allNodes.back()->conditionType = conditionType;
                            }
                        }
                    }
                    ImGui::EndMenu();
                }
 
                if (ImGui::BeginMenu("Decorator"))
                {
                    auto decoratorTypes = EnumCatalogManager::Get().GetDecoratorTypes();
                    for (const auto& decoratorType : decoratorTypes)
                    {
                        if (ImGui::MenuItem(decoratorType.c_str()))
                        {
                            CreateNewNode("Decorator", m_ContextMenuPosX, m_ContextMenuPosY);
                            NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
                            if (graph)
                            {
                                auto allNodes = graph->GetAllNodes();
                                if (!allNodes.empty())
                                    allNodes.back()->decoratorType = decoratorType;
                            }
                        }
                    }
                    ImGui::EndMenu();
                }
 
                ImGui::Separator();
                ImGui::TextDisabled("-- Atomic Tasks --");
 
                if (ImGui::MenuItem("Comment Box"))
                {
                    NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
                    if (graph)
                    {
                        ImVec2 canvasPos = ScreenSpaceToGridSpace(ImVec2(m_ContextMenuPosX, m_ContextMenuPosY));
                        int nodeId = graph->CreateNode(NodeType::Comment, canvasPos.x, canvasPos.y, "Comment");
                        GraphNode* cnode = graph->GetNode(nodeId);
                        if (cnode)
                            cnode->parameters["text"] = "// Enter comment here";
                    }
                    ImGui::CloseCurrentPopup();
                }
            }
 
            // ----- AtomicTaskRegistry nodes (with fuzzy filter) -----------
            {
                std::vector<std::string> taskIds = AtomicTaskRegistry::Get().GetAllTaskIDs();
                // Sort for deterministic order
                std::sort(taskIds.begin(), taskIds.end());
 
                bool anyShown = false;
                for (const auto& taskId : taskIds)
                {
                    if (!matchesFilter(taskId))
                        continue;
                    anyShown = true;
                    if (ImGui::MenuItem(taskId.c_str()))
                    {
                        CreateNewNode("Action", m_ContextMenuPosX, m_ContextMenuPosY);
                        NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
                        if (graph)
                        {
                            auto allNodes = graph->GetAllNodes();
                            if (!allNodes.empty())
                                allNodes.back()->actionType = taskId;
                        }
                    }
                }
                if (!anyShown && !searchLower.empty())
                    ImGui::TextDisabled("No results for \"%s\"", m_ContextMenuSearch);
            }
 
            // Clear search when popup closes
            if (!ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows))
                m_ContextMenuSearch[0] = '\0';
 
            ImGui::EndPopup();
        }
    }
 
    void NodeGraphPanel::CreateNewNode(const char* nodeType, float screenX, float screenY)
    {
        NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
        if (!graph)
        {
            std::cerr << "[NodeGraphPanel] Cannot create node: No active graph\n";
            return;
        }
        
        // Convert screen coordinates to canvas coordinates
        ImVec2 canvasPos = ScreenSpaceToGridSpace(ImVec2(screenX, screenY));
        
        // Validate coordinates are finite (not NaN or infinity)
        if (!std::isfinite(canvasPos.x) || !std::isfinite(canvasPos.y))
        {
            std::cerr << "[NodeGraphPanel] Invalid coordinates for node creation\n";
            return;
        }
        
        std::cout << "[NodeGraphPanel] Creating " << nodeType << " at canvas pos ("
                  << canvasPos.x << ", " << canvasPos.y << ")\n";
 
        // Use BlueprintAdapter to execute create node command through the editor stack
        Blueprint::CommandStack* stack = BlueprintEditor::Get().GetCommandStack();
        int graphId = NodeGraphManager::Get().GetActiveGraphId();
        NodeGraphShared::BlueprintAdapter adapter(stack, graphId);
        int createdId = adapter.CreateNode(nodeType, canvasPos.x, canvasPos.y, nodeType);
 
        std::cout << "[NodeGraphPanel] Requested create node of type " << nodeType << " via command stack, id=" << createdId << "\n";
 
        // If node created, select it in ImNodes and update internal selection state
        if (createdId > 0)
        {
            int globalUID = graphId * GRAPH_ID_MULTIPLIER + createdId;
            ImNodes::ClearNodeSelection();
            ImNodes::SelectNode(globalUID);
            m_SelectedNodeId = createdId;
            // Move editor view to the newly created node so it is visible to the user
            ImNodes::EditorContextMoveToNode(globalUID);
        }
    }
 
    void NodeGraphPanel::RenderNodeProperties()
    {
        // This would show properties of the selected node
        // Can be integrated into inspector panel
    }
 
    void NodeGraphPanel::HandleKeyboardShortcuts()
    {
        NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
        if (!graph)
            return;
 
        ImGuiIO& io = ImGui::GetIO();
        
        // Ctrl+Z: Undo
        if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_Z) && !io.KeyShift)
        {
            BlueprintEditor::Get().Undo();
        }
        
        // Ctrl+Y or Ctrl+Shift+Z: Redo
        if ((io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_Y)) ||
            (io.KeyCtrl && io.KeyShift && ImGui::IsKeyPressed(ImGuiKey_Z)))
        {
            BlueprintEditor::Get().Redo();
        }
        
        // Ctrl+D: Duplicate selected node
        if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_D))
        {
            int selectedNodeCount = ImNodes::NumSelectedNodes();
            if (selectedNodeCount > 0)
            {
                std::vector<int> selectedNodes(selectedNodeCount);
                ImNodes::GetSelectedNodes(selectedNodes.data());
                if (selectedNodes.size() > 0)
                {
                    int nodeId = selectedNodes[0];
                    std::string graphId = std::to_string(NodeGraphManager::Get().GetActiveGraphId());
                    auto cmd = std::make_unique<Olympe::Blueprint::DuplicateNodeCommand>(graphId, nodeId);
                    BlueprintEditor::Get().GetCommandStack()->ExecuteCommand(std::move(cmd));
                }
            }
        }
 
        // Ctrl+C: Copy selected nodes to system clipboard
        if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_C))
        {
            NodeGraph* g = NodeGraphManager::Get().GetActiveGraph();
            int gid = NodeGraphManager::Get().GetActiveGraphId();
            if (g != nullptr)
                NodeGraphClipboard::Get().CopySelectedNodes(g, gid);
        }
 
        // Ctrl+V: Paste nodes from system clipboard under the mouse cursor
        if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_V))
        {
            NodeGraph* g  = NodeGraphManager::Get().GetActiveGraph();
            int        gid = NodeGraphManager::Get().GetActiveGraphId();
            if (g != nullptr)
            {
                ImVec2 mousePos = ImGui::GetMousePos();
                ImVec2 gridPos  = ScreenSpaceToGridSpace(mousePos);
                NodeGraphClipboard::Get().PasteNodes(g, gid, gridPos.x, gridPos.y,
                                                     m_SnapToGrid, m_SnapGridSize);
            }
        }
 
        // Ctrl+G: Toggle snap-to-grid
        if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_G))
        {
            m_SnapToGrid = !m_SnapToGrid;
        }
 
        // Ctrl+M: Toggle minimap
        if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_M))
        {
            m_ShowMinimap = !m_ShowMinimap;
        }
 
        // Ctrl+0: Reset panning to origin (fit view)
        if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_0))
        {
            ImNodes::EditorContextResetPanning(ImVec2(0.0f, 0.0f));
        }
    }
 
 
    void NodeGraphPanel::RenderNodeEditModal()
    {
        if (!m_ShowNodeEditModal || m_EditingNodeId < 0)
            return;
 
        NodeGraph* graph = NodeGraphManager::Get().GetActiveGraph();
        if (!graph)
        {
            m_ShowNodeEditModal = false;
            return;
        }
 
        GraphNode* node = graph->GetNode(m_EditingNodeId);
        if (!node)
        {
            m_ShowNodeEditModal = false;
            return;
        }
 
        ImGui::OpenPopup("Edit Node");
        ImVec2 center = ImGui::GetMainViewport()->GetCenter();
        ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
        
        if (ImGui::BeginPopupModal("Edit Node", &m_ShowNodeEditModal, ImGuiWindowFlags_AlwaysAutoResize))
        {
            // Node name
            if (ImGui::InputText("Name", m_NodeNameBuffer, sizeof(m_NodeNameBuffer)))
            {
                // Name will be saved on OK
            }
            
            ImGui::Text("Type: %s", NodeTypeToString(node->type));
            ImGui::Text("ID: %d", node->id);
            ImGui::Separator();
            
            std::string graphId = std::to_string(NodeGraphManager::Get().GetActiveGraphId());
            
            // Type-specific parameters
            if (node->type == NodeType::BT_Action)
            {
                // Action type dropdown
                ImGui::Text("Action Type:");
                auto actionTypes = EnumCatalogManager::Get().GetActionTypes();
                if (ImGui::BeginCombo("##actiontype", node->actionType.c_str()))
                {
                    for (const auto& actionType : actionTypes)
                    {
                        bool isSelected = (node->actionType == actionType);
                        if (ImGui::Selectable(actionType.c_str(), isSelected))
                        {
                            std::string oldType = node->actionType;
                            node->actionType = actionType;
                            // Could create EditNodeCommand here
                        }
                        if (isSelected)
                            ImGui::SetItemDefaultFocus();
                    }
                    ImGui::EndCombo();
                }
                
                // Show and edit parameters
                ImGui::Separator();
                ImGui::Text("Parameters:");
                
                // Get parameter definitions from catalog
                const CatalogType* actionDef = EnumCatalogManager::Get().FindActionType(node->actionType);
                if (actionDef)
                {
                    for (const auto& paramDef : actionDef->parameters)
                    {
                        std::string currentValue = node->parameters[paramDef.name];
                        if (currentValue.empty())
                            currentValue = paramDef.defaultValue;
                        
                        char buffer[256];
                        strncpy_s(buffer, currentValue.c_str(), sizeof(buffer) - 1);
                        buffer[sizeof(buffer) - 1] = '\0';
                        
                        if (ImGui::InputText(paramDef.name.c_str(), buffer, sizeof(buffer)))
                        {
                            std::string oldValue = node->parameters[paramDef.name];
                            node->parameters[paramDef.name] = buffer;
                            // Could create SetParameterCommand here for undo support
                        }
                        
                        if (!actionDef->tooltip.empty() && ImGui::IsItemHovered())
                        {
                            ImGui::SetTooltip("%s", actionDef->tooltip.c_str());
                        }
                    }
                }
            }
            else if (node->type == NodeType::BT_Condition)
            {
                // Condition type dropdown
                ImGui::Text("Condition Type:");
                auto conditionTypes = EnumCatalogManager::Get().GetConditionTypes();
                if (ImGui::BeginCombo("##conditiontype", node->conditionType.c_str()))
                {
                    for (const auto& conditionType : conditionTypes)
                    {
                        bool isSelected = (node->conditionType == conditionType);
                        if (ImGui::Selectable(conditionType.c_str(), isSelected))
                        {
                            node->conditionType = conditionType;
                        }
                        if (isSelected)
                            ImGui::SetItemDefaultFocus();
                    }
                    ImGui::EndCombo();
                }
                
                // Show and edit parameters
                ImGui::Separator();
                ImGui::Text("Parameters:");
                
                const CatalogType* conditionDef = EnumCatalogManager::Get().FindConditionType(node->conditionType);
                if (conditionDef)
                {
                    for (const auto& paramDef : conditionDef->parameters)
                    {
                        std::string currentValue = node->parameters[paramDef.name];
                        if (currentValue.empty())
                            currentValue = paramDef.defaultValue;
                        
                        char buffer[256];
                        strncpy_s(buffer, currentValue.c_str(), sizeof(buffer) - 1);
                        buffer[sizeof(buffer) - 1] = '\0';
                        
                        if (ImGui::InputText(paramDef.name.c_str(), buffer, sizeof(buffer)))
                        {
                            node->parameters[paramDef.name] = buffer;
                        }
                    }
                }
            }
            else if (node->type == NodeType::BT_Decorator)
            {
                // Decorator type dropdown
                ImGui::Text("Decorator Type:");
                auto decoratorTypes = EnumCatalogManager::Get().GetDecoratorTypes();
                if (ImGui::BeginCombo("##decoratortype", node->decoratorType.c_str()))
                {
                    for (const auto& decoratorType : decoratorTypes)
                    {
                        bool isSelected = (node->decoratorType == decoratorType);
                        if (ImGui::Selectable(decoratorType.c_str(), isSelected))
                        {
                            node->decoratorType = decoratorType;
                        }
                        if (isSelected)
                            ImGui::SetItemDefaultFocus();
                    }
                    ImGui::EndCombo();
                }
            }
            
            ImGui::Separator();
            
            if (ImGui::Button("OK", ImVec2(120, 0)))
            {
                // Apply name change if different
                std::string newName(m_NodeNameBuffer);
                if (newName != node->name)
                {
                    node->name = newName;
                }
                
                // Mark graph as dirty since node was edited
                if (graph)
                    graph->MarkDirty();
                
                m_ShowNodeEditModal = false;
                m_EditingNodeId = -1;
            }
            
            ImGui::SameLine();
            
            if (ImGui::Button("Cancel", ImVec2(120, 0)))
            {
                m_ShowNodeEditModal = false;
                m_EditingNodeId = -1;
            }
            
            ImGui::EndPopup();
        }
    }
 
// ============================================================================
// Phase 8: Subgraph tab system
// ============================================================================
 
    void NodeGraphPanel::RenderSubgraphTabBar()
    {
        if (ImGui::BeginTabBar("SubgraphTabs"))
        {
            for (int i = 0; i < (int)m_SubgraphTabs.size(); ++i)
            {
                GraphTab& tab = m_SubgraphTabs[i];
 
                // Build label (add dirty marker when modified).
                std::string label = tab.displayName;
                if (tab.isDirty)
                    label += " *";
 
                ImGuiTabItemFlags flags = ImGuiTabItemFlags_None;
                if (i == m_ActiveSubgraphTabIndex)
                    flags |= ImGuiTabItemFlags_SetSelected;
 
                // Root tab cannot be closed; subgraph tabs show an X button.
                bool tabOpen = true;
                bool* pOpen = (i == 0) ? nullptr : &tabOpen;
 
                if (ImGui::BeginTabItem(label.c_str(), pOpen, flags))
                {
                    m_ActiveSubgraphTabIndex = i;
                    ImGui::EndTabItem();
                }
 
                if (pOpen && !tabOpen)
                    CloseSubgraphTab(i);
            }
 
            // "+ New SubGraph" trailing button.
            if (ImGui::TabItemButton("+ New SubGraph", ImGuiTabItemFlags_Trailing))
                ImGui::OpenPopup("NewSubgraphPopup");
 
            ImGui::EndTabBar();
        }
 
        // New SubGraph name popup.
        if (ImGui::BeginPopup("NewSubgraphPopup"))
        {
            ImGui::Text("SubGraph name:");
            ImGui::SetNextItemWidth(200.0f);
            ImGui::InputText("##newsgname", m_NewSubgraphNameBuffer,
                             sizeof(m_NewSubgraphNameBuffer));
 
            if (ImGui::Button("Create") ||
                (ImGui::IsItemFocused() &&
                 ImGui::IsKeyPressed(ImGuiKey_Enter)))
            {
                std::string name(m_NewSubgraphNameBuffer);
                if (!name.empty())
                {
                    CreateEmptySubgraph(name);
                    m_NewSubgraphNameBuffer[0] = '\0';
                    ImGui::CloseCurrentPopup();
                }
            }
            ImGui::SameLine();
            if (ImGui::Button("Cancel"))
            {
                m_NewSubgraphNameBuffer[0] = '\0';
                ImGui::CloseCurrentPopup();
            }
 
            ImGui::EndPopup();
        }
    }
 
    void NodeGraphPanel::OpenSubgraphTab(const std::string& subgraphUUID,
                                          const std::string& displayName)
    {
        // Check whether the tab is already open.
        for (int i = 0; i < (int)m_SubgraphTabs.size(); ++i)
        {
            if (m_SubgraphTabs[i].tabID == subgraphUUID)
            {
                m_ActiveSubgraphTabIndex = i;
                return;
            }
        }
 
        // Not open yet — create a new tab.
        std::string path = "subgraphs/" + subgraphUUID;
        m_SubgraphTabs.emplace_back(subgraphUUID, displayName, path);
        m_ActiveSubgraphTabIndex = (int)m_SubgraphTabs.size() - 1;
 
        std::cout << "[NodeGraphPanel] Opened subgraph tab: " << displayName
                  << " (" << subgraphUUID << ")\n";
    }
 
    void NodeGraphPanel::CloseSubgraphTab(int index)
    {
        // Index 0 is the root graph — never close it.
        if (index <= 0 || index >= (int)m_SubgraphTabs.size())
            return;
        std::cout << "[NodeGraphPanel] Closed subgraph tab: "
                  << m_SubgraphTabs[index].displayName << "\n";
 
        m_SubgraphTabs.erase(m_SubgraphTabs.begin() + index);
 
        // Clamp active index.
        if (m_ActiveSubgraphTabIndex >= (int)m_SubgraphTabs.size())
            m_ActiveSubgraphTabIndex = (int)m_SubgraphTabs.size() - 1;
        if (m_ActiveSubgraphTabIndex < 0)
            m_ActiveSubgraphTabIndex = 0;
    }
 
    void NodeGraphPanel::CreateEmptySubgraph(const std::string& name)
    {
        // Use a monotonically-increasing counter to ensure UUIDs remain unique
        // even when subgraph tabs are closed and new ones are created later.
        static int s_SubgraphCounter = 0;
        ++s_SubgraphCounter;
 
        std::string uuid = "sg_" + std::to_string(s_SubgraphCounter) + "_" + name;
        // Replace spaces with underscores for a valid key.
        std::replace(uuid.begin(), uuid.end(), ' ', '_');
 
        std::cout << "[NodeGraphPanel] Created empty subgraph '" << name
                  << "' with UUID: " << uuid << "\n";
 
        // Open it in a new tab.
        OpenSubgraphTab(uuid, name);
    }
 
    const GraphTab* NodeGraphPanel::GetActiveTab() const
    {
        if (m_ActiveSubgraphTabIndex >= 0 &&
            m_ActiveSubgraphTabIndex < (int)m_SubgraphTabs.size())
        {
            return &m_SubgraphTabs[m_ActiveSubgraphTabIndex];
        }
        return nullptr;
    }
 
    std::string NodeGraphPanel::GetActiveSubgraphUUID() const
    {
        const GraphTab* tab = GetActiveTab();
        if (tab && tab->tabID != "root")
            return tab->tabID;
        return "";
    }
 
}