NodeRowCalculatable.swift

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

import Foundation

public protocol NodeRowCalculatable: AnyObject, Identifiable where ID == RowID {
    associatedtype RowID: NodeRowId
    associatedtype PortData: Equatable
    
    // A given port (input or output) has a loop of values
    @MainActor var values: [PortData] { get set }
    
    // TODO: move into `InputNodeRowCalculatable`, since only for inputs?
    @MainActor var containsUpstreamConnection: Bool { get }
    
    // TODO: put into separate `OutputNodeRowCalculatable` protocol, since only for outputs?
    @MainActor func updateOutputValues(_ values: [PortData])
    
    @MainActor func updatePortViewModels(_ graph: any GraphCalculatable)
}

public protocol InputNodeRowCalculatable: NodeRowCalculatable {
    associatedtype OutputRowID: NodeRowId
    
    @MainActor var isPulseNodeType: Bool { get }
    
    @MainActor var values: [PortData] { get set }
    
    @MainActor func coerce(theseValues: [PortData],
                           toThisType: PortData,
                           currentGraphTime: TimeInterval,
                           isCycleRedEdge: Bool) -> [PortData]
    
    @MainActor func didInputsUpdate(newValues: [PortData],
                                    oldValues: [PortData])

    @MainActor var upstreamOutputCoordinate: OutputRowID? { get }
}

extension InputNodeRowCalculatable {
    @MainActor public var containsUpstreamConnection: Bool {
        self.upstreamOutputCoordinate != nil
    }
}

extension InputNodeRowCalculatable {
    @MainActor public func setValuesInInput(_ values: [Self.PortData]) {
        let oldValues = self.values
        self.values = values
        self.didInputsUpdate(newValues: values,
                             oldValues: oldValues)
    }
}

extension Array where Element: NodeRowCalculatable {
    @MainActor
    public var values: [[Element.PortData]] {
        self.map {
            $0.values
        }
    }
}

extension NodeCalculatable {
    // fka `updateAllValues`; but renamed since only actually for outputs
    @MainActor
    func updateOutputs(_ newValuesList: [[PortData]],
                       nodeDelegate: Self) {
        
        let oldValuesList: [[PortData]] = self.outputsValuesList
        let oldPortCount = oldValuesList.count
        let newPortCount = newValuesList.count
        let currentObserverCount = oldValuesList.count
        
        // Remove view models if loop count decreased
        if newPortCount < oldPortCount {
            // Sub-array can't exceed its current bounds or we get index-out-of-bounds
            // Helpers below will create any missing observers
            let arrayBoundary = Swift.min(newPortCount, currentObserverCount)
            
            // Shortens input port count when inputs removed from user
            self.outputsObservers = Array(self.outputsObservers[..<arrayBoundary])
        }
        
        guard oldValuesList != newValuesList else { return }
        
        newValuesList.enumerated().forEach { portId, values in
            guard let observer = self.outputsObservers[safe: portId] else {
                fatalErrorIfDebug()
                return
            }
            
            // Only update values if there's no upstream connection
            if !observer.containsUpstreamConnection {
                observer.updateOutputValues(values)
            }
        }
    }
}