/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2000 Michael Powers

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.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Vector;

import javax.swing.Timer;
import javax.swing.table.AbstractTableModel;

/**
 * PropertyEditorTableModel introspects an object to facilitate editing it in a
 * PropertyTable.
 *
 * Because the model always reflects the current state of the inspected object,
 * it is useful to have a table update at automated intervals. By default, this
 * feature is turned off. If you turn it on, you'll want to remember to turn it
 * off when you're done with the table model.
 *
 * @author michael@mpowers.net
 * @author $Author: cgruber $
 * @version $Revision: 904 $
 */
public class PropertyEditorTableModel extends AbstractTableModel implements ActionListener {
	protected Object inspectedObject = null;

	final String[] columnNames = { "Property", "Value" };
	static final String METHOD_TAG = " ";

	Vector properties = new Vector();
	Hashtable methods = new Hashtable(0);

	public void setObject(Object o) {
		inspectedObject = o;
		Class c = o.getClass();
		Method[] m = c.getMethods();

		properties = new Vector();
		methods = new Hashtable(m.length, 1F);
		String name, propertyName;
		for (int i = 0; i < m.length; i++) {
//				if ( m[i].getName().startsWith( "get" ) )
//					System.out.println( m[i].getName() + ": " + m[i].getReturnType().getName() );

			// get methods
			if (((m[i].getName().startsWith("get")) || (m[i].getName().startsWith("is")))
					&& (m[i].getParameterTypes().length == 0)) {
				name = m[i].getName();
				if (m[i].getName().startsWith("is")) {
					propertyName = name.substring(2, name.length());
					// probably should only add "is" methods if accompanied by "set" method
				} else { // "get"
					propertyName = name.substring(3, name.length());
				}
				if ((m[i].getReturnType().getName().equals(String.class.getName()))
						|| (m[i].getReturnType().getName().equals("boolean"))
						|| (m[i].getReturnType().getName().equals("int"))
						|| (m[i].getReturnType().getName().equals("float"))
						|| (m[i].getReturnType().getName().equals("char"))
						|| (m[i].getReturnType().getName().equals(Color.class.getName()))
						|| (m[i].getReturnType().getName().equals(Font.class.getName()))) {
					properties.addElement(propertyName); // put property
					methods.put(name, m[i]); // put method
				} else {
					// handle unknown types as invokable methods:
					properties.addElement(propertyName + METHOD_TAG);
					methods.put(propertyName + METHOD_TAG, m[i]);
				}
			} else
			// set methods
			if ((m[i].getName().startsWith("set")) && (m[i].getParameterTypes().length == 1)) {
				name = m[i].getName();
				if ((m[i].getParameterTypes()[0].getName().equals(String.class.getName()))
						|| (m[i].getParameterTypes()[0].getName().equals("boolean"))
						|| (m[i].getParameterTypes()[0].getName().equals("int"))
						|| (m[i].getParameterTypes()[0].getName().equals("float"))
						|| (m[i].getParameterTypes()[0].getName().equals(Color.class.getName()))
//				||  ( m[i].getParameterTypes()[0].getName().equals( Font.class.getName() ) )
				) {
//					System.out.println( "Accepted: " + name + ": " + m[i].getParameterTypes()[0].getName() );
					methods.put(name, m[i]); // set method
				} else {
//					System.out.println( "Rejected: " + name + ": " + m[i].getParameterTypes()[0].getName() );
				}
			} else
			// zero-parameter methods to be invoked on click
			if (m[i].getParameterTypes().length == 0) {
				properties.addElement(m[i].getName() + METHOD_TAG);
				methods.put(m[i].getName() + METHOD_TAG, m[i]);
			}

		}

		sort(properties);
		fireTableDataChanged();
	}

	public int getColumnCount() {
		return columnNames.length;
	}

	public int getRowCount() {
		return properties.size();
	}

	public String getColumnName(int col) {
		return columnNames[col];
	}

	public Object getValueAt(int row, int col) {
		if (col == 0)
			return properties.elementAt(row);
		else {
			Method m = null;
			m = (Method) methods.get("get" + ((String) properties.elementAt(row)));
			if (m == null) // try "is"
				m = (Method) methods.get("is" + ((String) properties.elementAt(row)));
			if (m == null) { // try entire method name
				m = (Method) methods.get((String) properties.elementAt(row));
				if (m != null)
					return m;
			}
			try {
				return m.invoke(inspectedObject, (Object[]) null);
			} catch (Exception exc) {
				System.out.println("InspectorFrame.tableModel.getValueAt: error occured while reflecting: ");
				System.out.println(exc);
			}
			return null;
		}
	}

	public Class getColumnClass(int col) {
//		System.out.println( "getColumnClass" );
		/*
		 * try { throw new Exception(); } catch ( Exception exc ) { exc.printStackTrace(
		 * System.out ); }
		 */ return new String().getClass();
	}

	public Class getCellClass(int row, int col) {
//		System.out.println( "getCellClass" );
		/*
		 * 
		 * Class c; Method m = (Method) methods.get( "set" + ( (String)
		 * properties.elementAt( row ) ) ) ; if ( m == null ) c = new
		 * Object().getClass(); else { c = m.getParameterTypes()[0];
		 * 
		 * // special case for boolean if ( c.getName().equals( "boolean" ) ) c = new
		 * Boolean(true).getClass();
		 * 
		 * // special case for int if ( c.getName().equals( "int" ) ) c = new
		 * Integer(0).getClass(); } System.out.println( row + ": " + c.getName() );
		 * return c;
		 */

//		return new String().getClass();

		Object o = getValueAt(row, col);
		if (o == null)
			o = "null";
		return o.getClass();
	}

