nodes.cpp

#include "nodes.h"
#include "TileCache.h"
#include "GPURenderer.h"
#include "Debug.h"
#include <algorithm>
#include <unordered_map>
#include <chrono>

namespace ImGui
{
    // Pre-linearize a color for the RGB565 tiles. The old tile format (GL_SRGB8_ALPHA8) converted
    // sRGB->linear when sampled during compositing, which darkens mid-tones; RGB565 stores linear and
    // does NO conversion, so baked colors read brighter/flatter. Baking pow(c, 2.2) into the color
    // values reproduces that darkening so tile content looks ~like it did before. Whites/blacks are
    // unchanged (only mid-tones move); alpha is left alone. Approximate (2.2 gamma vs true sRGB curve)
    // and does not affect RGB565's separate 5-6 bit banding. Apply ONLY to tile-baked colors - overlay
    // colors draw to the sRGB-ish default framebuffer and never shifted.
    static inline ImVec4 LinearizeForTile(const ImVec4& c) {
        return ImVec4(powf(c.x, 2.2f), powf(c.y, 2.2f), powf(c.z, 2.2f), c.w);
    }

    template<int n>
    struct BezierWeights
    {
        constexpr BezierWeights() : x_(), y_(), z_(), w_()
        {
            for (int i = 1; i <= n; ++i)
            {
                float t = (float)i / (float)(n + 1);
                float u = 1.0f - t;

                x_[i - 1] = u * u * u;
                y_[i - 1] = 3 * u * u * t;
                z_[i - 1] = 3 * u * t * t;
                w_[i - 1] = t * t * t;
            }
        }

        float x_[n];
        float y_[n];
        float z_[n];
        float w_[n];
    };

    static constexpr auto bezier_weights_ = BezierWeights<16>();

    float ImVec2Dot(const ImVec2& S1, const ImVec2& S2)
    {
        return (S1.x * S2.x + S1.y * S2.y);
    }

    float GetSquaredDistancePointSegment(const ImVec2& P, const ImVec2& S1, const ImVec2& S2)
    {
        const float l2 = (S1.x - S2.x) * (S1.x - S2.x) + (S1.y - S2.y) * (S1.y - S2.y);

        if (l2 < 1.0f)
        {
            return (P.x - S2.x) * (P.x - S2.x) + (P.y - S2.y) * (P.y - S2.y);
        }

        ImVec2 PS1(P.x - S1.x, P.y - S1.y);
        ImVec2 T(S2.x - S1.x, S2.y - S2.y);

        const float tf = ImVec2Dot(PS1, T) / l2;
        const float minTf = 1.0f < tf ? 1.0f : tf;
        const float t = 0.0f > minTf ? 0.0f : minTf;

        T.x = S1.x + T.x * t;
        T.y = S1.y + T.y * t;

        return (P.x - T.x) * (P.x - T.x) + (P.y - T.y) * (P.y - T.y);
    }

    float GetSquaredDistanceToBezierCurve(const ImVec2& point, const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4)
    {
        float minSquaredDistance = FLT_MAX;
        float tmp;

        ImVec2 L = p1;
        ImVec2 temp;

        for (int i = 1; i < 16 - 1; ++i)
        {
            const ImVec4& W = ImVec4(bezier_weights_.x_[i], bezier_weights_.y_[i], bezier_weights_.z_[i], bezier_weights_.w_[i]);

            temp.x = W.x * p1.x + W.y * p2.x + W.z * p3.x + W.w * p4.x;
            temp.y = W.x * p1.y + W.y * p2.y + W.z * p3.y + W.w * p4.y;

            tmp = GetSquaredDistancePointSegment(point, L, temp);

            if (minSquaredDistance > tmp)
            {
                minSquaredDistance = tmp;
            }

            L = temp;
        }

        tmp = GetSquaredDistancePointSegment(point, L, p4);

        if (minSquaredDistance > tmp)
        {
            minSquaredDistance = tmp;
        }

        return minSquaredDistance;
    }

	NodeView* GraphView::CreateNodeFromDesc(NodeViewDesc* desc, ImVec2 pos)
	{
		NodeView* node = new NodeView(desc->name_, desc->type_);
		
		ImVec2 inputs;
		ImVec2 outputs;

		////////////////////////////////////////////////////////////////////////////////

		for (int input_idx = 0; input_idx < ImGuiNodesConnectionsMaxNumber; ++input_idx)
		{
			if (desc->inputs_[input_idx].type_ == ImGuiNodesConnectorType_None)
				break;

			NodesInput* input = new NodesInput(desc->inputs_[input_idx].name_, desc->inputs_[input_idx].type_);

			inputs.x = ImMax(inputs.x, input->area_input_.GetWidth());
			inputs.y += input->area_input_.GetHeight();
			node->inputs_.push_back(input);
		}

		for (int output_idx = 0; output_idx < ImGuiNodesConnectionsMaxNumber; ++output_idx)
		{
			if (desc->outputs_[output_idx].type_ == ImGuiNodesConnectorType_None)
				break;
		
			NodesOutput* output = new NodesOutput(desc->outputs_[output_idx].name_, desc->outputs_[output_idx].type_);
		
			outputs.x = ImMax(outputs.x, output->area_output_.GetWidth());
			outputs.y += output->area_output_.GetHeight();
			node->outputs_.push_back(output);
		}

		////////////////////////////////////////////////////////////////////////////////
		
		node->BuildNodeGeometry(inputs, outputs);
		node->TranslateNode(pos); //
		node->state_ |= NodeStateFlag_Visible | NodeStateFlag_Hovered;

		return node;	
	}

	// Retrieves cached NodeView for the given nodeID, or creates and caches it if not found
	NodeView* GraphView::GetNodeView(const GraphData::Node& dataNode, ImVec2 position) {
		auto it = ImGui::GraphView::nodeViewCache_.find(dataNode.id);
		if (it != nodeViewCache_.end()) {
			// Update hierarchy state even for cached nodes (expand state may have changed)
			it->second->isExpandable = dataNode.isExpandable;
			it->second->isExpanded = layoutEngine->IsExpanded(dataNode.id);

			// Update position from LayoutEngine (source of truth for both layout and drag)
			if (layoutEngine->HasNodePosition(dataNode.id)) {
				ImVec2 layoutPos = layoutEngine->GetNodePosition(dataNode.id);
				ImVec2 delta = layoutPos - it->second->area_node_.Min;
				if (delta.x != 0.0f || delta.y != 0.0f) {
					it->second->TranslateNode(delta);
				}
			}

			return it->second;  // Return cached object
		}

		// Create new NodeView from relevant dataNode data
		NodeViewDesc desc = {};

		strncpy(desc.name_, dataNode.name.c_str(), ImGuiNodesNamesMaxLen - 1);
		desc.name_[ImGuiNodesNamesMaxLen - 1] = '\0';
		//desc.type_ = NodeType_Generic;  //When we introduce node types, use this

		// Map inputs
		for (size_t i = 0; i < dataNode.inputs.size() && i < ImGuiNodesConnectionsMaxNumber; i++) {
			strncpy(desc.inputs_[i].name_, dataNode.inputs[i].name.c_str(), 31);
			desc.inputs_[i].name_[31] = '\0';
			desc.inputs_[i].type_ = MapPortTypeToConnectorType(dataNode.inputs[i].type);
		}

		// Map outputs
		for (size_t i = 0; i < dataNode.outputs.size() && i < ImGuiNodesConnectionsMaxNumber; i++) {
			strncpy(desc.outputs_[i].name_, dataNode.outputs[i].name.c_str(), 31);
			desc.outputs_[i].name_[31] = '\0';
			desc.outputs_[i].type_ = MapPortTypeToConnectorType(dataNode.outputs[i].type);
		}

		NodeView* viewNode = CreateNodeFromDesc(&desc, position);
		// Note: viewNode->name_ already set by CreateNodeFromDesc (points to desc.name_)
		// Do NOT reassign here to dataNode.name.c_str() - that would create a dangling pointer!
		viewNode->nodeId = dataNode.id;

		// Copy hierarchy state for expand/collapse indicator
		viewNode->isExpandable = dataNode.isExpandable;
		viewNode->isExpanded = layoutEngine->IsExpanded(dataNode.id);

		// Apply dynamic size from LayoutEngine by rebuilding geometry
		ImVec2 calculatedSize = layoutEngine->GetNodeSize(dataNode.id);

		// Calculate current input/output sizes
		ImVec2 inputsSize(0, 0);
		ImVec2 outputsSize(0, 0);
		for (const auto* input : viewNode->inputs_) {
			inputsSize.x = ImMax(inputsSize.x, input->area_input_.GetWidth());
			inputsSize.y += input->area_input_.GetHeight();
		}
		for (const auto* output : viewNode->outputs_) {
			outputsSize.x = ImMax(outputsSize.x, output->area_output_.GetWidth());
			outputsSize.y += output->area_output_.GetHeight();
		}

		// Force the node to be EXACTLY the width LayoutEngine calculated
		// BuildNodeGeometry calculates: width = inputsSize.x + outputsSize.x + separator
		// We need: finalWidth = desiredWidth
		// So: inputsSize.x + outputsSize.x = desiredWidth - separator
		float separator = ImGuiNodesHSeparation * viewNode->area_name_.GetHeight();
		float desiredWidth = calculatedSize.x;
		float desiredIOWidth = desiredWidth - separator;

		// Scale inputs and outputs proportionally to fill desired width
		float currentIOWidth = inputsSize.x + outputsSize.x;
		if (currentIOWidth > 0) {
			float scale = desiredIOWidth / currentIOWidth;
			inputsSize.x *= scale;
			outputsSize.x *= scale;
		} else {
			// No inputs/outputs - split width evenly
			inputsSize.x = desiredIOWidth * 0.5f;
			outputsSize.x = desiredIOWidth * 0.5f;
		}

		// Reset area_name_ to origin before rebuilding (BuildNodeGeometry uses relative Translate)
		ImVec2 nameSize = viewNode->area_name_.GetSize();
		viewNode->area_name_.Min = ImVec2(0.0f, 0.0f);
		viewNode->area_name_.Max = nameSize;

		// Rebuild geometry with adjusted dimensions
		viewNode->BuildNodeGeometry(inputsSize, outputsSize);
		viewNode->TranslateNode(position);

		nodeViewCache_[dataNode.id] = viewNode;
		return viewNode;
	}

