package org.andromda.translation.ocl.query;
   
   import java.util.Iterator;
   import java.util.List;
   import org.andromda.core.translation.TranslationUtils;
   import org.andromda.translation.ocl.BaseTranslator;
   import org.andromda.translation.ocl.node.AFeatureCall;
   import org.andromda.translation.ocl.node.ALogicalExpressionTail;
   import org.andromda.translation.ocl.node.AParenthesesPrimaryExpression;
  import org.andromda.translation.ocl.node.APropertyCallExpression;
  import org.andromda.translation.ocl.node.ARelationalExpressionTail;
  import org.andromda.translation.ocl.node.AStandardDeclarator;
  import org.andromda.translation.ocl.node.PRelationalExpression;
  import org.andromda.translation.ocl.syntax.ConcreteSyntaxUtils;
  import org.apache.commons.lang.StringUtils;
  
  /**
   * Performs translation to the following: <ul> <li>Hibernate-QL</li> </ul>
   *
   * @author Chad Brandon
   */
  public class QueryTranslator
          extends BaseTranslator
  {
      /**
       * Contains the select clause of the query.
       */
      private StringBuffer selectClause;
  
      /**
       * Called by super class to reset any objects.
       */
      public void preProcess()
      {
          super.preProcess();
          this.selectClause = new StringBuffer();
          this.sortedByClause = new StringBuffer();
          this.declaratorCtr = 0;
      }
  
      /**
       * Stores the name of the initial declarator.
       */
      private short declaratorCtr;
  
      /**
       * True/false whether or not its the initial declarator. We care about this because we must know what the first one
       * is for differentiating between the first declarator (the beginning of the query) and any other declarators (the
       * connecting associations).
       * @return isInitialDeclarator
       */
      protected boolean isInitialDeclarator()
      {
          boolean isInitialDeclarator = (this.declaratorCtr <= 0);
          this.declaratorCtr++;
          return isInitialDeclarator;
      }
  
      /**
       * Helps out with 'includesAll', replaces the {1} in the expression fragment when a declarator is encountered (i.e.
       * '| <variable name>')
       * @param declarator
       */
      public void inAStandardDeclarator(AStandardDeclarator declarator)
      {
          final String methodName = "QueryTranslator.inAStandardDeclarator";
          if (logger.isDebugEnabled())
              logger.debug("performing " + methodName + " with declarator --> " + declarator);
  
          String temp = this.selectClause.toString();
  
          String declaratorName = ConcreteSyntaxUtils.getVariableDeclarations(declarator)[0].getName();
  
          // by default we'll assume we're replacing the {1} arg.
          short replacement = 1;
          if (this.isInitialDeclarator())
          {
              // handle differently if its the initial declarator,
              // replacement is {0}
              replacement = 0;
          }
  
          // now replace {1} reference
          temp = TranslationUtils.replacePattern(temp, String.valueOf(replacement), declaratorName);
          this.selectClause = new StringBuffer(temp);
      }
  
      /**
       * Override to handle any propertyCall expressions ( i.e. includes( <expression>), select( <expression>), etc.)
       * @param expression
       * @see BaseTranslator#handleTranslationFragment(Object)
       */
      public void inAPropertyCallExpression(APropertyCallExpression expression)
      {
          this.handleTranslationFragment(expression);
      }
  
      /**
       * Override to handle any featureCall expressions ( i.e. sortedBy( <expression>), etc.)
      * @param expression
      * @see BaseTranslator#handleTranslationFragment(Object)
      */
     public void inAFeatureCall(AFeatureCall expression)
     {
         // don't handle all instances here, since it's handled
         // in the property call expression.
         if (!TranslationUtils.trimToEmpty(expression).matches(OCLPatterns.ALL_INSTANCES))
         {
             this.handleTranslationFragment(expression);
         }
     }
 
     /**
      * Override to deal with logical 'and, 'or', 'xor, ... expressions.
      * @param logicalExpressionTail
      * @see BaseTranslator#handleTranslationFragment(Object)
      */
     public void inALogicalExpressionTail(ALogicalExpressionTail logicalExpressionTail)
     {
         this.handleTranslationFragment(logicalExpressionTail);
     }
 
     /**
      * Override to deal with relational ' <, '>', '=', ... expressions.
      * @param relationalExpressionTail
      * @see BaseTranslator#handleTranslationFragment(Object)
      */
     public void inARelationalExpressionTail(ARelationalExpressionTail relationalExpressionTail)
     {
         this.handleTranslationFragment(relationalExpressionTail);
     }
 
     /**
      * Override to deal with entering parenthesis expressions '( <expression>)'.
      * @param expression
      * @see org.andromda.core.translation.Expression#appendToTranslatedExpression(Object)
      */
     public void inAParenthesesPrimaryExpression(AParenthesesPrimaryExpression expression)
     {
         this.getExpression().appendSpaceToTranslatedExpression();
         this.getExpression().appendToTranslatedExpression("(");
     }
 
     /**
      * Override to deal with leaving parenthesis expressions '( <expression>)'.
      * @param expression
      * @see org.andromda.core.translation.Expression#appendToTranslatedExpression(Object)
      */
     public void outAParenthesesPrimaryExpression(AParenthesesPrimaryExpression expression)
     {
         this.getExpression().appendSpaceToTranslatedExpression();
         this.getExpression().appendToTranslatedExpression(")");
     }
 
     /**
      * Checks to see if the replacement is an argument and if so replaces the {index} in the fragment with the
      * 'argument' fragment from the template. Otherwise replaces the {index} with the passed in replacement value.
      *
      * @param fragment    the fragment to perform replacement.
      * @param replacement the replacement string
      * @param index       the index in the string to replace.
      * @return String the fragment with any replacements.
      */
     protected String replaceFragment(String fragment, String replacement, int index)
     {
         fragment = StringUtils.trimToEmpty(fragment);
         replacement = StringUtils.trimToEmpty(replacement);
         // if 'replacement' is an argument use that for the replacement
         // in the fragment
         if (this.isOperationArgument(replacement))
         {
             final String argument = replacement;
             replacement = this.getTranslationFragment("argument");
             replacement = TranslationUtils.replacePattern(replacement, String.valueOf(0), argument);
         }
         fragment = TranslationUtils.replacePattern(fragment, String.valueOf(index), replacement);
         return fragment;
     }
 
     /**
      * Stores the name of the fragment that maps the tail of the select clause.
      */
     private static final String SELECT_CLAUSE_TAIL = "selectClauseTail";
 
     /**
      * Stores the name of the fragment that maps to the head of the sortedBy clause.
      */
     private static final String SORTED_BY_CLAUSE_HEAD = "sortedByClauseHead";
 
     /**
      * Handles any final processing.
      */
     @Override
     public void postProcess()
     {
         // create the final translated expression
         String selectClauseTail = this.getTranslationFragment(SELECT_CLAUSE_TAIL);
         String existingExpression = StringUtils.trimToEmpty(this.getExpression().getTranslatedExpression());
 
         if (StringUtils.isNotBlank(selectClauseTail) && StringUtils.isNotBlank(existingExpression))
         {
             this.selectClause.append(' ');
             this.selectClause.append(selectClauseTail);
             this.selectClause.append(' ');
         }
 
         this.getExpression().insertInTranslatedExpression(0, selectClause.toString());
 
         if (this.sortedByClause.length() > 0)
         {
             this.getExpression().appendSpaceToTranslatedExpression();
             this.getExpression().appendToTranslatedExpression(this.getTranslationFragment(SORTED_BY_CLAUSE_HEAD));
             this.getExpression().appendSpaceToTranslatedExpression();
             this.getExpression().appendToTranslatedExpression(this.sortedByClause);
         }
 
         // remove any extra space from parenthesis
         this.getExpression().replaceInTranslatedExpression("\\(\\s*", "(");
         this.getExpression().replaceInTranslatedExpression("\\s*\\)", ")");
     }
 
     /*------------------------- Handler methods ---------------------------------------*/
 
     /*------------------------- PropertyCallExpression Handler methods ---------------------*/
 
     /**
      * @param translation
      * @param node
      */
     public void handleSubSelect(String translation, Object node)
     {
         APropertyCallExpression propertyCallExpression = (APropertyCallExpression) node;
 
         String primaryExpression = ConcreteSyntaxUtils.getPrimaryExpression(propertyCallExpression);
 
         // set the association which the 'includesAll' indicates (which
         // is the first feature call from the list of feature calls)
         translation = this.replaceFragment(translation, TranslationUtils.trimToEmpty(primaryExpression), 0);
 
         this.selectClause.append(' ');
         this.selectClause.append(translation);
     }
 
     /**
      * @param translation
      * @param node
      */
     public void handleIsLike(String translation, Object node)
     {
         APropertyCallExpression propertyCallExpression = (APropertyCallExpression) node;
         List featureCalls = ConcreteSyntaxUtils.getFeatureCalls(propertyCallExpression);
 
         List params = ConcreteSyntaxUtils.getParameters((AFeatureCall) featureCalls.get(0));
 
         translation = this.replaceFragment(translation, TranslationUtils.deleteWhitespace(params.get(0)), 0);
         translation = this.replaceFragment(translation, TranslationUtils.deleteWhitespace(params.get(1)), 1);
 
         if (StringUtils.isNotBlank(this.getExpression().getTranslatedExpression()))
         {
             this.getExpression().appendSpaceToTranslatedExpression();
         }
         this.getExpression().appendToTranslatedExpression(translation);
     }
 
     /**
      * @param translation
      * @param node
      */
     public void handleSelect(String translation, Object node)
     {
         this.selectClause.append(translation);
     }
 
     /**
      * @param translation
      * @param node
      */
     public void handleIncludes(String translation, Object node)
     {
         APropertyCallExpression propertyCallExpression = (APropertyCallExpression) node;
         List featureCalls = ConcreteSyntaxUtils.getFeatureCalls(propertyCallExpression);
 
         // since the parameters can only be either dotFeatureCall or
         // arrowFeatureCall we try one or the other.
         String parameters = StringUtils.deleteWhitespace(ConcreteSyntaxUtils.getParametersAsString(
                 (AFeatureCall) featureCalls.get(0)));
 
         String primaryExpression = ConcreteSyntaxUtils.getPrimaryExpression(propertyCallExpression);
 
         translation = this.replaceFragment(translation, primaryExpression, 1);
         translation = this.replaceFragment(translation, parameters, 0);
 
         this.getExpression().appendSpaceToTranslatedExpression();
         this.getExpression().appendToTranslatedExpression(translation);
     }
 
     /**
      * @param translation
      * @param node
      */
     public void handleDotOperation(String translation, Object node)
     {
         APropertyCallExpression propertyCallExpression = (APropertyCallExpression) node;
         String firstArgument = ConcreteSyntaxUtils.getPrimaryExpression(propertyCallExpression);
         translation = this.replaceFragment(translation, firstArgument, 0);
         List featureCalls = ConcreteSyntaxUtils.getFeatureCalls(propertyCallExpression);
         if (featureCalls != null && !featureCalls.isEmpty())
         {
             // here we loop through the feature calls and find the ones
             // that are operation feature calls, we then retrieve and replace
             // all parameters in the translated expression
             for (final Iterator callIterator = featureCalls.iterator(); callIterator.hasNext();)
             {
                 AFeatureCall featureCall = (AFeatureCall) callIterator.next();
 
                 if (TranslationUtils.trimToEmpty(featureCall).matches(OCLPatterns.OPERATION_FEATURE_CALL))
                 {
                     List parameters = ConcreteSyntaxUtils.getParameters(featureCall);
                     if (parameters != null && !parameters.isEmpty())
                     {
                         Iterator parameterIterator = parameters.iterator();
                         for (int ctr = 1; parameterIterator.hasNext(); ctr++)
                         {
                             translation = this.replaceFragment(translation, (String) parameterIterator.next(), ctr);
                         }
                     }
                     break;
                 }
             }
         }
         this.getExpression().appendSpaceToTranslatedExpression();
         this.getExpression().appendToTranslatedExpression(translation);
     }
 
     private StringBuffer sortedByClause;
 
     /**
      * @param translation
      * @param node
      */
     public void handleSortedBy(String translation, Object node)
     {
         if (this.sortedByClause.length() > 0)
         {
             this.sortedByClause.append(", ");
         }
         this.sortedByClause.append(TranslationUtils.deleteWhitespace(ConcreteSyntaxUtils.getParametersAsString(
                 (AFeatureCall) node)));
     }
 
     /*------------------------- Logical Expression Handler (and, or, xor, etc.) ----------------------*/
 
     /**
      * @param translation
      * @param node
      */
     public void handleLogicalExpression(String translation, Object node)
     {
         this.getExpression().appendSpaceToTranslatedExpression();
         this.getExpression().appendToTranslatedExpression(translation);
     }
 
     /*------------------------- Relational Expression Handler (=, <, >, >=, etc.) --------------------*/
 
     /**
      * @param translation
      * @param node
      */
     public void handleRelationalExpression(String translation, Object node)
     {
         ARelationalExpressionTail relationalExpressionTail = (ARelationalExpressionTail) node;
 
         String[] leftAndRightExpressions = ConcreteSyntaxUtils.getLeftAndRightExpressions(
                 (PRelationalExpression) relationalExpressionTail.parent());
         String leftExpression = StringUtils.deleteWhitespace(leftAndRightExpressions[0]);
         String rightExpression = StringUtils.deleteWhitespace(leftAndRightExpressions[1]);
         if (leftExpression.matches(OCLPatterns.OPERATION_FEATURE_CALL))
         {
             leftExpression = "";
         }
         translation = this.replaceFragment(translation, leftExpression, 0);
         if (rightExpression.matches(OCLPatterns.OPERATION_FEATURE_CALL))
         {
             rightExpression = "";
         }
         translation = this.replaceFragment(translation, rightExpression, 1);
 
         this.getExpression().appendSpaceToTranslatedExpression();
         this.getExpression().appendToTranslatedExpression(translation);
     }
 }