/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2000 Intersect Software Corporation

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;

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.util.Calendar;
import java.util.Date;
import java.util.Enumeration;
import java.util.Iterator;

import net.wotonomy.foundation.NSArray;
import net.wotonomy.foundation.NSSelector;
import net.wotonomy.foundation.internal.ValueConverter;
import net.wotonomy.foundation.internal.WotonomyException;
import net.wotonomy.ui.EOAssociation;
import net.wotonomy.ui.EODisplayGroup;

/**
* DateAssociation binds any component that has a set and get Date methods and
* fire actions events when the date has been changed.  Bindings are:
* <ul>
* <li>value: a property convertable to/from a date</li>
* <li>editable: a boolean property that determines whether
* the user can edit the date in the component</li>
* <li>enabled: a boolean property that determines whether
* the component is enabled or disabled</li>
* </ul>
*
* @author rob@yahoo.com
* @version $Revision: 904 $
*/
public class DateAssociation extends EOAssociation
                             implements ActionListener, FocusListener
{
    static final NSArray aspects =
        new NSArray( new Object[] {
            ValueAspect, EnabledAspect, EditableAspect
        } );
    static final NSArray aspectSignatures =
        new NSArray( new Object[] {
            AttributeToOneAspectSignature,
			AttributeToOneAspectSignature,
			AttributeToOneAspectSignature
        } );
    static final NSArray objectKeysTaken =
        new NSArray( new Object[] {
            "date", "enabled", "editable"
        } );

	private final static NSSelector getDate =
		new NSSelector( "getDate" );
	private final static NSSelector setDate =
		new NSSelector( "setDate",
		new Class[] { Date.class } );
	private final static NSSelector addActionListener =
		new NSSelector( "addActionListener",
		new Class[] { ActionListener.class } );
	private final static NSSelector removeActionListener =
		new NSSelector( "removeActionListener",
		new Class[] { ActionListener.class } );
	private final static NSSelector addFocusListener =
		new NSSelector( "addFocusListener",
		new Class[] { FocusListener.class } );
	private final static NSSelector removeFocusListener =
		new NSSelector( "removeFocusListener",
		new Class[] { FocusListener.class } );
	private final static NSSelector setEditable =
		new NSSelector( "setEditable",
		new Class[] { boolean.class } );

	// dirty handling
	private boolean needsUpdate;
    private Date nullValue; // placeholder for null value flag

    /**
    * Constructor specifying the object to be controlled by this
    * association.  Does not establish connection.
    */
    public DateAssociation ( Object anObject )
    {
        super( anObject );
		needsUpdate = false;
        nullValue = null;
    }

    /**
    * Returns a List of aspect signatures whose contents
    * correspond with the aspects list.  Each element is
    * a string whose characters represent a capability of
    * the corresponding aspect. <ul>
    * <li>"A" attribute: the aspect can be bound to
    * an attribute.</li>
    * <li>"1" to-one: the aspect can be bound to a
    * property that returns a single object.</li>
    * <li>"M" to-one: the aspect can be bound to a
    * property that returns multiple objects.</li>
    * </ul>
    * An empty signature "" means that the aspect can
    * bind without needing a key.
    * This implementation returns "A1M" for each
    * element in the aspects array.
    */
    public static NSArray aspectSignatures ()
    {
        return aspectSignatures;
    }

    /**
    * Returns a List that describes the aspects supported
    * by this class.  Each element in the list is the string
    * name of the aspect.  This implementation returns an
    * empty list.
    */
    public static NSArray aspects ()
    {
        return aspects;
    }

    /**
    * Returns a List of EOAssociation subclasses that,
    * for the objects that are usable for this association,
    * are less suitable than this association.
    */
    public static NSArray associationClassesSuperseded ()
    {
        return new NSArray();
    }

    /**
    * Returns whether this class can control the specified
    * object.
    */
    public static boolean isUsableWithObject ( Object anObject )
    {
        return setDate.implementedByObject( anObject );
    }

    /**
    * Returns a List of properties of the controlled object
    * that are controlled by this class.  For example,
    * "stringValue", or "selected".
    */
    public static NSArray objectKeysTaken ()
    {
        return objectKeysTaken;
    }

    /**
    * Returns the aspect that is considered primary
    * or default.  This is typically "value" or somesuch.
    */
    public static String primaryAspect ()
    {
        return ValueAspect;
    }

    /**
    * Returns whether this association can bind to the
    * specified display group on the specified key for
    * the specified aspect.
    */
    public boolean canBindAspect (
        String anAspect, EODisplayGroup aDisplayGroup, String aKey)
    {
        return ( aspects.containsObject( anAspect ) );
    }

    /**
    * Establishes a connection between this association
    * and the controlled object.  This implementation
	* attempts to add this class as an ActionListener
	* and Focus Listener to the specified object.
    */
    public void establishConnection ()
    {
		Object component = object();
		try
		{
			if ( addActionListener.implementedByObject( component ) )
			{
				addActionListener.invoke( component, this );
			}
			if ( addFocusListener.implementedByObject( component ) )
			{
				addFocusListener.invoke( component, this );
			}
		}
		catch ( Exception exc )
		{
			throw new WotonomyException(
				"Error while establishing connection", exc );
		}

        super.establishConnection();

		// forces update from bindings
		subjectChanged();
    }

    /**
    * Breaks the connection between this association and
    * its object.  Override to stop listening for events
    * from the object.
    */
    public void breakConnection ()
    {
		Object component = object();
		try
		{
			if ( removeActionListener.implementedByObject( component ) )
			{
				removeActionListener.invoke( component, this );
			}
			if ( removeFocusListener.implementedByObject( component ) )
			{
				removeFocusListener.invoke( component, this );
			}
		}
		catch ( Exception exc )
		{
			throw new WotonomyException(
				"Error while breaking connection", exc );
		}
        super.breakConnection();
    }

    /**
    * Called when either the selection or the contents
    * of an associated display group have changed.
    */
    public void subjectChanged ()
    {
		Object component = object();
		EODisplayGroup displayGroup;
		String key;
		Object value;

		// value aspect
		displayGroup = displayGroupForAspect( ValueAspect );
		if ( displayGroup != null )
		{
                    key = displayGroupKeyForAspect( ValueAspect );
                    if ( component instanceof Component )
                    {
                        ((Component)component).setEnabled( 
                                displayGroup.enabledToSetSelectedObjectValueForKey( key ) );
                    }
                    if ( displayGroup.selectedObjects().size() > 1 )
                    {
                        // if there're more than one object selected, set
                        // the value to blank for all of them.
                        Object previousValue;

                        Iterator indexIterator = displayGroup.selectionIndexes().
                                                  iterator();

                        // get value for the first selected object.
                        int initialIndex = ( (Integer)indexIterator.next() ).intValue();
                        previousValue = displayGroup.valueForObjectAtIndex(
                                                  initialIndex, key );
                        value = null;

                        // go through the rest of the selected objects, compare each
                        // value with the previous one. continue comparing if two
                        // values are equal, break the while loop if they're different.
                        // the final value will be the common value of all selected objects
                        // if there is one, or be blank if there is not.
                        while ( indexIterator.hasNext() )
                        {
                            int index = ( (Integer)indexIterator.next() ).intValue();
                            Object currentValue = displayGroup.valueForObjectAtIndex(
                                                  index, key );
                            if ( currentValue != null && !currentValue.equals( previousValue ) )
                            {
                                value = null;
                                break;
                            }
                            else
                            {
                                // currentValue is the same as the previous one
                                value = currentValue;
                            }

                        } // end while

                    } else {

                        value = displayGroup.selectedObjectValueForKey( key );
                    } // end checking size of displayGroup

                    // convert value to date
                    try
                    {
                        Date dateValue = null;
                        // (Date) ValueConverter.convertObjectToClass( value, Date.class );

                        if ( value instanceof Date )
                        {
                            dateValue = (Date) value;
                        }

                        if ( ( dateValue == null ) && ( value instanceof Calendar ) )
                        {
                            dateValue = ( ( Calendar )value ).getTime();
                        }

                        if ( dateValue == null )
                        {
                            // current time (placeholder)
                            nullValue = new Date();
                            dateValue = nullValue;
                        }
                        else
                        {
                            nullValue = null;
                        }

                        if ( !dateValue.equals( getDate.invoke( component ) ) )
                        {	// No need to update if there is no change.
                            setDate.invoke( component, dateValue );
                            needsUpdate = false;
                        }

                    }
                    catch ( Exception exc )
                    {
                            throw new WotonomyException(
                                    "Error while updating component connection", exc );
                    }
		}

		// enabled aspect
		displayGroup = displayGroupForAspect( EnabledAspect );
		key = displayGroupKeyForAspect( EnabledAspect );
		if ( ( ( displayGroup != null ) || ( key != null ) )
		&& ( component instanceof Component ) )
		{
			if ( displayGroup != null )
			{
				value =
					displayGroup.selectedObjectValueForKey( key );
			}
			else
			{
				// treat bound key without display group as a value
				value = key;
			}
            Boolean converted = null;
            if ( value != null ) 
            {
                converted = (Boolean)
                    ValueConverter.convertObjectToClass(
                        value, Boolean.class );
            }
            if ( converted == null ) converted = Boolean.FALSE;
            if ( converted.booleanValue() != ((Component)component).isEnabled() )
            {
                ((Component)component).setEnabled( converted.booleanValue() );
            }
		}

		// editable aspect
		displayGroup = displayGroupForAspect( EditableAspect );
		key = displayGroupKeyForAspect( EditableAspect );
		if ( ( ( displayGroup != null ) || ( key != null ) )
		&& ( setEditable.implementedByObject( component ) ) )
		{
            try
            {
                if ( displayGroup != null )
                {
                    value =
                        displayGroup.selectedObjectValueForKey( key );
                }
                else
                {
                    // treat bound key without display group as a value
                    value = key;
                }
                Boolean converted = (Boolean)
                    ValueConverter.convertObjectToClass(
                        value, Boolean.class );

                if ( converted != null )
                {
                    setEditable.invoke( component, converted );
                }
            }
			catch ( Exception exc )
			{
				throw new WotonomyException(
					"Error while updating component connection (editable aspect)", exc );
			}
		}
    }

    /**
    * Forces this association to cause the object to
    * stop editing and validate the user's input.
    * @return false if there were problems validating,
    * or true to continue.
    */
    public boolean endEditing ()
    {
		return writeValueToDisplayGroup();
    }

	/**
	* Writes the value currently in the component
	* to the selected object in the display group
	* bound to the value aspect.
        * @return false if there were problems validating,
        * or true to continue.
	*/
	protected boolean writeValueToDisplayGroup()
	{
            if ( !needsUpdate ) return true;

            EODisplayGroup displayGroup =
                    displayGroupForAspect( ValueAspect );
            if ( displayGroup != null )
            {
                String key = displayGroupKeyForAspect( ValueAspect );
                                Object component = object();
                Object value = null;
                try
                {
                    if ( getDate.implementedByObject( component ) )
                    {
                            value = getDate.invoke( component );
                    }
                    if ( nullValue != null )
                    {
                        if ( nullValue.equals( value ) )
                        {
                            value = null;
                        }
                    }
                }
                catch ( Exception exc )
                {
                        throw new WotonomyException(
                                "Error updating display group", exc );
                }

                needsUpdate = false;

                boolean returnValue = true;
                Iterator selectedIterator = displayGroup.selectionIndexes().iterator();
                while ( selectedIterator.hasNext() )
                {
                    int index = ( (Integer)selectedIterator.next() ).intValue();

                    if ( !displayGroup.setValueForObjectAtIndex( value, index, key ) )
                    {
                        returnValue = false;
                    }
                }
                return returnValue;

            }
            return false;
	}

    // interface ActionListener

	/**
	* Updates object on action performed.
	*/
	public void actionPerformed( ActionEvent evt )
	{
        needsUpdate = true;
		writeValueToDisplayGroup();  // TODO: Should we do this here or on focus lost?
	}

    // interface FocusListener

	/**
	* Notifies of beginning of edit.
	*/
    public void focusGained(FocusEvent evt)
    {
		Object o;
		EODisplayGroup displayGroup;
        Enumeration e = aspects().objectEnumerator();
		while ( e.hasMoreElements() )
		{
			displayGroup =
				displayGroupForAspect( e.nextElement().toString() );
			if ( displayGroup != null )
			{
				displayGroup.associationDidBeginEditing( this );
			}
		}
    }

	/**
	* Updates object on focus lost and notifies of end of edit.
	*/
    public void focusLost(FocusEvent evt)
    {
		if ( endEditing() )
		{
			Object o;
			EODisplayGroup displayGroup;
			Enumeration e = aspects().objectEnumerator();
			while ( e.hasMoreElements() )
			{
				displayGroup =
					displayGroupForAspect( e.nextElement().toString() );
				if ( displayGroup != null )
				{
					displayGroup.associationDidEndEditing( this );
				}
			}
		}
		else
		{
			// probably should notify of a validation error here,
			// but how to also handle actionPerformed without copying code?
/*
			Object value = null;
			try
			{
				if ( getText.implementedByObject( object() ) )
				{
					value = getText.invoke( object() );
				}
			}
			catch ( Exception exc )
			{
				throw new WotonomyException(
					"Error updating display group", exc );
			}

			EODisplayGroup displayGroup =
					displayGroupForAspect( ValueAspect );
			String key = displayGroupKeyForAspect( ValueAspect );
			if ( displayGroup != null )
			{
				if ( displayGroup.associationFailedToValidateValue(
					this, (String) value, key, object(),
					"That format was not recognized." ) )
				{
					new net.wotonomy.ui.swing.util.StackTraceInspector();
				}
				if ( object() instanceof Component )
				{
					((Component)object()).requestFocus();
				}
			}
*/
		}
    }
}

