/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2005 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.mindtree.techworks.insight.preferences.model;
  
  import java.io.Serializable;
  import java.util.HashMap;
  import java.util.Iterator;
  
  
  /**
   * This class stores a list of Preference attributes. It has a unique identifier
   * and name. No preference attribute can exist without a preference.
   * 
   * @see PreferenceAttribute PreferenceAttribute
   * @author Bindul Bhowmik
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   */
  public class Preference implements Serializable {
  
  	/**
  	 * Used for object serialization
  	 */
  	private static final long serialVersionUID = -9070247330487678727L;
  
  	/**
  	 * Seperator between the IDs of parent and child Preferences
  	 */
  	public static final String ID_SEPERATOR = "@";
  
  	/**
  	 * The unique identifier for the Preference
  	 */
  	private String id;
  
  	/**
  	 * The display name of the Preference
  	 */
  	private String name;
  
  	/**
  	 * Is the preference user modifiable. If the value of this field is set to
  	 * false, it overrides any value set for user modifiable in child
  	 * PreferenceAttributes of this object, and they will all be considered to
  	 * have their userModifiable field set to false.
  	 * 
  	 * @see PreferenceAttribute#isUserModifiable() isUserModifiable in
  	 *      PreferenceAttribute
  	 */
  	private boolean isUserModifiable;
  
  	/**
  	 * If this preference is a child of another preference, the reference to the
  	 * parent preference is stored here.
  	 */
  	private Preference parentPreference;
  
  	/**
  	 * Contains a list of child Preferences of this preference.
  	 */
  	private HashMap childPreferences;
  
  	/**
  	 * Child PreferenceAttributes for this Preference.
  	 */
  	private HashMap preferenceAttributes;
  
  	/**
  	 * The display class used by the GUI for displaying preferences.
  	 */
  	private String displayClass;
  
  	/**
  	 * If this is an aggregated attribute, in which case, it won't show up in
  	 * the tree of the Preference GUI.
  	 */
  	private boolean isAggregated;
  
 	/**
 	 * The manager of the Application. The preference notifies the manager for
 	 * any change in values of its attributes using this instance.
 	 */
 	private transient PreferenceModelManager preferenceModelManager;
 
 	/**
 	 * Constructor which sets the fields.
 	 * 
 	 * @param id The unique identifier for the Preference
 	 * @param isUserModifiable s the preference user modifiable
 	 * @param isAggregated If this is an aggregated preference.
 	 */
 	public Preference (String id, boolean isUserModifiable, boolean isAggregated) {
 
 		this.id = id;
 		this.isUserModifiable = isUserModifiable;
 		this.isAggregated = isAggregated;
 		preferenceAttributes = new HashMap();
 	}
 
 	/**
 	 * Utility constructor which sets the display name also
 	 * 
 	 * @param id The unique identifier for the Preference
 	 * @param isUserModifiable s the preference user modifiable
 	 * @param isAggregated If this is an aggregated preference.
 	 * @param name The display name of the Preference
 	 */
 	public Preference (String id, boolean isUserModifiable,
 			boolean isAggregated, String name) {
 
 		this(id, isUserModifiable, isAggregated);
 		this.name = name;
 	}
 
 
 	/**
 	 * @return Returns the isAggregated.
 	 */
 	public boolean isAggregated () {
 
 		return isAggregated;
 	}
 
 	/**
 	 * @return Returns the id.
 	 */
 	public String getId () {
 
 		return id;
 	}
 
 	/**
 	 * Returns the complete Id of the preference, including the parent's id. The
 	 * id is of the form:
 	 * 
 	 * <pre>
 	 * PARENTID_CHILDID
 	 * </pre>
 	 * 
 	 * @see Preference#ID_SEPERATOR Seperator between two IDs
 	 * @return The complete id of the Preference
 	 */
 	public String getCompleteId () {
 
 		if (null == parentPreference) {
 			return id;
 		} else {
 			return parentPreference.getCompleteId() + ID_SEPERATOR + id;
 		}
 	}
 
 	/**
 	 * @return Returns the isUserModifiable.
 	 */
 	public boolean isUserModifiable () {
 
 		return isUserModifiable;
 	}
 
 	/**
 	 * @return Returns the name.
 	 */
 	public String getName () {
 
 		return name;
 	}
 
 	/**
 	 * Adds a preferenceAttribute to the Preference. If a preference already
 	 * exists with the id of the PreferenceAttribute passed, the addition will
 	 * fail. Also if the parent of the preference is not this object, then also
 	 * addition fails.
 	 * 
 	 * @param preferenceAttribute The <code>PreferenceAttribute</code> to add.
 	 * @return <code>true</code> if the addition is succesfull or
 	 *         <code>false</code>
 	 */
 	public boolean addPreferenceAttribute (
 			PreferenceAttribute preferenceAttribute) {
 
 		if (preferenceAttributes.containsKey(preferenceAttribute.getId())) {
 			return false;
 		} else if (!this.equals(preferenceAttribute.getParent())) {
 			return false;
 		} else {
 			preferenceAttributes.put(preferenceAttribute.getId(),
 					preferenceAttribute);
 			if (null != preferenceModelManager) {
 				if (null != preferenceModelManager) {
 					preferenceModelManager.preferenceAttributeChanged(this.getCompleteId(), preferenceAttribute.getId(), PreferenceModelManager.OPERATION_PREF_ATTR_ADDED);
 				}
 			}
 			return true;
 		}
 	}
 
 	/**
 	 * Registers the manager for this preference. Checks if any other manager is
 	 * already registered with the instance.
 	 * 
 	 * @param manager The preferenceModelManager to set.
 	 * @return <code>true</code> if the registration succeeds or
 	 *         <code>false</code>
 	 */
 	public boolean registerPreferenceModelManager (
 			PreferenceModelManager manager) {
 
 		if (null == preferenceModelManager) {
 			preferenceModelManager = manager;
 			// Register children...
 			if (null != childPreferences) {
 				Iterator childPreferenceItr = childPreferences.values()
 						.iterator();
 				while (childPreferenceItr.hasNext()) {
 					Preference childPreference = (Preference) childPreferenceItr
 							.next();
 					childPreference.registerPreferenceModelManager(manager);
 				}
 			}
 			return true;
 		} else {
 			return false;
 		}
 	}
 
 	/**
 	 * Deregisters the manager from this preference. Does a check to see if the
 	 * manager being asked to be deregistered is the one registered for
 	 * notifications.
 	 * 
 	 * @param manager The manager to deregister
 	 * @return <code>true</code> if the deregistration succeeds or
 	 *         <code>false</code>
 	 */
 	public boolean deregisterPreferenceModelManager (
 			PreferenceModelManager manager) {
 
 		if (null != preferenceModelManager
 				&& preferenceModelManager.equals(manager)) {
 			preferenceModelManager = null;
 			// DeRegister children...
 			if (null != childPreferences) {
 				Iterator childPreferenceItr = childPreferences.values()
 						.iterator();
 				while (childPreferenceItr.hasNext()) {
 					Preference childPreference = (Preference) childPreferenceItr
 							.next();
 					childPreference.deregisterPreferenceModelManager(manager);
 				}
 			}
 			return true;
 		} else {
 			return false;
 		}
 	}
 
 	/**
 	 * Method called by the attributes to notify of a value change
 	 * 
 	 * @param attributeId The attribute whose value changed
 	 * @param newValue The new value of the attribute
 	 */
 	void notifyAttributeValueChange (String attributeId, String newValue) {
 
 		// Notification is done with the complete id.
 		if (null != preferenceModelManager
 				&& preferenceAttributes.containsKey(attributeId)) {
 			preferenceModelManager.attributeValueChanged(getCompleteId(),
 					attributeId, newValue);
 		}
 	}
 
 	/**
 	 * Returns a PreferenceAttribute for the id specified. Searches also the
 	 * parent preferences for the attribute.
 	 * 
 	 * @param attributeId The id of the attribute
 	 * @return PreferenceAttribute for the id supplied.
 	 * @throws ArrayIndexOutOfBoundsException If the id is not found.
 	 */
 	public PreferenceAttribute getPreferenceAttributeById (String attributeId) {
 
 		if (preferenceAttributes.containsKey(attributeId)) {
 			return (PreferenceAttribute) preferenceAttributes.get(attributeId);
 		} else if (null != parentPreference) {
 			return parentPreference.getPreferenceAttributeById(attributeId);
 		} else {
 			throw new ArrayIndexOutOfBoundsException(
 					"Preference Attribute not present");
 		}
 	}
 
 	/**
 	 * Checks if the preference has an attribute with the attribute id. Checks
 	 * the parent preference also for the attribute.
 	 * 
 	 * @param attributeId The id to check
 	 * @return <code>true</code> if the attribute is present or
 	 *         <code>false</code>
 	 */
 	public boolean isPreferenceAttributePresent (String attributeId) {
 
 		if (preferenceAttributes.containsKey(attributeId)) {
 			return true;
 		} else if (null != parentPreference) {
 			return parentPreference.isPreferenceAttributePresent(attributeId);
 		} else {
 			return false;
 		}
 	}
 
 	/**
 	 * Returns an iterator for all the Preference Attributes.
 	 * 
 	 * @return <code>Iterator</code> for all the Preference Attribtues.
 	 */
 	public Iterator iteratePreferenceAttributes () {
 
 		return preferenceAttributes.values().iterator();
 	}
 
 	/**
 	 * Returns an iterator for the ids of all the Preference Attribtues in this
 	 * Preference.
 	 * 
 	 * @return <code>Iterator</code> for all the Preference Attribute Keys.
 	 */
 	public Iterator iteratePreferenceAttributeIds () {
 
 		return preferenceAttributes.keySet().iterator();
 	}
 
 	/**
 	 * Returns a child preference for the Id passed
 	 * 
 	 * @param preferenceId The id of the preference required.
 	 * @return Preference for the id passed.
 	 * @throws ArrayIndexOutOfBoundsException If the Preference for the id
 	 *             passed is not present.
 	 */
 	public Preference getPreferenceById (String preferenceId) {
 
 		if (null != childPreferences) {
 			if (childPreferences.containsKey(preferenceId)) {
 				return (Preference) childPreferences.get(preferenceId);
 			} else if (preferenceId.indexOf(ID_SEPERATOR) > 0) {
 				int parentLocation = preferenceId.indexOf(ID_SEPERATOR);
 				String parentKey = preferenceId.substring(0, parentLocation);
 				
 				if (childPreferences.containsKey(parentKey)) {
 					return ((Preference) childPreferences.get(parentKey)).getPreferenceById(preferenceId.substring(parentLocation + 1));
 				} else {
 					throw new ArrayIndexOutOfBoundsException("Preference not present");
 				}
 			} else {
 				throw new ArrayIndexOutOfBoundsException("Preference not present");
 			}
 		} else {
 			throw new ArrayIndexOutOfBoundsException("Preference not present");
 		}
 	}
 
 	/**
 	 * Checks if the Preference with the id specified is a child of this
 	 * preference.
 	 * 
 	 * @param preferenceId The id of the child preference to check.
 	 * @return <code>true</code> if the preference is present or
 	 *         <code>false</code>
 	 */
 	public boolean isPreferencePresent (String preferenceId) {
 
 		if (null != childPreferences) {
 			return childPreferences.containsKey(preferenceId);
 		} else {
 			return false;
 		}
 
 	}
 
 	/**
 	 * Returns an iterator to the child Preferences.
 	 * 
 	 * @return An iterator of the child preferences or <code>null</code> if
 	 *         none are present.
 	 */
 	public Iterator iterateChildPreferences () {
 
 		if (null != childPreferences) {
 			return childPreferences.values().iterator();
 		} else {
 			return null;
 		}
 	}
 
 	/**
 	 * Returns an iterator to the child Preference ids.
 	 * 
 	 * @return An iterator of the child preference ids or <code>null</code> if
 	 *         none are present.
 	 */
 	public Iterator iterateChildPreferenceIds () {
 
 		if (null != childPreferences) {
 			return childPreferences.keySet().iterator();
 		} else {
 			return null;
 		}
 	}
 
 	/**
 	 * Constructs and returns a PreferenceInfo object for this instance.
 	 * 
 	 * @see PreferenceInfo PreferenceInfo
 	 * @return PreferenceInfo for this object.
 	 */
 	public PreferenceInfo getPreferenceInfo () {
 
 		PreferenceInfo preferenceInfo = new PreferenceInfo();
 		preferenceInfo.setId(this.id);
 		preferenceInfo.setName(this.name);
 		preferenceInfo.setUserModifiable(this.isUserModifiable);
 		preferenceInfo.setAggregated(this.isAggregated);
 		preferenceInfo.setCompleteId(getCompleteId());
 
 		// Get child preference info's
 		if (null != childPreferences) {
 			for (Iterator childPrefItr = childPreferences.values().iterator(); childPrefItr
 					.hasNext();) {
 				preferenceInfo
 						.addChildPreferenceInfo(((Preference) childPrefItr
 								.next()).getPreferenceInfo());
 			}
 		}
 
 		return preferenceInfo;
 	}
 
 	/**
 	 * @return Returns the displayClass.
 	 */
 	public String getDisplayClass () {
 
 		return displayClass;
 	}
 
 	/**
 	 * @param displayClass The displayClass to set.
 	 */
 	public void setDisplayClass (String displayClass) {
 
 		this.displayClass = displayClass;
 	}
 
 	/**
 	 * Sets the parent preference of this preference
 	 * 
 	 * @param parentPreference Parent preference
 	 */
 	protected void setParent (Preference parentPreference) {
 
 		this.parentPreference = parentPreference;
 	}
 
 	/**
 	 * Adds a child preference to this preference
 	 * 
 	 * @param preference The preference to add
 	 * @return <code>true</code> If preference is added successfully or
 	 *         <code>false</code>
 	 */
 	public boolean addChildPreference (Preference preference) {
 
 		if (null == childPreferences) {
 			childPreferences = new HashMap();
 		}
 
 		if (childPreferences.containsKey(preference.getId())) {
 			return false;
 		} else {
 			childPreferences.put(preference.getId(), preference);
 			preference.setParent(this);
 			if (null != preferenceModelManager) {
 				preference
 						.registerPreferenceModelManager(preferenceModelManager);
 				// Send notification
 				preferenceModelManager.childPreferenceChanged(this
 						.getCompleteId(), preference.getId(),
 						PreferenceModelManager.OPERATION_CHILD_PREF_ADDED);
 			}
 			return true;
 		}
 	}
 	
 	/**
 	 * Removes a child preference
 	 * @param preference The preference to remove
 	 * @return <code>true</code> if remove succeeds or <code>false</code>.
 	 */
 	public boolean removePreference(Preference preference) {
 		if (preference.parentPreference == this) {
 			if (null != childPreferences && childPreferences.containsKey(preference.getId())) {
 				childPreferences.remove(preference.getId());
 				preference.deregisterPreferenceModelManager(this.preferenceModelManager);
 				preference.parentPreference = null;
 				// Send Notification
 				if (null != preferenceModelManager) {
 					preferenceModelManager
 							.childPreferenceChanged(
 									this.getCompleteId(),
 									preference.getId(),
 									PreferenceModelManager.OPERATION_CHILD_PREF_REMOVED);
 				}
 				return true;
 			} else {
 				return false;
 			}
 		} else {
 			return false;
 		}
 	}
 	
 	/**
 	 * Removes a preference attribute from this preference
 	 * @param preferenceAttribute The preferenceAttribute to remove
 	 * @return <code>true</code> if the removal succeeds or <code>false</code>.
 	 */
 	public boolean removePreferenceAttribute(PreferenceAttribute preferenceAttribute) {
 		if (preferenceAttribute.getParent().equals(this) && this.preferenceAttributes.containsValue(preferenceAttribute)) {
 			this.preferenceAttributes.remove(preferenceAttribute.getId());
 			if (null != preferenceModelManager) {
 				preferenceModelManager.preferenceAttributeChanged(this.getCompleteId(), preferenceAttribute.getId(), PreferenceModelManager.OPERATION_PREF_ATTR_REMOVED);
 			}
 			return true;
 		} else {
 			return false;
 		}
 	}
 	/**
 	 * @param name The name to set.
 	 */
 	public void setName(String name) {
 		this.name = name;
 	}
 }