	// Helper to map DataModel PortType to ImGui ConnectorType
	ImGuiNodesConnectorType GraphView::MapPortTypeToConnectorType(GraphData::PortType portType) {
		switch (portType) {
		case GraphData::PortType::INT: return ImGuiNodesConnectorType_Int;
		case GraphData::PortType::FLOAT: return ImGuiNodesConnectorType_Float;
		case GraphData::PortType::BOOL: return ImGuiNodesConnectorType_Bool;
		default: return ImGuiNodesConnectorType_Generic;
		}
	}

	// Builds connection cache from DataModel to avoid 2M map lookups per frame
	// Includes connection substitution for expanded nodes (port mapping)
	void GraphView::BuildConnectionCache() {
		nodes_connections_.clear();
		connection_lookup_.clear();

		// Build cached connections from DataModel with substitution
		for (const auto& conn : dataModel->GetConnections()) {
			int actualSrcNodeId = conn.sourceNodeId;
			int actualSrcPort = conn.sourcePortIndex;
			int actualDstNodeId = conn.targetNodeId;
			int actualDstPort = conn.targetPortIndex;

			// Substitute source if parent is expanded
			if (layoutEngine->IsExpanded(conn.sourceNodeId)) {
				const GraphData::Node* child = dataModel->FindChildProvidingOutputPort(
					conn.sourceNodeId, conn.sourcePortIndex);

				if (!child) continue;  // No child provides this port = hidden connection

				actualSrcNodeId = child->id;
				actualSrcPort = dataModel->FindChildPortIndex(child->parentOutputPortMap, conn.sourcePortIndex);

				if (actualSrcPort < 0) continue;  // Port mapping failed
			}

			// Substitute target if parent is expanded
			if (layoutEngine->IsExpanded(conn.targetNodeId)) {
				const GraphData::Node* child = dataModel->FindChildAcceptingInputPort(
					conn.targetNodeId, conn.targetPortIndex);

				if (!child) continue;  // No child accepts this port = hidden connection

				actualDstNodeId = child->id;
				actualDstPort = dataModel->FindChildPortIndex(child->parentInputPortMap, conn.targetPortIndex);

				if (actualDstPort < 0) continue;  // Port mapping failed
			}

			// Look up cached NodeView objects for actual (substituted) nodes
			auto srcIt = nodeViewCache_.find(actualSrcNodeId);
			auto dstIt = nodeViewCache_.find(actualDstNodeId);

			// Skip if either node not in cache (not active)
			if (srcIt == nodeViewCache_.end() || dstIt == nodeViewCache_.end())
				continue;

			NodeView* srcView = srcIt->second;
			NodeView* dstView = dstIt->second;

			// Validate port indices
			if (actualSrcPort >= srcView->outputs_.size() ||
				actualDstPort >= dstView->inputs_.size())
				continue;

			// Build connection pair with cached pointers
			NodesConnectionPair connPair;
			connPair.output_node = srcView;
			connPair.output = srcView->outputs_[actualSrcPort];
			connPair.input_node = dstView;
			connPair.input = dstView->inputs_[actualDstPort];
			connPair.state = ImGuiNodesConnectionStateFlag_Default;

			nodes_connections_.push_back(connPair);
			connection_lookup_[{connPair.input, connPair.output}] =
				&nodes_connections_.back();
		}
	}

