package org.tinyjee.maven.dim.utils;
   
   import org.apache.maven.doxia.logging.Log;
   import org.tinyjee.maven.dim.spi.Globals;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Collection;
   import java.util.List;
  import java.util.regex.Pattern;
  
  /**
   * Implements an array list that allows sub-list selections via regular expressions and / or selectors.
   *
   * @author Juergen_Kellerer, 2011-10-09
   */
  public class SelectableArrayList<E> extends ArrayList<E> {
  
  	private static final long serialVersionUID = 7547555631109691023L;
  
  	/**
  	 * Defines a selector to be used when selecting a sub-list.
  	 *
  	 * @param <E> the type of element that the selector operates on.
  	 */
  	public interface Selector<E> {
  		boolean accept(E element);
  	}
  
  	public SelectableArrayList() {
  	}
  
  	public SelectableArrayList(int initialCapacity) {
  		super(initialCapacity);
  	}
  
  	public SelectableArrayList(Collection<? extends E> collection) {
  		super(collection);
  	}
  
  	@Override
  	@SuppressWarnings("unchecked")
  	public SelectableArrayList<E> clone() {
  		return (SelectableArrayList) super.clone();
  	}
  
  	/**
  	 * Selects a sub list of all elements that were matched by the given selector.
  	 *
  	 * @param selector the selector to use for matching the elements.
  	 * @return a sub list of matched elements.
  	 */
  	public SelectableArrayList<E> select(Selector<E> selector) {
  		// Using clone to copy the list to allow extending this class.
  		SelectableArrayList<E> clone = clone();
  
  		// Note: clear + add should be more effective on ArrayList than iterating and removing.
  		clone.clear();
  		for (E e : this) {
  			if (selector.accept(e)) clone.add(e);
  		}
  
  		if (clone.isEmpty() && !isEmpty()) {
  			Log log = Globals.getLog();
  			log.debug("No elements were matched when selecting from " + size() + " elements by selector: " + selector);
  		}
  
  		return clone;
  	}
  
  	/**
  	 * Selects all elements whose string representation matches the given regular expression.
  	 *
  	 * @param regularExpression the regular expression to match.
  	 * @return A sub list of all elements that match the given regular expression.
  	 */
  	public SelectableArrayList<E> selectMatching(String regularExpression) {
  		return select(createRegularExpressionSelector(regularExpression));
  	}
  
  	/**
  	 * Selects all elements whose string representation matches the one of given regular expressions.
  	 *
  	 * @param regularExpressions the regular expressions to match using OR.
  	 * @return A sub list of all elements that matches one of the given regular expressions.
  	 */
  	@SuppressWarnings("unchecked")
  	public SelectableArrayList<E> selectMatching(String... regularExpressions) {
  		List<Selector<E>> selectors = new ArrayList<Selector<E>>(regularExpressions.length);
  		for (String regularExpression : regularExpressions)
  			selectors.add(createRegularExpressionSelector(regularExpression));
  		return select(createOrSelector(selectors.toArray(new Selector[selectors.size()])));
  	}
  
  	/**
  	 * Selects all elements whose string representation does NOT match the given regular expression.
  	 *
  	 * @param regularExpression the regular expression to match.
  	 * @return A sub list of all elements that do NOT match the given regular expression.
 	 */
 	public SelectableArrayList<E> selectNonMatching(String regularExpression) {
 		return select(createInvertSelector(createRegularExpressionSelector(regularExpression)));
 	}
 
 	/**
 	 * Creates a selector that combines the given selectors with OR (accepts the element if one of the given selectors accepts it).
 	 *
 	 * @param selectors the selectors that match the actual content.
 	 * @return a selector that combines the given selectors with OR.
 	 */
 	public Selector<E> createOrSelector(final Selector<E>... selectors) {
 		return new Selector<E>() {
 			public boolean accept(E element) {
 				for (Selector<E> selector : selectors)
 					if (selector.accept(element)) return true;
 				return false;
 			}
 
 			@Override
 			public String toString() {
 				return "OrSelector{" +
 						"selectors=" + Arrays.toString(selectors) +
 						'}';
 			}
 		};
 	}
 
 	/**
 	 * Creates a selector that inverts the given selector.
 	 *
 	 * @param other the selector to invert.
 	 * @return a selector that inverts the given selector.
 	 */
 	public Selector<E> createInvertSelector(final Selector<E> other) {
 		return new Selector<E>() {
 			public boolean accept(E element) {
 				return !other.accept(element);
 			}
 
 			@Override
 			public String toString() {
 				return "InvertSelector{" +
 						"selector=" + other +
 						'}';
 			}
 		};
 	}
 
 	/**
 	 * Creates a selector that matches the given regular expression against the string representation of the element to select.
 	 *
 	 * @param regularExpression the regular expression to use for selecting.
 	 * @return a selector that matches the given regular expression against the string representation of the element to select.
 	 */
 	public Selector<E> createRegularExpressionSelector(final String regularExpression) {
 		return new Selector<E>() {
 			final Pattern pattern = Pattern.compile(regularExpression);
 
 			public boolean accept(E element) {
 				return pattern.matcher(String.valueOf(element)).matches();
 			}
 
 			@Override
 			public String toString() {
 				return "RegularExpressionSelector{" +
 						"pattern=" + pattern +
 						'}';
 			}
 		};
 	}
 }