package org.ocltf.concretesyntax.impl;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   import java.util.List;
   
   import org.apache.commons.lang.ObjectUtils;
   import org.apache.commons.lang.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.ocltf.concretesyntax.OperationCS;
  import org.ocltf.concretesyntax.VariableDeclarationCS;
  import org.ocltf.parser.node.AActualParameterList;
  import org.ocltf.parser.node.ACommaExpression;
  import org.ocltf.parser.node.AFeatureCall;
  import org.ocltf.parser.node.AFeatureCallParameters;
  import org.ocltf.parser.node.AOperation;
  import org.ocltf.parser.node.APropertyCallExpression;
  import org.ocltf.parser.node.ARelationalExpression;
  import org.ocltf.parser.node.ARelationalExpressionTail;
  import org.ocltf.parser.node.AStandardDeclarator;
  import org.ocltf.parser.node.ATypeDeclaration;
  import org.ocltf.parser.node.AVariableDeclaration;
  import org.ocltf.parser.node.AVariableDeclarationList;
  import org.ocltf.parser.node.AVariableDeclarationListTail;
  import org.ocltf.parser.node.PActualParameterList;
  import org.ocltf.parser.node.PEqualExpression;
  import org.ocltf.parser.node.POperation;
  import org.ocltf.parser.node.PRelationalExpression;
  import org.ocltf.parser.node.PVariableDeclaration;
  import org.ocltf.parser.node.PVariableDeclarationList;
  import org.ocltf.parser.node.TName;
  import org.ocltf.translation.TranslationUtils;
  import org.ocltf.utils.ExceptionUtils;
  
  /***
   * Contains some utilities for concrete syntax value retrieval.
   * 
   * @author Chad Brandon
   */
  public class ConcreteSyntaxUtils {
  	
  	private static final Log logger = LogFactory.getLog(ConcreteSyntaxUtils.class);
  
  	/***
  	 * Iterates through the passed in list and concates all
  	 * the values of objects toString value to a StringBuffer
  	 * and returns the StringBuffer.
  	 * 
  	 * @param list the List of objects to concatinate.
  	 * @return StringBuffer the concatinated contents of the list.
  	 */
  	public static StringBuffer concatContents(List list) {
  		StringBuffer name = new StringBuffer();
  		if (list != null) {
  			Iterator iterator = list.iterator();
  			while (iterator.hasNext()) {
  				String value = ObjectUtils.toString(iterator.next());
  				name.append(value);
  			}
  		}
  		return name;
  	}
  
  	/***
  	 * Retrieves all the variable declarations for the passed in operation.
  	 * 
  	 * @param operation
  	 * @return VariableDeclarations
  	 */
  	public static OperationCS getOperationDeclaration(POperation operation) {
  		String methodName = "getOperationDeclaration";
  		ExceptionUtils.checkNull(methodName, "operation", operation);
  		
  		OperationCS operationDeclaration = null;
  		
  		AOperation op = (AOperation)operation;		
  		
  		ATypeDeclaration typeDeclaration = (ATypeDeclaration)op.getReturnTypeDeclaration();
  		String returnType = null;
  		if (typeDeclaration != null) {
  			returnType = ObjectUtils.toString(typeDeclaration .getType());
  		}
  		
  		operationDeclaration =
  			new OperationDeclarationCSImpl(
  				ObjectUtils.toString(op.getName()),
  				returnType,
  				ConcreteSyntaxUtils.getVariableDeclarations(operation));
  				
  		if (logger.isDebugEnabled()) {
  			logger.debug("completed " + methodName + 
  				" with operationDeclaration --> " + operationDeclaration);
  		}
  			
  		return operationDeclaration;	
  	}
  	
 	/***
 	 * Retrieves all the variable declarations for the passed in 
 	 * <code>operation</code>.
 	 * 
 	 * @param operation the operation for which to retrieve the variable declarations.
 	 * @return VariableDeclaration[] 
 	 */
 	public static VariableDeclarationCS[] getVariableDeclarations(POperation operation) {
 		String methodName = "getVariableDeclarations";
 		ExceptionUtils.checkNull(methodName, "operation", operation);
 		return ConcreteSyntaxUtils.getVariableDeclarations(
 			((AOperation)operation).getParameters());
 	}
 	
 	/***
 	 * Retrieves all the variable declarations for the passed in 
 	 * <code>standardDeclarator</code>.
 	 * 
 	 * @param standardDeclarator the standard declartor for which to retrieve the
 	 *        VariableDeclarationCS instances.
 	 * @return VariableDeclarationCS[]
 	 */
 	public static VariableDeclarationCS[] getVariableDeclarations(AStandardDeclarator standardDeclarator) {
 		String methodName = "getVariableDeclarations";
 		ExceptionUtils.checkNull(methodName, "standardDeclarator", standardDeclarator);
 		return ConcreteSyntaxUtils.getVariableDeclarations(
 				standardDeclarator.getVariableDeclarationList());
 	}
 	
 	/***
 	 * Creates a new VariableDeclarationCS from the passed in PVariableDeclaration.
 	 * @param variableDeclaration the PVariableDeclaration that the new VariableDeclarationCS
 	 *        will be created from.
 	 * @param initialValue the initial value of the variable declaration.
 	 * @return VariableDeclarationCS the new VariableDeclarationCS
 	 */
 	protected static VariableDeclarationCS newVariableDeclaration(
 		PVariableDeclaration variableDeclaration,
 		PEqualExpression initialValue) {
 		String methodName = "newVariableDeclaration";
 		ExceptionUtils.checkNull(methodName, "variableDeclaration", variableDeclaration);
 		
 		AVariableDeclaration declaration = (AVariableDeclaration)variableDeclaration;
 		ATypeDeclaration typeDeclaration = (ATypeDeclaration )declaration.getTypeDeclaration();
 		String type = null;
 		String name = ObjectUtils.toString(declaration.getName()).trim();
 		if (typeDeclaration != null) {
 			type = ObjectUtils.toString(typeDeclaration.getType());
 		}
 		return new VariableDeclarationCSImpl(name, type, ObjectUtils.toString(initialValue).trim());
 	}
 	
 	/***
 	 * Creates an array of VariableDeclarationCS[] from the passed in PVariableDeclarationList.
 	 * @param variableDeclarationList the PVariableDeclarationList that the new VariableDeclarationCS
 	 *        will be created from.
 	 * @return VariableDeclarationCS[] the new VariableDeclarationCS array
 	 */
 	public static VariableDeclarationCS[] getVariableDeclarations(
 		PVariableDeclarationList variableDeclarationList) {
 		
 		Collection declarations = new ArrayList();
 		
 		if (variableDeclarationList != null) {
 			AVariableDeclarationList variables = 
 				(AVariableDeclarationList)variableDeclarationList;
 			
 			if (variables != null) {
 				//add the first one
 				declarations.add(
 					ConcreteSyntaxUtils.newVariableDeclaration(
 							variables.getVariableDeclaration(), variables.getVariableDeclarationValue()));
 				
 				//add the rest
 				List variableTails = variables.getVariableDeclarationListTail();
 				if (variableTails != null) {
 					Iterator variableTailIt = variableTails.iterator();
 					while (variableTailIt.hasNext()) {
 						AVariableDeclarationListTail tail = 
 							(AVariableDeclarationListTail)variableTailIt.next();
 						declarations.add(
 							ConcreteSyntaxUtils.newVariableDeclaration(
 								tail.getVariableDeclaration(), tail.getVariableDeclarationValue()));
 					}
 				}	
 			}
 		}
 		return (VariableDeclarationCS[])declarations.toArray(new VariableDeclarationCS[0]);	
 	}	
 	
 	/***
 	 * Gets all the parameters from a AFeatureCall instance.
 	 * 
 	 * @param featureCall the featureCall for which to retrieve the parameters
 	 * @return List the list containing any parameters retrieved, or
      *         an empty array if none could be retrieved
 	 */
 	public static List getParameters(AFeatureCall featureCall) {
         List parameters = new ArrayList();
         if (featureCall != null) {
              AFeatureCallParameters callParameters = 
                  (AFeatureCallParameters)
                      featureCall.getFeatureCallParameters();
             if (callParameters != null) {
             	PActualParameterList parameterList = 
                     callParameters.getActualParameterList();
         		if (parameterList != null) {
         			AActualParameterList params = (AActualParameterList)parameterList;
         			
         			//add the first param if it exists
         			String firstParam = TranslationUtils.trimToEmpty(params.getExpression());
         			if (StringUtils.isNotEmpty(firstParam)) {
         				parameters.add(firstParam);
         			}
         		
         			//now add the rest of the params which are contained in the tail
         			List restOfParams = params.getCommaExpression();
         			if (restOfParams != null && !restOfParams.isEmpty()) {
         				Iterator paramIt = restOfParams.iterator();
         				while (paramIt.hasNext()) {
         					ACommaExpression parameterListTail = 
         						(ACommaExpression)paramIt.next();
         					parameters.add(
                                     TranslationUtils.trimToEmpty(
         						        parameterListTail.getExpression()));
         				}
         			}
         		}
             }
         }
 		return parameters;
 	}
     
     /***
      * Gets all the parameters from a AFeatureCall instance as a comma
      * seperated String.
      * 
      * @param featureCall the featureCall for which to retrieve the parameters
      * @return String the comma seperated String
      */
     public static String getParametersAsString(AFeatureCall featureCall) {
         return StringUtils.join(
                 ConcreteSyntaxUtils.getParameters(
                     featureCall).iterator(), ",");
     }
 	
 	/***
 	 * Gets the left and right expressions of a PRelationalExpression 
 	 * and puts then into a List.  The left expression will be the first
 	 * expression in the list.
 	 * @param relationalExpression
 	 * @return the left and right paranthesis in [0] and [1] of the String[]/
 	 */
 	public static String[] getLeftAndRightExpressions(PRelationalExpression relationalExpression) {
 		String[] expressions = new String[2];
 		ARelationalExpression expression = (ARelationalExpression)relationalExpression;
 		
 		//set the left expression
 		expressions[0] = TranslationUtils.trimToEmpty(expression.getAdditiveExpression());
 		
 		ARelationalExpressionTail expressionTail = 
 			(ARelationalExpressionTail)expression.getRelationalExpressionTail();
 		
 		//set the right expression
 		expressions[1] = TranslationUtils.trimToEmpty(expressionTail.getAdditiveExpression());
 		
 		return expressions;
 	}
 	
 	/***
 	 * Concatinates the type from the passed in name and pathNameTail.
 	 * @param name the starting name of the type
 	 * @param pathNameTail the tail pieces of the name
 	 * @return String the concatinated name.
 	 */
 	public static String getType(TName name, List pathNameTail) {
 		StringBuffer type = 
 			ConcreteSyntaxUtils.concatContents(pathNameTail);
 		type.insert(0, TranslationUtils.trimToEmpty(name));	
 		return StringUtils.deleteWhitespace(type.toString());	
 	}
 	
     /***
      * Gets the "real" primary expression, as opposed to the primary expression
      * retrieved from the parser syntax (since it leaves off any navigational
      * relationships). 
      * 
      * @param expression the APosfixExpression instance for which to retrieve 
      *        the primary expression
      * 
      * @return String the "real" primary expression or the passed in expression.
      */
     public static String getPrimaryExpression(APropertyCallExpression expression) {
         String methodName = "getPrimaryExpression";
         if (logger.isDebugEnabled()) {
         	logger.debug("performing " + methodName + 
                 " with expression --> '" + expression + "'");
         }    
     	StringBuffer primaryExpression = new StringBuffer();
     	if (expression != null) {
             //append the first part of the primary expression
             primaryExpression.append(
     	        TranslationUtils.trimToEmpty(expression.getPrimaryExpression()));
                 
             List expressionTail = new ArrayList(expression.getPropertyCallExpressionTail());
             if (expressionTail.size() > 1) {
             	//if it its greater than one, we assume the rest of the primary expression
                 //is all of the list elements except for the last, so we'll remove
                 //the last link and concatinate them together to add the rest of 
                 //the primary expression
             	expressionTail.remove(expressionTail.size() - 1);
                 primaryExpression.append(ConcreteSyntaxUtils.concatContents(expressionTail));
             }
             
             if (logger.isDebugEnabled()) {
                 logger.debug("completed " + methodName + " with primaryExpression --> '"
                     + primaryExpression + "'");
             }
         }
         return StringUtils.deleteWhitespace(primaryExpression.toString());
     }
     
     /***
      * Gets all feature calls from the passed in APropertyCallExpression instance.
      * 
      * @param expression the APosfixExpression instance for which to retrieve 
      *        the primary expression
      * 
      * @return String the "real" primary expression or the passed in expression.
      */
     public static List getFeatureCalls(APropertyCallExpression expression) {
         String methodName = "getFeatureCalls";
         if (logger.isDebugEnabled()) {
             logger.debug("performing " + methodName + 
                 " with expression --> '" + expression + "'");
         }    
         List featureCalls = new ArrayList();
         if (expression != null) {
         	List tails = expression.getPropertyCallExpressionTail();
             if (tails != null && !tails.isEmpty()) {
             	for (int ctr = 0; ctr < tails.size(); ctr++) {
                     featureCalls.add(
                         TranslationUtils.getProperty(tails.get(ctr), 
                     	"featureCall"));
                 }
             }
         }
         return featureCalls;
     }
     
 
     /***
      * Loads a List of variable declaration names from the
      * <code>variableDeclarations</code>
      * 
      * @param variableDeclarations an array of VariableDeclarationCS objects
      * @return List the list of argument names as Strings/
      */
     public static List getArgumentNames(VariableDeclarationCS[] variableDeclarations) {
         List names = new ArrayList();
         for (int ctr = 0; ctr < variableDeclarations.length; ctr++) {
             names.add(variableDeclarations[ctr].getName());
         }
         return names;
     }
 
 
 }