/*
    * $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.gui.preferences;
  
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.Rectangle;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.util.HashMap;
  import java.util.Iterator;
  
  import javax.swing.JButton;
  import javax.swing.JDialog;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JOptionPane;
  import javax.swing.JSplitPane;
  import javax.swing.JTree;
  import javax.swing.event.TreeSelectionEvent;
  import javax.swing.event.TreeSelectionListener;
  import javax.swing.tree.DefaultMutableTreeNode;
  import javax.swing.tree.DefaultTreeCellRenderer;
  
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.ResourceManager;
  import com.mindtree.techworks.insight.ShutdownHookManager;
  import com.mindtree.techworks.insight.preferences.PreferenceManager;
  import com.mindtree.techworks.insight.preferences.model.Preference;
  import com.mindtree.techworks.insight.preferences.model.PreferenceInfo;
  
  /**
   * The <code>PreferencesFrame</code> class is the GUI for maintaining Insight
   * preferences. The preferences include both transient and persistent ones.
   * 
   * @see com.mindtree.techworks.insight.preferences
   * @author Regunath B
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   */
  
  public class PreferencesFrame extends JDialog implements TreeSelectionListener {
  
  	/**
  	 * 
  	 */
  	private static final long serialVersionUID = 6632219854510095454L;
  
  	/**
  	 * Useful constants for display sizes - width
  	 */
  	private static final int SPLIT_PANE_WIDTH = 700;
  
  	/**
  	 * Useful constants for display sizes - height
  	 */
  	private static final int SPLIT_PANE_HEIGHT = 450;
  
  	/**
  	 * Layout definition.
  	 */
  	private GridBagLayout gl;
  
  	/**
  	 * Layout constrains
  	 */
  	private GridBagConstraints gc;
  
  	/**
  	 * Split pane that display the list of preferences and permits editing the
  	 * preference attributes
  	 */
  	private JSplitPane splitPane;
  
 	/**
 	 * JTree used for displaying the preference names
 	 */
 	private JTree preferencesTree;
 
 	/**
 	 * Buttons in the display - save the preferences
 	 */
 	protected JButton saveButton;
 
 	/**
 	 * Buttons in the display - cancel the changes
 	 */
 	private JButton cancelButton;
 
 	/**
 	 * Insight for this class
 	 */
 	private JFrame parent;
 
 	/**
 	 * Hashmap containing loaded AbstractPreferencesUIPanel instances
 	 */
 	protected HashMap loadedUIPanels;
 
 	/**
 	 * Constructor for this class.
 	 * 
 	 * @param parent
 	 *            The parent frame for this dialog for this class
 	 */
 	public PreferencesFrame (JFrame parent) {
 
 		super (JOptionPane.getFrameForComponent (parent), InsightConstants
 				.getLiteral ("MAINTAIN_PREFERENCES"), true);
 		this.parent = parent;
 		initialize ();
 	}
 
 	/**
 	 * Constructs an instance of this class. This constructor is to be called
 	 * when this window is to come up without a parent. By default, if this
 	 * constructor is called, then a <code>System.exit(0)</code> is called
 	 * when this window closes.
 	 */
 	public PreferencesFrame () {
 
 		setTitle (InsightConstants.getLiteral ("MAINTAIN_PREFERENCES"));
 		JOptionPane.getFrameForComponent(this).setIconImage(
 				ResourceManager.getInstance().loadImageIcon("INSIGHT_ICON")
 						.getImage());
 
 		// This has come up on its own, so add a shutdown hook
 		ShutdownHookManager
 				.addShutdownAction (ShutdownHookManager.SHUTDOWN_ACTION_SAVE_PREFERENCES);
 
 		initialize ();
 	}
 
 	/**
 	 * Initializes the display of this dialog.
 	 */
 	private void initialize () {
 
 		loadedUIPanels = new HashMap ();
 		gl = new GridBagLayout ();
 		gc = new GridBagConstraints ();
 		getContentPane ().setLayout (gl);
 
 		preferencesTree = new JTree (getPreferenceNames ());
 		this.splitPane = new JSplitPane (JSplitPane.HORIZONTAL_SPLIT,
 				preferencesTree, null);
 
 		// hide the root node
 		preferencesTree.setRootVisible (false);
 		// display the handles
 		preferencesTree.setShowsRootHandles (true);
 		// disable icon display
 		DefaultTreeCellRenderer nodeRenderer = (DefaultTreeCellRenderer) preferencesTree
 				.getCellRenderer ();
 		nodeRenderer.setLeafIcon (null);
 		nodeRenderer.setClosedIcon (null);
 		nodeRenderer.setOpenIcon (null);
 		// add this class as a TreeSelectionListener to the JTree
 		preferencesTree.addTreeSelectionListener (this);
 
 		// set the preferred component and hence window size
 		this.splitPane.setPreferredSize (new Dimension (SPLIT_PANE_WIDTH,
 				SPLIT_PANE_HEIGHT));
 		this.preferencesTree.setMinimumSize (new Dimension (
 				SPLIT_PANE_WIDTH / 5, SPLIT_PANE_HEIGHT));
 		addComponent (this.splitPane, 0, 0, 1, 1, 3, 1);
 
 		ButtionActionProcessor actionProcessor = new ButtionActionProcessor ();
 		saveButton = new JButton (InsightConstants.getLiteral ("SAVE"));
 		cancelButton = new JButton (InsightConstants.getLiteral ("CANCEL"));
 		saveButton.addActionListener (actionProcessor);
 		cancelButton.addActionListener (actionProcessor);
 		addComponent (saveButton, 0, 1, 0, 0, 1, 1);
 		addComponent (cancelButton, 1, 1, 0, 0, 1, 1);
 
 		// Add a window adapter to clear state when the user closes this
 		// frame by clicking on window close
 		this.addWindowListener (new WindowAdapter () {
 
 			public void windowClosing (WindowEvent event) {
 
 				resetWidgets ();
 			}
 		});
 	}
 
 	/**
 	 * Displays this frame
 	 */
 	public void showPreferences () {
 
 		// select the first node
 		this.preferencesTree.setSelectionRow (0);
 		this.pack ();
 		// Center this window in Insight
 		if (null != parent) {
 			// Center this window relative to the parent
 			int insightX = this.parent.getX ();
 			int insightY = this.parent.getY ();
 			int thisX = insightX
 					+ ((this.parent.getWidth () - this.getWidth ()) / 2);
 			int thisY = insightY
 					+ ((this.parent.getHeight () - this.getHeight ()) / 2);
 			this.setLocation (thisX, thisY);
 		} else {
 			// Center it on the screen
 			Dimension dim = getToolkit ().getScreenSize ();
 			Rectangle abounds = getBounds ();
 			setLocation ((dim.width - abounds.width) / 2,
 							(dim.height - abounds.height) / 2);
 		}
 
 		this.show ();
 	}
 
 	/**
 	 * Hides this frame
 	 */
 	public void hidePreferences () {
 
 		if (null != parent) {
 			// If this has a parent it can be reused!
 			this.hide ();
 			resetWidgets ();
 		} else {
 			// No parent so this will never be used again.
 			this.dispose ();
 			System.exit (0);
 		}
 	}
 
 	/**
 	 * Interface implementation method
 	 * 
 	 * @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent)
 	 */
 	public void valueChanged (TreeSelectionEvent arg0) {
 
 		DefaultMutableTreeNode node = (DefaultMutableTreeNode) preferencesTree
 				.getLastSelectedPathComponent ();
 		if (node == null) {
 			return;
 		}
 		Object nodeInfo = node.getUserObject ();
 		PreferenceInfo prefInfo = (PreferenceInfo) nodeInfo;
 		Preference selectedPreference = PreferenceManager.getInstance ()
 				.getPreference (prefInfo.getCompleteId ());
 		AbstractPreferencesUIPanel uiPanel = (AbstractPreferencesUIPanel) loadedUIPanels
 				.get (selectedPreference.getId ());
 		if (uiPanel == null) {
 			try {
 				uiPanel = (AbstractPreferencesUIPanel) Class
 						.forName (selectedPreference.getDisplayClass ())
 						.newInstance ();
 				loadedUIPanels.put (selectedPreference.getId (), uiPanel);
 				uiPanel.initialize (selectedPreference, this);
 			} catch (Exception ex) {
 				ex.printStackTrace ();
 				this.splitPane.setRightComponent (new JLabel (InsightConstants
 						.getLiteral ("ERROR_PREF_UI")));
 				return;
 			}
 		}
 		this.splitPane.setRightComponent (uiPanel);
 	}
 
 	/**
 	 * Adds the specified component to this panel using the specified
 	 * constraints.
 	 * 
 	 * @param c
 	 *            The component to add
 	 * @param gridx
 	 *            Horizontal location on the grid
 	 * @param gridy
 	 *            Vertical location on the grid
 	 * @param weightx
 	 *            The horizontal weight
 	 * @param weighty
 	 *            The vertical weight
 	 * @param width
 	 *            The width of the component
 	 * @param height
 	 *            The height of the component
 	 */
 	private final void addComponent (Component c, int gridx, int gridy,
 			int weightx, int weighty, int width, int height) {
 
 		gc.fill = GridBagConstraints.BOTH;
 		gc.anchor = GridBagConstraints.NORTHWEST;
 		gc.insets = new Insets (5, 5, 5, 5);
 		gc.gridx = gridx;
 		gc.gridy = gridy;
 		gc.weightx = weightx;
 		gc.weighty = weighty;
 		gc.gridwidth = width;
 		gc.gridheight = height;
 		gl.setConstraints (c, gc);
 		getContentPane ().add (c);
 	}
 
 	/**
 	 * Helper method that gets the preferences
 	 * 
 	 * @return The tree with all the loaded preferences.
 	 */
 	private DefaultMutableTreeNode getPreferenceNames () {
 
 		DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode ();
 		PreferenceManager prefManager = PreferenceManager.getInstance ();
 		for (Iterator iterator = prefManager.getAllPreferenceNames ()
 				.iterator (); iterator.hasNext ();) {
 			PreferenceInfo prefInfo = (PreferenceInfo) iterator.next ();
 			addPreferenceToTree (prefInfo, rootNode);
 		}
 		return rootNode;
 	}
 
 	/**
 	 * Helper method that recursively adds the the specified PrefenceInfo and
 	 * its children as leaves to the JTree using the specified tree node.
 	 * 
 	 * @param prefInfo
 	 *            the PreferenceInfo containing the preference and its children
 	 * @param parentNode
 	 *            the DefaultMutableTreeNode to add the prefernce to
 	 */
 	private void addPreferenceToTree (PreferenceInfo prefInfo,
 			DefaultMutableTreeNode parentNode) {
 
 		if (prefInfo.isUserModifiable () && !prefInfo.isAggregated ()) {
 			DefaultMutableTreeNode thisNode = new DefaultMutableTreeNode (
 					prefInfo);
 			parentNode.add (thisNode);
 			Iterator iterator = prefInfo.iterateChildPreferenceInfos ();
 			while (iterator != null && iterator.hasNext ()) {
 				addPreferenceToTree ((PreferenceInfo) iterator.next (),
 										thisNode);
 			}
 		}
 	}
 
 	/**
 	 * Helper method to reset the widgets
 	 */
 	protected void resetWidgets () {
 
 		this.loadedUIPanels.clear ();
 		// disable selected row. This is needed because
 		// the panel contnets are loaded in valueChanged() method is fired
 		this.preferencesTree.setSelectionRow ( -1);
 	}
 
 	/**
 	 * This class listens for events on the parent dialog.
 	 * 
 	 * @author <a href="mailto:regunath_b@mindtree.com">Regunath B</a>
 	 * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
 	 */
 	private final class ButtionActionProcessor implements ActionListener {
 
 		/**
 		 * Interface method implementation
 		 * 
 		 * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
 		 */
 		public void actionPerformed (ActionEvent e) {
 
 			Object source = e.getSource ();
 			if (source == saveButton) {
 				// inform the PreferenceManager of an intent to save
 				// preference(s)
 				PreferenceManager.getInstance ().startPreferencesSave ();
 				Iterator iterator = loadedUIPanels.values ().iterator ();
 				while (iterator.hasNext ()) {
 					// inform the preference GUIs to update the Preference
 					// values for persistence
 					((AbstractPreferencesUIPanel) iterator.next ())
 							.setPreferenceValues ();
 				}
 				// inform the PreferenceManager of save preference(s) completion
 				PreferenceManager.getInstance ().endPreferencesSave ();
 			}
 			hidePreferences ();
 		}
 
 	}
 
 }