/* (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.service;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Map;
  
  import org.caleigo.core.CompositeEntityDescriptor;
  import org.caleigo.core.DataQuery;
  import org.caleigo.core.EntityRelationPath;
  import org.caleigo.core.ICompositeEntityDescriptor;
  import org.caleigo.core.IEntityDescriptor;
  import org.caleigo.core.IEntityRelationPath;
  
  
  /*** Instances of this class is used to get as few uniq aliases as possible  
   * in a SQL SELECT statement's SELECT-, FROM-, JOIN- and WHERE-
   * expressions/clauses.
   *  
   * @author Niklas Norberg
   */
  public class SQLSelectCommand
  {
      //nno-todo Kommentera mera
      // Data members --------------------------------------------------------
      private StringBuffer mSQLCommand = new StringBuffer(2000);
      private String mRootAlias;
      private HashMap mUniqAliasMap = new HashMap();
      private HashMap mDeclaredAliasMap = new HashMap(); 
      private EntityRelationPathAliasTree mEntityRelationPathAliasTree = new EntityRelationPathAliasTree();
      
      // Access methods ------------------------------------------------------
      
      protected String getRootAlias(){
          return mRootAlias;
      }
      
      public String toString(){
          return mSQLCommand.toString();
      }
          
      private String getAvailabeAlias(String suggestedAlias)
      {
          for(;;)
          {
              if( mUniqAliasMap.containsKey(suggestedAlias) )
                  suggestedAlias = CompositeEntityDescriptor.increaseStringEndingWithNumber(suggestedAlias);
              else
                  break;
          }
          return suggestedAlias;
      }
      
      private boolean isAliasTaken(String alias)
      {
          if( mUniqAliasMap.containsKey(alias) )
              return true;
          else
              return false;
      }
      
      protected boolean isAliasDeclared(String alias)
      {
          if( mDeclaredAliasMap.containsKey(alias) )
              return true;
          else
              return false;
      }
      
          
      private void printUniqAliases()
      {
          Iterator it = mUniqAliasMap.keySet().iterator();
          while(it.hasNext())
              System.out.println(it.next());
      }
      
      /*** Get uniq aliases for a path.
       * 
      * @param entityRelationPath a path to get uniq aliases for.
      * @return a String-array containing uniq aliases for the path.
      */
     protected String[] getAliasArray(IEntityRelationPath entityRelationPath)
     {
         return mEntityRelationPathAliasTree.getAliasArray(entityRelationPath);
     }
         
     // Mutable methods -----------------------------------------------------
         
     protected void append(String str)
     {
         mSQLCommand.append(str);
     }
         
     protected void append(char c)
     {
         mSQLCommand.append(c);
     }
     
     protected void shortenCommandWith(int shortenThisMuch)
     {
         mSQLCommand.setLength(mSQLCommand.length()-shortenThisMuch);
     }
     
     protected void setRootAlias(String rootAlias){
         mRootAlias = rootAlias;
         this.markAliasAsUniq(rootAlias);
     }
         
     private void markAliasAsUniq(String uniqAlias)
     {
         if( !mUniqAliasMap.containsKey(uniqAlias) )
             mUniqAliasMap.put(uniqAlias, null);
         else
             throw new RuntimeException("The alias: "+uniqAlias+" isn't uniq!");
     }
     
     protected void markAliasAsDeclared(String declaredAlias)
     {
         if( !mDeclaredAliasMap.containsKey(declaredAlias) )
             mDeclaredAliasMap.put(declaredAlias, null);
         else
             throw new RuntimeException("The alias: "+declaredAlias+
                     "have already been declared once!");
     }
     
     /***
      * 
      * @param entityRelationPathMapForFieldGroups
      */
     private void addAndMakeUniqueAliasForPathsInMap(Map entityRelationPathMapForFieldGroups)
     {
         //Make a list sorted in size order, shortest first
         LinkedList entityRelationPathlist = new LinkedList();
         Iterator it = entityRelationPathMapForFieldGroups.keySet().iterator();
         //add the first one
         if(it.hasNext())
             entityRelationPathlist.add( (EntityRelationPath)it.next() );
         //add the rest if any
         while(it.hasNext())
         {
             IEntityRelationPath entityRelationPath = (IEntityRelationPath)it.next();
             
             for(int i=0;i<entityRelationPathlist.size();i++)
             {
                 if( entityRelationPath.getRelationCount() <= ((IEntityRelationPath)entityRelationPathlist.get(i)).getRelationCount() )
                 {
                     entityRelationPathlist.add(i, entityRelationPath);
                     break;
                 }
                 else if ( i == entityRelationPathlist.size()-1 )
                 {
                     //It's the for loop's last iteration-cycle let's just add it
                     entityRelationPathlist.add(entityRelationPath);
                     break;
                 }
             }
         }
         
 //        System.out.println("\n\n\n\n\n\n\n\n\n");
         // We must do this in length order to make sure that we always use alias
         // that were set manually
         ListIterator listIter = entityRelationPathlist.listIterator();
         while(listIter.hasNext())
         {
             IEntityRelationPath entityRelationPath = (IEntityRelationPath)listIter.next();
             String[] aliases = (String[])entityRelationPathMapForFieldGroups.get(entityRelationPath);
 //            for (int i = 0; i < aliases.length; i++)
 //                System.out.print(aliases[i]+"  -  ");
 //            System.out.println("\n\n");
             mEntityRelationPathAliasTree.makeUniqAliasForPath(entityRelationPath, aliases);
         }
     }
     
     
     /*** This method collects all entity relation path in a field group tree.
      * String-arrays are created and paired with every path.
      * Lastly every path are added to the internal member
      * mEntityRelationPathAliasTree and uniq alias are made for slave entities.
      * 
      * @param rootFieldGroup the root in the field group tree.
      */
     protected void collectAllEntityRelationPathsAndMakeUniqAliases(ICompositeEntityDescriptor.ICompositeFieldGroup rootFieldGroup)
     {
         HashMap entityRelationPathMapForFieldGroups = new HashMap();
         
         //The last parameter (the Map) gets filled with values.
         this.collectAllEntityRelationPaths(rootFieldGroup, null, new ArrayList(), entityRelationPathMapForFieldGroups);
         
         this.addAndMakeUniqueAliasForPathsInMap(entityRelationPathMapForFieldGroups);
         
 //        this.printAllPathsAndBelongingArray();//dbg-printing
           
     }
     
     /*** This method make recursive calls to itself and thereby collects paths
      * and alias lists in a field group tree.
      * 
      * @param parent root for a field group tree.
      * @param entityRelationPath the path to append to (appending is done to a
      * copy), (should be null for the root).
      * @param aliasList the list to append aliases to (appending is done to a
      * copy).
      * @param entityRelationPathMapForFieldGroups a Map with  entity relation
      * paths as keys and alias as values. The Map is changed by this method.
      */
     private void collectAllEntityRelationPaths(final ICompositeEntityDescriptor.ICompositeFieldGroup parent,
                                                 final EntityRelationPath entityRelationPath,
                                                 final List aliasList,
                                                 Map entityRelationPathMapForFieldGroups)
     {
         if (entityRelationPath !=null )
         {//It's not the root let's add path and it's belonging aliasList
             
             //put aliases in the map with the entity relation path as key
             entityRelationPathMapForFieldGroups.put(entityRelationPath, aliasList.toArray(new String[]{})); 
             
             //DEBUG OBS how we use the fact that a copy has the same hachcode!!!
             //EntityRelationPath entityRelationPath_COPY = new EntityRelationPath(entityRelationPath);
             //String[] stringArrayRetreived = (String[])entityRelationPathMapForFieldGroups.get(entityRelationPath_COPY);
             //System.out.println(stringArrayRetreived);
             //end-DEBUG
         }
         for(int j=0; j<parent.getChildFieldGroupCount(); j++)
         {
             ICompositeEntityDescriptor.ICompositeFieldGroup child = parent.getChildFieldGroup(j);
             EntityRelationPath entityRelationPath2Append2;
             //make a copy and append to this copy and send it further
             ArrayList aliasList2Append2 = new ArrayList(aliasList);
             if(entityRelationPath ==null)
             {
                 entityRelationPath2Append2 = new EntityRelationPath(child.getParentRelationPath());
                 aliasList2Append2.add(mRootAlias!=null?mRootAlias:parent.getEntityIdentity());
             }
             else
             {
                 //make a copy and append to this copy and send it further
                 entityRelationPath2Append2 = new EntityRelationPath(entityRelationPath);
                 entityRelationPath2Append2.appendRelationPath(new EntityRelationPath(child.getParentRelationPath()));
             }
             for (int i = 0; i < child.getParentRelationPath().getRelationCount()-1; i++)
                 aliasList2Append2.add(null);//null only temporarely
             
             // TRICKY make sure that supplied entity identities
             // ( i.e. when calling fgBuilder.beginFieldGroup(region_EntityDescriptor, "Region_1"); )
             // are used:
             if( child.getEntityIdentity() != child.getBaseEntityDescriptor().getCodeName() )
             {
                 this.markAliasAsUniq(child.getEntityIdentity());
                 aliasList2Append2.add(child.getEntityIdentity());
                 //To test code (at other place) that should make aliases for nulls
                 //disable the two above lines and uncomment the following line
                 //aliasList2Append2.add(null);//dbg
             }
             else
                 aliasList2Append2.add(null);//null only temporarely
             
             //make the recursive call
             this.collectAllEntityRelationPaths(child, entityRelationPath2Append2, aliasList2Append2, entityRelationPathMapForFieldGroups);
         }
     }
     
     
     
     
     
     /*** This method collects paths and alias lists in an external qualifer and
      * make uniq alias.
      * 
      * @param xTernalQualifiers the external qualifer to collect paths and alias
      * from. 
      */
     protected void collectAllEntityRelationPathsAndMakeUniqAliases(DataQuery.ExternalQualifier[] xTernalQualifiers)
     {
         HashMap entityRelationPathMapForXternalQualifiers = new HashMap();
         
         //The last parameter (the Map) gets filled with values.
         this.collectAllEntityRelationPaths(xTernalQualifiers, entityRelationPathMapForXternalQualifiers);
         
         this.addAndMakeUniqueAliasForPathsInMap(entityRelationPathMapForXternalQualifiers);
         
 //        this.printAllPathsAndBelongingArray();//dbg-printing
         
     }
     
     /*** This method collects paths and alias lists in an external qualifer.
      * 
      * @param xTernalQualifiers the external qualifer to collect paths and alias
      * from. 
      */    
     private void collectAllEntityRelationPaths(DataQuery.ExternalQualifier[] xTernalQualifiers, Map entityRelationPathMapForXternalQualifiers)
     {
         for (int i = 0; i < xTernalQualifiers.length; i++)
         {
             IEntityRelationPath path2Qualifer =  xTernalQualifiers[i].getEntityRelationPath();
             String[] aliases = new String[path2Qualifer.getRelationCount()+1];
             
             //set first alias in the alias array.
             IEntityDescriptor firstEntityDescriptorInPath = path2Qualifer.getFirstEntityDescriptor();
             if(firstEntityDescriptorInPath instanceof ICompositeEntityDescriptor)
             {
                 Iterator iter = path2Qualifer.getFirstFieldDescriptors();
                 //should have been validated so the first one should have the same field group as the rest so first one is as good as anyone.
                 firstEntityDescriptorInPath = ((ICompositeEntityDescriptor.ICompositeFieldDescriptor) iter.next()).getFieldGroup().getBaseEntityDescriptor();
                 
             }
             //Get an uniq alias:
             String uniqAlias = SQLSelectCommand.this.getAvailabeAlias(firstEntityDescriptorInPath.getCodeName());
             //then mark alias as uniq
             SQLSelectCommand.this.markAliasAsUniq(uniqAlias);
             //and use it!
             aliases[0] = uniqAlias;
             
             //set last alias in the alias array.
             aliases[aliases.length-1] = mRootAlias;
             
             //put aliases in the map with the entity relation path as key
             entityRelationPathMapForXternalQualifiers.put(path2Qualifer, aliases);
         }
     }
     
     
     
     
     
     
     
     
     
     
     /*** Debug-print method. */
     private void printAllPathsAndBelongingArray()
     {
         Map uniqAliasMap = mEntityRelationPathAliasTree.getUniqAliasMap();
         mEntityRelationPathAliasTree.printAllPathsAndBelongingArray(uniqAliasMap);
     }
     
     
     
     /*** Instances of this class should hold all possibly parts (subpaths) of
      * all entity relation paths that exist in an IEntityDescriptor-instance and
      * it's optional belonging DataQuery. EntityRelationPathAliasTree-objects
      * will represent all paths a tree of uniq aliases. It is used to make a
      * SQL-select-statement with as few as possible used uniq aliases.  
      * 
      * @author Niklas Norberg
      */
     private class EntityRelationPathAliasTree
     {
         private HashMap mEntityRelationPathMap_With_Uniq_Aliases = new HashMap();
         
         private Map getUniqAliasMap()
         {
             return mEntityRelationPathMap_With_Uniq_Aliases;
         }
         
         /*** Get uniq aliases for a path.
          * 
          * @param entityRelationPath a path to get uniq aliases for.
          * @return a String-array containing uniq aliases for the path.
          */
         private String[] getAliasArray(IEntityRelationPath entityRelationPath)
         {
             return (String[])mEntityRelationPathMap_With_Uniq_Aliases.get(entityRelationPath);
         }
         
         /*** Make uniq aliases for a path and ADDS the path and the aliases to the
          * Map.
          * 
          * @param path2MakeAliasFor the path to make aliases for.
          * @param aliasArray2AddAliases2 uniq aliases are added to this array.
          */
         private void makeUniqAliasForPath(IEntityRelationPath path2MakeAliasFor, String[] aliasArray2AddAliases2)
         {
             // Observe that as code is written startCopyAliasFromIndex
             // must and always are >= 1!
             int startCopyAliasFromIndex = 1;
             
             //Try to copy aliases from existing uniq arrays
             Iterator it = mEntityRelationPathMap_With_Uniq_Aliases.keySet().iterator();
             while(it.hasNext())
             {
                 IEntityRelationPath path2CopyAliasFrom = (IEntityRelationPath)it.next();
                 startCopyAliasFromIndex = this.copyAlias( path2MakeAliasFor, aliasArray2AddAliases2, path2CopyAliasFrom, startCopyAliasFromIndex);
                 if (startCopyAliasFromIndex==aliasArray2AddAliases2.length)
                     break;
             }
             
             //Make new aliases for the rest (if any) of the array
             if (startCopyAliasFromIndex<aliasArray2AddAliases2.length)
             {
                 // This variable (entityDescriptor2MakeAliasFor) is the
                 // IEntityDescriptor (along the path) that either already has an 
                 // uniq alias or shall get a new uniq alias:
                 IEntityDescriptor entityDescriptor2MakeAliasFor = path2MakeAliasFor.getFirstEntityDescriptor();
                 
                 //Walk path (iterate over entity descriptors) to the one that had the last set alias
                 for (int relationIndex = 0; relationIndex < startCopyAliasFromIndex-1; relationIndex++)
                     entityDescriptor2MakeAliasFor = path2MakeAliasFor.getRelation(relationIndex).getRelatedEntityDescriptor(entityDescriptor2MakeAliasFor);
                 
                 //Get and set aliases for the rest of the array
                 for (int aliasIndex = startCopyAliasFromIndex; aliasIndex < aliasArray2AddAliases2.length; aliasIndex++)
                 {//aliasIndex>=1
                     int relationIndex = aliasIndex-1;
                     entityDescriptor2MakeAliasFor = path2MakeAliasFor.getRelation(relationIndex).getRelatedEntityDescriptor(entityDescriptor2MakeAliasFor);
                     
                     if(aliasArray2AddAliases2[aliasIndex]!=null)
                     {//alias was set earlier
                         //check that alias is marked as occupied
                         if( !SQLSelectCommand.this.isAliasTaken(aliasArray2AddAliases2[aliasIndex]) )
                             throw new RuntimeException("The alias: "+
                                     aliasArray2AddAliases2[aliasIndex]+
                                     " should been marked uniq but isn't!");
                     }
                     else
                     {      
                         //Get an uniq alias:
                         String uniqAlias = SQLSelectCommand.this.getAvailabeAlias(entityDescriptor2MakeAliasFor.getCodeName());
                         //than mark alias as uniq
                         SQLSelectCommand.this.markAliasAsUniq(uniqAlias);
                         //and use it!
                         aliasArray2AddAliases2[aliasIndex] = uniqAlias;
                     }
                 }
             }
             
             //put the now complete alias array in the map
             mEntityRelationPathMap_With_Uniq_Aliases.put(path2MakeAliasFor, aliasArray2AddAliases2);
         }
         
         /*** Help method that is used to copy uniq alises.
          * It follows another path as long as the road is same and copy over
          * aliases. Copying are only made if needed, if aliases are set already
          * it checks that they are the same in both arrays!
          * 
          * @param path2MakeAliasFor path to make aliases for.
          * @param aliasArray2AddAliases2 alias array to copy uniq aliases to.
          * @param path2CopyAliasFrom path to follow.
          * @param startingFromIndex index to start copying from.
          * @return an int representing the index for the next alias to set,
          * if all aliases are done this integer will equal the length of the
          * parameter aliasArray2AddAliases2.
          */
         private int copyAlias(IEntityRelationPath path2MakeAliasFor,
                                 String[] aliasArray2AddAliases2,
                                 IEntityRelationPath path2CopyAliasFrom,
                                 int startCopyFromIndex)
         {
             if(startCopyFromIndex>path2CopyAliasFrom.getRelationCount()+1)
             {
                 // The path path2CopyAliasFrom ain't long enough.
                 return startCopyFromIndex;
             }
             
             String[] uniqAliases = this.getAliasArray(path2CopyAliasFrom);
             
             int pathIndex = 0;
             int aliasIndex = 1;
             
             while( aliasIndex < aliasArray2AddAliases2.length)
             {
                 if(pathIndex==path2CopyAliasFrom.getRelationCount())
                 {//We have followed the path: path2CopyAliasFrom beyond the end.
                     break;
                 }
                 
                 if( path2MakeAliasFor.getRelation(pathIndex) == path2CopyAliasFrom.getRelation(pathIndex) &&
                         path2MakeAliasFor.isRelationByReference(pathIndex) == path2CopyAliasFrom.isRelationByReference(pathIndex))
                 {//The paths follow the same road so far.
                     if(aliasIndex<startCopyFromIndex || aliasArray2AddAliases2[aliasIndex]!=null)
                     {
                         //DEBUG just double-check that alias is same!
                         if( !aliasArray2AddAliases2[aliasIndex].equals(uniqAliases[aliasIndex]) )
                             throw new RuntimeException("WHOOPS ALIAS SHOULD BE EQUAL FOR PATH'S FOLLOWING THE SAME PATH!");
                     }
                     else
                     {
                         //copy the alias-String only if the place to copy to is null
                         aliasArray2AddAliases2[aliasIndex] = uniqAliases[aliasIndex];
                     }
                     //We have checked/copied the alias let's get the next one!
                     pathIndex++;
                     aliasIndex++;
                     continue;//continue to follow path in path2CompareAliasWith
                 }
                 else
                 {//Paths take different ways from here on.
                     break;
                 }
             }
             
             return aliasIndex>startCopyFromIndex?aliasIndex:startCopyFromIndex;
         }
         
         /*** Debug-method that prints all IEntityRelationPaths and the beloning
          * String-array that are contained in the parameter entityRelationPathMap
          */
         private void printAllPathsAndBelongingArray(Map entityRelationPathMap)
         {
             Iterator it = entityRelationPathMap.keySet().iterator();
             if (it.hasNext())
             {
                 System.out.println("\n\n");
                 while(it.hasNext())
                 {
                     IEntityRelationPath key = (IEntityRelationPath)it.next();
                     System.out.println(key);
                     String[] aliases = (String[])entityRelationPathMap.get(key);
                     int i = 0;
                     while (i < aliases.length-1)
                         System.out.print(aliases[i++]+", ");
                     System.out.println(aliases[i]);
                 }
                 System.out.println("\n\n");
             }
         }  
         
     }
     
      
     
  }