package com.trendmicro.grid.acl.ds;
   
   import com.trendmicro.grid.acl.l0.datatypes.Tagged;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.List;
   
  /**
   * Implements a OO layout to hold parsed tag queries.
   *
   * @author juergen_kellerer, 2010-05-07
   * @version 1.0
   */
  public abstract class TagQueryExpression {
  
  	private static final TagQueryExpression[] EMPTY_ARRAY = new TagQueryExpression[0];
  
  	/**
  	 * Returns true if the tag should be excluded.
  	 *
  	 * @return true if the tag should be excluded.
  	 */
  	public abstract boolean isNegated();
  
  	/**
  	 * Returns true if the expression is a collection of child expressions.
  	 *
  	 * @return true if the expression is a collection of child expressions.
  	 */
  	public abstract boolean isExpression();
  
  	/**
  	 * Returns the tag of of this expression, or an empty string if this
  	 * expression is a collection of child expressions.
  	 *
  	 * @return the tag of of this expression, or an empty string if this
  	 *         expression is a collection of child expressions.
  	 */
  	public abstract String getTag();
  
  	/**
  	 * Returns child expressions.
  	 *
  	 * @return child expressions.
  	 */
  	public abstract TagQueryExpression[] getExpression();
  
  	/**
  	 * Returns true if the given element matches this expression.
  	 *
  	 * @param taggedElement the tagged element to check.
  	 * @return true if the given element matches this expression.
  	 */
  	public abstract boolean matches(Tagged taggedElement);
  
  
  	/**
  	 * Normalizes a given tag query to a list of groups that get combined using OR.
  	 *
  	 * @param expression the given expression to convert.
  	 * @return a list of 1 or more entries.
  	 */
  	public static List<TagQueryExpression> splitIntoORList(TagQueryExpression expression) {
  		List<TagQueryExpression> list = new ArrayList<TagQueryExpression>();
  		if (expression.isExpression()) {
  			TagQueryExpression[] expressions = expression.getExpression();
  			if (expressions.length != 0) {
  				if (expressions[0].isExpression())
  					list.addAll(Arrays.asList(expressions));
  				else
  					list.add(expression);
  			}
  		} else
  			list.add(TagQueryExpression.create(Collections.singletonList(expression)));
  
  		return list;
  	}
  
  	/**
  	 * Parses the given expression.
  	 *
  	 * @param expression		the expression to parse.
  	 * @param expressionVersion the expression version to use. (may be set to 'null')
  	 * @return the parsed expression.
  	 */
  	public static TagQueryExpression parse(String expression, String expressionVersion) {
  		return TagQueryExpressionBuilder.getBuilder(expression).parse(expression);
  	}
  
  	/**
  	 * Parses the given expression and splits it into an OR list.
  	 *
  	 * @param expression		the expression to parse.
  	 * @param expressionVersion the expression version to use. (may be set to 'null')
  	 * @return the parsed and split expression.
  	 */
  	public static List<TagQueryExpression> parseAndSplit(String expression, String expressionVersion) {
 		return splitIntoORList(parse(expression, expressionVersion));
 	}
 
 	/**
 	 * Creates a new expression for the given single tag.
 	 *
 	 * @param tag the tag to create the expression for, may be prefixed with '-'.
 	 * @return a new expression for the given single tag.
 	 */
 	public static TagQueryExpression create(final String tag) {
 		return new TagQueryExpression() {
 
 			final boolean negated = tag.startsWith("-");
 			final String tagValue = (negated ? tag.substring(1) : tag).toLowerCase();
 
 			@Override
 			public boolean isNegated() {
 				return negated;
 			}
 
 			@Override
 			public boolean isExpression() {
 				return false;
 			}
 
 			@Override
 			public String getTag() {
 				return tagValue;
 			}
 
 			@Override
 			public boolean matches(Tagged taggedElement) {
 				return taggedElement.containsTag(tag) || negated;
 			}
 
 			@Override
 			public TagQueryExpression[] getExpression() {
 				return EMPTY_ARRAY;
 			}
 
 			@Override
 			public String toString() {
 				return (isNegated() ? " -" : " ") + tagValue;
 			}
 		};
 	}
 
 	/**
 	 * Creates a new expression for the given list of child expressions.
 	 *
 	 * @param expressions the expressions to wrap.
 	 * @return a new expression for the given list of child expressions.
 	 */
 	public static TagQueryExpression create(final List<TagQueryExpression> expressions) {
 		return new TagQueryExpression() {
 
 			final TagQueryExpression[] tagExpressions =
 					expressions.toArray(new TagQueryExpression[expressions.size()]);
 
 			@Override
 			public boolean isNegated() {
 				return false;
 			}
 
 			@Override
 			public boolean isExpression() {
 				return true;
 			}
 
 			@Override
 			public String getTag() {
 				return "";
 			}
 
 			@Override
 			public boolean matches(Tagged taggedElement) {
 				for (TagQueryExpression expression : tagExpressions) {
 					if (!expression.matches(taggedElement))
 						return false;
 				}
 				return true;
 			}
 
 			@Override
 			public TagQueryExpression[] getExpression() {
 				return tagExpressions;
 			}
 
 			@Override
 			public String toString() {
 				return "TagQuery{" +
 						"expression=" + (tagExpressions == null ? null : Arrays.asList(tagExpressions)) +
 						'}';
 			}
 		};
 	}
 }