/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2000 Blacksmith, Inc.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see http://www.gnu.org
*/

package net.wotonomy.ui.swing.components;

import java.awt.AWTEventMulticaster;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.Vector;

import javax.swing.AbstractButton;
import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.UIManager;

/**
 * ButtonPanel handles display and event broadcasting of standard buttons like
 * OK/Cancel/Save/etc. The constructor takes a list or array of strings, each
 * representing a button to appear on the panel from left to right. Any button
 * click will send an action event to all listeners with the action command
 * containing the corresponding string. Note action events are simply forwarded
 * from the buttons themselves, so the source of the event will be the button,
 * not the button panel. The button panel is the source of the STATE_CHANGED
 * events that notify about changes to the panel itself.<BR>
 * <BR>
 *
 * @author michael@mpowers.net
 * @author $Author: cgruber $
 * @version $Revision: 904 $
 */
public class ButtonPanel extends JPanel implements ActionListener, MouseMotionListener {
	// TODO: Button text should be read from resources.
	/**
	 * Specifies a "OK" button. This is also the action command sent by the OK
	 * button.
	 */
	public static final String OK = "OK";
	/**
	 * Specifies a "Save" button. This is also the action command sent by the Save
	 * button.
	 */
	public static final String SAVE = "Save";
	/**
	 * Specifies a "Refresh" button. This is also the action command sent by the
	 * Refresh button.
	 */
	public static final String REFRESH = "Refresh";
	/**
	 * Specifies a "Clear All" button. This is also the action command sent by the
	 * Clear All button.
	 */
	public static final String CLEAR_ALL = "Clear All";
	/**
	 * Specifies a "Refresh" button. This is also the action command sent by the
	 * Cancel button.
	 */
	public static final String CANCEL = "Cancel";
	/**
	 * Specifies a "Yes" button. This is also the action command sent by the Yes
	 * button.
	 */
	public static final String YES = "Yes";
	/**
	 * Specifies a "No" button. This is also the action command sent by the No
	 * button.
	 */
	public static final String NO = "No";
	/**
	 * Specifies an "Add" button. This is also the action command sent by the Add
	 * button.
	 */
	public static final String ADD = "Add";
	/**
	 * Specifies a "Remove" button. This is also the action command sent by the
	 * Remove button.
	 */
	public static final String REMOVE = "Remove";
	/**
	 * This is the action command to all listeners when the button state is changed.
	 */
	public static final String STATE_CHANGED = "STATE_CHANGED";

	/**
	 * This is the container to which buttons are added.
	 */
	protected Container buttonContainer = null; // useful for subclasses
	/**
	 * This is the list of all buttons on the panel.
	 */
	protected Vector buttonList = null;
	/**
	 * The insets for this panel, so they can be modified.
	 */
	protected Insets insets = new Insets(5, 5, 5, 5);

	/**
	 * This is the layout manager - which must be a FlowLayout or subclass.
	 */
	protected FlowLayout buttonPanelLayout = null;

	// for action multicasting
	protected ActionListener actionListener = null;

	/**
	 * Constructs a ButtonPanel. Three buttons are created so the panel is filled
	 * when used in a GUI-builder environment.
	 */
	public ButtonPanel() {
		buttonList = new Vector();
		initLayout();

		// default labels for bean layout
		setLabels(new String[] { "One", "Two", "Three" });
	}

	/**
	 * This method is responsible for the initial layout of the panel. Subclasses
	 * can implement different layouts, but this method is responsible for
	 * initializing buttonContainer and buttonPanelLayout and setting the container
	 * to use the layout.
	 */
	protected void initLayout() {
		this.setInsets(super.getInsets());
		buttonContainer = this;
		buttonPanelLayout = new BetterFlowLayout(BetterFlowLayout.RIGHT);
		buttonContainer.setLayout(buttonPanelLayout);
		((BetterFlowLayout) buttonPanelLayout).setWidthUniform(true);

		// setBackground( Color.blue ); // useful for debugging
	}

