GraphCalculatable.swift

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

import Foundation

public protocol GraphCalculatable<Node>: AnyObject {
    associatedtype Node: NodeCalculatable
    typealias TopologicalData = GraphTopologicalData<Node>
    
    var topologicalData: TopologicalData { get }
    
    @MainActor var nodes: [Node.ID: Node] { get set }
    
    // Which ports, after a graph runs, needs to be updated
    @MainActor var portsToUpdate: Set<NodePortType<Node>> { get set }
    
    // Should we update the preview layers after this graph run?
    @MainActor var shouldResortPreviewLayers: Bool { get set }
    
    @MainActor func getNode(id: Node.ID) -> Node?
    
    @MainActor func getNodesToAlwaysRun() -> Set<Node.ID>
    
    @MainActor func getAnimationNodes() -> Set<Node.ID>
    
    @MainActor func evaluateComponentOutputs()
    
    @MainActor func didPortsUpdate(ports: Set<NodePortType<Node>>)
    
    @MainActor var currentGraphTime: TimeInterval { get }
}

extension GraphCalculatable {
    @MainActor
    func createConnections() -> Self.TopologicalData.Connections {
        let inputsObservers = self.nodes.values
            .flatMap { $0.inputsObservers }

        return inputsObservers.reduce(into: .init()) { result, inputObserver in
            if let upstreamConnection = inputObserver.upstreamOutputCoordinate {
                guard var connectedInputs = result[upstreamConnection] else {
                    result.updateValue([inputObserver.id], forKey: upstreamConnection)
                    return
                }

                connectedInputs.insert(inputObserver.id)
                result.updateValue(connectedInputs, forKey: upstreamConnection)
            }
        }
    }
    
    @MainActor  public var connections: Self.TopologicalData.Connections {
        self.topologicalData.connections
    }
    
    @MainActor  public var shallowDownstreamNodes: Self.TopologicalData.ShallowDownstreamNodesDict {
        self.topologicalData.shallowDownstreamNodes
    }
    
    @MainActor func setConnections(_ newConnections: Self.TopologicalData.Connections) {
        self.topologicalData.connections = newConnections
    }
    
    @MainActor  var nodesForNextGraphStep: Set<Node.ID> {
        get {
            self.topologicalData.nodesForNextGraphStep
        }
        set(newValue) {
            self.topologicalData.nodesForNextGraphStep = newValue
        }
    }
    
    @MainActor public var nodesToRunOnGraphStep: Set<Node.ID> {
        self.topologicalData.nodesToRunOnGraphStep
    }
    
    @MainActor public var hasUnprocessedCycleNodes: Bool {
        !self.topologicalData.cycleNodesForNextGraphStep.isEmpty
    }
    
    @MainActor public func setNodesForNextGraphStep(_ nodeIds: Set<Node.ID>) {
        self.topologicalData.nodesForNextGraphStep = nodeIds
    }
    
    @MainActor public func immediatelyUpstreamNodes(for node: Node.ID) -> Set<Node.ID> {
        self.topologicalData.immediatelyUpstreamNodes(for: node)
    }
}