/*
 * $Log$
 * Revision 1.2  2006/02/18 23:19:05  cgruber
 * Update imports and maven dependencies.
 *
 * Revision 1.1  2006/02/16 13:22:22  cgruber
 * Check in all sources in eclipse-friendly maven-enabled packages.
 *
 * Revision 1.7  2004/01/28 18:34:57  mpowers
 * Better handling for enabling.
 * Now respecting enabledToSetSelectedObjectValueForKey from display group.
 *
 * Revision 1.6  2003/08/06 23:07:52  chochos
 * general code cleanup (mostly, removing unused imports)
 *
 * Revision 1.5  2001/07/30 16:32:55  mpowers
 * Implemented support for bulk-editing.  Detail associations will now
 * apply changes to all selected objects.
 *
 * Revision 1.4  2001/02/17 17:23:49  mpowers
 * More changes to support compiling with jdk1.1 collections.
 *
 * Revision 1.3  2001/02/17 16:52:05  mpowers
 * Changes in imports to support building with jdk1.1 collections.
 *
 * Revision 1.2  2001/01/17 16:25:26  mpowers
 * Now catching null values from data object.
 *
 * Revision 1.1  2001/01/10 22:26:32  mpowers
 * Contributing DateAssociation.
 *
 * Revision 1.1  2001/01/10 21:30:27  rglista
 * Initial checkin
 *
 *
 */