/*
    * $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;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import com.mindtree.techworks.insight.preferences.model.Preference;
  import com.mindtree.techworks.insight.preferences.model.PreferenceInfo;
  import com.mindtree.techworks.insight.preferences.model.PreferenceModelManager;
  
  
  /**
   * <p>
   * This is a singleton class to be used by the entire application for accessing
   * and storing <code>Preferences</code>.
   * </p>
   * <p>
   * The PreferencesManager is designed not to throw any exceptions, and whenever
   * a particular exception value is missing or cannot be saved, it will simply
   * return <code>null</code>. It is upto the calling method to determine
   * whether it wants to terminate the usecase or continue with the execution of
   * the program or display a warning to the user.
   * </p>
   * 
   * @see com.mindtree.techworks.insight.preferences.model.Preference Preference
   * @author Bindul Bhowmik
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   */
  public class PreferenceManager implements PreferenceModelManager {
  
  	/**
  	 * Instance for the singleton.
  	 */
  	private static PreferenceManager instance = null;
  
  	/**
  	 * Seperator between the preference and the preference-attribute ids for a
  	 * listener.
  	 */
  	private static final String LISTENER_KEY_SEPERATOR = "_";
  
  	/**
  	 * Interval (in milliseconds) after which dirty preferences are checked to
  	 * be stored.
  	 */
  	private static final int MAX_DIRTY_PREFERENCES = 5;
  
  	/**
  	 * Local cache for preferences
  	 */
  	private HashMap preferenceCache = null;
  
  	/**
  	 * Holds all the listeners interested in being notified of a preference
  	 * attribute value change.
  	 */
  	private HashMap attributeChangeListeners = null;
  
  	/**
  	 * Holds all the listeners interested in being notified of a preference
  	 * change
  	 */
  	private HashMap preferenceChangeListeners = null;
  
  	/**
  	 * If a preference notification lock is enabled, all
  	 */
  	private LinkedList preferenceChangesToNotify = new LinkedList();
  
  	/**
  	 * Should Preference Notifications be locked.
 	 */
 	private boolean lockPreferenceNotifications = false;
 
 	/**
 	 * Stores the ids of all dirty preferences.
 	 */
 	private List dirtyPreferences = null;
 
 	/**
 	 * Keeps a track of total number of dirty preferences.
 	 */
 	private int totalDirtyCount;
 
 	/**
 	 * Caches the preferenceNameList
 	 */
 	private Map preferenceNameMap = null;
 
 	/**
 	 * Checks if all preferences are loaded.
 	 */
 	private boolean isAllPreferencesLoaded = false;
 
 	/**
 	 * Private constructor to avoid instantiations outside the class.
 	 */
 	private PreferenceManager () {
 
 		preferenceCache = new HashMap();
 		attributeChangeListeners = new HashMap();
 		preferenceChangeListeners = new HashMap();
 		dirtyPreferences = new ArrayList();
 	}
 
 	/**
 	 * Returns the singleton instance of PreferenceManager.
 	 * 
 	 * @return The singleton instance of PreferenceManager
 	 */
 	public static PreferenceManager getInstance () {
 
 		if (null == instance) {
 			//Instantiate the instance - double check lock!
 			synchronized (PreferenceManager.class) {
 				if (null == instance) {
 					instance = new PreferenceManager();
 				}
 			}
 		}
 		return instance;
 	}
 
 	/**
 	 * Checks if any preferences are dirty, then stores them to the store.
 	 */
 	private void storePreferences () {
 
 		//do some writing
 		synchronized (dirtyPreferences) {
 			List preferencesToStore = new ArrayList();
 			for (Iterator dirtyPreferencesItr = dirtyPreferences.iterator(); dirtyPreferencesItr
 					.hasNext();) {
 				String completeDirtyPreferenceId = (String) dirtyPreferencesItr
 						.next();
 				String dirtyPreferenceId = completeDirtyPreferenceId;
 				int idIndex = completeDirtyPreferenceId
 						.indexOf(Preference.ID_SEPERATOR);
 				if (idIndex > -1) {
 					dirtyPreferenceId = completeDirtyPreferenceId.substring(0,
 							idIndex);
 				}
 				preferencesToStore.add(preferenceCache.get(dirtyPreferenceId));
 			}
 			PreferenceDataHandler dataHandler = null;
 			try {
 				dataHandler = PreferenceDataHandlerFactory.getDefaultHandler();
 				dataHandler.savePreferences(preferencesToStore);
 			} catch (PreferenceHandlerInstantiationException e) {
 				e.printStackTrace();
 			} catch (PreferenceHandlerStoreException e) {
 				// TODO Decide how to notify the application
 				e.printStackTrace();
 			}
 			totalDirtyCount = 0;
 		}
 	}
 
 	/**
 	 * Returns a Preference
 	 * 
 	 * @param preferenceId The preferenceId for which the preference is sought
 	 * @return Preference The Preference
 	 */
 	public Preference getPreference (String preferenceId) {
 
 		Preference preferenceToReturn = null;
 
 		if (!preferenceCache.containsKey(preferenceId)) {
 			loadPreference(preferenceId);
 		}
 		preferenceToReturn = (Preference) preferenceCache.get(preferenceId);
 
 		int parentLocation = preferenceId.indexOf(Preference.ID_SEPERATOR);
 
 		if (null == preferenceToReturn && parentLocation > 0) {
 			String parentPreferenceId = preferenceId.substring(0,
 					parentLocation);
 			if (!preferenceCache.containsKey(parentPreferenceId)) {
 				loadPreference(parentPreferenceId);
 			}
 			Preference parentPreference = (Preference) preferenceCache
 					.get(parentPreferenceId);
 			preferenceToReturn = parentPreference
 					.getPreferenceById(preferenceId
 							.substring(parentLocation + 1));
 		}
 
 		return preferenceToReturn;
 	}
 
 	/**
 	 * Loads a preference into the cache
 	 * 
 	 * @param preferenceId
 	 */
 	private void loadPreference (String preferenceId) {
 
 		PreferenceDataHandler dataHandler = null;
 		Preference preference = null;
 		try {
 			dataHandler = PreferenceDataHandlerFactory.getDefaultHandler();
 			preference = dataHandler.getPreference(preferenceId);
 		} catch (PreferenceHandlerInstantiationException e) {
 			e.printStackTrace();
 		}
 		if (null != preference) {
 			preference.registerPreferenceModelManager(this);
 			preferenceCache.put(preferenceId, preference);
 		}
 	}
 
 	/**
 	 * Returns preference info
 	 * 
 	 * @return List of
 	 *         {@link com.mindtree.techworks.insight.preferences.model.PreferenceInfo PreferenceInfo}
 	 *         objects.
 	 */
 	public Collection getAllPreferenceNames () {
 
 		Collection preferenceNameList = null;
 
 		if (null == preferenceNameMap) {
 			PreferenceDataHandler dataHandler = null;
 			try {
 				dataHandler = PreferenceDataHandlerFactory.getDefaultHandler();
 				preferenceNameList = dataHandler.getPreferenceNameList();
 				// Populate the Preference Name map
 				preferenceNameMap = new HashMap();
 				for (Iterator preferenceNameItr = preferenceNameList.iterator(); preferenceNameItr
 						.hasNext();) {
 					PreferenceInfo preferenceInfo = (PreferenceInfo) preferenceNameItr
 							.next();
 					preferenceNameMap.put(preferenceInfo.getId(),
 							preferenceInfo);
 				}
 			} catch (PreferenceHandlerInstantiationException e) {
 				e.printStackTrace();
 			}
 		} else {
 			preferenceNameList = preferenceNameMap.values();
 		}
 
 		return preferenceNameList;
 	}
 
 	/**
 	 * Returns all the preferences
 	 * 
 	 * @return A {@link Collection Collection}of Preferences
 	 */
 	public Collection getAllPreferences () {
 
 		if (!isAllPreferencesLoaded) {
 
 			//Preferences are not loaded, load them.
 			if (null == preferenceNameMap) {
 				//Load the preference names
 				getAllPreferenceNames();
 			}
 
 			//Load the preferences
 			PreferenceDataHandler dataHandler = null;
 			try {
 				dataHandler = PreferenceDataHandlerFactory.getDefaultHandler();
 				Collection allPreferences = dataHandler.getAllPreferences();
 				for (Iterator allPreferencesIterator = allPreferences
 						.iterator(); allPreferencesIterator.hasNext();) {
 					Preference preference = (Preference) allPreferencesIterator
 							.next();
 					if (!preferenceCache.containsKey(preference.getId())) {
 						preference.registerPreferenceModelManager(this);
 						preferenceCache.put(preference.getId(), preference);
 					}
 				}
 
 			} catch (PreferenceHandlerInstantiationException e) {
 				e.printStackTrace();
 			}
 
 			isAllPreferencesLoaded = true;
 		}
 		return preferenceCache.values();
 	}
 
 	/**
 	 * Registeres a listener to be notified of changes in attribute values.
 	 * 
 	 * @param completePreferenceId The preference the listener is interested in
 	 * @param attributeId The attribute in the preference the listener is
 	 *            interested in
 	 * @param listener The listener to register. Must implement
 	 *            {@link PreferenceAttributeChangeListener PreferenceAttributeChangeListener}
 	 */
 	public void registerListener (String completePreferenceId,
 			String attributeId, PreferenceAttributeChangeListener listener) {
 
 		String key = completePreferenceId + LISTENER_KEY_SEPERATOR
 				+ attributeId;
 		ArrayList listenerList = null;
 		if (attributeChangeListeners.containsKey(key)) {
 			listenerList = (ArrayList) attributeChangeListeners.get(key);
 		} else {
 			listenerList = new ArrayList();
 		}
 
 		if (!listenerList.contains(listener)) {
 			listenerList.add(listener);
 			attributeChangeListeners.put(key, listenerList);
 		}
 	}
 
 	/**
 	 * Removes a listener from the list of listeners for an attribute, if
 	 * already registered.
 	 * 
 	 * @param completePreferenceId The preference the listener is interested in
 	 * @param attributeId The attribute in the preference the listener is
 	 *            interested in
 	 * @param listener The listener to register.
 	 */
 	public void deregisterListener (String completePreferenceId,
 			String attributeId, PreferenceAttributeChangeListener listener) {
 
 		String key = completePreferenceId + LISTENER_KEY_SEPERATOR
 				+ attributeId;
 		if (attributeChangeListeners.containsKey(key)) {
 			ArrayList listenerList = (ArrayList) attributeChangeListeners
 					.get(key);
 			listenerList.remove(listener);
 		}
 	}
 
 	/**
 	 * Registeres a listener to be notified of changes in preference values.
 	 * 
 	 * @param completePreferenceId The preference the listener is interested in
 	 * @param listener The listener to register. Must implement
 	 *            {@link PreferenceChangeListener PreferenceChangeListener}
 	 */
 	public void registerListener (String completePreferenceId,
 			PreferenceChangeListener listener) {
 
 		ArrayList listenerList = null;
 		if (preferenceChangeListeners.containsKey(completePreferenceId)) {
 			listenerList = (ArrayList) preferenceChangeListeners
 					.get(completePreferenceId);
 		} else {
 			listenerList = new ArrayList();
 		}
 
 		if (!listenerList.contains(listener)) {
 			listenerList.add(listener);
 			preferenceChangeListeners.put(completePreferenceId, listenerList);
 		}
 
 	}
 
 	/**
 	 * Removes a listener from the list of listeners for a preference, if
 	 * already registered.
 	 * 
 	 * @param completePreferenceId The preference the listener is interested in
 	 * @param listener The listener to register.
 	 */
 	public void deregisterListener (String completePreferenceId,
 			PreferenceChangeListener listener) {
 
 		if (preferenceChangeListeners.containsKey(completePreferenceId)) {
 			ArrayList listenerList = (ArrayList) preferenceChangeListeners
 					.get(completePreferenceId);
 			listenerList.remove(listener);
 		}
 	}
 
 	/**
 	 * Notifies all interested parties about change in an Attribute's value.
 	 * Also helps in lazy writing.
 	 * <p>
 	 * This method is called by the <code>PreferenceAttribute</code> whose
 	 * value changes. It is used by the PreferenceManager to notify all
 	 * interested instances of
 	 * {@link PreferenceAttributeChangeListener PreferenceAttributeChangeListener}
 	 * instances registered with the PreferenceManager.
 	 * </p>
 	 * <p>
 	 * This method is also used by the manager to lazy write the preferences. If
 	 * a different instance implements
 	 * {@link PreferenceModelManager PreferenceModelManager}is used, then the
 	 * instance of PreferenceManager should register with that instance for
 	 * notifications of all attribute value changes.
 	 * </p>
 	 * 
 	 * @see com.mindtree.techworks.insight.preferences.model.PreferenceModelManager#attributeValueChanged(java.lang.String,
 	 *      java.lang.String, java.lang.String)
 	 */
 	public void attributeValueChanged (String completePreferenceId,
 			String attributeId, String newValue) {
 
 		// Attribute Change Notification
 		String key = completePreferenceId + LISTENER_KEY_SEPERATOR
 				+ attributeId;
 		if (attributeChangeListeners.containsKey(key)) {
 			ArrayList listenerList = (ArrayList) attributeChangeListeners
 					.get(key);
 			for (Iterator listenerIterator = listenerList.iterator(); listenerIterator
 					.hasNext();) {
 				PreferenceAttributeChangeListener listener = (PreferenceAttributeChangeListener) listenerIterator
 						.next();
 				listener.attributeValueChanged(completePreferenceId,
 						attributeId, newValue);
 			}
 		}
 		
 		// Preference change notification
 		notifyPreferenceChangeListeners(completePreferenceId);
 
 		// Lazy Writing.
 		if (!dirtyPreferences.contains(completePreferenceId)) {
 			dirtyPreferences.add(completePreferenceId);
 		}
 		totalDirtyCount++ ;
 		// Store the preferences based on Dirty Count
 		if (totalDirtyCount >= MAX_DIRTY_PREFERENCES) {
 			storePreferences();
 		}
 	}
 
 	/**
 	 * This method is used by the Manager to primarily regenerate the
 	 * PreferenceInfo for the preference.
 	 * 
 	 * @see com.mindtree.techworks.insight.preferences.model.PreferenceModelManager#childPreferenceChanged(java.lang.String,
 	 *      java.lang.String, int)
 	 */
 	public void childPreferenceChanged (String preferenceId,
 			String childPreferenceId, int operation) {
 
 		// Preference change notification
 		notifyPreferenceChangeListeners(preferenceId);
 		
 		String parentPreferenceId = preferenceId;
 		if (preferenceId.indexOf(Preference.ID_SEPERATOR) > -1) {
 			parentPreferenceId = preferenceId.substring(0, preferenceId
 					.indexOf(Preference.ID_SEPERATOR));
 		}
 
 		if (null != preferenceNameMap
 				&& preferenceCache.containsKey(parentPreferenceId)) {
 			// Regenerate the preference info
 			Preference preference = (Preference) preferenceCache
 					.get(parentPreferenceId);
 			preferenceNameMap.put(parentPreferenceId, preference
 					.getPreferenceInfo());
 		}
 
 		// Lazy Writing.
 		if (!dirtyPreferences.contains(preferenceId)) {
 			dirtyPreferences.add(preferenceId);
 		}
 		totalDirtyCount++ ;
 		// Store the preferences based on Dirty Count
 		if (totalDirtyCount >= MAX_DIRTY_PREFERENCES) {
 			storePreferences();
 		}
 
 	}
 
 	/**
 	 * Method to be called when the application is being shut down. The manager
 	 * will store all dirty preferences.
 	 */
 	public void applicationShuttingDown () {
 
 		if (totalDirtyCount > 0) {
 			storePreferences();
 		}
 	}
 
 	/**
 	 * @see com.mindtree.techworks.insight.preferences.model.PreferenceModelManager#preferenceAttributeChanged(java.lang.String,
 	 *      java.lang.String, int)
 	 */
 	public void preferenceAttributeChanged (String preferenceId,
 			String preferenceAttributeId, int operation) {
 
 		// Preference change notification
 		notifyPreferenceChangeListeners(preferenceId);
 		
 		// Lazy Writing.
 		if (!dirtyPreferences.contains(preferenceId)) {
 			dirtyPreferences.add(preferenceId);
 		}
 		totalDirtyCount++ ;
 		// Store the preferences based on Dirty Count
 		if (totalDirtyCount >= MAX_DIRTY_PREFERENCES) {
 			storePreferences();
 		}
 	}
 
 	/**
 	 * Informs this PreferenceManager of an impending preference(s) save
 	 */
 	public void startPreferencesSave () {
 
 		lockPreferenceNotifications = true;
 	}
 
 	/**
 	 * Informs this PreferenceManager that the save is complete
 	 */
 	public void endPreferencesSave () {
 		lockPreferenceNotifications = false;
 		if (!preferenceChangesToNotify.isEmpty()) {
 			for (int i = preferenceChangesToNotify.size(); i >0; i--) {
 				notifyPreferenceChangeListeners((String) preferenceChangesToNotify.removeFirst());
 			}
 		}
 	}
 	
 	/**
 	 * Notifies a listener on change of a preference
 	 * @param completePreferenceId The preference id to notify for
 	 */
 	private void notifyPreferenceChangeListeners(String completePreferenceId) {
 		if (lockPreferenceNotifications) {
 			if (!preferenceChangesToNotify.contains(completePreferenceId)) {
 				preferenceChangesToNotify.addLast(completePreferenceId);
 			}
 		} else {
 			Iterator keys = preferenceChangeListeners.keySet().iterator();
 			while (keys.hasNext()) {
 				String key = (String) keys.next();
 				if (completePreferenceId.startsWith(key)) {
 					Iterator listeners = ((List) preferenceChangeListeners.get(key)).iterator();
 					while (listeners.hasNext()) {
 						((PreferenceChangeListener) listeners.next()).preferenceChanged(key);
 					}
 				}
 			}
 		}
 	}
 
 }