	// Resolve every edge to its final world-space GPUConnectionData ONCE. This is the tile-invariant
	// half of the old per-tile edge loop (expand/collapse substitution, GetEdgeRoutePoints, port-position
	// lookups, control-point packing). Tiles then only run the cheap per-tile bbox cull over the result,
	// so a 200k-node bake stops re-resolving ~1M edges for each of ~75 tiles. Requires nodeViewCache_ to
	// be populated (connector positions come from it), which RenderToTile guarantees before calling this.
	// Recompute one cached edge's polyline + bbox from the CURRENT node/connector positions. Uses the
	// resolved ids/ports already stored on `ce` (set during the full build), so it does NO substitution -
	// just routing + endpoint snap + control-point packing. This is the per-edge unit both the full build
	// and the incremental drag refresh share.
	void GraphView::ResolveEdgeGeometry(CachedEdge& ce) {
		std::vector<ImVec2> routePoints = layoutEngine->GetEdgeRoutePoints(ce.srcNodeId, ce.dstNodeId);
		if (routePoints.size() < 2) { ce.numPoints = 0; return; }

		// Snap endpoints to the real port connectors (read straight from the NodeViews - no map).
		auto srcIt = nodeViewCache_.find(ce.srcNodeId);
		if (srcIt != nodeViewCache_.end() && srcIt->second &&
		    ce.srcPort >= 0 && ce.srcPort < srcIt->second->outputs_.size() &&
		    srcIt->second->outputs_[ce.srcPort])
			routePoints[0] = srcIt->second->outputs_[ce.srcPort]->pos_;
		auto dstIt = nodeViewCache_.find(ce.dstNodeId);
		if (dstIt != nodeViewCache_.end() && dstIt->second &&
		    ce.dstPort >= 0 && ce.dstPort < dstIt->second->inputs_.size() &&
		    dstIt->second->inputs_[ce.dstPort])
			routePoints.back() = dstIt->second->inputs_[ce.dstPort]->pos_;

		// World-space route bbox, padded for the GPU control-point bow (±50px). Precomputed so the
		// per-tile cull is a single ImRect overlap test instead of a re-scan of the polyline.
		ImVec2 bbMin = routePoints[0], bbMax = routePoints[0];
		for (const ImVec2& p : routePoints) {
			bbMin.x = ImMin(bbMin.x, p.x); bbMin.y = ImMin(bbMin.y, p.y);
			bbMax.x = ImMax(bbMax.x, p.x); bbMax.y = ImMax(bbMax.y, p.y);
		}
		const float kEdgeCullMargin = 64.0f;
		ce.bbMin = ImVec2(bbMin.x - kEdgeCullMargin, bbMin.y - kEdgeCullMargin);
		ce.bbMax = ImVec2(bbMax.x + kEdgeCullMargin, bbMax.y + kEdgeCullMargin);

		// Store the polyline in the shared pool. An edge keeps its slot across re-resolves (a drag moves
		// points but can't change the route's point COUNT, since that's set by the layers it crosses), so
		// the incremental drag path writes in place and the pool never grows during a drag. Only a first
		// resolve, or the rare count change, appends - the stale slot is then abandoned, which BuildEdge-
		// RenderCache's full rebuild reclaims.
		if (ce.numPoints != (uint32_t)routePoints.size()) {
			ce.pointOffset = (uint32_t)edgePointPool_.size();
			ce.numPoints = (uint32_t)routePoints.size();
			edgePointPool_.resize(ce.pointOffset + ce.numPoints);
		}
		for (uint32_t i = 0; i < ce.numPoints; i++)
			edgePointPool_[ce.pointOffset + i] = routePoints[i];

		ce.color = ImGui::ColorConvertFloat4ToU32(ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
		ce.thickness = 2.0f;  // world-space width; the shader scales by zoom
	}

	// Copy a cached polyline into the fixed-size struct the shaders read. A deep edge accrues one dummy
	// waypoint per crossed layer and can exceed the cap; never truncate (that strands the far endpoint) -
	// keep the exact endpoints and evenly subsample the interior.
	void GraphView::FillGPUConnection(const CachedEdge& ce, GPUConnectionData& out) const {
		out = GPUConnectionData{};
		const ImVec2* pts = &edgePointPool_[ce.pointOffset];
		if (ce.numPoints <= (uint32_t)MAX_EDGE_POINTS) {
			for (uint32_t i = 0; i < ce.numPoints; i++)
				out.controlPoints[i] = pts[i];
			out.numPoints = ce.numPoints;
		} else {
			const size_t last = ce.numPoints - 1;
			out.controlPoints[0] = pts[0];
			out.controlPoints[MAX_EDGE_POINTS - 1] = pts[last];
			for (int i = 1; i < MAX_EDGE_POINTS - 1; i++) {
				float t = (float)i / (float)(MAX_EDGE_POINTS - 1);
				size_t srcIdx = (size_t)(t * (float)last + 0.5f);
				if (srcIdx == 0) srcIdx = 1;
				if (srcIdx >= last) srcIdx = last - 1;
				out.controlPoints[i] = pts[srcIdx];
			}
			out.numPoints = MAX_EDGE_POINTS;
		}
		out.color = ce.color;
		out.thickness = ce.thickness;
	}

	void GraphView::BuildEdgeRenderCache() {
		edgeRenderCache_.clear();
		edgeIndexByNode_.clear();
		edgeRenderCache_.reserve(dataModel->GetConnections().size());
		// Reclaims any slots abandoned by point-count changes since the last full build.
		edgePointPool_.clear();
		// Most edges are straight (2 points); deeper routes just grow the pool from here.
		edgePointPool_.reserve(dataModel->GetConnections().size() * 2);

		for (const auto& conn : dataModel->GetConnections()) {
			int srcNodeId = conn.sourceNodeId;
			int dstNodeId = conn.targetNodeId;
			int srcPort = conn.sourcePortIndex;
			int dstPort = conn.targetPortIndex;

			// Expand/collapse port substitution (mirrors BuildConnectionCache). Done ONCE here; the
			// incremental drag refresh reuses the resolved ids/ports and skips this.
			if (layoutEngine->IsExpanded(srcNodeId)) {
				const GraphData::Node* child = dataModel->FindChildProvidingOutputPort(srcNodeId, conn.sourcePortIndex);
				if (child) {
					srcNodeId = child->id;
					srcPort = dataModel->FindChildPortIndex(child->parentOutputPortMap, conn.sourcePortIndex);
				} else continue;
			}
			if (layoutEngine->IsExpanded(dstNodeId)) {
				const GraphData::Node* child = dataModel->FindChildAcceptingInputPort(dstNodeId, conn.targetPortIndex);
				if (child) {
					dstNodeId = child->id;
					dstPort = dataModel->FindChildPortIndex(child->parentInputPortMap, conn.targetPortIndex);
				} else continue;
			}

			CachedEdge ce;
			ce.srcNodeId = srcNodeId; ce.dstNodeId = dstNodeId;
			ce.srcPort = srcPort;     ce.dstPort = dstPort;
			ResolveEdgeGeometry(ce);
			if (ce.numPoints < 2) continue;  // unroutable (missing endpoints) - drop it

			int idx = (int)edgeRenderCache_.size();
			edgeRenderCache_.push_back(ce);
			edgeIndexByNode_[srcNodeId].push_back(idx);
			if (dstNodeId != srcNodeId) edgeIndexByNode_[dstNodeId].push_back(idx);
		}
	}

	void GraphView::TileRangeForRect(const ImVec2& mn, const ImVec2& mx,
	                                 int& x0, int& y0, int& x1, int& y1) {
		const int TS = TileCache::TILE_SIZE;
		// Integer division truncates toward zero, so negative coords would fold onto tile 0 and put
		// off-world geometry in the origin tile's bucket. Clamp instead - TileCache's grid starts at 0.
		x0 = mn.x < 0.0f ? 0 : (int)(mn.x / TS);
		y0 = mn.y < 0.0f ? 0 : (int)(mn.y / TS);
		x1 = mx.x < 0.0f ? 0 : (int)(mx.x / TS);
		y1 = mx.y < 0.0f ? 0 : (int)(mx.y / TS);
	}

	// Bucket every visible node into the tiles its rect overlaps. Runs once per bake instead of the
	// old whole-graph scan per tile (see nodeIdsByTile_).
	void GraphView::BuildNodeBuckets() {
		nodeIdsByTile_.clear();
		for (const auto& pair : nodeViewCache_) {
			const NodeView* node = pair.second;
			if (!(node->state_ & NodeStateFlag_Visible))
				continue;   // same filter the per-tile rect loop used

			int x0, y0, x1, y1;
			TileRangeForRect(node->area_node_.Min, node->area_node_.Max, x0, y0, x1, y1);
			for (int ty = y0; ty <= y1; ++ty)
				for (int tx = x0; tx <= x1; ++tx)
					nodeIdsByTile_[std::make_pair(tx, ty)].push_back(pair.first);
		}
	}

	// Bucket every cached edge into the tiles its (already padded) route bbox overlaps.
	void GraphView::MarkBucketOverride(const std::vector<int>& movedNodeIds) {
		for (int nodeId : movedNodeIds) {
			bucketOverrideNodeIds_.insert(nodeId);
			auto it = edgeIndexByNode_.find(nodeId);
			if (it == edgeIndexByNode_.end()) continue;
			for (int idx : it->second) {
				if (std::find(bucketOverrideEdgeIdxs_.begin(), bucketOverrideEdgeIdxs_.end(), idx)
				    == bucketOverrideEdgeIdxs_.end())
					bucketOverrideEdgeIdxs_.push_back(idx);
			}
		}
	}

	void GraphView::BuildEdgeBuckets() {
		edgeIdxByTile_.clear();
		// A full rebuild re-buckets from current positions, so the drag overrides are absorbed.
		bucketOverrideNodeIds_.clear();
		bucketOverrideEdgeIdxs_.clear();
		for (int i = 0; i < (int)edgeRenderCache_.size(); ++i) {
			const CachedEdge& ce = edgeRenderCache_[i];
			int x0, y0, x1, y1;
			TileRangeForRect(ce.bbMin, ce.bbMax, x0, y0, x1, y1);
			for (int ty = y0; ty <= y1; ++ty)
				for (int tx = x0; tx <= x1; ++tx)
					edgeIdxByTile_[std::make_pair(tx, ty)].push_back(i);
		}
	}

	void GraphView::RefreshEdgeGeometryForNodes(const std::vector<int>& movedNodeIds) {
		if (!edgeRenderCacheValid_ || edgeRenderCache_.empty()) return;  // nothing built yet -> full build will run
		for (int nodeId : movedNodeIds) {
			auto it = edgeIndexByNode_.find(nodeId);
			if (it == edgeIndexByNode_.end()) continue;
			for (int idx : it->second)
				ResolveEdgeGeometry(edgeRenderCache_[idx]);
		}
	}

	void GraphView::ProcessNodes()
	{
		ImDrawList* draw_list = ImGui::GetWindowDrawList();
		ImVec2 offset = pos_ + world_shift_;

		////////////////////////////////////////////////////////////////////////////////

		ImGui::SetWindowFontScale(scale_);

		// Check if culling is enabled (culling_rect_ has non-zero area)
		bool use_culling = (culling_rect_.GetWidth() > 0.0f && culling_rect_.GetHeight() > 0.0f);

		int nodes_culled = 0;
		int nodes_rendered = 0;

		// Track expanded parent nodes to draw boundaries
		std::vector<int> expandedParentIds;

		// First pass: Render active nodes (root + expanded children)
		std::vector<const GraphData::Node*> activeNodes = layoutEngine->GetActiveNodes(*dataModel);

		for (const GraphData::Node* dataNode : activeNodes)
		{
			// Get position + size from LayoutEngine
			ImVec2 pos = layoutEngine->GetNodePosition(dataNode->id);

			NodeView* viewNode = GetNodeView(*dataNode, pos);

			// Track if this node's parent is expanded (to draw boundary later)
			if (dataNode->parentId != -1 && layoutEngine->IsExpanded(dataNode->parentId)) {
				// Check if we've already added this parent
				if (std::find(expandedParentIds.begin(), expandedParentIds.end(), dataNode->parentId) == expandedParentIds.end()) {
					expandedParentIds.push_back(dataNode->parentId);
				}
			}

			// culling world space nodes out if outside of tile space
			if (use_culling && !culling_rect_.Overlaps(viewNode->area_node_)) {
				nodes_culled++;
				continue;
			}
			nodes_rendered++;
			viewNode->DrawNode(draw_list, offset, scale_);
		}

		// Draw subgraph boundaries for expanded parents (found in first pass)
		for (int parentId : expandedParentIds) {
			const GraphData::Node* parent = dataModel->GetNode(parentId);
			if (!parent) continue;

			// Calculate bounding box of all children
			ImVec2 min(FLT_MAX, FLT_MAX);
			ImVec2 max(-FLT_MAX, -FLT_MAX);

			for (int childId : parent->childNodeIds) {
				ImRect childBounds = layoutEngine->GetNodeBounds(childId);
				if (childBounds.GetWidth() > 0) {  // Valid bounds
					min.x = ImMin(min.x, childBounds.Min.x);
					min.y = ImMin(min.y, childBounds.Min.y);
					max.x = ImMax(max.x, childBounds.Max.x);
					max.y = ImMax(max.y, childBounds.Max.y);
				}
			}

			// Add padding around subgraph
			float padding = 20.0f;
			min.x -= padding;
			min.y -= padding;
			max.x += padding;
			max.y += padding;

			// Transform to screen space
			ImVec2 screenMin = (min * scale_) + offset;
			ImVec2 screenMax = (max * scale_) + offset;

			// Draw dark blue boundary with some transparency
			draw_list->AddRect(screenMin, screenMax,
				ImColor(0.2f, 0.3f, 0.8f, 0.6f), 0.0f, 0, 3.0f * scale_);

			// Draw filled rect with low alpha for visual grouping
			draw_list->AddRectFilled(screenMin, screenMax,
				ImColor(0.2f, 0.3f, 0.8f, 0.1f));
		}

        // Second pass: Render connections (now that all NodeViews exist)
        // Build connection cache if needed (avoids 2M map lookups per frame)
        if (!connectionCacheValid_) {
            BuildConnectionCache();
            connectionCacheValid_ = true;
        }

        // Render connections from cached array (fast!)
        for (const auto& conn : nodes_connections_)
        {
            // Calculate Bezier control points in world space (before transform)
            ImVec2 p1_world = conn.input->pos_;
            ImVec2 p2_world = p1_world + ImVec2(-50.0f, 0.0f);
            ImVec2 p4_world = conn.output->pos_;
            ImVec2 p3_world = p4_world + ImVec2(+50.0f, 0.0f);

            // Cull connections: check if edge bounding box overlaps culling rect
            if (use_culling)
            {
                // Calculate bounding box of all 4 Bezier control points
                ImVec2 edgeMin(ImMin(ImMin(p1_world.x, p2_world.x), ImMin(p3_world.x, p4_world.x)),
                               ImMin(ImMin(p1_world.y, p2_world.y), ImMin(p3_world.y, p4_world.y)));
                ImVec2 edgeMax(ImMax(ImMax(p1_world.x, p2_world.x), ImMax(p3_world.x, p4_world.x)),
                               ImMax(ImMax(p1_world.y, p2_world.y), ImMax(p3_world.y, p4_world.y)));
                ImRect edgeBounds(edgeMin, edgeMax);

                // Skip if edge bounding box doesn't overlap culling rect
                if (!culling_rect_.Overlaps(edgeBounds))
                    continue;
            }

            // Transform to screen space
            ImVec2 p1 = offset + (p1_world * scale_);
            ImVec2 p2 = offset + (p2_world * scale_);
            ImVec2 p3 = offset + (p3_world * scale_);
            ImVec2 p4 = offset + (p4_world * scale_);

            // Draw connection with state-based color
            if (conn.state == ImGuiNodesConnectionStateFlag_Hovered)
                draw_list->AddBezierCubic(p1, p2, p3, p4, ImColor(1.0f, 0.7f, 0.0f, 1.0f), 2.0f * scale_);
            else
                draw_list->AddBezierCubic(p1, p2, p3, p4, ImColor(1.0f, 1.0f, 1.0f, 1.0f), 2.0f * scale_);
        }
		//DELETE ME
		//for (int node_idx = 0; node_idx < nodes_.size(); ++node_idx)
		//{
		//	NodeView* node = nodes_[node_idx];
		//
		//	// Cull nodes: skip if node is outside the culling rect
		//	if (use_culling && !culling_rect_.Overlaps(node->area_node_))
		//	{
		//		nodes_culled++;
		//		continue;
		//	}
		//
		//	node->DrawNode(draw_list, offset, scale_);
		//}

		if (gDebugEnabled && use_culling && nodes_culled > 0)
		{
			// Debug: print culling stats (only first time to avoid spam)
			static int debug_count = 0;
			if (debug_count++ < 10)
			{
				printf("    Culling: rendered %d nodes, culled %d nodes (culling rect: %.0f,%.0f-%.0f,%.0f)\n",
					   nodes_rendered, nodes_culled,
					   culling_rect_.Min.x, culling_rect_.Min.y,
					   culling_rect_.Max.x, culling_rect_.Max.y);
			}
		}

		ImGui::SetWindowFontScale(1.0f);

		////////////////////////////////////////////////////////////////////////////////

		if (state_ == ImGuiNodesState_Selecting)
		{
            //Optimization: Cache verts instead of sending every frame
            //Send all vect comps to the gpu
			draw_list->AddRectFilled(area_.Min, area_.Max, ImColor(1.0f, 1.0f, 0.0f, 0.1f)); 
			draw_list->AddRect(area_.Min, area_.Max, ImColor(1.0f, 1.0f, 0.0f, 0.5f));
		}

		////////////////////////////////////////////////////////////////////////////////


		ImGui::SetCursorPos(ImVec2(0.0f, 0.0f));
		ImGui::NewLine();

		switch (state_)
		{
			case ImGuiNodesState_Default: ImGui::Text("ImGuiNodesState_Default"); break;
			case ImGuiNodesState_HoveringNode: ImGui::Text("ImGuiNodesState_HoveringNode"); break;
			case ImGuiNodesState_HoveringInput: ImGui::Text("ImGuiNodesState_HoveringInput"); break;
			case ImGuiNodesState_HoveringOutput: ImGui::Text("ImGuiNodesState_HoveringOutput"); break;
            case ImGuiNodesState_Dragging: ImGui::Text("ImGuiNodesState_Dragging"); break;
            case ImGuiNodesState_DraggingInput: ImGui::Text("ImGuiNodesState_DraggingInput"); break;
            case ImGuiNodesState_DraggingOutput: ImGui::Text("ImGuiNodesState_DraggingOutput"); break;
			case ImGuiNodesState_Selecting: ImGui::Text("ImGuiNodesState_Selecting"); break;
            case ImGuiNodesState_HoveringConnection: ImGui::Text("ImGuiNodesState_HoveringConnection"); break;
            default: ImGui::Text("UNKNOWN"); break;
		}

		ImGui::NewLine();

		ImGui::Text("Position: %.2f, %.2f", pos_.x, pos_.y);
		ImGui::Text("Size: %.2f, %.2f", size_.x, size_.y);
		ImGui::Text("Mouse: %.2f, %.2f", mouse_.x, mouse_.y);
		ImGui::Text("Scroll: %.2f, %.2f", world_shift_.x, world_shift_.y);
		ImGui::Text("Scale: %.2f", scale_);

		ImGui::NewLine();

		if (element_node_)
			ImGui::Text("Element_node: %s", element_node_->name_);
		if (element_input_)
			ImGui::Text("Element_input: %s", element_input_->name_);
		if (element_output_)
			ImGui::Text("Element_output: %s", element_output_->name_);


		////////////////////////////////////////////////////////////////////////////////
	}

	void GraphView::ProcessContextMenu()
	{
		ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8, 8));