	/**
	 * Constructs a ButtonPanel using specified buttons.
	 * 
	 * @param buttonList An array containing the strings to be used in labeling the
	 *                   buttons.
	 */
	public ButtonPanel(String[] buttonList) {
		this();
		setLabels(buttonList);
	}

	/**
	 * Constructs a ButtonPane using specified actions. For each action, a button is
	 * created, that when pressed the corresponding action is activated. The "name"
	 * of the action is used as the title of the button.
	 * 
	 * @param actionList An array of actions to be used to create buttons with.
	 */
	public ButtonPanel(Action[] actionList) {
		this();
		setLabels(actionList);
	}

	/**
	 * Creates the buttons to appear on the panel. Any existing buttons are
	 * replaced. The labels are used as names and action commands in addition to
	 * labels.
	 * 
	 * @param labels An array of strings to be used in labeling the buttons. If
	 *               null, all buttons will be removed.
	 */
	public void setLabels(String[] labels) {
		if (labels == null) {
			labels = new String[] {};
		}

		buttonContainer.removeAll();
		this.buttonList = new Vector(labels.length);

		String item = null;
		Component button;
		for (int i = 0; i < labels.length; i++) {
			item = labels[i];
			if (item != null) {
				button = createComponentWithLabel(item.toString());
				this.buttonList.addElement(item);
				addComponentToPanel(button);
				button.setEnabled(this.isEnabled());
				/*
				 * if ( i == 0 ) { JRootPane root = SwingUtilities.getRootPane( button ); if (
				 * root != null ) root.setDefaultButton( button ); }
				 */
			} else {
				throw new IllegalArgumentException("ButtonPanel.setButtons: nulls are not allowed.");
			}
		}

		this.revalidate();
		this.repaint();
		broadcastEvent(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, STATE_CHANGED));
	}

	/**
	*
	*/
	public void setLabels(Action[] actions) {
		if (actions == null) {
			actions = new Action[] {};
		}

		buttonContainer.removeAll();
		this.buttonList = new Vector(actions.length);

		Action action = null;
		Component button;
		for (int i = 0; i < actions.length; i++) {
			action = actions[i];
			if (action != null) {
				String name = (String) action.getValue(Action.NAME);
				button = createComponentWithLabel(name);
				this.buttonList.addElement(name);
				addComponentToPanel(button);
				button.setEnabled(this.isEnabled() ? action.isEnabled() : false);

				// Add the action to the "button" if it knows about action listeners.
				try {
					Method addActionListenerMethod = button.getClass().getMethod("addActionListener",
							new Class[] { ActionListener.class });
					addActionListenerMethod.invoke(button, new Object[] { action });
				} catch (NoSuchMethodException e) {
					/* Do Nothing */ } catch (IllegalAccessException e) {
					e.printStackTrace();
					/* TODO: Do Something? */ } catch (InvocationTargetException e) {
					e.printStackTrace();
					/* TODO: Do Something? */ }

				// Create a new listener for property change events and have
				// the action broadcast to that listener.
				PropertyChangeListener pcListener = new ActionChangeListener(button);
				action.addPropertyChangeListener(pcListener);
			} else {
				throw new IllegalArgumentException("ButtonPanel.setButtons: nulls are not allowed.");
			}
		}

		this.revalidate();
		this.repaint();
		broadcastEvent(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, STATE_CHANGED));
	}

	/**
	 * Gets the labels of the buttons that appear on the panel, ordered from left to
	 * right.
	 * 
	 * @return A new list containing strings used in labeling the buttons.
	 */
	public String[] getLabels() {
		String[] labels = new String[buttonList.size()];
		int i = 0;
		for (Enumeration it = buttonList.elements(); it.hasMoreElements();) {
			labels[i++] = it.nextElement().toString();
		}
		return labels;
	}

	/**
	 * Gets the first component having the specified name.
	 * 
	 * @return A component with the specified name, or null if none match.
	 */
	public Component getButton(String aLabel) {
		if (aLabel == null)
			return null;

		Component c = null;
		int count = buttonContainer.getComponentCount();
		for (int i = 0; i < count; i++) {
			c = buttonContainer.getComponent(i);
			if (aLabel.equals(c.getName())) {
				return c;
			}
		}
		return null;
	}

	/**
	 * Creates a new component with the specified label. The label is also used for
	 * the component's name and action command, if any. (This implementation returns
	 * a JButton.)
	 * 
	 * @param aLabel The label for the component that will be created.
	 * @return The newly created component.
	 */
	protected Component createComponentWithLabel(String aLabel) {
		String buttonLabel = aLabel; // TODO: get string from resource
		JButton newButton = new JButton(); // might allow other types in future
		newButton.setName(aLabel);
		newButton.setText(buttonLabel);
		newButton.setActionCommand(aLabel);
		newButton.addActionListener(this);
		return newButton;
	}

	/**
	 * Adds a component to the right-most side of the layout.
	 * 
	 * @param aComponent The component to be added to the layout.
	 */
	protected void addComponentToPanel(Component aComponent) {
		buttonContainer.add(aComponent);
	}

	/**
	 * Changes the alignment of the buttons in the panel. Defaults to
	 * right-justified.
	 * 
	 * @param alignment A valid alignment code, per BetterFlowLayout implementation.
	 * @see BetterFlowLayout
	 */
	public void setAlignment(int alignment) {
		buttonPanelLayout.setAlignment(alignment);
		buttonContainer.doLayout();
	}

	/**
	 * Gets the alignment of the buttons in the panel.
	 * 
	 * @return An alignment code, per FlowLayout implementation.
	 * @see FlowLayout
	 */
	public int getAlignment() {
		return buttonPanelLayout.getAlignment();
	}

	/**
	 * Changes the horizontal spacing between components in the panel.
	 * 
	 * @param newHgap the new spacing, in pixels. May not be negative.
	 */
	public void setHgap(int newHgap) {
		if (newHgap < 0)
			return; // may not be negative
		buttonPanelLayout.setHgap(newHgap);
	}

	/**
	 * Gets the current horizontal spacing between components.
	 * 
	 * @return the current horizontal spacing, in pixels.
	 */
	public int getHgap() {
		return buttonPanelLayout.getHgap();
	}

	/**
	 * Changes the vertical spacing between components in the panel.
	 * 
	 * @param newVgap the new spacing, in pixels. May not be negative.
	 */
	public void setVgap(int newVgap) {
		if (newVgap < 0)
			return; // may not be negative
		buttonPanelLayout.setVgap(newVgap);
	}

	/**
	 * Gets the current vertical spacing between components.
	 * 
	 * @return the current vertical spacing, in pixels.
	 */
	public int getVgap() {
		return buttonPanelLayout.getVgap();
	}

	/**
	 * Changes the insets for this panel.
	 * 
	 * @param newInsets the new insets.
	 */
	public void setInsets(Insets newInsets) {
		insets = newInsets;
	}

	/**
	 * Overridden to return the user-specified insets for this panel.
	 * 
	 * @return the current insets for this panel.
	 */
	public Insets getInsets() {
		return insets;
	}

	/**
	 * Overridden to call setEnabled on all components on panel.
	 * 
	 * @param isEnabled whether to enable the panel and all components on it.
	 */
	public void setEnabled(boolean isEnabled) {
		super.setEnabled(isEnabled);
		int count = buttonContainer.getComponentCount();
		for (int i = 0; i < count; i++) {
			buttonContainer.getComponent(i).setEnabled(isEnabled);
		}
	}

	// Action Multicast methods

	/**
	 * Adds an action listener to the list that will be notified by button events
	 * and changes in button state.
	 * 
	 * @param l An action listener to be notified.
	 */
	public void addActionListener(ActionListener l) {
		actionListener = AWTEventMulticaster.add(actionListener, l);
	}

	/**
	 * Removes an action listener from the list that will be notified by button
	 * events and changes in button state.
	 * 
	 * @param l An action listener to be removed.
	 */
	public void removeActionListener(ActionListener l) {
		actionListener = AWTEventMulticaster.remove(actionListener, l);
	}

	/**
	 * Notifies all registered action listeners of a pending Action Event.
	 * 
	 * @param e An action event to be broadcast.
	 */
	protected void broadcastEvent(ActionEvent e) {
		if (actionListener != null) {
			actionListener.actionPerformed(e);
		}
	}

	// interface ActionListener

	/**
	 * Called by buttons on panel and by other components that might be set to
	 * broadcast events to this listener.
	 * 
	 * @param e An action event to be received.
	 */
	public void actionPerformed(ActionEvent e) {
		broadcastEvent(e);
	}

	/**
	 * A property change listener that listens specifically for property changes
	 * from action objects. This is the class that ties in the action to the button.
	 * This class is added to an action as a property change listener. The
	 * corresponding component is referenced by this class toe easily handle updates
	 * to the component caused by changes to the action.
	 */
	public class ActionChangeListener implements PropertyChangeListener {
		/** The UI component that is affected by the action's changes. */
		Component theComponent;

		/**
		 * Constructs an ActionChangeListener with the given component being the
		 * recipient of the action's changes.
		 * 
		 * @param The component to bind with the action.
		 */
		public ActionChangeListener(Component aComponent) {
			super();
			theComponent = aComponent;
		}

		/**
		 * Called whenever a property changes on the action object.
		 * 
		 * @pram e The property change event generated by the action.
		 */
		public void propertyChange(PropertyChangeEvent e) {
			String propertyName = e.getPropertyName();
			if (propertyName.equals(Action.NAME)) {
				String name = (String) e.getNewValue();
				if (theComponent instanceof AbstractButton) {
					AbstractButton button = (AbstractButton) theComponent;
					String oldName = button.getName();
					button.setText(name);
					button.setName(name);
					button.setActionCommand(name);

					// Replace the old name of the component with the new name
					// in the ButtonPanel's list of components.
					buttonList.setElementAt(name, buttonList.indexOf(oldName));
				}

				// TODO: If component is not a button (or doesn't define the getText()
				// then what should be done.
			} else if (propertyName.equals("enabled")) {
				Boolean enabled = (Boolean) e.getNewValue();
				theComponent.setEnabled(ButtonPanel.this.isEnabled() ? enabled.booleanValue() : false);
			}

			// TODO: Icon?
		}
	}

	// for testing

	public static void main(String[] argv) {
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (Exception exc) {

		}

		JFrame dialog = new JFrame();
		BorderLayout bl = new BorderLayout(20, 20);

		ButtonPanel panel = new ButtonPanel();
//        ButtonPanel panel = new ButtonPanel( new String[] { "OkayOkay", "CancelCancel" } );

		dialog.getContentPane().setLayout(bl);
		dialog.getContentPane().add(panel, BorderLayout.CENTER);
		dialog.setLocation(50, 50);
		// dialog.setSize( 450, 150 );

		panel.setAlignment(BetterFlowLayout.CENTER_VERTICAL);
		panel.getButton("One").setEnabled(false);

		dialog.pack();
		dialog.setVisible(true);

		try {
			BeanInfo info = Introspector.getBeanInfo(ButtonPanel.class);
			PropertyDescriptor[] props = info.getPropertyDescriptors();
			for (int i = 0; i < props.length; i++) {
				System.out.println(props[i].getName());
			}
		} catch (Exception exc) {
			System.out.println(exc);
		}

	}

	public void mouseDragged(MouseEvent e) {
	}

	public void mouseMoved(MouseEvent e) {
	}

}