	/*
	 * Don't need to implement this method unless your table's editable.
	 */
	public boolean isCellEditable(int row, int col) {
		// Note that the data/cell address is constant,
		// no matter where the cell appears onscreen.
		if (col < 1) {
			return false;
		} else {
			// handle method invocation
			if (((String) properties.elementAt(row)).endsWith(METHOD_TAG))
				return true;
			// handle read-only properties
			Method m = (Method) methods.get("set" + ((String) properties.elementAt(row)));
			if (m == null)
				return false;
			else
				return true;
		}
	}

	/*
	 * Don't need to implement this method unless your table's data can change.
	 */
	public void setValueAt(Object value, int row, int col) {
		// test for inspected object
		if (inspectedObject == null)
			return;
		// handle method invocation - no need to update values
		if (((String) properties.elementAt(row)).endsWith(METHOD_TAG)) {
			fireTableDataChanged();
			return;
		}
		;

		// handle writable properties
		Method m = (Method) methods.get("set" + ((String) properties.elementAt(row)));
		String parameterType = m.getParameterTypes()[0].getName();

		// ugly cast code
		if ((parameterType.equals("int")) || (parameterType.equals("java.lang.Integer"))) {
			try {
				value = new Integer((String) value);
			} catch (NumberFormatException e) {
				System.out.println("PropertyEditorTableModel.setValueAt: User attempted to enter non-integer"
						+ " value (" + value + ") into an integer-only column.");
			}
		}
		Object[] parameters = { value };
		try {
			m.invoke(inspectedObject, parameters);
			if (inspectedObject instanceof Component) {
				Component c = (Component) inspectedObject;
				if (c.getParent() != null)
					c.getParent().repaint();
			}
		} catch (Exception exc) {
			System.out.println("PropertyEditorTableModel.setValueAt: error occured while reflecting: ");
			System.out.println(exc);
		}

		fireTableDataChanged();
	}

	protected void sort(Vector v) {
		quickSort(v, 0, v.size() - 1);
	}

	// Liberated from the BasicDirectoryModel which was...
	// Liberated from the 1.1 SortDemo

	// This is a generic version of C.A.R Hoare's Quick Sort
	// algorithm. This will handle arrays that are already
	// sorted, and arrays with duplicate keys.<BR>
	//
	// If you think of a one dimensional array as going from
	// the lowest index on the left to the highest index on the right
	// then the parameters to this function are lowest index or
	// left and highest index or right. The first time you call
	// this function it will be with the parameters 0, a.length - 1.
	//
	// @param a an integer array
	// @param lo0 left boundary of array partition
	// @param hi0 right boundary of array partition
	private void quickSort(Vector v, int lo0, int hi0) {
		int lo = lo0;
		int hi = hi0;
		String mid;

		if (hi0 > lo0) {
			// Arbitrarily establishing partition element as the midpoint of
			// the array.
			mid = (String) v.elementAt((lo0 + hi0) / 2);

			// loop through the array until indices cross
			while (lo <= hi) {
				// find the first element that is greater than or equal to
				// the partition element starting from the left Index.
				//
				// Nasty to have to cast here. Would it be quicker
				// to copy the vectors into arrays and sort the arrays?
				while ((lo < hi0) && lt((String) v.elementAt(lo), mid)) {
					++lo;
				}

				// find an element that is smaller than or equal to
				// the partition element starting from the right Index.
				while ((hi > lo0) && lt(mid, (String) v.elementAt(hi))) {
					--hi;
				}

				// if the indexes have not crossed, swap
				if (lo <= hi) {
					swap(v, lo, hi);
					++lo;
					--hi;
				}
			}

			// If the right index has not reached the left side of array
			// must now sort the left partition.
			if (lo0 < hi) {
				quickSort(v, lo0, hi);
			}

			// If the left index has not reached the right side of array
			// must now sort the right partition.
			if (lo < hi0) {
				quickSort(v, lo, hi0);
			}

		}
	}

	private void swap(Vector a, int i, int j) {
		Object T = a.elementAt(i);
		a.setElementAt(a.elementAt(j), i);
		a.setElementAt(T, j);
	}

	protected boolean lt(String a, String b) {
		return a.compareTo(b) < 0;
	}

	// automated updates

	private boolean autoUpdating = false;
	private int updateInterval = 2000; // one-second delay on average
	protected Timer timer = null;

	public boolean isAutoUpdating() {
		return autoUpdating;
	}

	public void setAutoUpdating(boolean shouldAutoUpdate) {
		if (shouldAutoUpdate) {
			if (timer == null) {
				timer = new Timer(updateInterval, this);
				timer.setRepeats(true);
				timer.start();
			}
		} else {
			if (timer != null) {
				timer.stop();
				timer = null;
			}
		}

		autoUpdating = shouldAutoUpdate;
	}

	public int getUpdateInterval() {
		return updateInterval;
	}

	public void setUpdateInterval(int anInterval) {
		if (timer != null) {
			timer.setDelay(anInterval);
		}

		updateInterval = anInterval;
	}

	public void actionPerformed(ActionEvent evt) {
		if (evt.getSource() == timer) {
			fireTableDataChanged();
		}
	}

}