package nodebox.node;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import static nodebox.base.Preconditions.checkState;

/**

* A connectable object on a node. Ports provide input and output capabilities between nodes.

* <p/>

* Ports have a certain data class. Only ports with the same class of data can be connected together.

*/

public class Port {

public enum Direction {

IN, OUT

}

/**

* The cardinality of a port defines if it can store a single value or multiple values.

* <p/>

* When the cardinality is single, use getValue() and setValue() to access the data.

* For ports with multiple cardinality, use getValues(), addValue() and clearValues().

*/

public enum Cardinality {

SINGLE, MULTIPLE

}

private Node node;

private String name;

private Cardinality cardinality;

private Direction direction;

// Depending on the cardinality, either value or values is used.

private Object value;

private List<Object> values;

public Port(Node node, String name) {

this(node, name, Cardinality.SINGLE, Direction.IN);

}

public Port(Node node, String name, Cardinality cardinality) {

this(node, name, cardinality, Direction.IN);

}

public Port(Node node, String name, Direction direction) {

this(node, name, Cardinality.SINGLE, direction);

}

public Port(Node node, String name, Cardinality cardinality, Direction direction) {

if (direction == Direction.OUT && cardinality != Cardinality.SINGLE)

throw new IllegalArgumentException("Output ports can't have multiple cardinality.");

this.node = node;

validateName(name);

this.name = name;

this.cardinality = cardinality;

this.direction = direction;

}

public Node getNode() {

return node;

}

public Node getParentNode() {

return node.getParent();

}

public boolean hasParentNode() {

return getParentNode() != null;

}

public String getName() {

return name;

}

public void validateName(String name) {

if (name == null || name.trim().length() == 0)

throw new InvalidNameException(this, name, "Name cannot be null or empty.");

if (node.hasPort(name))

throw new InvalidNameException(this, name, "There is already a port named " + name + ".");

if (node.hasParameter(name))

throw new InvalidNameException(this, name, "There is already a parameter named " + name + ".");

// Use the same validation as for nodes.

Node.validateName(name);

}

public Cardinality getCardinality() {

return cardinality;

}

public Direction getDirection() {

return direction;

}

public void validate(Object value) throws IllegalArgumentException {

node.validate(value);

}

/**

* Gets the value of this port.

* <p/>

* This value will be null if the port is disconnected

* or an error occured during processing.

*

* @return the value for this port.

*/

public Object getValue() {

if (cardinality != Cardinality.SINGLE)

throw new AssertionError("You can only call getValue when cardinality is SINGLE.");

return value;

}

/**

* Gets a list of values for this port.

* <p/>

* This method is guaranteed to return a list, although it can be empty.

*

* @return the values for this port.

*/

public List<Object> getValues() {

if (cardinality != Cardinality.MULTIPLE)

throw new AssertionError("You can only call getValues when cardinality is MULTIPLE.");

if (values == null) return new ArrayList<Object>();

return values;

}

/**

* Set the value for this port.

* <p/>

* This method should not be called directly. Instead, values are set automatically when nodes are updated.

* <p/>

* This method can only be used when cardinality is set to single.

* <p/>

* Setting this value will not trigger any notifications or dirty flags.

*

* @param value the value for this port.

* @throws IllegalArgumentException if the value is not of the required data class.

*/

public void setValue(Object value) throws IllegalArgumentException {

if (cardinality != Cardinality.SINGLE)

throw new AssertionError("You can only call setValue when cardinality is SINGLE.");

validate(value);

this.value = value;

}

/**

* Add a value to this port.

* <p/>

* This method should not be called directly. Instead, values are added automatically when nodes are updated.

* <p/>

* This method can only be used when cardinality is set to multiple.

* <p/>

* Adding a value will not trigger any notifications or dirty flags.

*

* @param value the value to add for this port.

* @throws IllegalArgumentException if the value is not of the required data class.

*/

public void addValue(Object value) throws IllegalArgumentException {

if (cardinality != Cardinality.MULTIPLE)

throw new AssertionError("You can only call addValue when cardinality is MULTIPLE.");

validate(value);

if (values == null)

values = new ArrayList<Object>();

values.add(value);

}

/**

* Reset the value(s) of the port.

* This method is called automatically when nodes are updated or disconnected.

*/

public void reset() {

value = null;

values = null;

}

//// Connections ////

public boolean isInputPort() {

return direction == Direction.IN;

}

public boolean isOutputPort() {

return direction == Direction.OUT;

}

/**

* Checks if this port is connected to another port.

*

* @return true if this port is connected.

*/

public boolean isConnected() {

checkState(hasParentNode(), "Port %s has no parent node.", this);

return getParentNode().isChildConnected(this);

}

/**

* Checks if this port is connected to the given port.

*

* @param port the other port to check.

* @return true if a connection exists between this port and the given port.

*/

public boolean isConnectedTo(Port port) {

if (!isConnected()) return false;

if (!hasParentNode()) return false;

return getParentNode().isChildConnectedTo(this, port);

}

/**

* Checks if this port is connected to the output port of the given node.

*

* @param outputNode the node whose output port will be checked.

* @return true if a connection exists between this port and the given node.

*/

public boolean isConnectedTo(Node outputNode) {

return isConnectedTo(outputNode.getOutputPort());

}

/**

* Get the connections on this port.

*

* @return a list of connections, possibly empty.

*/

public List<Connection> getConnections() {

Node parent = getParentNode();

if (parent == null) return Collections.emptyList();

List<Connection> connections = new ArrayList<Connection>();

for (Connection c : parent.getConnections()) {

if (this == c.getInput() || this == c.getOutput()) {

connections.add(c);

}

}

return connections;

}

/**

* Checks if this port can connect to the output port of the given node.

* <p/>

* This method does not check for cyclic dependencies.

*

* @param outputNode the output (upstream) node.

* @return true if the node can be connected.

*/

public boolean canConnectTo(Node outputNode) {

if (outputNode == null) return false;

if (getNode() == outputNode) return false;

return canConnectTo(outputNode.getOutputPort());

}

/**

* Check if this port can connect to the given output port.

* <p/>

* This method does not check for cyclic dependencies.

*

* @param outputPort the upstream output port.

* @return true if this port can connect to the given port.

*/

public boolean canConnectTo(Port outputPort) {

if (outputPort == null) return false;

if (outputPort == this) return false;

if (outputPort.getDirection() != Direction.OUT) return false;

// An input port can only be connected to an output port.

// Since we just checked the direction of the output port,

// we need to make sure if this port is an input.

if (direction != Direction.IN) return false;

// Check if the data classes match.

// They can either be equal, or the output type can be downcasted to the input type.

Class inputClass = node.getDataClass();

Class outputClass = outputPort.node.getDataClass();

return inputClass.isAssignableFrom(outputClass);

}

/**

* Connect this (input) port to the given output node.

*

* @param outputNode the output node

* @return the Connection objects

* @throws IllegalArgumentException if the connection could not be made (because of cyclic dependency)

* @see Node#connectChildren(Port, Port)

*/

public Connection connect(Node outputNode) throws IllegalArgumentException {

if (outputNode == null)

throw new IllegalArgumentException("Output node cannot be null.");

if (getParentNode() == null)

throw new IllegalArgumentException("This port has no parent node.");

return getParentNode().connectChildren(this, outputNode.getOutputPort());

}

/**

* Disconnects this port.

*/

public void disconnect() {

getParentNode().disconnectChildPort(this);

}

/**

* Create a clone of this port that can be set on the given node.

* This new port is not added to the given node.

* <p/>

* The value of this port is not cloned, since values cannot be cloned.

*

* @param n the node to clone the port onto.

* @return a new Port object

*/

public Port clone(Node n) {

return new Port(n, getName(), getCardinality(), getDirection());

}

/**

* Copy this port onto the new node.

* <p/>

* Also clones any upstream connections.

*

* @param newNode the new node

* @return a new, cloned port.

*/

public Port copy(Node newNode) {

return new Port(newNode, getName(), getCardinality(), getDirection());

}

/**

* Clone the connections of this port onto the new port.

* <p/>

* If the old connection points to nodes within the copy map they will be replaced with connections to the new node.

*

* @param newPort the new port to clone the connections onto.

* @param copyMap a mapping between the old nodes and the new nodes.

*/

public void cloneConnection(Port newPort, Map<Node, Node> copyMap) {

assert newPort.name.equals(getName());

assert newPort.cardinality == cardinality;

assert newPort.node != node;

checkState(newPort.getConnections().isEmpty(), "The new port should not be connected to anything.");

for (Connection c : getConnections()) {

Node n = c.getOutputNode();

Node outputNode;

if (copyMap.containsKey(n)) {

outputNode = copyMap.get(n);

} else {

outputNode = n;

}

// If the new node is under a different parent connections cannot be retained, and no

// connections are created.

if (outputNode.getParent() == newPort.getNode().getParent()) {

newPort.connect(outputNode);

}

}

}

@Override

public String toString() {

return node.getName() + "." + getName();

}

}