/*
    * 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: AttributeManager.java
   * Created: 2007-00-00
   * Author: awos
   * $Id: AttributeManager.java 2817 2009-05-05 13:17:57Z tmilos $
   */
  
  package pl.edu.agh.cast.model.attributes;
  
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  import java.util.SortedMap;
  import java.util.TreeMap;
  
  import org.eclipse.osgi.util.NLS;
  
  import pl.edu.agh.cast.data.model.property.IPropertyChangeProvider;
  import pl.edu.agh.cast.data.model.property.PropertyChangeProviderHelper;
  import pl.edu.agh.cast.util.Messages;
  
  import com.thoughtworks.xstream.annotations.XStreamOmitField;
  
  /**
   * Class responsible for holding available attribute types for different model element types.
   *
   * Available attribute types are specific for model element types, such as {@link Node}, {@link ConnectionGroup},
   * {@link Legend} etc.
   *
   * For convenience, the manager acts as a forwarder of all events fired by its registered attributes. Events have ID
   * {@link #ATTRIBUTES_PROPERTY_CHANGE}, and oldValue set to corresponding {@link PropertyChangeEvent} object that is
   * being forwarded.
   *
   * @author AGH CAST Team
   */
  public abstract class AttributeManager implements Serializable, IPropertyChangeProvider, PropertyChangeListener {
  
  	private static final long serialVersionUID = 8685580835572389886L;
  
  	/**
  	 * ID of the <em>AttributesProperty</em> property.
  	 */
  	public static final String ATTRIBUTES_PROPERTY_CHANGE = "AttributeManager.AttributesProperty"; //$NON-NLS-1$
  
  	/**
  	 * ID of the <em>RegistrationStatus</em> property.
  	 */
  	public static final String ATTRIBUTE_REGISTRATION_STATUS = "AttributeManager.RegistrationStatus"; //$NON-NLS-1$
  
  	private SortedMap<String, Attribute> registeredAttributes;
  
  	/**
  	 * Default constructor.
  	 */
  	public AttributeManager() {
  		registeredAttributes = new TreeMap<String, Attribute>();
  		pcpHelper = new PropertyChangeProviderHelper(this);
  	}
  
  	/**
  	 * Checks if an attribute with given ID is registered.
  	 *
  	 * @param id
  	 *            ID to check
  	 * @return <code>true</code> if an attribute with given ID is registered
  	 */
  	public boolean isRegisteredId(String id) {
  		return registeredAttributes.containsKey(id);
  	}
  
  	/**
  	 * Registers attribute in current manager. Fires {@link #ATTRIBUTE_REGISTRATION_STATUS} event with new value set to
  	 * the created attribute object and oldValue set to null.
  	 *
  	 * @param id
  	 *            name (id) of attribute
  	 * @param nameIsLocalizable
  	 *            whether attribute's name should be used as a key to get attribute friendly name from {@link Messages}
  	 * @param type
  	 *            attribute's value type
  	 * @param defaultValue
  	 *            default value of the attribute
  	 * @param permanent
  	 *            if attribute is built-in and cannot be unregistered
  	 * @param editable
 	 *            if attribute's value can be changed
 	 * @param showAsLabel
 	 *            if attribute is included in label
 	 * @param ownerTypeName
 	 *            the name of the type in domain model which defines this attribute; should be null if the attribute is
 	 *            not localizable
 	 * @param modelExtensionId
 	 *            the name of the model extension which defines the owner type of the attribute; should be null, if the
 	 *            attribute is not localizable or it is a predefined attribute
 	 * @throws IllegalArgumentException
 	 *             if attribute is already registered
 	 */
 	private void registerAttribute(String id, boolean nameIsLocalizable, ValueType type, Object defaultValue,
 	        boolean permanent, boolean editable, boolean showAsLabel, String ownerTypeName, String modelExtensionId) {
 		if (isRegisteredId(id)) {
 			throw new IllegalArgumentException(NLS.bind("Attribute '{0}' already registered", id)); //$NON-NLS-1$
 		} else {
 			Attribute attribute = new Attribute(id, nameIsLocalizable, type, defaultValue, permanent, editable,
 			        showAsLabel, ownerTypeName, modelExtensionId);
 			registeredAttributes.put(id, attribute);
 			attribute.addPropertyChangeListener(this);
 			firePropertyChange(ATTRIBUTE_REGISTRATION_STATUS, null, attribute);
 		}
 	}
 
 	/**
 	 * Returns list of permanent attributes.
 	 *
 	 * @return list of permanent attributes
 	 */
 	public List<Attribute> getPermanentAttributes() {
 		List<Attribute> permanentAttributes = new ArrayList<Attribute>();
 		for (Attribute attribute : registeredAttributes.values()) {
 			if (attribute.isPermanent()) {
 				permanentAttributes.add(attribute);
 			}
 		}
 		return permanentAttributes;
 	}
 
 	/**
 	 * Registers new {@link Attribute} in this manager.
 	 *
 	 * @param id
 	 *            id of the new attribute
 	 * @param valueType
 	 *            value type of the new attribute
 	 */
 	public void registerAttribute(String id, ValueType valueType) {
 		registerAttribute(id, false, valueType, valueType.getDefaultValue(), false, true, false, null, null);
 	}
 
 	/**
 	 * Modifies registered attribute's showAsLabel flag.
 	 *
 	 * @param id
 	 *            attribute name
 	 * @param showAsLabel
 	 *            new value of the showAsLabel flag
 	 * @throws IllegalArgumentException
 	 *             if attribute <code>name</code> is not registered in this manager
 	 */
 	public void setAttributeIsLabel(String id, boolean showAsLabel) {
 		getAttribute(id).setShowAsLabel(showAsLabel);
 	}
 
 	/**
 	 * This register method should be used for predefined attributes, i.e. attributes defined in the Core plug-in.
 	 */
 	protected void registerPermanentAttribute(String id, ValueType type, boolean editable, boolean showAsLabel) {
 		registerAttribute(id, true, type, type.getDefaultValue(), true, editable, showAsLabel, null, null);
 	}
 
 	/**
 	 * This register method should be used for attributes defined in domain models.
 	 */
 	protected void registerPermanentAttribute(String id, ValueType type, boolean editable, boolean showAsLabel,
 	        String ownerTypeId, String modelExtensionId) {
 		registerAttribute(id, true, type, type.getDefaultValue(), true, editable, showAsLabel, ownerTypeId,
 		        modelExtensionId);
 	}
 
 	/**
 	 * Returns a collection of registered attributes.
 	 *
 	 * @return an unmodifiable collection of attributes registered in this manager
 	 */
 	public Collection<Attribute> getAttributes() {
 		return Collections.unmodifiableCollection(registeredAttributes.values());
 	}
 
 	/**
 	 * Unregisters an attribute from this manager. Fires {@link #ATTRIBUTE_REGISTRATION_STATUS} event with old value set
 	 * to the removed attribute object and newValue set to null.
 	 *
 	 * @param id
 	 *            name of attribute to remove
 	 * @throws IllegalArgumentException
 	 *             if attribute was not registered in this manager, or attribute is permanent
 	 */
 	public void unregisterId(String id) {
 		if (!registeredAttributes.containsKey(id)) {
 			throw new IllegalArgumentException(NLS.bind(Messages.ModelElementPropertyManager_0, id));
 		}
 
 		if (registeredAttributes.get(id).isPermanent()) {
 			throw new IllegalArgumentException(NLS.bind("Permanent attribute '{0}' cannot be unregistered", id)); //$NON-NLS-1$
 		}
 		Attribute removed = registeredAttributes.remove(id);
 		removed.removePropertyChangeListener(this);
 		firePropertyChange(ATTRIBUTE_REGISTRATION_STATUS, removed, null);
 	}
 
 	/**
 	 * Returns attribute with given id (name).
 	 *
 	 * @param id
 	 *            attribute name
 	 * @return {@link Attribute} object registered in this manager
 	 * @throws IllegalArgumentException
 	 *             if attribute <code>id</code> is not registered in this manager
 	 */
 	public Attribute getAttribute(String id) {
 		if (!registeredAttributes.containsKey(id)) {
 			throw new IllegalArgumentException(NLS.bind(Messages.ModelElementPropertyManager_0, id));
 		}
 		return registeredAttributes.get(id);
 	}
 
 	/**
 	 * Initialize this manager after deserializing attributes.
 	 *
 	 * @param attributes
 	 *            list of attributes to register
 	 */
 	public void init(List<Attribute> attributes) {
 		for (Attribute a : attributes) {
 			registeredAttributes.put(a.getName(), a);
 			a.addPropertyChangeListener(this);
 		}
 	}
 
 	/**
 	 * Forward property change events from single attributes.
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
 	 */
 	public void propertyChange(PropertyChangeEvent evt) {
 		if (Attribute.PROPERTY_SHOW_AS_LABEL.equals(evt.getPropertyName())) {
 			firePropertyChange(AttributeManager.ATTRIBUTES_PROPERTY_CHANGE, evt, null);
 		}
 	}
 
 	/**
 	 * Property change support
 	 */
 	@XStreamOmitField
 	private transient PropertyChangeProviderHelper pcpHelper;
 
 	protected Object readResolve() {
 		pcpHelper = new PropertyChangeProviderHelper(this);
 		for (Attribute a : registeredAttributes.values()) {
 			a.addPropertyChangeListener(this);
 		}
 		return this;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.data.model.property.IPropertyChangeProvider#addPropertyChangeListener(java.beans.PropertyChangeListener)
 	 */
 	public void addPropertyChangeListener(PropertyChangeListener l) {
 		pcpHelper.addPropertyChangeListener(l);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.data.model.property.IPropertyChangeProvider
 	 *      #removePropertyChangeListener(java.beans.PropertyChangeListener)
 	 */
 	public void removePropertyChangeListener(PropertyChangeListener l) {
 		pcpHelper.removePropertyChangeListener(l);
 	}
 
 	protected void firePropertyChange(String property, Object oldValue, Object newValue) {
 		pcpHelper.firePropertyChange(property, oldValue, newValue);
 	}
 
 }