PipedGraphModel::
PipedGraphModel(std::shared_ptr<NodeDelegateModelRegistry> registry) :
    DataFlowGraphModel(registry)
{
    executing = false;
}

PipedGraphModel::~PipedGraphModel(void)
{}

bool
PipedGraphModel::canPropagate(const ConnectionId conn)
{
    if (executing)
        return true;
    // data should only be passed on if the graph is being executed
    // or if the node is capable of performing the calculation in
    // such a negligible amount of time that it may as well calculate
    // immediately (think math or array nodes)
    Node *delegate = this->delegateModel<Node>(conn.inNodeId);
    return delegate->canInstantCompute();
}

void
PipedGraphModel::stopExecute(void)
{
    executing = false;
}

void
PipedGraphModel::execute(void)
{
    executing = true;
    for (NodeId id : this->allNodeIds())
    {
        // check each node for any inputs, and if it contains none, then
        // it must be an input node, from which we can propagate the rest of the
        // graph
        Node *delegate = this->delegateModel<Node>(id);
        if (delegate->numInputs() == 0 && delegate->numOutputs() > 0)
            this->propagate(id);
    }
    executing = false;
}

void
PipedGraphModel::onOutPortDataUpdated(NodeId const nodeId,
                                      PortIndex const portIndex)
{
    const std::unordered_set<ConnectionId> &connected =
        connections(nodeId, PortType::Out, portIndex);

    const QVariant portDataToPropagate =
        portData(nodeId, PortType::Out, portIndex, PortRole::Data);
    const std::shared_ptr<PipedNodeData> data =
        qvariant_cast<std::shared_ptr<PipedNodeData>>(portDataToPropagate);

    int con = 0;
    for (auto const &cn : connected) {
        if (canPropagate(cn)) {
            setPortData(cn.inNodeId,
                        PortType::In,
                        cn.inPortIndex,
                        con > 0 ? QVariant::fromValue(data->clone()) :
                                  QVariant::fromValue(data), // fork connections
                        PortRole::Data);
            ++con;
        }
    }
}