		if (ImGui::BeginPopup("NodesContextMenu"))
		{
			for (int node_idx = 0; node_idx < nodes_desc_.size(); ++node_idx)
				if (ImGui::MenuItem(nodes_desc_[node_idx].name_))
				{
					//New way to add nodes (will have no connections!): (layout engine decides pos)
					// GraphData::Node newNode(nextId, "NewNode");
					//dataModel->AddNode(newNode);

					//Old way to make nodes:
					//NodeView* node = CreateNodeFromDesc(&nodes_desc_[node_idx], (mouse_ - world_shift_ - pos_) / scale_);
					//nodes_.push_back(node);
				}

			ImGui::EndPopup();
		}

		ImGui::PopStyleVar();
	}

	ImVec2 GraphView::GetRenderedNodeSize(const GraphData::Node& dataNode, ImVec2 pos)
	{
		NodeView* view = GetNodeView(dataNode, pos);  // creates + caches if missing
		if (!view) return ImVec2(150.0f, 50.0f);
		return view->area_node_.GetSize();
	}

	void GraphView::BuildOverlayNodeText(int nodeId, ImVec2 livePos, uint32_t color,
	                                     std::vector<GPUCharData>& out) const
	{
		if (!gpuRenderer_) return;
		auto it = nodeViewCache_.find(nodeId);
		if (it == nodeViewCache_.end()) return;
		const NodeView* node = it->second;
		const GraphData::Node* dataNode = dataModel ? dataModel->GetNode(nodeId) : nullptr;
		if (!dataNode) return;

		// The cached connector geometry is relative to the node's BAKED top-left. Offset by how far
		// the node has moved (livePos - bakedTopLeft) so labels track the live position.
		ImVec2 off = ImVec2(livePos.x - node->area_node_.Min.x,
		                    livePos.y - node->area_node_.Min.y);

		// Title
		gpuRenderer_->BuildTextChars(dataNode->name.c_str(),
		                             ImVec2(livePos.x + 8.0f, livePos.y + 4.0f), color, out);

		// "+" symbol for expandable (collapsed) parent nodes - matches the tile path (nodes.cpp text loop).
		// Positioned at the right of the title bar; livePos is the live top-left, so offset by node width.
		if (!dataNode->childNodeIds.empty() && layoutEngine && !layoutEngine->IsExpanded(nodeId)) {
			float plusX = livePos.x + node->area_node_.GetWidth() - 20.0f;  // 20px from right edge
			float plusY = livePos.y + 4.0f;                                // same Y as title
			gpuRenderer_->BuildTextChars("+", ImVec2(plusX, plusY), color, out);
		}

		// Input connector labels
		for (int i = 0; i < node->inputs_.size(); ++i) {
			const NodesInput* input = node->inputs_[i];
			if (input->type_ == ImGuiNodesConnectorType_Invisible) continue;
			ImVec2 p = ImVec2(input->area_name_.Min.x + off.x, input->area_name_.Min.y + off.y);
			gpuRenderer_->BuildTextChars(input->name_, p, color, out);
		}
		// Output connector labels
		for (int i = 0; i < node->outputs_.size(); ++i) {
			const NodesOutput* output = node->outputs_[i];
			if (output->type_ == ImGuiNodesConnectorType_Invisible) continue;
			ImVec2 p = ImVec2(output->area_name_.Min.x + off.x, output->area_name_.Min.y + off.y);
			gpuRenderer_->BuildTextChars(output->name_, p, color, out);
		}
	}

	void GraphView::BuildOverlayEdges(const std::function<ImVec2(int)>& livePos,
	                                  std::vector<GPUConnectionData>& out) const
	{
		if (!dataModel || !layoutEngine) return;

		// Per-node world offset from baked top-left to live position (0 for non-animated nodes).
		auto liveOffset = [&](int nodeId) -> ImVec2 {
			auto it = nodeViewCache_.find(nodeId);
			if (it == nodeViewCache_.end()) return ImVec2(0.0f, 0.0f);
			ImVec2 baked = it->second->area_node_.Min;
			ImVec2 lp = livePos(nodeId);
			return ImVec2(lp.x - baked.x, lp.y - baked.y);
		};

		for (const auto& conn : dataModel->GetConnections()) {
			int srcNodeId = conn.sourceNodeId, dstNodeId = conn.targetNodeId;
			int srcPort = conn.sourcePortIndex, dstPort = conn.targetPortIndex;

			// Same expand/collapse substitution as the tile path.
			if (layoutEngine->IsExpanded(srcNodeId)) {
				const GraphData::Node* c = dataModel->FindChildProvidingOutputPort(srcNodeId, conn.sourcePortIndex);
				if (c) { srcNodeId = c->id; srcPort = dataModel->FindChildPortIndex(c->parentOutputPortMap, conn.sourcePortIndex); }
				else continue;
			}
			if (layoutEngine->IsExpanded(dstNodeId)) {
				const GraphData::Node* c = dataModel->FindChildAcceptingInputPort(dstNodeId, conn.targetPortIndex);
				if (c) { dstNodeId = c->id; dstPort = dataModel->FindChildPortIndex(c->parentInputPortMap, conn.targetPortIndex); }
				else continue;
			}

			// ONLY edges touching an animated node (the inverse of the tile path's hole-punch).
			if (!IsAnimated(srcNodeId) && !IsAnimated(dstNodeId)) continue;

			std::vector<ImVec2> routePoints = layoutEngine->GetEdgeRoutePoints(srcNodeId, dstNodeId);
			// Freshly-expanded children aren't in layoutEngine->nodePositions_ yet (only committed
			// on settle), so GetEdgeRoutePoints returns empty for them. Fall back to a direct 2-point
			// route; the endpoints are overwritten with live port positions just below anyway.
			if (routePoints.size() < 2) {
				routePoints.clear();
				routePoints.push_back(ImVec2(0.0f, 0.0f));  // placeholder src (set below)
				routePoints.push_back(ImVec2(0.0f, 0.0f));  // placeholder dst (set below)
			}

			// Endpoints: use cached port positions offset to the live node position. (Dummy
			// waypoints in the middle stay at their baked positions - fine, endpoints dominate.)
			ImVec2 srcOff = liveOffset(srcNodeId);
			ImVec2 dstOff = liveOffset(dstNodeId);
			auto sit = nodeViewCache_.find(srcNodeId);
			if (sit != nodeViewCache_.end() && srcPort >= 0 && srcPort < (int)sit->second->outputs_.size()) {
				ImVec2 pp = sit->second->outputs_[srcPort]->pos_;
				routePoints[0] = ImVec2(pp.x + srcOff.x, pp.y + srcOff.y);
			}
			auto dit = nodeViewCache_.find(dstNodeId);
			if (dit != nodeViewCache_.end() && dstPort >= 0 && dstPort < (int)dit->second->inputs_.size()) {
				ImVec2 pp = dit->second->inputs_[dstPort]->pos_;
				routePoints.back() = ImVec2(pp.x + dstOff.x, pp.y + dstOff.y);
			}

			GPUConnectionData gpuConn = {};
			size_t n = routePoints.size() <= (size_t)MAX_EDGE_POINTS ? routePoints.size() : (size_t)MAX_EDGE_POINTS;
			if (n < 2) continue;
			if (routePoints.size() <= (size_t)MAX_EDGE_POINTS) {
				for (size_t i = 0; i < n; i++) gpuConn.controlPoints[i] = routePoints[i];
			} else {
				const size_t last = routePoints.size() - 1;
				gpuConn.controlPoints[0] = routePoints[0];
				gpuConn.controlPoints[MAX_EDGE_POINTS - 1] = routePoints[last];
				for (int i = 1; i < MAX_EDGE_POINTS - 1; i++) {
					float t = (float)i / (float)(MAX_EDGE_POINTS - 1);
					size_t si = (size_t)(t * (float)last + 0.5f);
					if (si == 0) si = 1; if (si >= last) si = last - 1;
					gpuConn.controlPoints[i] = routePoints[si];
				}
			}
			gpuConn.numPoints = (uint32_t)n;
			gpuConn.color = ImGui::ColorConvertFloat4ToU32(ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
			gpuConn.thickness = 2.0f;
			out.push_back(gpuConn);
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	// High-level rendering methods
	////////////////////////////////////////////////////////////////////////////////

	// Sync nodeViewCache_ (and the expanded-parent list) from the DataModel + LayoutEngine for every
	// active node. Tile-invariant, so the bake loop calls this ONCE and then renders all dirty tiles;
	// RenderToTile() calls it too so single-tile/interactive callers stay correct (it's idempotent).
	// Guarded by nodeViewsSynced_ to collapse the repeats within one bake.
	void GraphView::SyncNodeViews()
	{
		if (nodeViewsSynced_)
			return;

		std::vector<const GraphData::Node*> activeNodes = layoutEngine->GetActiveNodes(*dataModel);
		expandedParentIds_.clear();

		for (const GraphData::Node* dataNode : activeNodes) {
			ImVec2 pos = layoutEngine->GetNodePosition(dataNode->id);
			GetNodeView(*dataNode, pos);  // Populates nodeViewCache_

			// Track if this node's parent is expanded (to draw boundary later)
			if (dataNode->parentId != -1 && layoutEngine->IsExpanded(dataNode->parentId)) {
				if (std::find(expandedParentIds_.begin(), expandedParentIds_.end(), dataNode->parentId) == expandedParentIds_.end()) {
					expandedParentIds_.push_back(dataNode->parentId);
				}
			}
		}

		// Expand order (least-recent first) is the boundary-box z-order; also tile-invariant.
		std::sort(expandedParentIds_.begin(), expandedParentIds_.end(),
		          [this](int a, int b) {
		              return layoutEngine->GetExpandOrder(a) < layoutEngine->GetExpandOrder(b);
		          });

		nodeViewsSynced_ = true;
		spatialBucketsValid_ = false;  // nodeViewCache_ just changed -> node buckets are stale
	}

	void GraphView::RenderToTile(Tile* tile)
{
	// Set up tile rendering context
	pos_ = ImVec2(0, 0);
	world_shift_ = -tile->worldBounds.Min;
	scale_ = 1.0f;
	culling_rect_ = tile->worldBounds;

	// Node-view sync is TILE-INVARIANT and hoisted to SyncNodeViews(), called once per bake by the
	// render loop. It walks every active node (GetActiveNodes + 3 std::map lookups each), so doing it
	// per tile cost O(nodes x tiles) - ~400M tree traversals at 650k nodes x 200 tiles, which dominated
	// bake time. Correctness is unchanged: it still runs fully BEFORE any tile renders, which is what
	// BuildEdgeRenderCache and the subgraph-boundary box require (they read positions for nodes outside
	// the current tile, so a per-tile cull here would drop edges and half-draw seam-straddling nodes).
	SyncNodeViews();
	const std::vector<int>& expandedParentIds = expandedParentIds_;

	// Choose rendering path: GPU or CPU
	if (useGPURendering_ && gpuRenderer_ && gpuRenderer_->IsSupported()) {
		// GPU rendering path (OpenGL 4.3+ compute shaders)

		// Rebuild connection cache if needed (same as CPU path). Topology change -> also stale geometry.
		if (!connectionCacheValid_) {
			BuildConnectionCache();
			connectionCacheValid_ = true;
			edgeRenderCacheValid_ = false;  // topology changed -> geometry must be re-resolved too
		}
		// Re-resolve world-space edge geometry when stale (topology change). A node drag does NOT flip
		// this flag - it calls RefreshEdgeGeometryForNodes to patch just the moved edges incrementally.
		if (!edgeRenderCacheValid_) {
			BuildEdgeRenderCache();  // resolve every edge's world geometry ONCE; tiles just cull it below
			edgeRenderCacheValid_ = true;
			spatialBucketsValid_ = false;  // edge indices moved -> edge buckets are stale
		}

		// Spatial buckets: also tile-invariant, so build once per bake. This is what turns the bake from
		// O(nodes x tiles) into O(nodes + tiles) - the loops below iterate this tile's bucket instead of
		// re-scanning the whole graph and culling.
		if (!spatialBucketsValid_) {
			BuildNodeBuckets();
			BuildEdgeBuckets();
			spatialBucketsValid_ = true;
		}

		// This tile's buckets. Absent key = nothing here; use a shared empty list so the loops below
		// don't need a null check.
		static const std::vector<int> kNoIds;
		std::pair<int,int> tileKey(
			(int)(tile->worldBounds.Min.x / TileCache::TILE_SIZE),
			(int)(tile->worldBounds.Min.y / TileCache::TILE_SIZE));
		auto nodeBucketIt = nodeIdsByTile_.find(tileKey);
		auto edgeBucketIt = edgeIdxByTile_.find(tileKey);
		const std::vector<int>& tileNodeIds  = (nodeBucketIt != nodeIdsByTile_.end()) ? nodeBucketIt->second : kNoIds;
		const std::vector<int>& tileEdgeIdxs = (edgeBucketIt != edgeIdxByTile_.end()) ? edgeBucketIt->second : kNoIds;
		// Drag overrides as a vector so the node loops can iterate bucket and overrides uniformly.
		const std::vector<int> overrideNodeIdList(bucketOverrideNodeIds_.begin(), bucketOverrideNodeIds_.end());

		// GPU BUILD APPROACH: per-tile we now do ONLY the cheap work - reject edges whose (precomputed)
		// world bbox doesn't touch this tile, hole-punch animated edges, then upload. All the heavy
		// resolution (substitution, routing, port lookup, control-point packing) already happened once
		// in BuildEdgeRenderCache(), instead of repeating for every tile.
		// Reuse the persistent staging buffer (see tileConnScratch_): clear keeps the capacity earlier
		// tiles grew, so this stops re-reserving the whole graph's edge count for every tile.
		std::vector<GPUConnectionData>& gpuConnections = tileConnScratch_;
		gpuConnections.clear();

		bool use_culling = (culling_rect_.GetWidth() > 0.0f && culling_rect_.GetHeight() > 0.0f);

		// Only the edges bucketed into THIS tile, plus any drag overrides - no whole-graph scan.
		auto EmitEdge = [&](int edgeIdx) {
			const CachedEdge& ce = edgeRenderCache_[edgeIdx];

			// Hole-punch: skip edges touching an animated node - they're redrawn live from the overlay.
			if (IsAnimated(ce.srcNodeId) || IsAnimated(ce.dstNodeId))
				return;

			// The bucket is tile-granular (whole 8192^2 cells) while culling_rect_ can be a sub-rect,
			// so keep the exact bbox test. It now runs on a handful of edges instead of all ~3M.
			if (use_culling && !culling_rect_.Overlaps(ImRect(ce.bbMin, ce.bbMax)))
				return;

			// Expand to the fixed-size GPU struct here, for this tile's edges only (see edgePointPool_).
			gpuConnections.emplace_back();
			FillGPUConnection(ce, gpuConnections.back());
		};
		for (int edgeIdx : tileEdgeIdxs) {
			// Drawn by the override pass below (its bucket entry is at the pre-drag position).
			if (!bucketOverrideEdgeIdxs_.empty() &&
			    std::find(bucketOverrideEdgeIdxs_.begin(), bucketOverrideEdgeIdxs_.end(), edgeIdx)
			        != bucketOverrideEdgeIdxs_.end())
				continue;
			EmitEdge(edgeIdx);
		}
		for (int edgeIdx : bucketOverrideEdgeIdxs_)
			EmitEdge(edgeIdx);

		// Render edges (GPU builds everything!)
		if (!gpuConnections.empty()) {
			int edgeMode = layoutEngine->GetEdgeRenderMode();
			gpuRenderer_->RenderEdgesGPUBuild(gpuConnections, culling_rect_, world_shift_, scale_, edgeMode);
		}

		// Build circle endpoint data from edges (persistent buffer; see tileCircleScratch_).
		// Already sized off the culled edge list rather than the whole graph, so this is just to avoid
		// re-growing the same allocation on every tile.
		std::vector<GPUCircleData>& gpuCircles = tileCircleScratch_;
		gpuCircles.clear();
		gpuCircles.reserve(gpuConnections.size() * 2);  // 2 circles per edge (start + end)

		for (const auto& conn : gpuConnections) {
			// Calculate circle radius to match ImGui's connector dot size
			float dotRadius = (ImGuiNodesConnectorDotDiameter * 0.5f) * 19.0f;

			// Start point circle (first control point)
			GPUCircleData startCircle;
			startCircle.center = conn.controlPoints[0];
			startCircle.radius = dotRadius;
			startCircle.color = conn.color;
			startCircle.padding[0] = 0.0f;
			startCircle.padding[1] = 0.0f;
			gpuCircles.push_back(startCircle);

			// End point circle (last control point)
			GPUCircleData endCircle;
			endCircle.center = conn.controlPoints[conn.numPoints - 1];
			endCircle.radius = dotRadius;
			endCircle.color = conn.color;
			endCircle.padding[0] = 0.0f;
			endCircle.padding[1] = 0.0f;
			gpuCircles.push_back(endCircle);
		}

		// DEBUG: Print first circle data (once)
		static bool printedCircles = false;
		if (!printedCircles && !gpuCircles.empty()) {
			printf("DEBUG: Rendering %zu circles\n", gpuCircles.size());
			for (int i = 0; i < 3 && i < gpuCircles.size(); i++) {
				const GPUCircleData& c = gpuCircles[i];
				// Decode color bytes (ABGR format)
				unsigned char r = (c.color >> 0) & 0xFF;
				unsigned char g = (c.color >> 8) & 0xFF;
				unsigned char b = (c.color >> 16) & 0xFF;
				unsigned char a = (c.color >> 24) & 0xFF;
				printf("  Circle %d: center=(%.1f,%.1f) radius=%.1f color=0x%08X (R=%u G=%u B=%u A=%u)\n",
				       i, c.center.x, c.center.y, c.radius, c.color, r, g, b, a);
			}
			printedCircles = true;
		}

		// Convert nodes to GPU format (persistent buffer; see tileNodeScratch_)
		std::vector<GPUNodeData>& gpuNodes = tileNodeScratch_;
		gpuNodes.clear();

		// use_culling already defined above for edge culling

		// Only the nodes bucketed into THIS tile (BuildNodeBuckets already applied the Visible filter),
		// plus the drag overrides. Iterating the bucket then the override set, skipping overrides in the
		// first pass, guarantees each node is emitted at most once.
		for (int pass = 0; pass < 2; ++pass) {
			const std::vector<int>& srcIds = (pass == 0) ? tileNodeIds : overrideNodeIdList;
			for (int nodeId : srcIds) {
			if (pass == 0 && bucketOverrideNodeIds_.count(nodeId)) continue;  // drawn in pass 1
			auto nodeIt = nodeViewCache_.find(nodeId);
			if (nodeIt == nodeViewCache_.end()) continue;
			const NodeView* node = nodeIt->second;

			// Overrides bypassed BuildNodeBuckets, so apply its Visible filter here.
			if (pass == 1 && !(node->state_ & NodeStateFlag_Visible))
				continue;

			// Bucket is tile-granular; culling_rect_ may be a sub-rect, so keep the exact test.
			if (use_culling && !culling_rect_.Overlaps(node->area_node_))
				continue;

			// Hole-punch: skip nodes being animated - the overlay draws them live from the SSBO.
			if (IsAnimated(nodeId))
				continue;

			GPUNodeData nodeData;
			nodeData.pos = node->area_node_.Min;
			nodeData.size = node->area_node_.GetSize();

			// Node body color (dark gray). Linearized for the RGB565 tiles (see LinearizeForTile).
			nodeData.color = ImGui::ColorConvertFloat4ToU32(LinearizeForTile(ImVec4(0.3f, 0.3f, 0.3f, 0.9f)));

			// Title bar color (lighter gray, matching ImGui style)
			nodeData.titleBarColor = ImGui::ColorConvertFloat4ToU32(LinearizeForTile(ImVec4(0.5f, 0.5f, 0.5f, 0.9f)));

			// Title bar height (same calculation as ImGui: title_height_ = ImGuiNodesTitleHight * area_name_.GetHeight())
			nodeData.titleBarHeight = node->title_height_;

			// White border always visible
			nodeData.borderWidth = 2.0f;

			// Corner rounding (matching ImGui style: title_height * 0.3)
			nodeData.rounding = node->title_height_ * 0.3f;

			nodeData.padding = 0.0f;

			gpuNodes.push_back(nodeData);
			}
		}

		// Render nodes to current FBO
		if (!gpuNodes.empty()) {
			gpuRenderer_->RenderNodeRects(gpuNodes, culling_rect_, world_shift_, scale_);
		}

		// Render text using SDF atlas (if ready)
		if (gpuRenderer_->IsSDFReady()) {
			// Persistent buffer (see tileCharScratch_). This reserve was the single biggest cost in the
			// bake: nodeViewCache_.size() * 50 chars * 48 B = ~1 GB allocated, touched and freed PER TILE
			// at 400k nodes, to hold the few thousand glyphs a tile actually contains.
			std::vector<GPUCharData>& gpuChars = tileCharScratch_;
			gpuChars.clear();

			
			const float FONT_SCALE = 18.0f / 32.0f; //32 is the original SDF glyph font size from the .png

			// Helper lambda to add text characters to the buffer
			auto AddTextChars = [&](const char* text, ImVec2 startPos, uint32_t color) {
				float cursorX = startPos.x;
				float cursorY = startPos.y;

				for (const char* s = text; *s; s++) {
					unsigned int c = (unsigned int)(unsigned char)*s;  // Cast to unsigned char first!
					if (c < 32 || c >= 128) continue;  // Skip control characters and non-ASCII (UTF-8 continuation bytes)

					// Get glyph from BMFont (pre-generated SDF atlas)
					const BMGlyph* glyph = gpuRenderer_->GetGlyph(c);
					if (!glyph) {
						// DEBUG: Print missing glyphs
						static int missingCount = 0;
						if (missingCount++ < 10) {
							printf("WARNING: Missing glyph for '%c' (code %u) in text '%s'\n", (char)c, c, text);
						}
						continue;
					}

					// Calculate character quad (BMFont uses xoffset/yoffset instead of X0/Y0)
					// Apply font scaling to match desired UI size
					float x0 = cursorX + (glyph->xoffset * FONT_SCALE);
					float y0 = cursorY + (glyph->yoffset * FONT_SCALE);
					float x1 = x0 + (glyph->width * FONT_SCALE);
					float y1 = y0 + (glyph->height * FONT_SCALE);

					// Skip zero-size glyphs (e.g., space)
					if (glyph->width > 0 && glyph->height > 0) {
						GPUCharData charData;
						charData.pos = ImVec2(x0, y0);
						charData.size = ImVec2(x1 - x0, y1 - y0);
						charData.uv0 = glyph->uv0;
						charData.uv1 = glyph->uv1;
						charData.color = color;
						charData.padding[0] = 0.0f;
						charData.padding[1] = 0.0f;
						charData.padding[2] = 0.0f;
						gpuChars.push_back(charData);
					}

					// Advance cursor (also scaled)
					cursorX += (glyph->xadvance * FONT_SCALE);
				}
			};

			// Only this tile's bucket (+ drag overrides, same two-pass scheme as the node rects). The old
			// whole-graph scan here was the worst of the three: it did a dataModel->GetNode() hash lookup
			// for every node in the graph, per tile, before culling.
			for (int pass = 0; pass < 2; ++pass) {
			const std::vector<int>& srcIds = (pass == 0) ? tileNodeIds : overrideNodeIdList;
			for (int nodeId : srcIds) {
				if (pass == 0 && bucketOverrideNodeIds_.count(nodeId)) continue;  // drawn in pass 1
				auto nodeIt = nodeViewCache_.find(nodeId);
				if (nodeIt == nodeViewCache_.end()) continue;
				const NodeView* node = nodeIt->second;

				// Cull first, THEN resolve the data node - the lookup is only needed for text we keep.
				if (!culling_rect_.Overlaps(node->area_node_))
					continue;

				// Hole-punch: animated nodes are drawn live by the overlay, not baked here.
				if (IsAnimated(nodeId))
					continue;

				const GraphData::Node* dataNode = dataModel->GetNode(nodeId);
				if (!dataNode) continue;

				// DEBUG: Print color being used (once)
				static bool printedColor = false;
				if (!printedColor) {
					uint32_t whiteColor = ImGui::GetColorU32(ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
					ImVec4 colorVec = ImGui::ColorConvertU32ToFloat4(whiteColor);
					printf("DEBUG: Text color RGBA = (%.2f, %.2f, %.2f, %.2f), packed = 0x%08X\n",
					       colorVec.x, colorVec.y, colorVec.z, colorVec.w, whiteColor);
					printedColor = true;
				}

				// Use dark text color for readability on light gray nodes
				// RGB(0.15, 0.15, 0.15) = dark gray, almost black
				uint32_t textColor = ImGui::GetColorU32(ImVec4(1.0f, 1.0f, 1.0f, 1.0f));

				// 1. Render node title
				const char* titleText = dataNode->name.c_str();
				ImVec2 titlePos = node->area_node_.Min + ImVec2(8.0f, 4.0f);  // Padding inside node
				AddTextChars(titleText, titlePos, textColor);

				// 2. Render "+" symbol for expandable (collapsed) nodes
				if (!dataNode->childNodeIds.empty() && layoutEngine && !layoutEngine->IsExpanded(nodeId)) {
					// Position: right side of title bar, slightly inset
					float plusSymbolX = node->area_node_.Max.x - 20.0f;  // 20px from right edge
					float plusSymbolY = node->area_node_.Min.y + 4.0f;   // Same Y as title
					ImVec2 plusPos = ImVec2(plusSymbolX, plusSymbolY);
					AddTextChars("+", plusPos, textColor);
				}

				// 3. Render input connector labels
				for (int input_idx = 0; input_idx < node->inputs_.size(); ++input_idx) {
					const NodesInput* input = node->inputs_[input_idx];
					if (input->type_ == ImGuiNodesConnectorType_Invisible)
						continue;

					// Position matches DrawInput: area_name_.Min
					ImVec2 inputTextPos = input->area_name_.Min;
					AddTextChars(input->name_, inputTextPos, textColor);
				}

				// 4. Render output connector labels
				for (int output_idx = 0; output_idx < node->outputs_.size(); ++output_idx) {
					const NodesOutput* output = node->outputs_[output_idx];
					if (output->type_ == ImGuiNodesConnectorType_Invisible)
						continue;

					// Position matches DrawOutput: area_name_.Min
					ImVec2 outputTextPos = output->area_name_.Min;
					AddTextChars(output->name_, outputTextPos, textColor);
				}
			}
			}

			// DEBUG: Print first few characters being rendered (once)
			static bool printedChars = false;
			if (!printedChars && !gpuChars.empty()) {
				printf("DEBUG: First 3 characters being rendered:\n");
				for (int i = 0; i < 3 && i < gpuChars.size(); i++) {
					const GPUCharData& ch = gpuChars[i];
					ImVec4 colorVec = ImGui::ColorConvertU32ToFloat4(ch.color);
					printf("  Char %d: pos=(%.1f,%.1f) size=(%.1f,%.1f) uv0=(%.3f,%.3f) uv1=(%.3f,%.3f) color=RGBA(%.2f,%.2f,%.2f,%.2f)\n",
					       i, ch.pos.x, ch.pos.y, ch.size.x, ch.size.y,
					       ch.uv0.x, ch.uv0.y, ch.uv1.x, ch.uv1.y,
					       colorVec.x, colorVec.y, colorVec.z, colorVec.w);
				}
				printedChars = true;
			}

			// Render all characters
			if (!gpuChars.empty()) {
				gpuRenderer_->RenderText(gpuChars, culling_rect_, world_shift_, scale_);
			}
		}

		// Render subgraph boundaries (blue rectangles around expanded parent nodes).
		// Sorted by expand order in SyncNodeViews() (least-recent first, so the most-recently-expanded
		// one renders LAST = on top, matching the hit-test z-order in GetExpandedSubgraphAt).
		std::vector<ImRect> subgraphBounds;
		for (int parentId : expandedParentIds) {
			const GraphData::Node* parent = dataModel->GetNode(parentId);
			if (!parent) continue;

			// Suppress the boundary while this subgraph's children are animating. The box is
			// computed from the children's committed (home) positions, so during an expand/collapse
			// animation it would sit at the destination while the children are still in flight - and
			// it can't be hole-punched like the nodes. Skip it until the children settle (expand) /
			// as soon as they start moving (collapse). Any animated child => this subgraph is in flux.
			bool anyChildAnimated = false;
			for (int childId : parent->childNodeIds) {
				if (IsAnimated(childId)) { anyChildAnimated = true; break; }
			}
			if (anyChildAnimated) continue;

			// Calculate bounding box of all children using ACTUAL RENDERED BOUNDS
			ImVec2 min(FLT_MAX, FLT_MAX);
			ImVec2 max(-FLT_MAX, -FLT_MAX);

			for (int childId : parent->childNodeIds) {
				// Use actual rendered bounds from nodeViewCache, not LayoutEngine
				// (LayoutEngine uses fixed height, but rendered nodes vary by input/output count).
				// Use find(), NOT operator[] - the latter inserts a null entry for an uncached child,
				// which later crashes GetNodeAt when it dereferences it.
				auto cvit = nodeViewCache_.find(childId);
				NodeView* childNode = (cvit != nodeViewCache_.end()) ? cvit->second : nullptr;
				if (childNode && childNode->area_node_.GetWidth() > 0) {
					min.x = ImMin(min.x, childNode->area_node_.Min.x);
					min.y = ImMin(min.y, childNode->area_node_.Min.y);
					max.x = ImMax(max.x, childNode->area_node_.Max.x);
					max.y = ImMax(max.y, childNode->area_node_.Max.y);
				}
			}

			printf("Subgraph boundary for parent %d BEFORE padding: min=(%.1f, %.1f) max=(%.1f, %.1f)\n",
				parentId, min.x, min.y, max.x, max.y);

			// Add padding around subgraph
			float padding = 20.0f;
			min.x -= padding;
			min.y -= padding;
			max.x += padding;
			max.y += padding;

			printf("Subgraph boundary for parent %d AFTER padding: min=(%.1f, %.1f) max=(%.1f, %.1f)\n",
				parentId, min.x, min.y, max.x, max.y);

			subgraphBounds.push_back(ImRect(min, max));
		}

		// Render subgraph bounds (if any)
		if (!subgraphBounds.empty()) {
			ImU32 outlineColor = ImGui::ColorConvertFloat4ToU32(LinearizeForTile(ImVec4(0.2f, 0.3f, 0.8f, 0.6f)));
			gpuRenderer_->RenderSubgraphBounds(subgraphBounds, culling_rect_, world_shift_, scale_,
			                                    outlineColor, 3.0f / scale_);
		}

		// Render circle endpoints LAST (on top of everything)
		if (!gpuCircles.empty()) {
			gpuRenderer_->RenderCircles(gpuCircles, culling_rect_, world_shift_, scale_);
		}

		ProcessContextMenu();
	} else {
		// CPU rendering path (ImGui draw lists)
		ProcessNodes();
		ProcessContextMenu();
	}
}

void GraphView::RenderInteractive(ImVec2 windowPos, ImVec2 cameraOffset, float cameraZoom)
{
	// Set up interactive rendering context
	pos_ = windowPos;
	world_shift_ = -cameraOffset;
	scale_ = cameraZoom;
	culling_rect_ = ImRect();  // No culling, or could set to viewport bounds

	// Update mouse state for interaction helpers
	mouse_ = ImGui::GetMousePos();
	size_ = ImGui::GetContentRegionAvail();

	// Render nodes to screen
	ProcessNodes();
	ProcessContextMenu();
}

void GraphView::RenderMinimap(ImRect minimapArea, ImVec2 worldSize)
{
	// Set up minimap rendering context
	pos_ = minimapArea.Min;
	world_shift_ = ImVec2(0, 0);  // Show from world origin
	scale_ = minimapArea.GetWidth() / worldSize.x;  // Fit world to minimap
	culling_rect_ = ImRect();  // Show everything

	// Render nodes to minimap (could skip connections for clarity)
	ProcessNodes();
}

////////////////////////////////////////////////////////////////////////////////
// Interaction helpers (called from main.cpp)
////////////////////////////////////////////////////////////////////////////////

NodeView* GraphView::GetNodeAt(ImVec2 worldPos)
{
	//Search cached nodes in reverse order (last inserted = drawn on top)
	//This way top-most (last drawn) node will be selected when multiple nodes overlap
	for (auto it = nodeViewCache_.rbegin(); it != nodeViewCache_.rend(); ++it)
	{
		NodeView* node = it->second;
		if (!node) continue;  // cache can briefly hold a null (e.g. mid expand/collapse churn)
		if (node->area_node_.Contains(worldPos))
		{
			return node;
		}
	}
	return nullptr;
}

int GraphView::GetExpandedSubgraphAt(ImVec2 worldPos)
{
	// Among ALL expanded subgraph boundaries containing worldPos, return the TOPMOST one - the
	// most recently expanded (highest expand order). This matches the visual z-order so shift-
	// clicking where two boundaries overlap collapses the one drawn on top.
	int bestId = -1;
	int bestOrder = -1;

	for (size_t i = 0; i < dataModel->GetNodeCount(); i++) {
		const GraphData::Node* node = dataModel->GetNode(i);
		if (!node) continue;

		// Check if this node is expanded
		if (layoutEngine->IsExpanded(node->id) && node->isExpandable) {
			// Calculate bounding box of all children (same logic as rendering)
			ImVec2 min(FLT_MAX, FLT_MAX);
			ImVec2 max(-FLT_MAX, -FLT_MAX);

			for (int childId : node->childNodeIds) {
				ImRect childBounds = layoutEngine->GetNodeBounds(childId);
				if (childBounds.GetWidth() > 0) {
					min.x = ImMin(min.x, childBounds.Min.x);
					min.y = ImMin(min.y, childBounds.Min.y);
					max.x = ImMax(max.x, childBounds.Max.x);
					max.y = ImMax(max.y, childBounds.Max.y);
				}
			}

			// Add padding (same as rendering)
			float padding = 20.0f;
			min.x -= padding;
			min.y -= padding;
			max.x += padding;
			max.y += padding;

			// Keep the topmost (most-recently-expanded) boundary that contains the click.
			ImRect boundary(min, max);
			if (boundary.Contains(worldPos)) {
				int order = layoutEngine->GetExpandOrder(node->id);
				if (order > bestOrder) {
					bestOrder = order;
					bestId = node->id;
				}
			}
		}
	}

	return bestId;  // -1 if not clicked on any subgraph boundary
}

void GraphView::SelectNode(NodeView* node, bool addToSelection)
{
	if (!node) return;

	if (!addToSelection)
	{
		// Clear existing selection from all cached nodes
		for (auto& pair : nodeViewCache_)
		{
			pair.second->state_ &= ~NodeStateFlag_Selected;
		}
	}

	// Select the node
	node->state_ |= NodeStateFlag_Selected;
}

void GraphView::ClearSelection()
{
	for (auto& pair : nodeViewCache_)
	{
		pair.second->state_ &= ~NodeStateFlag_Selected;
	}
}

void GraphView::DragSelectedNodes(ImVec2 worldDelta)
{
	for (auto& pair : nodeViewCache_)
	{
		NodeView* node = pair.second;
		if (node->state_ & NodeStateFlag_Selected)
		{
			node->TranslateNode(worldDelta, false);

			// Update LayoutEngine position (make it the source of truth)
			if (layoutEngine) {
				layoutEngine->nodePositions_[node->nodeId] = node->area_node_.Min;
			}
		}
	}
}

void GraphView::DragSubgraph(int parentId, ImVec2 worldDelta)
{
	if (!dataModel) return;
	const GraphData::Node* parent = dataModel->GetNode(parentId);
	if (!parent) return;

	for (int childId : parent->childNodeIds) {
		auto it = nodeViewCache_.find(childId);
		if (it == nodeViewCache_.end() || !it->second) continue;
		NodeView* node = it->second;
		node->TranslateNode(worldDelta, false);
		if (layoutEngine) {
			layoutEngine->nodePositions_[childId] = node->area_node_.Min;
		}
	}
}

}  // namespace ImGui