/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common 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.
   *
   * CosyBeans-Common 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 CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components.customizer;
  
  import com.cosylab.gui.components.SimpleDisplayer;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.IconHelper;
  
  import com.cosylab.logging.DebugLogger;
  
  import java.awt.BorderLayout;
  import java.awt.Component;
  import java.awt.FlowLayout;
  import java.awt.Graphics;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  
  import java.util.Arrays;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.Map;
  import java.util.Properties;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.Icon;
  import javax.swing.JButton;
  import javax.swing.JComponent;
  import javax.swing.JDialog;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JSplitPane;
  import javax.swing.JTree;
  import javax.swing.SwingUtilities;
  import javax.swing.event.AncestorEvent;
  import javax.swing.event.AncestorListener;
  import javax.swing.event.TreeSelectionEvent;
  import javax.swing.event.TreeSelectionListener;
  import javax.swing.tree.DefaultMutableTreeNode;
  import javax.swing.tree.DefaultTreeCellRenderer;
  import javax.swing.tree.DefaultTreeModel;
  import javax.swing.tree.TreeCellRenderer;
  
  
  /**
   * <code>Customizer</code> is used for displaying diferent <code>Editor</code>
   * s of a displayer component. It is a <code>javax.swing.JPanel</code>
   * containing a tree of availble editor aspects and a panel containing the
   * selected aspect editors. The component also supports display via popup
   * dialog.
   *
   * @author <a href="mailto:igor.krizar@cosylab.com">Igor Kriznar </a>
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik </a>
   * @version $id$
   * 
   * @deprecated Use AbstractCustomizerPanel
   */
  public class Customizer extends JPanel
  {
  	private static final long serialVersionUID = 1L;
  	private final static Logger log = DebugLogger.getLogger(Customizer.class
  		    .getName(), Level.OFF);
  	private JComponent displayer;
  	private Editor editor;
  	private Map<String, Class> editorTypes;
  	private HashMap<Class, Editor> editors;
  	private JPanel aspectPanel;
  	private JTree aspectTree;
  	private JDialog dialog;
 	private JPanel panel;
 	private boolean editing = false;
 	private String lastAspect;
 
 	/*
 	 * Used for rendering the tree of available aspects.
 	 */
 	private class AspectTreeCellRenderer extends DefaultTreeCellRenderer
 		implements TreeCellRenderer
 	{
 		private static final long serialVersionUID = 1L;
 
 		/**
 		 * Creates ne instance.
 		 */
 		public AspectTreeCellRenderer()
 		{
 			try {
 				setDisabledIcon(null);
 				setLeafIcon(new Icon() {
 						public int getIconHeight()
 						{
 							return 5;
 						}
 
 						public int getIconWidth()
 						{
 							return 5;
 						}
 
 						public void paintIcon(Component c, Graphics g, int x,
 						    int y)
 						{
 							g.setColor(ColorHelper.getCosyControlShadow());
 							g.drawOval(x, y, 5, 5);
 						}
 					});
 				setOpenIcon(IconHelper.createIcon("icons/navigation/Down16.gif"));
 				setClosedIcon(IconHelper.createIcon(
 				        "icons/navigation/Forward16.gif"));
 
 				//setIcon(IconHelper.createIcon("icons/navigation/Forward16.gif"));
 			} catch (Exception e) {
 				setClosedIcon(null);
 				setDisabledIcon(null);
 				setLeafIcon(null);
 				setOpenIcon(null);
 			}
 		}
 	}
 
 	/**
 	 * Creates an empty Customizer with no displayer or editors.
 	 */
 	public Customizer()
 	{
 		super();
 		editors = new HashMap<Class, Editor>();
 		editorTypes = new LinkedHashMap<String, Class>();
 	}
 
 	/**
 	 * Creates a Customizer for provided
 	 * <code>com.cosylab.gui.components.SimpleDisplayer</code>.
 	 *
 	 * @param disp the displayer to be customized.
 	 */
 	public Customizer(SimpleDisplayer disp)
 	{
 		this((JComponent)disp, disp.getEditors());
 	}
 
 	/**
 	 * Creates a Customizer for provided arbitrary displayer component with
 	 * specified editor types.
 	 *
 	 * @param disp the component to be customized.
 	 * @param editorTypes mappings of available aspects and coresponding editor
 	 *        types
 	 */
 	public Customizer(JComponent disp, Map<String, Class> editorTypes)
 	{
 		this();
 		setDisplayer(disp);
 		addEditors(editorTypes);
 	}
 
 	/*
 	 * Used for testing the correctness of editor types mappings
 	 */
 	private void testEditors(Map map)
 	{
 		Iterator it = map.values().iterator();
 
 		while (it.hasNext()) {
 			Object element = it.next();
 
 			if (!(element instanceof Class)
 			    || !Editor.class.isAssignableFrom((Class)element)) {
 				throw new IllegalArgumentException("Element '" + element
 				    + "' does not implement editor interface "
 				    + Editor.class.getName() + ".");
 			}
 		}
 	}
 
 	/**
 	 * Returns a live editor instance for the specified aspect.
 	 *
 	 * @param aspect an aspect
 	 *
 	 * @return instance of editor if used by this customizer  or null
 	 *
 	 * @throws InstantiationException if instantiation fails
 	 * @throws IllegalAccessException if instantiation fails
 	 */
 	public Editor getEditor(String aspect)
 		throws InstantiationException, IllegalAccessException
 	{
 		return getEditor((Class)editorTypes.get(aspect));
 	}
 
 	/**
 	 * Returns a live editor instance for the specified type, if it is
 	 * registered in pair with any of aspects.
 	 *
 	 * @param type <code>Class</code> of the editor
 	 *
 	 * @return instance of editor if used by this customizer  or null
 	 *
 	 * @throws InstantiationException if instantiation fails
 	 * @throws IllegalAccessException if instantiation fails
 	 */
 	public Editor getEditor(Class type)
 		throws InstantiationException, IllegalAccessException
 	{
 		if (type == null) {
 			return null;
 		}
 
 		if (!editorTypes.values().contains(type)) {
 			return null;
 		}
 
 		return _getEditor(type);
 	}
 
 	/*
 	 * Get fo any type.
 	 */
 	private Editor _getEditor(Class type)
 		throws InstantiationException, IllegalAccessException
 	{
 		if (type == null) {
 			return null;
 		}
 
 		Editor e = editors.get(type);
 
 		if (e != null) {
 			return e;
 		}
 
 		e = (Editor)type.newInstance();
 
 		editors.put(type, e);
 
 		return e;
 	}
 
 	/*
 	 * Initializes the custmoizer
 	 */
 	private void initialize()
 	{
 		initAspectTree();
 		initAspectPanel(null);
 		setLayout(new BorderLayout());
 		add(getButtonsPanel(), BorderLayout.SOUTH);
 		add(new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
 		        new JScrollPane(aspectTree), new JScrollPane(aspectPanel)));
 	}
 
 	/*
 	 * Initializes the tree of available aspects
 	 */
 	private void initAspectTree()
 	{
 		if (aspectTree == null) {
 			aspectTree = new JTree();
 			aspectTree.setCellRenderer(new AspectTreeCellRenderer());
 			aspectTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() {
 					public void valueChanged(TreeSelectionEvent e)
 					{
 						Object[] aspectPath = ((DefaultMutableTreeNode)e.getNewLeadSelectionPath()
 							.getLastPathComponent()).getUserObjectPath();
 						String aspect = "";
 
 						for (int i = 1; i < aspectPath.length; i++) {
 							aspect += "/" + (String)aspectPath[i];
 						}
 
 						initAspectPanel(aspect.substring(1));
 					}
 				});
 
 			//aspectTree.setPreferredSize(new Dimension(100,100));
 		}
 
 		fillAspectTree();
 
 		for (int i = 0; i < aspectTree.getRowCount(); i++) {
 			aspectTree.expandRow(i);
 		}
 
 		/*aspectTree.setPreferredSize(new Dimension(
 		        (int)(aspectTree.getPreferredSize().getWidth() * 1.1),
 		        (int)aspectTree.getPreferredSize().getHeight()));*/
 	}
 
 	/*
 	 * Fills the tree of aspects with available aspects
 	 */
 	private void fillAspectTree()
 	{
 		Iterator<String> keys = editorTypes.keySet().iterator();
 
 		//Arrays.sort(keys);
 		((DefaultTreeModel)aspectTree.getModel()).setRoot(new DefaultMutableTreeNode(
 		        ""));
 		aspectTree.setRootVisible(false);
 
 		while(keys.hasNext()) {
 			addAspectToTree(new String(keys.next()));
 		}
 		((DefaultTreeModel)aspectTree.getModel()).reload();
 	}
 
 	/*
 	 * Adds an aspect to the tree of aspects
 	 */
 	private void addAspectToTree(String aspect)
 	{
 		DefaultMutableTreeNode parent = (DefaultMutableTreeNode)((DefaultTreeModel)aspectTree
 			.getModel()).getRoot();
 
 		while (aspect.indexOf('/') >= 0) {
 			String parentAspect = aspect.substring(0, aspect.indexOf('/'));
 			aspect = aspect.substring(aspect.indexOf('/') + 1);
 
 			Enumeration en = parent.children();
 			DefaultMutableTreeNode tempParent = null;
 
 			while (en.hasMoreElements()) {
 				tempParent = (DefaultMutableTreeNode)en.nextElement();
 
 				if (tempParent.getUserObject().equals(parentAspect)) {
 					parent = tempParent;
 
 					break;
 				}
 			}
 
 			if (tempParent != parent) {
 				tempParent = new DefaultMutableTreeNode(parentAspect);
 				parent.add(tempParent);
 				parent = tempParent;
 			}
 		}
 
 		parent.add(new DefaultMutableTreeNode(aspect));
 	}
 
 	/*
 	 * Initializes and returns the panel of buttons (OK, Apply, Cancel) that
 	 * control the customizer
 	 */
 	private JComponent getButtonsPanel()
 	{
 		if (panel == null) {
 			panel = new JPanel();
 
 			panel.setLayout(new FlowLayout(FlowLayout.RIGHT, 11, 11));
 
 			/* OK button */
 			JButton button = new JButton("OK");
 			button.addActionListener(new ActionListener() {
 					public void actionPerformed(ActionEvent e)
 					{
 						commitEditing();
 					}
 				});
 			panel.add(button);
 
 			/* Apply button */
 			button = new JButton("Apply");
 			button.addActionListener(new ActionListener() {
 					public void actionPerformed(ActionEvent e)
 					{
 						applyEditing();
 					}
 				});
 			panel.add(button);
 
 			/* Cancel button */
 			button = new JButton("Cancel");
 			button.addActionListener(new ActionListener() {
 					public void actionPerformed(ActionEvent e)
 					{
 						cancelEditing();
 					}
 				});
 			panel.add(button);
 		}
 
 		return panel;
 	}
 
 	/*
 	 * Initializes the panel containing the editor component of the specified
 	 * aspect
 	 */
 	private synchronized void initAspectPanel(final String aspect)
 	{
 		log.fine("Invoking display for '" + aspect + "'");
 		lastAspect = aspect;
 
 		if (aspectPanel == null) {
 			aspectPanel = new JPanel();
 			aspectPanel.setLayout(new GridBagLayout());
 		}
 
 		if (editor!=null) {
 			editor.stopEditing();
 		}
 		aspectPanel.removeAll();
 
 		try {
 			if (containsEditor(aspect)) {
 				editor = getEditor(aspect);
 				
 
 				/*SwingUtilities.invokeLater(new Runnable() {
 				        public void run()
 				        {*/
 				/*if (ed != null) {
 				    aspectPanel.remove(ed);
 				}*/
 				aspectPanel.add(editor.getEditorComponent(displayer, aspect),
 				    new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0,
 				        GridBagConstraints.NORTH,
 				        GridBagConstraints.HORIZONTAL, new Insets(4, 4, 4, 4),
 				        0, 0));
 
 				/*}
 				});*/
 			}
 		} catch (Exception e) {
 			System.out.println("Failed to load editor '"
 			    + editorTypes.get(aspect) + "' for aspect '" + aspect + "': "
 			    + e);
 
 			e.printStackTrace();
 		}
 
 		log.fine("Calling repaint for '" + aspect + "'");
 
 		revalidate();
 		repaint();
 	}
 
 	/**
 	 * Determines wether the customizer contains an editor type asociated the
 	 * specified aspect.
 	 *
 	 * @param aspect
 	 *
 	 * @return <code>true</code> if the customizer contains an editor type
 	 *         asociated with the aspect and <code>false</code> otherwise
 	 */
 	public boolean containsEditor(String aspect)
 	{
 		return editorTypes.containsKey(aspect);
 	}
 
 	/*
 	 * Tells all the editors to stop editing. Invoked when the dialog closes.
 	 */
 	private void _stopEditing()
 	{
 		editing = false;
 
 		Iterator<Editor> it = editors.values().iterator();
 		Editor element;
 		while (it.hasNext()) {
 			element = it.next();
 
 			try {
 				element.stopEditing();
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 
 		if (dialog != null) {
 			dialog.dispose();
 		}
 	}
 
 	/*
 	 * Invoked when Cancel button is pressed.
 	 */
 	private void cancelEditing()
 	{
 		SwingUtilities.invokeLater(new Runnable() {
 				public void run()
 				{
 					_cancelEditing();
 				}
 			});
 	}
 
 	/*
 	 * Invoked when Cancel button is pressed.
 	 */
 	private void _cancelEditing()
 	{
 		Iterator<Editor> it = editors.values().iterator();
 
 		Editor element;
 		while (it.hasNext()) {
 			element = it.next();
 
 			try {
 				element.revertSettings();
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 
 		_stopEditing();
 	}
 
 	/*
 	 * Uses invokeLater. Invoked when Apply button is pressed.
 	 */
 	private void applyEditing()
 	{
 		SwingUtilities.invokeLater(new Runnable() {
 				public void run()
 				{
 					_applyEditing();
 				}
 			});
 	}
 
 	/*
 	 * Invoked when Apply button is pressed.
 	 */
 	private void _applyEditing()
 	{
 		Iterator<Editor> it = editors.values().iterator();
 
 		Editor element;
 		while (it.hasNext()) {
 			element = it.next();
 
 			try {
 				element.applySettings();
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	/*
 	 * Invoked when OK button is pressed.
 	 */
 	private void commitEditing()
 	{
 		SwingUtilities.invokeLater(new Runnable() {
 				public void run()
 				{
 					_applyEditing();
 					_stopEditing();
 				}
 			});
 	}
 
 	/**
 	 * <p>
 	 * Shows customizer dialog centered around specified component.
 	 * </p>
 	 * 
 	 * <p>
 	 * Dialog title is composed from customiser name. Initial size is set to
 	 * the size of customiser.
 	 * </p>
 	 *
 	 * @param c a component on which customizer dialog to be centered
 	 *
 	 * @return a <code>javax.swing.JDialog</code> instance with customizer
 	 */
 	public JDialog showDialog(Component c)
 	{
 		if (dialog == null) {
 			dialog = new JDialog();
 			dialog.setTitle(getName() + " Customizer");
 			dialog.setModal(false);
 			dialog.addWindowListener(new WindowAdapter() {
 					public void windowClosing(WindowEvent e)
 					{
 						if (editing) {
 							cancelEditing();
 						}
 
 						Iterator it = editors.values().iterator();
 
 						while (it.hasNext()) {
 							Editor element = (Editor)it.next();
 							element.stopEditing();
 						}
 					}
 				});
 			dialog.setSize(getSize().width + dialog.getInsets().left
 			    + dialog.getInsets().right,
 			    getSize().height + dialog.getInsets().top
 			    + dialog.getInsets().bottom);
 			dialog.getContentPane().setLayout(new BorderLayout());
 			dialog.getContentPane().add(this, BorderLayout.CENTER);
 
 			dialog.setLocation((int)((c.getWidth() - dialog.getWidth()) / 2.0),
 			    (int)((c.getHeight() - dialog.getHeight()) / 2.0));
 			dialog.setLocationRelativeTo(c);
 		}
 
 		initAspectPanel(lastAspect);
 		dialog.setVisible(true);
 		editing = true;
 
 		return dialog;
 	}
 
 	/**
 	 * <p>
 	 * Shows Customizer dialog centered around customized displayer.
 	 * </p>
 	 * 
 	 * <p>
 	 * Dialog title is composed from Customizer name. Initial size is set to
 	 * the size of Customizer.
 	 * </p>
 	 *
 	 * @return a <code>JDialog</code> instance with customizer
 	 */
 	public JDialog showDialog()
 	{
 		return showDialog(displayer);
 	}
 
 	/**
 	 * <p>
 	 * Trys to load default <code>Editor</code> s for specified displayer. Trys
 	 * to load first default editors with <code>#looadDefaultEditors()</code>
 	 * and then creates new Customizer.
 	 * </p>
 	 * 
 	 * <p>
 	 * Customizer tys to listen, when dispalyer is not visible any more and
 	 * close itself.
 	 * </p>
 	 *
 	 * @param disp a displayer for witch customizer is to be created
 	 *
 	 * @return new customizer for speficied displayer
 	 */
 	public static Customizer loadDefaultCustomizer(JComponent disp)
 	{
 		final Customizer c = new Customizer(disp, loadDefaultEditorTypes(disp));
 
 		// Set default name from class name.
 		c.setName(disp.getClass().getName().substring(disp.getClass().getName()
 		        .lastIndexOf('.') + 1));
 
 		// trys to get when componnet is not visible any more
 		disp.addComponentListener(new ComponentAdapter() {
 				public void componentHidden(ComponentEvent e)
 				{
 					c.cancelEditing();
 				}
 			});
 
 		disp.addAncestorListener(new AncestorListener() {
 				public void ancestorAdded(AncestorEvent event)
 				{
 					// ignored
 				}
 
 				public void ancestorMoved(AncestorEvent event)
 				{
 					// ignored
 				}
 
 				public void ancestorRemoved(AncestorEvent event)
 				{
 					c.cancelEditing();
 				}
 			});
 
 		c.setSize(400, 300);
 
 		return c;
 	}
 
 	/**
 	 * Trys to load default <code>Editor</code> s for specified displayer.
 	 * Following things tries to do in specified orther to find editors:
 	 * 
 	 * <ul>
 	 * <li>
 	 * Tryes to locate class with name that is same as displayer class with
 	 * "Editor" at the end. if this class exists and has an array of
 	 * <code>String</code> s "ASPECTS" as static field, than this editor si
 	 * added to the customiser with all the listed aspects.
 	 * </li>
 	 * <li>
 	 * Trys to load from system resources file "&lt;class name&gt;.editors"
 	 * from same folder as "&lt;class name&gt;.java" file. This file must
 	 * contain "key=value" pairs in separate lines, where key si aspect of
 	 * editor and value is full class name of editor.
 	 * </li>
 	 * <li>
 	 * If diplayer implements interface
 	 * <code>com.cosylab.gui.components.SimpleDisplayer</code>, editors are
 	 * taken from this interface.
 	 * </li>
 	 * </ul>
 	 * 
 	 * Latter found editors replaces existing editors in returned Map.
 	 *
 	 * @param disp a displayer for witch editors are to be created
 	 *
 	 * @return new <code>java.util.Map</code> with editor types
 	 */
 	public static Map<String, Class> loadDefaultEditorTypes(Object disp)
 	{
 		log.fine("Loading for displayer '" + disp.getClass().getName() + "'.");
 
 		Map<String, Class> map = new LinkedHashMap<String, Class>();
 
 		/* Try to guess editor from classname. */
 		Class cl = disp.getClass();
 
 		boolean found = false;
 
 		while (!cl.equals(Object.class) && !found) {
 			String editor = cl.getName() + "Editor";
 
 			try {
 				Class c = Class.forName(editor);
 
 				String[] aspects = (String[])c.getField("ASPECTS").get(null);
 
 				if (aspects != null) {
 					log.finer("Loaded from ASPECT field :'"
 					    + Arrays.asList(aspects));
 
 					for (int i = 0; i < aspects.length; i++) {
 						map.put(aspects[i], c);
 					}
 				}
 
 				found = true;
 			} catch (Exception e) {
 				// No luck.
 			}
 
 			/* Try to get editors from file. */
 			String file = cl.getName().replace('.', File.separatorChar)
 				+ ".editors";
 
 			Properties p = new Properties();
 
 			try {
 				InputStream in = ClassLoader.getSystemResourceAsStream(file);
 
 				if (in != null) {
 					p.load(in);
 					log.finer("Loaded from file :'" + file + "': '" + p + "'.");
 					found = true;
 				} else {
 					log.finer("File not found :'" + file + "'.");
 				}
 			} catch (IOException e) {
 				log.finer("Failed to load from file :'" + file + "': '" + e
 				    + "'.");
 				e.printStackTrace();
 			}
 
 			Iterator it = p.keySet().iterator();
 
 			while (it.hasNext()) {
 				String element = (String)it.next();
 
 				try {
 					map.put(element, Class.forName(p.getProperty(element)));
 				} catch (Exception e) {
 					e.printStackTrace();
 				}
 			}
 
 			cl = cl.getSuperclass();
 		}
 
 		/* Try to get editors from SimpleDisplayer. */
 		if (disp instanceof SimpleDisplayer) {
 			map.putAll(((SimpleDisplayer)disp).getEditors());
 		}
 
 		return map;
 	}
 
 	/**
 	 * Adds map with editors to this customizer, overrides existing editors
 	 * with same aspect. Map must contain pairs key/value, where key is aspect
 	 * name and value is <code>Class</code> of editor.
 	 *
 	 * @param newEditorTypes to be added
 	 */
 	public void addEditors(Map<String, Class> newEditorTypes)
 	{
 		testEditors(newEditorTypes);
 		editorTypes.putAll(newEditorTypes);
 		editors.clear();
 		initialize();
 	}
 
 	/**
 	 * Gets the dsiplayer component to be customized by this customizer.
 	 *
 	 * @return dispalyer being customized
 	 */
 	public JComponent getDisplayer()
 	{
 		return displayer;
 	}
 
 	/**
 	 * Sets the displayer component to be customized
 	 *
 	 * @param component to be customized
 	 */
 	public void setDisplayer(JComponent component)
 	{
 		displayer = component;
 	}
 
 	public JPanel getAspectPanel() {
 		return aspectPanel;
 	}
 
 	public JTree getAspectTree() {
 		return aspectTree;
 	}
 }
 
 /* __oOo__ */