/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * 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, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.core;
  
  
  import java.util.*;
  
  import org.caleigo.core.event.*;
  
  /*** <Description for OrderedProxySelection>
   *
   * @author  Dennis Zikovic
   * @version 1.00
   *
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2001-12-07  Dennis Zikovic    Creation
   */
  public class OrderedProxySelection extends ProxySelection
  {
      // Constants ---------------------------------------------------------------
      
      // Data members ------------------------------------------------------------
      private int[] mIndexArray;
      private Comparator mComparator;
      
      // Constructors ------------------------------------------------------------
      
      /*** Creates new OrderedProxySelection
       */
      public OrderedProxySelection(IEntityDescriptor entityDescriptor) 
      {
          super(entityDescriptor);
      }
      
      /*** Creates new OrderedProxySelection
       */
      public OrderedProxySelection(IEntityDescriptor entityDescriptor, Comparator comparator) 
      {
          this(entityDescriptor);
          mComparator = comparator;
      }
      
      /*** Creates new OrderedProxySelection
       */
      public OrderedProxySelection(ISelection selection) 
      {
          super(selection);
      }
      
      /*** Creates new OrderedProxySelection
       */
      public OrderedProxySelection(ISelection selection, Comparator comparator) 
      {
          this(selection);
          mComparator = comparator;
          this.sort();
      }
      
      // Superclass overrides ----------------------------------------------------
      
      /*** Adds the provided IEntity object to at the specified index in the 
       * selection object. If an entity with the same identity already exists 
       * in the selection the requeat is ignored and false is returned.
       */
      public boolean addEntity(int index, IEntity entity)
      {
          if(this.getRemoteSelection()!=null)
              return this.getRemoteSelection().addEntity(this.getRemoteIndex(index), entity);
          else
              return false;
      }
      
      /*** Access method that returns the contained IEntity object with the 
       * specified index.
       */
      public IEntity getEntity(int index)
      {
          if(this.getRemoteSelection()!=null)
              return this.getRemoteSelection().getEntity(this.getRemoteIndex(index));
          else
             return null;
     }
     
     /*** Mutation method that removes the indexed entity from the selection.
      * Returns the indexed entity if it was found and removed otherwise null  
      * is returned. The entities are not effecte in any other way.
      */
     public IEntity removeEntity(int index)
     {
         if(this.getRemoteSelection()!=null)
             return this.getRemoteSelection().removeEntity(this.getRemoteIndex(index));
         else
             return null;
     }
     
     /*** Access method that views the selection objct as a grid where row is
      * the entity index and column is the field index for the stored entities.
      */
     public Object getData(int row, int column)
     {
         if(this.getRemoteSelection()!=null)
             return this.getRemoteSelection().getData(this.getRemoteIndex(row), column);
         else
             return this.getEntityDescriptor().getFieldDescriptor(column).getDefaultValue();
     }
     
     /*** Mutation method that views the selection objct as a grid where row is
      * the entity index and column is the field index for the stored entities.
      */
     public void setData(int row, int column, Object dataValue)
     {
         if(this.getRemoteSelection()!=null)
             this.getRemoteSelection().setData(this.getRemoteIndex(row), column, dataValue);
     }
     
     /*** Creates a sub selection with the indexed entities in the called 
      * selection. The created selection that should be independant of changes 
      * in the source/called selection after the time of creation.
      */
     public ISelection createSubSelection(int[] indexArray)
     {
         ISelection selection = new Selection(this.getEntityDescriptor());
         for(int j=0; j<indexArray.length; j++)
             selection.addEntity(this.getEntity(indexArray[j]));
         return selection;
     }
 
     /*** Help method that returns the index of the provided IEntity object in 
      * the selection if it exists othewise a negative value is returned.
      */
     public int indexOf(IEntity entity)
     {
         if(this.getRemoteSelection()!=null)
             return this.getOrderedIndex(this.getRemoteSelection().indexOf(entity));
         else
             return -1;
     }
 
     /*** Access method that returns the selections relay listener.
      */
     protected RelayListener createRelayListener()
     {
         return new OrderedRelayListener();
     }
 
     /*** Overriden to sort the index map for the new remote selection. 
      */
     protected void doAfterRemoteChange()
     {
         this.sort();
     }
 
     // Access methods ----------------------------------------------------------
     
     public Comparator getComparator()
     {
         return mComparator;
     }
     
     public void setComparator(Comparator comp)
     {
         mComparator = comp;
         this.sort();
     }
     
     public void setCollationField(IFieldDescriptor fieldDescriptor)
     {
         this.setCollationField(fieldDescriptor, true);
     }
     
     public void setCollationField(IFieldDescriptor fieldDescriptor, boolean ascending)
     {
         mComparator = new EntityCollator(this.getEntityDescriptor());
         ((EntityCollator)mComparator).addCollationField(fieldDescriptor, ascending);
         this.sort();
     }
     
     public void addCollationField(IFieldDescriptor fieldDescriptor)
     {
         this.addCollationField(fieldDescriptor, true);
     }
 
     public void addCollationField(IFieldDescriptor fieldDescriptor, boolean ascending)
     {
         if(!(mComparator instanceof EntityCollator))
             mComparator = new EntityCollator(this.getEntityDescriptor());
         ((EntityCollator)mComparator).addCollationField(fieldDescriptor, ascending);
         this.sort();
     }
 
     public void clearCollationFields()
     {
         mComparator = null;
     }
     
     /*** Converts an ordered entity index to a remote unordered index.
      */
     public int getRemoteIndex(int orderedIndex)
     {
         if(mComparator!=null && mIndexArray!=null && mIndexArray.length>0)
             return mIndexArray[orderedIndex];
         else
             return orderedIndex;
     }
     
     /*** Converts a remote unordered entity index to an ordered index.
      */
     public int getOrderedIndex(int remoteIndex)
     {
         if(mComparator==null || mIndexArray==null)
             return remoteIndex;
 
         int orderedIndex = mIndexArray.length-1;
         while(orderedIndex>=0 && mIndexArray[orderedIndex]!=remoteIndex)
             orderedIndex--;
         return orderedIndex;
     }
     
     // Help methods ------------------------------------------------------------
 
     /*** Sorts the selection using the current entity collator. Note that the
      * sort is automatically called when a new collator is set using any of
      * the order changing methods in the object. The method should however be 
      * used if the registered Comperator is changed externally.
      */ 
     public void sort()
     {
         if(!this.hasRemoteSelection())
             mIndexArray = null;
         
         // Break if no Comparator is defined.
         if(mComparator==null || !this.hasRemoteSelection())
             return;
         
         // Check for size changes.
         ISelection remoteSelection = this.getRemoteSelection();
         if(mIndexArray==null || mIndexArray.length!=remoteSelection.size())
         {            
             if(mIndexArray!=null && mIndexArray.length<remoteSelection.size())
             {
                 // If the size has increased, use the old array to save order.
                 int[] oldArray = mIndexArray;
                 mIndexArray = new int[remoteSelection.size()];
                 System.arraycopy(oldArray, 0, mIndexArray, 0, oldArray.length);
                 for(int j=oldArray.length; j<mIndexArray.length; j++)
                     mIndexArray[j] = j;
             }
             else
             {
                 // Else, do it the hard way.
                 mIndexArray = new int[remoteSelection.size()];
                 for(int j=0; j<mIndexArray.length; j++)
                     mIndexArray[j] = j;
             }
         }
         
         // Sort the index array.   
         boolean orderChanged = false;
         int j, k, tmp;
         for(j=1; j<mIndexArray.length; j++) 
         {
             k=j;
             while(k>0 &&  mComparator.compare(remoteSelection.getEntity(mIndexArray[j]), remoteSelection.getEntity(mIndexArray[k-1])) < 0)
                 k--;
             
             if(k<j) 
             {
                 tmp = mIndexArray[j];
                 System.arraycopy(mIndexArray, k, mIndexArray, k+1, j-k);
                 mIndexArray[k] = tmp;
                 orderChanged = true;
             }
         }
         
         // Fire contents change event if order was changed.
         if(orderChanged)
             this.fireContentsChanged();
     }
     
     // Nested classes ----------------------------------------------------------
     
     protected class OrderedRelayListener extends RelayListener
     {
         // ISelectionListener implementation -----------------------------------
         public void entityRemoved(SelectionEvent event)
         {
             // Could be improved, resort is not really necessary!
             sort(); 
             super.entityRemoved(event);
         }
         
         public void entityAdded(SelectionEvent event)
         {
             // If sorted insert new entity sp that sorting order is maintained
             if(mComparator!=null && hasRemoteSelection())
             {
                 ISelection remoteSelection = getRemoteSelection();
                 int[] newIndexArray = new int[mIndexArray.length + 1];
                 int insertIndex = -1;
                 
                 // Find index in mIndexArray for the added entity
                 for (int j=0; j<mIndexArray.length; j++)
                     if (mComparator.compare(remoteSelection.getEntity(mIndexArray[j]), event.getEntity()) > 0)
                     {
                         insertIndex = j;
                         break;
                     }
                     
                 // New entity is greater than or equal to the last entity, insert last
                 if (insertIndex == -1)
                     insertIndex = newIndexArray.length - 1;
                     
                 // Recreate mIndexArray
                 newIndexArray[insertIndex] = remoteSelection.indexOf(event.getEntity());
                 System.arraycopy(mIndexArray, 0, newIndexArray, 0, insertIndex);
                 System.arraycopy(mIndexArray, insertIndex, newIndexArray, insertIndex + 1, mIndexArray.length - insertIndex);
                     
                 mIndexArray = newIndexArray;
             }
 
             super.entityAdded(event);
         }
         
         public void contentsChanged(SelectionEvent event)
         {
             sort();
             super.contentsChanged(event);
         }        
         
         // IEntityChangeListener implemntation ---------------------------------
         public void dataChanged(EntityChangeEvent event)
         {
             // Could be improved, resort is not allways necessary!       
             // Can we afford to resort for every data change?!!
             sort();
             super.dataChanged(event);
         }
         
         // IProxyListener implementation ---------------------------------------
         public void remoteChanged(ProxyEvent event)
         {
             sort();
             super.remoteChanged(event);
         }
     }
 }