/*
    * 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: IMoveable.java
   * Created: 2007-00-00
   * Author: fox, awos
   * $Id: Node.java 3054 2009-07-27 10:23:07Z kpietak $
   */
  
  package pl.edu.agh.cast.model.visual.backward;
  
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.eclipse.draw2d.geometry.Dimension;
  import org.eclipse.draw2d.geometry.Point;
  
  import pl.edu.agh.cast.Activator;
  import pl.edu.agh.cast.backward.figure.icons.NodeIconProvider;
  import pl.edu.agh.cast.model.attributes.Attribute;
  import pl.edu.agh.cast.model.attributes.AttributeManager;
  import pl.edu.agh.cast.model.attributes.AttributeValue;
  import pl.edu.agh.cast.model.attributes.NodeAttributeManager;
  
  import com.thoughtworks.xstream.annotations.XStreamAlias;
  import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
  import com.thoughtworks.xstream.annotations.XStreamOmitField;
  
  /**
   * Class representing nodes of {@link IDiagram}.
   *
   * @author AGH CAST Team
   */
  @XStreamAlias("node")
  public class Node extends ModelElement implements Cloneable, IMoveable {
  
  	/*
  	 * XXX: IMPORTANT!! When adding new fields to this class, be careful to update the copyTo method.
  	 */
  
  	private static boolean suppressLocationChangeEvents = false;
  
  	private static final long serialVersionUID = -7236469860157722758L;
  
  	// BEGIN Events fired by node
  
  	/**
  	 * Name of the <em>Location changed</em> event.
  	 */
  	public static final String LOCATION = "Node.location"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Connections changed</em> event.
  	 */
  	public static final String CONNECTIONS = "Node.Connections"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Selected</em> event.
  	 */
  	public static final String SELECTED = "Node.selected"; //$NON-NLS-1$
  
  	/**
  	 * Name of the <em>Selected primary</em> event.
  	 */
  	public static final String SELECTED_PRIMARY = "Node.selectedPrimary"; //$NON-NLS-1$
  
  	// END Events fired by node
  
  	/**
  	 * Default node type.
  	 */
  	public static final String DEFAULT_NODE_TYPE = "default"; //$NON-NLS-1$
  
  	/**
  	 * Location of the node.
  	 */
  	@XStreamAlias("location")
  	protected Point location = new Point(-1, -1);
  
  	/**
  	 * Dimensions of the node.
  	 */
  	@XStreamAlias("dimensions")
  	protected Dimension dimensions = new Dimension(60, 60);
  
  	/**
  	 * Type of the node.
  	 */
  	@XStreamAlias("type")
  	@XStreamAsAttribute
 	private String type = DEFAULT_NODE_TYPE;
 
 	/**
 	 * Node's image identifier - one from {@link pl.edu.agh.cast.util.Images}.
 	 */
 	@XStreamAlias("imageId")
 	@XStreamAsAttribute
 	protected String imageId;
 
 	/**
 	 * List of {@link ConnectionGroup}s adjacent to the node.
 	 */
 	@XStreamOmitField
 	protected List<ConnectionGroup> connectionGroups;
 
 	/**
 	 * Node's {@link AttributeManager}.
 	 */
 	@XStreamAlias("attributeManager")
 	private NodeAttributeManager attributeManager;
 
 	/**
 	 * Creates new Node instance.
 	 *
 	 * @param id
 	 *            id of the node; non-null
 	 * @param isMainNode
 	 *            whether the node is a <em>main</em> node or not. Main nodes are highlighted on diagrams.
 	 * @param attributeManager
 	 *            {@link AttributeManager} for the node
 	 * @throws IllegalArgumentException
 	 *             if supplied node id is null
 	 */
 	public Node(String id, boolean isMainNode, NodeAttributeManager attributeManager) {
 		super();
 
 		this.attributeManager = attributeManager;
 
 		if (id == null) {
 			throw new IllegalArgumentException("Node id cannot be null"); //$NON-NLS-1$
 		}
 
 		// default label = id
 		setAttributeValue(NodeAttributeManager.PERMANENT_ID, id);
 		setAttributeValue(NodeAttributeManager.PERMANENT_LABEL, id);
 		setAttributeValue(NodeAttributeManager.PERMANENT_ISMAIN, Boolean.valueOf(isMainNode));
 		connectionGroups = new LinkedList<ConnectionGroup>();
 
 		bindToAttributeManager();
 	}
 
 	/**
 	 * Creates new Node instance in specified location.
 	 *
 	 * @param id
 	 *            id of the node
 	 * @param isMainNode
 	 *            whether the node is a <em>main</em> node or not. Main nodes are highlighted on diagrams.
 	 * @param attributeManager
 	 *            {@link AttributeManager} for the node
 	 * @param location
 	 *            the location of the node
 	 */
 	protected Node(String id, boolean isMainNode, NodeAttributeManager attributeManager, Point location) {
 		this(id, isMainNode, attributeManager);
 		this.location = location;
 	}
 
 	/**
 	 * Inits transient fields during deserialization.
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.ModelElement#readResolve()
 	 */
 	@Override
 	protected Object readResolve() {
 		this.connectionGroups = new LinkedList<ConnectionGroup>();
 		if (this.attributeManager == null) {
 			Activator.getLogger().debug("Creating new NodeAttributeManager"); //$NON-NLS-1$
 			this.attributeManager = new NodeAttributeManager();
 		}
 		super.readResolve();
 		return this;
 	}
 
 	/**
 	 * Adds adjacent {@link ConnectionGroup} to this node.
 	 *
 	 * @param connectionGroup
 	 *            {@link ConnectionGroup} to add
 	 */
 	public void addConnectionGroup(ConnectionGroup connectionGroup) {
 		if (!connectionGroups.contains(connectionGroup)) {
 			connectionGroups.add(connectionGroup);
 			firePropertyChange(CONNECTIONS, null, connectionGroup);
 		}
 	}
 
 	/**
 	 * Removes adjacent {@link ConnectionGroup} to this node.
 	 *
 	 * @param connectionGroup
 	 *            {@link ConnectionGroup} to remove
 	 * @return status of the operation (see {@link List#remove(Object)} for details)
 	 */
 	public boolean removeConnectionGroup(ConnectionGroup connectionGroup) {
 		boolean result = connectionGroups.remove(connectionGroup);
 		firePropertyChange(CONNECTIONS, connectionGroup, null);
 		return result;
 	}
 
 	/**
 	 * Returns the list of all {@link ConnectionGroup}s adjacent to this node.
 	 *
 	 * @return list of all adjacent {@link ConnectionGroup}s
 	 */
 	public List<ConnectionGroup> getConnectionGroups() {
 		return Collections.unmodifiableList(connectionGroups);
 	}
 
 	/**
 	 * Returns the Id of this node.
 	 *
 	 * @return Id of this node
 	 */
 	public String getId() {
 		AttributeValue attributeValue = getAttributeValue(NodeAttributeManager.PERMANENT_ID);
 		return (String)attributeValue.getValue();
 	}
 
 	/**
 	 * Returns a label, composed of values of all {@link pl.edu.agh.cast.model.attributes.ValueType#String} attributes
 	 * that have {@link Attribute#isShowAsLabel()} set.
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IMoveable#getLabel()
 	 */
 	public String getLabel() {
 		StringBuilder part1 = new StringBuilder(60);
 		StringBuilder part2 = new StringBuilder(60);
 		// first append all permanent attributes
 		for (Attribute a : getAttributeManager().getAttributes()) {
 			if (a.isShowAsLabel()) {
 				AttributeValue attributeValue = getAttributeValue(a.getName());
 				if (null != attributeValue.getValue()) {
 					String s = attributeValue.format();
 					if (attributeValue.getAttribute().getType().isList()) {
 						s = s.replace(';', '\n');
 					}
 					(a.isPermanent() ? part1 : part2).append(s).append('\n');
 				}
 			}
 		}
 		if (part1.length() > 0 || part2.length() > 0) {
 			// remove part1's last "\n" if part2 is empty
 			if (part1.length() > 0 && part2.length() == 0) {
 				part1.delete(part1.length() - 1, part1.length());
 			}
 			if (part2.length() > 0) {
 				part2.delete(part2.length() - 1, part2.length());
 			}
 			return part1.append(part2).toString();
 		} else {
 			return ""; //$NON-NLS-1$
 		}
 	}
 
 	/**
 	 * Returns <em>main</em> flag for this node.
 	 *
 	 * @return <em>main</em> node flag
 	 */
 	public boolean isMainNode() {
 		return ((Boolean)getAttributeValue(NodeAttributeManager.PERMANENT_ISMAIN).getValue()).booleanValue();
 	}
 
 	/**
 	 * Sets the type of this node.
 	 *
 	 * @param type
 	 *            type of the node
 	 */
 	public void setType(String type) {
 		this.type = type;
 	}
 
 	/**
 	 * Returns the type of this node.
 	 *
 	 * @return type of this node
 	 */
 	public String getType() {
 		return type;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IMoveable#getLocation()
 	 */
 	public Point getLocation() {
 		return location;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.IMoveable#setLocation(org.eclipse.draw2d.geometry.Point)
 	 */
 	public void setLocation(Point newLocation) {
 		Point oldLocation = location;
 		location = newLocation;
 		if (!Node.isSuppressLocationChangeEvents()) {
 			firePropertyChange(Node.LOCATION, oldLocation, newLocation);
 		}
 	}
 
 	/**
 	 * Returns the dimension of this node.
 	 *
 	 * @return dimension of this node
 	 */
 	public Dimension getDimensions() {
 		return dimensions;
 	}
 
 	/**
 	 * Sets dimensions of Node. SHOULD ONLY be called once, after corresponding figure's dimensions are calculated.
 	 *
 	 * @param dimensions
 	 *            new dimensions of this node
 	 */
 	public void setDimensions(Dimension dimensions) {
 		this.dimensions = dimensions;
 	}
 
 	/**
 	 * Copies all fields of this {@link Node} instance to <code>that</code> instance.
 	 *
 	 * @param that
 	 *            instance of {@link Node} to copy this instance to
 	 */
 	public void copyTo(Node that) {
 		that.attributeManager = attributeManager;
 		copyAttributes(that);
 
 		that.setDimensions(this.getDimensions());
 		that.setLocation(this.getLocation());
 		that.setImageId(this.getImageId());
 		that.setType(this.getType());
 		// XXX: add code for any new fields in Node here
 	}
 
 	/**
 	 * Returns the Id of an image that is used to display this node.
 	 *
 	 * @return Id of this node's image
 	 */
 	public String getImageId() {
 		if (imageId == null) {
 			return NodeIconProvider.getInstance().getIconId(getType());
 		} else {
 			return imageId;
 		}
 	}
 
 	public void setImageId(String id) {
 		imageId = id;
 	}
 
 	/**
 	 * Returns the number of {@link Connection}s this node is target for.
 	 *
 	 * @return number of {@link Connection}s this node is target for
 	 */
 	public int getTotalTargetConnectionsCount() {
 		int count = 0;
 		for (ConnectionGroup group : connectionGroups) {
 			count += group.getTargetConnectionCountFor(this);
 		}
 		return count;
 	}
 
 	/**
 	 * Returns the number of {@link Connection}s this node is source for.
 	 *
 	 * @return number of {@link Connection}s this node is source for
 	 */
 	public int getTotalSourceConnectionsCount() {
 		int count = 0;
 		for (ConnectionGroup group : connectionGroups) {
 			count += group.getSourceConnectionCountFor(this);
 		}
 		return count;
 	}
 
 	/**
 	 * Returns the number of {@link Connection}s this node is source or target for.
 	 *
 	 * @return number of {@link Connection}s this node is source or target for
 	 */
 	public int getTotalConnectionsCount() {
 		return getTotalTargetConnectionsCount() + getTotalSourceConnectionsCount();
 	}
 
 	/**
 	 * Checks if this node is directly connected to given <code>node</code>.
 	 *
 	 * @param node
 	 *            another node to check connection for
 	 * @return <code>true</code> if there is a direct {@link Connection} between this node and given <code>node</code>
 	 */
 	public boolean isConnected(Node node) {
 		for (ConnectionGroup group : getConnectionGroups()) {
 			if (group.isBetween(this, node) && (group.getConnectionCount() > 0)) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		return "PN " + getLabel(); //$NON-NLS-1$
 	}
 
 	/**
 	 * Two nodes are equal if their {@link #getId()}s 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 Node)) {
 			return false;
 		}
 
 		Node that = (Node)obj;
 		if (!getId().equals(that.getId())) {
 			return false;
 		}
 		return true;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#hashCode()
 	 */
 	@Override
 	public int hashCode() {
 		return getId().hashCode();
 	}
 
 	/**
 	 * Selects this node.
 	 *
 	 * @param primary
 	 *            whether the selection is primary
 	 */
 	public void select(boolean primary) {
 		// UNUSED [tmilos]
 		if (primary) {
 			firePropertyChange(SELECTED_PRIMARY, false, true);
 		} else {
 			firePropertyChange(SELECTED, false, true);
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.model.visual.backward.ModelElement#getAttributeManager()
 	 */
 	@Override
 	public AttributeManager getAttributeManager() {
 		return attributeManager;
 	}
 
 	public static void setSuppressLocationChangeEvents(boolean suppressLocationChangeEvents) {
 		Node.suppressLocationChangeEvents = suppressLocationChangeEvents;
 	}
 
 	public static boolean isSuppressLocationChangeEvents() {
 		return suppressLocationChangeEvents;
 	}
 
 }