/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2001 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;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import net.wotonomy.control.EOKeyValueCoding;
import net.wotonomy.control.EOKeyValueCodingSupport;
import net.wotonomy.control.EOObserverCenter;
import net.wotonomy.foundation.NSArray;

/**
* GenericAssociation binds one or more properties on an 
* observable object to a display group.  The controlled
* object is expected to use the ObserverCenter and will
* be observed by this association. <br><br>
*
* Bindings for this association are <i>generic</i>: the 
* name of the aspect will be treated as a property key 
* on the displayed object(s) and synchronized with the 
* bound property on the controlled object. <br><br>
*
* NOTE: because we cannot assume that the controlled
* object will retain a reference to this association,
* you must explicitly retain a reference to prevent
* the association from getting garbage collected.
*
* @author michael@mpowers.net
* @author $Author: cgruber $
* @version $Revision: 904 $
*/
public class GenericAssociation extends EOAssociation
{
    protected boolean objectModified;
    protected Set aspectsModified;
    
    static final NSArray aspects = 
        new NSArray( new Object[] {
        } );
    static final NSArray aspectSignatures = 
        new NSArray( new Object[] {
        } );
    static final NSArray objectKeysTaken = 
        new NSArray( new Object[] {
        } );
		
    /**
    * Constructor specifying the object to be controlled by this
    * association.  Does not establish connection.
    */
    public GenericAssociation ( Object anObject )
    {
        super( anObject );
        objectModified = false;
        aspectsModified = new HashSet();
    }
    
    /**
    * 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 true;
    }
    
    /**
    * 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 "";
    }
        
    /**
    * 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 true;
    }
    
    /**
    * Establishes a connection between this association
    * and the controlled object.  This implementation 
	* registers with ObserverCenter for change notifications
    * from the controlled object.
    */
    public void establishConnection ()
    {
		EOObserverCenter.addObserver( this, object() );
        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 ()
    {
		EOObserverCenter.removeObserver( this, object() );
        super.breakConnection();
    }
    
    /**
    * Overridden to track which observed object is changing.
    */
    public void objectWillChange( Object anObject )
    {
        if ( object() == anObject ) 
        { 
            objectModified = true;
        }
        else
        {
            aspectsModified.add( aspectToGroup.allKeysForObject( anObject ) );
        }
    }

    /**
    * Called when either the selection or the contents 
    * of an associated display group have changed.
    */
    public void subjectChanged ()
    {
        String aspect;
        String key;
        Object value;
        EODisplayGroup displayGroup;
        Iterator iterator;
        
        iterator = aspectsModified.iterator();
        while ( iterator.hasNext() )
        {
            aspect = (String) iterator.next();
            key = displayGroupKeyForAspect( aspect );
            displayGroup = displayGroupForAspect( aspect );

            value = readValueFromDisplayGroupForKey( displayGroup, key );    
            writeValueForKey( object(), value, key );
        }
        aspectsModified.clear();
        
        if ( objectModified )
        {
            iterator = aspectToGroup.keySet().iterator();
            while ( iterator.hasNext() )
            {
                aspect = (String) iterator.next();
                key = displayGroupKeyForAspect( aspect );
                value = readValueForKey( object(), key );
                displayGroup = displayGroupForAspect( aspect );
                displayGroup.setSelectedObjectValue( value, key );
            }
        }
    }
    
    protected Object readValueForKey( Object object, String key )
    {
        if ( object instanceof EOKeyValueCoding )
        {
            return ((EOKeyValueCoding)object).valueForKey( key );
        }
        return EOKeyValueCodingSupport.valueForKey( object, key );
    }
    
    protected void writeValueForKey( Object object, Object value, String key )
    {
        if ( object instanceof EOKeyValueCoding )
        {
            ((EOKeyValueCoding)object).takeValueForKey( value, key );
        }
        else
        {
            EOKeyValueCodingSupport.takeValueForKey( object, value, key );
        }
    }
    
    protected Object readValueFromDisplayGroupForKey( 
        EODisplayGroup displayGroup, String key )
    {
        Object value;
        
        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
        
        return value;
    }
	
	/**
	* 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 writeValueForAspect( Object value, String aspect )
	{
		EODisplayGroup displayGroup = 
			displayGroupForAspect( aspect );
		if ( displayGroup != null )
		{
			String key = displayGroupKeyForAspect( aspect );

            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;
	}

    /**
    * 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 false;
//!	    return writeValueToDisplayGroup();
    }
	
}

/*
 * $Log$
 * Revision 1.2  2006/02/18 23:14:35  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.3  2003/08/06 23:07:52  chochos
 * general code cleanup (mostly, removing unused imports)
 *
 * Revision 1.2  2001/11/08 19:51:24  mpowers
 * Draft implementation.
 *
 * Revision 1.1  2001/11/02 23:15:04  mpowers
 * Contributing "generic association".
 *
 *
 */