/*
    * 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 java.awt.Color;
  import java.beans.Customizer;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.lang.reflect.InvocationTargetException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Iterator;
  
  import javax.swing.JComponent;
  import javax.swing.JSplitPane;
  import javax.swing.border.LineBorder;
  import javax.swing.table.TableModel;
  
  import com.cosylab.gui.components.introspection.BeanPropertiesTableModel;
  import com.cosylab.gui.components.introspection.DefaultPropertiesTable;
  import com.cosylab.util.Debug;
  import com.cosylab.util.ObjectList;
  
  /**
   * A bridge between java.bean.Customizer and Cosy style Customizers.
   * 
   * @author Alen Vrecko
   * 
   */
  public class CustomizerEditor extends JSplitPane implements Customizer, Editor {
  
  	private static final long serialVersionUID = 1L;
  
  	private DefaultPropertiesTable defaultPropertiesTable = null;
  
  	private HashMap<String, ArrayList> customEditors = null;
  
  	private HashMap defaultPropertiesTableModels = null;
  
  	private Object displayer = null;
  
  	private ObjectList activeEditors = null;
  
  	/**
  	 * Cunstructs an empty editor.
  	 */
  	public CustomizerEditor() {
  
  		defaultPropertiesTableModels = new HashMap();
  		customEditors = new HashMap<String, ArrayList>();
  		activeEditors = new ObjectList(Editor.class);
  		defaultPropertiesTable = new DefaultPropertiesTable();
  		defaultPropertiesTable.setBorder(new LineBorder(Color.BLACK));
  
  		defaultPropertiesTable
  				.addPropertyChangeListener(new PropertyChangeListener() {
  
  					public void propertyChange(PropertyChangeEvent evt) {
  						firePropertyChange(evt.getPropertyName(), null, evt
  								.getNewValue());
  						applyTableProperties();
  
  					}
  				});
  	}
  
  	/**
  	 * <p>
  	 * Should return names of properties of a dispalyer to be edited within the
  	 * sepcified aspect through generic proeprty tables. This empty
  	 * implementation however returns null.
  	 * </p>
  	 * 
  	 * <p>
  	 * Subclasses should override this method to return arrays of
  	 * <code>String</code> names of properties to be edited via property
  	 * tables in the specified aspect.
  	 * </p>
  	 * 
  	 * <p>
  	 * The Strings returned should specify names of qualified <i>JavaBean</i>
 	 * properties with conventional getter and setter methods.
 	 * </p>
 	 * 
 	 * <p>
 	 * If a custom editor has been specified for the aspect the result of theis
 	 * method is ignored as the custom editor is used for editing the aspect
 	 * instead of generic property table.
 	 * </p>
 	 * 
 	 * @param aspect
 	 *            the aspect of the displayer to be edited with generic proeprty
 	 *            table
 	 * 
 	 * @return array of names of properties to be edited with the proeprty table
 	 *         in the specified aspect
 	 */
 	public String[] getDefaultProperties(String aspect) {
 		Debug.out(aspect);
 
 		return null;
 	}
 
 	/**
 	 * Returns the editor component for the selected aspect and displayer. If a
 	 * custom editor exists for the selected aspect, it is returned. Otherwise a
 	 * property table is returned containing the selected proeprties of the
 	 * aspect as returned by <code>#getDefaultProperties(String)</code>
 	 * method.
 	 * 
 	 * @param displayer
 	 *            the component for which the editor should be returned
 	 * @param aspect
 	 *            the specific editing aspect for which the editor should be
 	 *            returned
 	 * 
 	 * @return the editor component for the selected aspect and displayer.
 	 * 
 	 * @throws IllegalArgumentException
 	 *             if no custom editor is found for the aspect and
 	 *             getDefaultProperties(String) returns null for the aspect.
 	 * 
 	 * @see com.cosylab.gui.components.customizer.Editor#getEditorComponent(Object,
 	 *      String)
 	 */
 	public JComponent getEditorComponent(Object displayer, String aspect)
 			throws IllegalArgumentException {
 		Editor ed;
 		Iterator it = activeEditors.iterator();
 
 		while (it.hasNext()) {
 			if ((ed = (Editor) it.next()).canEdit(displayer, aspect)) {
 				return ed.getEditorComponent(displayer, aspect);
 			}
 		}
 
 		ArrayList l = (ArrayList) customEditors.get(aspect);
 
 		if (l != null) {
 			it = l.iterator();
 
 			while (it.hasNext()) {
 				if ((ed = (Editor) it.next()).canEdit(displayer, aspect)) {
 					activeEditors.add(ed);
 
 					return ed.getEditorComponent(displayer, aspect);
 				}
 			}
 		}
 
 		initializeDefaultPropertiesTable(displayer, aspect);
 
 		return defaultPropertiesTable;
 	}
 
 	/**
 	 * Overrides the current editor for the specified aspect with the editor
 	 * specified. This method can be used to replace generic property tables as
 	 * editors for the aspect specified.
 	 * 
 	 * @param aspect
 	 *            for which to use the editor specified
 	 * @param editor
 	 *            the editor to replace the current editor of the aspect
 	 *            specified
 	 */
 	public void addCustomEditor(String aspect, Editor editor) {
 		ArrayList<Editor> l = (ArrayList<Editor>) customEditors.get(aspect);
 
 		if (l == null) {
 			l = new ArrayList<Editor>();
 			customEditors.put(aspect, l);
 		}
 
 		l.add(editor);
 	}
 
 	/**
 	 * Applies all the changes done to the custom editors as well as the
 	 * property tables.
 	 * 
 	 * @see com.cosylab.gui.components.customizer.Editor#applySettings()
 	 */
 	public void applySettings() {
 		applyTableProperties();
 
 		Editor[] eds = getActiveEditors();
 
 		for (int i = 0; i < eds.length; i++) {
 			eds[i].applySettings();
 		}
 	}
 
 	/**
 	 * Inspecting the <code>ASPECTS</code> and all the custom editors, this
 	 * method determines, wether the specified aspect of the dispalyer can be
 	 * edited by this editor.
 	 * 
 	 * @param displayer
 	 *            Object to be edited (is ignored and can be <code>null</code>)
 	 * @param aspect
 	 *            String name of aspect to be edited.
 	 * 
 	 * @return <code>true</code> if the specifed aspect of the displayer can
 	 *         be edited, <code>false</code> otherwise.
 	 * 
 	 * @see com.cosylab.gui.components.customizer.Editor#canEdit(Object, String)
 	 */
 	public boolean canEdit(Object displayer, String aspect) {
 		ArrayList l = (ArrayList) customEditors.get(aspect);
 
 		if (l != null) {
 			Iterator it = l.iterator();
 
 			while (it.hasNext()) {
 				if (((Editor) it.next()).canEdit(displayer, aspect)) {
 					return true;
 				}
 			}
 		}
 
 		return (Arrays.binarySearch(ASPECTS, aspect) >= 0 && getDefaultProperties(aspect) != null);
 	}
 
 	/**
 	 * Reverts all the changes done to the custom editors as well as the
 	 * property tables.
 	 * 
 	 * @see com.cosylab.gui.components.customizer.Editor#revertSettings()
 	 */
 	public void revertSettings() {
 		Editor[] eds = getActiveEditors();
 
 		for (int i = 0; i < eds.length; i++) {
 			eds[i].revertSettings();
 		}
 	}
 
 	/**
 	 * Stops editing with all custom editors as well as property tables.
 	 * 
 	 * @see com.cosylab.gui.components.customizer.Editor#stopEditing()
 	 */
 	public void stopEditing() {
 		defaultPropertiesTableModels.clear();
 
 		Editor[] eds = getActiveEditors();
 
 		for (int i = 0; i < eds.length; i++) {
 			eds[i].stopEditing();
 		}
 
 		activeEditors.clear();
 	}
 
 	/*
 	 * Applies the changes done to the property tables.
 	 */
 	protected void applyTableProperties() {
 		if (displayer == null) {
 			return;
 		}
 
 		Object[] modelList = defaultPropertiesTableModels.values().toArray();
 
 		for (int i = 0; i < modelList.length; i++) {
 			BeanPropertiesTableModel model = (BeanPropertiesTableModel) modelList[i];
 
 			try {
 				model.applyProperties();
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	/*
 	 * Initializes the proeprty table for the selected displayer and aspect.
 	 */
 	protected void initializeDefaultPropertiesTable(Object displayer,
 			String aspect) throws IllegalArgumentException {
 		this.displayer = displayer;
 
 		if (defaultPropertiesTableModels.containsKey(aspect)) {
 			defaultPropertiesTable
 					.setModel((TableModel) defaultPropertiesTableModels
 							.get(aspect));
 		} else {
 			String[] names = getDefaultProperties(aspect);
 
 			BeanPropertiesTableModel model = new BeanPropertiesTableModel(
 					displayer, names);
 			defaultPropertiesTableModels.put(aspect, model);
 			defaultPropertiesTable.setModel(model);
 		}
 	}
 
 	/*
 	 * Returns all the custom editors that have been supplied.
 	 */
 	private Editor[] getActiveEditors() {
 		return (Editor[]) activeEditors.toArray();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.beans.Customizer#setObject(java.lang.Object)
 	 */
 	public void setObject(Object bean) {
 		// reflection work since there is no other alternative.
 
 		try {
 			Object o = bean.getClass().getMethod("getCustomizer", null).invoke(
 					bean, null);
 			if (o != null) {
 				customizer = (com.cosylab.gui.components.customizer.Customizer) o;
 //				JTree aspectTree = customizer.getAspectTree();
 //
 //				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];
 //								}
 //
 //								setRightComponent(customizer
 //										.getAspectInPanel(aspect.substring(1)));
 //
 //							}
 //						});
 //
 //				setLeftComponent(aspectTree);
 //
 //				String aspect = aspectTree.getModel().getChild(
 //						aspectTree.getModel().getRoot(), 0).toString();
 //
 //				setRightComponent(new JScrollPane(customizer
 //						.getAspectInPanel(aspect)));
 //
 //				aspectTree.setSelectionRow(0);
 				
 				setLeftComponent(customizer.getAspectTree());
 				setRightComponent(customizer.getAspectPanel());
 
 			}
 		} catch (SecurityException e) {
 
 		} catch (NoSuchMethodException e) {
 
 		} catch (IllegalArgumentException e) {
 
 		} catch (IllegalAccessException e) {
 
 		} catch (InvocationTargetException e) {
 
 		}
 
 	}
 
 	private com.cosylab.gui.components.customizer.Customizer customizer;
 
 }