GraphCalculate.swift

//
//  GraphCalculate.swift
//
//
//  Created by Elliot Boschwitz on 6/8/24.
//

import Foundation

extension GraphCalculatable {
    @MainActor
    /// The main graph calculator. Shouldn't be called directly unless you know what you're doing.
    public func calculate(
        from nodeIds: Set<Node.ID>
    ) -> (
        Set<NodePortType<Node>>, // portsToUpdate
        Bool // shouldResortPreviewLayers
    ) {
        let redEdgeCycles = self.topologicalData.cycleNodesForNextGraphStep
        
        return self.traverseGraph(from: nodeIds,
                                  redEdgeCycles: redEdgeCycles) { queuedNodeResult, queue in
            // Retrieve the node afresh everytime,
            // since an upstream node's changes may have changed its inputs
            guard let node = self.getNode(id: queuedNodeResult.nodeId) else {
                // Not necessarily bad -- can happen if we deleted nodes but those nodes were still scheduled to run.
                //                fatalErrorIfDebug()
                return
            }
            
            let existingOutputValues = node.outputsValuesList
            let outputCoordinates = node.outputCoordinates
            
            guard let evalResult = self.calculateNode(node) else {
                return
            }
            
            // Update queue with NodeIds for nodes which need re-evaluation
            let changedInputIds = self.getChangedDownstreamInputIds(
                evalResult: evalResult,
                sourceNode: node,
                existingOutputsValues: existingOutputValues,
                outputCoordinates: outputCoordinates)
            
            let changedNodeIds = Set(changedInputIds.map { (id: Self.Node.InputRow.ID) in
                id.nodeId
            })
                        
            // Update queue set with changed downstream nodes
            queue = changedNodeIds.union(Set(queue))
        }
    }
    
    @MainActor
    /// The main graph calculator. Shouldn't be called directly unless you know what you're doing.
    public func traverseGraph(
        from nodeIds: Set<Node.ID>,
        redEdgeCycles: Set<CycleNodeUpdateData<Node>>,
        callback: @escaping @MainActor (QueuedNodeResultType<Node>, inout Set<Node.ID>) -> ()
    ) -> (
        Set<NodePortType<Node>>, // portsToUpdate
        Bool // shouldResortPreviewLayers
    ) {
        let graphState = self

        var visitedNodes = Set<Node.ID>()
        var queue = nodeIds
        
        // Reset state on scheduled cycle nodes
        self.topologicalData.nodesForNextGraphStep = .init()
        self.topologicalData.cycleNodesForNextGraphStep = .init()
        
        var portsToUpdate = Set<NodePortType<Node>>()
        
        // First handle red edge cycle nodes from last graph step by update inputs of nodes
        for cycleNodeData in redEdgeCycles {
            let didChangeInputs = self.updateInputs(inputCoordinate: cycleNodeData.portId,
                                                    upstreamOutputValues: cycleNodeData.values,
                                                    mediaList: cycleNodeData.mediaList,
                                                    upstreamOutputChanged: true,
                                                    // empty cycle starting points ensures we update inputs
                                                    cycleStartingPoints: .init())
            
            // Run red edge cycle node's eval if inputs changed from this update
            if didChangeInputs {
                queue.insert(cycleNodeData.nodeId)
            }
        }
        
        while let queuedNodeResult = topologicalData.getNextNodeToCalculate(for: queue,
                                                                  visitedNodes: visitedNodes) {
            let nodeId = queuedNodeResult.nodeId
            queue.remove(nodeId)
            
            guard !visitedNodes.contains(nodeId) else {
                assertInDebug(self.topologicalData.cycleContains(nodeId))
                
#if DEV_DEBUG
                // print("GraphState.calculate: scheduling cycle node \(nodeId)")
#endif
                
                self.topologicalData.nodesForNextGraphStep.insert(nodeId)
                continue
            }
            
            visitedNodes.insert(nodeId)
            
            callback(queuedNodeResult, &queue)
            
            // Track changed outputs here, inputs in didInputsUpdate
            portsToUpdate.insert(NodePortType<Node>.allOutputs(nodeId))
        } // while let ...
        
        
        // Why are we unioning this?
        // Can we just return the value instead?
        // Is `self.portsToUpdate` updated somewhere else, e.g. in the update of an input-observer?
        self.portsToUpdate = self.portsToUpdate.union(portsToUpdate)
        
        return (self.portsToUpdate, self.shouldResortPreviewLayers)
    }
    
    @MainActor
    public func scheduleForNextGraphStep(_ id: Node.ID) {
        self.topologicalData.nodesForNextGraphStep.insert(id)
    }
    
    @MainActor
    public func scheduleForNextGraphStep(_ idSet: Set<Node.ID>) {
        self.topologicalData.nodesForNextGraphStep = self.topologicalData.nodesForNextGraphStep.union(idSet)
    }
    
    @MainActor
    public func scheduleForNextGraphStep(_ idList: [Node.ID]) {
        self.scheduleForNextGraphStep(Set(idList))
    }
}