/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.0 (the "License").
    * You may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * http://www.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: ConnectionGroup.java
   * Created: 2007-00-00
   * Author: awos
   * $Id: ConnectionGroup.java 2955 2009-06-04 09:20:08Z tmilos $
   */
  
  package pl.edu.agh.cast.model.visual.backward;
  
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  
  import pl.edu.agh.cast.common.HexColor;
  import pl.edu.agh.cast.model.attributes.AttributeManager;
  import pl.edu.agh.cast.model.attributes.AttributeValue;
  import pl.edu.agh.cast.model.attributes.ConnectionGroupAttributeManager;
  
  /**
   * Stores list of all connections between two nodes.
   *
   * @author AGH CAST Team
   */
  public class ConnectionGroup extends ModelElement {
  
  	/*
  	 * XXX: If you add a new property to this class, you must add it to CloneSelectionHelperTest and
  	 * CloneSelectionHelper.
  	 */
  
  	private static final long serialVersionUID = -3863944666693937115L;
  
  	// BEGIN Events fired by connection group
  
  	/**
  	 * Name of the <em>Connection count changed</em> event.
  	 */
  	public static final String CONNECTION_COUNT_CHANGED = "ConnectionGroup_ConnCountChanged"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Connection single line label changed</em> event.
  	 */
  	public static final String SINGLE_CONNECTION_LABEL = "ConnectionGroup_SingleLineLabel"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Connection double line source-to-target label changed</em> event.
  	 */
  	public static final String DOUBLE_CONNECTION_SOURCE_LABEL = "ConnectionGroup_DoubleLineSourceToTargetLabel"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Connection double line target-to-source label changed</em> event.
  	 */
  	public static final String DOUBLE_CONNECTION_TARGET_LABEL = "ConnectionGroup_DoubleLineTargetToSourceLabel"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Variable thickness line label changed</em> event.
  	 */
  	public static final String VARIABLE_THICKNESS_CONNECTION_LABEL = "ConnectionGroup_VariableThicknessLineLabel"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Line thickness changed</em> event.
  	 */
  	public static final String LINE_THICKNESS = "ConnectionGroup_LineThickness"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Line color changed</em> event.
  	 */
  	public static final String LINE_COLOR = "ConnectionGroup_LineColor"; //$NON-NLS-1$
  
  	// END Events fired by connection group
  
  	private static final String NO_SUCH_NODE_MESSAGE = "Node does not belong to this connection group"; //$NON-NLS-1$
  
  	private Node left;
  
  	private Node right;
  
  	/**
  	 * List of connections originating from left node.
  	 */
  	private List<Connection> leftConnections = new LinkedList<Connection>();
  
  	/**
  	 * List of connections originating from right node.
  	 */
  	private List<Connection> rightConnections = new LinkedList<Connection>();
  
  	private ConnectionGroupAttributeManager attributeManager;
 
 	/**
 	 * Creates a connection group.
 	 *
 	 * @param left
 	 *            left side node; may not be null
 	 * @param right
 	 *            right side node; may not be null
 	 * @param attributeManager
 	 *            {@link AttributeManager} for this {@link ConnectionGroup}
 	 */
 	public ConnectionGroup(Node left, Node right, ConnectionGroupAttributeManager attributeManager) {
 		super();
 		setSource(left);
 		setTarget(right);
 		this.attributeManager = attributeManager;
 
 		bindToAttributeManager();
 		setMandatoryProperties();
 	}
 
 	private void setMandatoryProperties() {
 		setAttributeValue(SINGLE_CONNECTION_LABEL, Integer.toString(leftConnections.size() + rightConnections.size()));
 		setAttributeValue(DOUBLE_CONNECTION_SOURCE_LABEL, Integer.toString(leftConnections.size()));
 		setAttributeValue(DOUBLE_CONNECTION_TARGET_LABEL, Integer.toString(rightConnections.size()));
 		setAttributeValue(LINE_THICKNESS, 1);
 		setAttributeValue(LINE_COLOR, new HexColor(0, 0, 0));
 	}
 
 	public int getConnectionCount() {
 		return leftConnections.size() + rightConnections.size();
 	}
 
 	/**
 	 * Returns the number of connections from target to source for given {@link Node}.
 	 *
 	 * @param node
 	 *            the node to count connections for
 	 * @return number of connections from target to source
 	 */
 	public int getTargetConnectionCountFor(Node node) {
 		if (right.equals(node)) {
 			return leftConnections.size();
 		} else if (left.equals(node)) {
 			return rightConnections.size();
 		}
 		throw new IllegalArgumentException(NO_SUCH_NODE_MESSAGE);
 	}
 
 	/**
 	 * Returns the number of connections from source to target for given {@link Node}.
 	 *
 	 * @param node
 	 *            the node to count connections for
 	 * @return number of connections from source to target
 	 */
 	public int getSourceConnectionCountFor(Node node) {
 		if (left.equals(node)) {
 			return leftConnections.size();
 		} else if (right.equals(node)) {
 			return rightConnections.size();
 		}
 		throw new IllegalArgumentException(NO_SUCH_NODE_MESSAGE);
 	}
 
 	/**
 	 * Returns list of connections originating from left node.
 	 *
 	 * @return list of connections originating from left node
 	 *
 	 * @deprecated Use {@link #getSourceConnectionsFor(Node)}
 	 */
 	@Deprecated
 	public List<Connection> getLeftConnections() {
 		return leftConnections;
 	}
 
 	/**
 	 * Returns list of connections originating from right node.
 	 *
 	 * @return list of connections originating from right node
 	 *
 	 * @deprecated Use {@link #getTargetConnectionsFor(Node)}
 	 */
 	@Deprecated
 	public List<Connection> getRightConnections() {
 		return rightConnections;
 	}
 
 	/**
 	 * Returns a list of source {@link Connection}s for <code>node</code>.
 	 *
 	 * @param node
 	 *            {@link Node} to get source {@link Connection}s for
 	 * @return list of source connections for the <code>node</code>
 	 */
 	public List<Connection> getSourceConnectionsFor(Node node) {
 		if (left.equals(node)) {
 			return leftConnections;
 		} else if (right.equals(node)) {
 			return rightConnections;
 		}
 		throw new IllegalArgumentException(NO_SUCH_NODE_MESSAGE);
 
 	}
 
 	/**
 	 * Returns a list of target {@link Connection}s for <code>node</code>.
 	 *
 	 * @param node
 	 *            {@link Node} to get target {@link Connection}s for
 	 * @return list of target connections for the <code>node</code>
 	 */
 	public List<Connection> getTargetConnectionsFor(Node node) {
 		if (right.equals(node)) {
 			return leftConnections;
 		} else if (left.equals(node)) {
 			return rightConnections;
 		}
 		throw new IllegalArgumentException(NO_SUCH_NODE_MESSAGE);
 
 	}
 
 	/**
 	 * Returns the list of all {@link Connection}s in this group.
 	 *
 	 * @return list of all {@link Connection}s in this group
 	 */
 	public List<Connection> getAllConnections() {
 		Set<Connection> connections = new HashSet<Connection>();
 		connections.addAll(leftConnections);
 		connections.addAll(rightConnections);
 		List<Connection> result = new LinkedList<Connection>();
 		result.addAll(connections);
 		return result;
 	}
 
 	public Node getSource() {
 		return left;
 	}
 
 	/**
 	 * Sets source node of this connection group.
 	 *
 	 * @param node
 	 *            source node; may not be null
 	 * @throws IllegalArgumentException
 	 *             if node is null
 	 */
 	public void setSource(Node node) {
 		if (node == null) {
 			throw new IllegalArgumentException("source may not be null"); //$NON-NLS-1$
 		}
 		left = node;
 	}
 
 	public Node getTarget() {
 		return right;
 	}
 
 	/**
 	 * Sets target node of this connection group.
 	 *
 	 * @param node
 	 *            target node; may not be null
 	 * @throws IllegalArgumentException
 	 *             if node is null
 	 */
 	public void setTarget(Node node) {
 		if (node == null) {
 			throw new IllegalArgumentException("target may not be null"); //$NON-NLS-1$
 		}
 		right = node;
 	}
 
 	/**
 	 * Updates attribute value only if it was a numerical value (i.e. it can be assumed it was the default connection
 	 * count in the group).
 	 *
 	 * @param name
 	 *            name of the attribute
 	 * @param newValue
 	 *            new value of the attribute
 	 */
 	private void updateProperty(String name, int newValue) {
 		AttributeValue property = getAttributeValue(name);
 
 		try {
 			Object value = property.getValue();
 			if (value instanceof String) {
 				Integer.parseInt((String)value);
 			}
 
 			setAttributeValue(name, Integer.toString(newValue));
 		} catch (NumberFormatException ex) {
 			// if property value is not of type integer we do not update it
 		}
 	}
 
 	private void updateProperties() {
 		// Update single line label
 		updateProperty(SINGLE_CONNECTION_LABEL, leftConnections.size() + rightConnections.size());
 		updateProperty(DOUBLE_CONNECTION_SOURCE_LABEL, leftConnections.size());
 		updateProperty(DOUBLE_CONNECTION_TARGET_LABEL, rightConnections.size());
 	}
 
 	/**
 	 * Adds a new {@link Connection} originating from left node.
 	 *
 	 * @param connection
 	 *            new {@link Connection} originating from left node
 	 */
 	public void addLeftConnection(Connection connection) {
 		int oldSourceConnectionCount = leftConnections.size();
 		leftConnections.add(connection);
 
 		updateProperties();
 
 		firePropertyChange(CONNECTION_COUNT_CHANGED, oldSourceConnectionCount, leftConnections.size());
 	}
 
 	/**
 	 * Adds a new {@link Connection} originating from right node.
 	 *
 	 * @param connection
 	 *            new {@link Connection} originating from right node
 	 */
 	public void addRightConnection(Connection connection) {
 		int oldTargetConnectionCount = rightConnections.size();
 		rightConnections.add(connection);
 
 		updateProperties();
 
 		firePropertyChange(CONNECTION_COUNT_CHANGED, oldTargetConnectionCount, rightConnections.size());
 	}
 
 	/**
 	 * Removes a {@link Connection} originating from left node.
 	 *
 	 * @param connection
 	 *            {@link Connection} originating from left node
 	 */
 	public void removeLeftConnection(Connection connection) {
 		if (!leftConnections.contains(connection)) {
 			return;
 		}
 		int oldSourceConnectionCount = leftConnections.size();
 		leftConnections.remove(connection);
 
 		updateProperties();
 
 		firePropertyChange(CONNECTION_COUNT_CHANGED, oldSourceConnectionCount, leftConnections.size());
 	}
 
 	/**
 	 * Removes a {@link Connection} originating from right node.
 	 *
 	 * @param connection
 	 *            {@link Connection} originating from right node
 	 */
 	public void removeRightConnection(Connection connection) {
 		if (!rightConnections.contains(connection)) {
 			return;
 		}
 		int oldTargetConnectionCount = rightConnections.size();
 		rightConnections.remove(connection);
 
 		updateProperties();
 
 		firePropertyChange(CONNECTION_COUNT_CHANGED, oldTargetConnectionCount, rightConnections.size());
 	}
 
 	/**
 	 * Adds this connection group to both nodes.
 	 */
 	public void addConnectionGroupToNodes() {
 		left.addConnectionGroup(this);
 		right.addConnectionGroup(this);
 	}
 
 	/**
 	 * Removes this connection group from both nodes - counterpart of {@link #addConnectionGroupToNodes()}.
 	 */
 	public void removeConnectionGroupFromNodes() {
 		left.removeConnectionGroup(this);
 		right.removeConnectionGroup(this);
 	}
 
 	/**
 	 * Checks if this connection group is between two given nodes.
 	 *
 	 * @param node1
 	 *            first node
 	 * @param node2
 	 *            second node
 	 * @return <code>true</code> if this connection group is between two given nodes
 	 */
 	public boolean isBetween(Node node1, Node node2) {
 		return (node1.equals(left) && node2.equals(right)) || (node1.equals(right) && node2.equals(left));
 	}
 
 	/**
 	 * Adds new {@link Connection} to this group.
 	 *
 	 * @param connection
 	 *            new {@link Connection}
 	 */
 	public void addConnection(Connection connection) {
 		if (connection.getSourceNode().equals(left) || connection.getSourceNode().equals(right)) {
 			if (connection.getSourceNode().equals(left)) {
 				addLeftConnection(connection);
 			}
 			if (connection.getSourceNode().equals(right)) {
 				addRightConnection(connection);
 			}
 		} else {
 			throw new IllegalArgumentException(NO_SUCH_NODE_MESSAGE);
 		}
 	}
 
 	/**
 	 * Removes {@link Connection} to this group.
 	 *
 	 * @param connection
 	 *            {@link Connection} to remove
 	 */
 	public void removeConnection(Connection connection) {
 		if (connection.getSourceNode().equals(left)) {
 			removeLeftConnection(connection);
 		} else if (connection.getSourceNode().equals(right)) {
 			removeRightConnection(connection);
 		} else {
 			throw new IllegalArgumentException(NO_SUCH_NODE_MESSAGE);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		return "CG " + left.getLabel() + ":" + right.getLabel(); //$NON-NLS-1$//$NON-NLS-2$
 	}
 
 	public ConnectionGroupAttributeManager getPropertyManager() {
 		return attributeManager;
 	}
 
 	/**
 	 * Two {@link ConnectionGroup}s are equal if their sources and targets are equal.
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#equals(java.lang.Object)
 	 */
 	@Override
 	public boolean equals(Object obj) {
 		if (obj == this) {
 			return true;
 		}
 		if (!(obj instanceof ConnectionGroup)) {
 			return false;
 		}
 		ConnectionGroup that = (ConnectionGroup)obj;
 
 		if (!this.left.equals(that.left)) {
 			return false;
 		}
 		if (!this.right.equals(that.right)) {
 			return false;
 		}
 
 		return true;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#hashCode()
 	 */
 	@Override
 	public int hashCode() {
 		return (left.getId() + right.getId()).hashCode();
 	}
 
 	/**
 	 * Copies all fields of this {@link ConnectionGroup} instance to <code>that</code> instance.
 	 *
 	 * @param that
 	 *            instance of {@link ConnectionGroup} to copy this instance to
 	 */
 	public void copyTo(ConnectionGroup that) {
 		// do not copy source and target - these are handled differently
 		that.attributeManager = attributeManager;
 		copyAttributes(that);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.ModelElement#getAttributeManager()
 	 */
 	@Override
 	public AttributeManager getAttributeManager() {
 		return attributeManager;
 	}
 }