package com.trendmicro.grid.acl.l0;
   
   import com.trendmicro.grid.acl.Limits;
   
   import java.io.Serializable;
   import java.util.*;
   
   import static com.trendmicro.grid.acl.Limits.MAX_INCOMING_REQUEST_BATCH_SIZE;
   import static net.sf.tinyjee.util.Assert.assertNotNull;
  
  /**
   * Defines a collection that fails if more than {@link Limits#MAX_INCOMING_REQUEST_BATCH_SIZE} elements are added.
   *
   * @author Juergen_Kellerer, 2011-02-22
   * @version 1.0
   */
  public class BatchCollection<E> extends AbstractCollection<E> implements Serializable {
  
  	private static final long serialVersionUID = 1600249921512556499L;
  
  	/**
  	 * Defines an invoker that may be used to handle chunks of batch collections.
  	 *
  	 * @param <E> The type of the input collection elements.
  	 * @param <R> The return type of the invocation.
  	 */
  	public interface Invoker<E, R> {
  		/**
  		 * Is called for every batch chunk that is handled within the method {@link #invokeOnChunksOf}
  		 *
  		 * @param chunk A chunk of elements that fit into one batch request.
  		 * @return The result of the invocation on the given chunk.
  		 * @throws WebException May be thrown when calling a service.
  		 */
  		public R invoke(BatchCollection<E> chunk) throws WebException;
  	}
  
  	/**
  	 * Creates a new final singleton batch collection using the given element.
  	 *
  	 * @param element the element to add.
  	 * @return a new singleton batch collection using the given element.
  	 */
  	public static <E> BatchCollection<E> of(E element) {
  		return new BatchCollection<E>(element);
  	}
  
  	/**
  	 * Creates a new final batch collection using the given elements.
  	 *
  	 * @param elements the elements to add.
  	 * @return a new batch collection using the given elements.
  	 * @throws BatchSizeExceededException If more elements than allowed are specified.
  	 */
  	public static <E> BatchCollection<E> of(E... elements) {
  		return of(Arrays.asList(elements));
  	}
  
  	/**
  	 * Creates a new final batch collection using the given elements.
  	 *
  	 * @param elements the elements to add.
  	 * @return a new batch collection using the given elements.
  	 * @throws BatchSizeExceededException If more elements than allowed are specified.
  	 */
  	public static <E> BatchCollection<E> of(Collection<? extends E> elements) {
  		return new BatchCollection<E>(elements);
  	}
  
  	/**
  	 * Creates chunks of batch collections that honor the built-in batch limit using the given elements.
  	 *
  	 * @param elements the elements to add (may be larger than the actual batch size).
  	 * @return chunks of batch collections using the given elements.
  	 */
  	public static <E> List<BatchCollection<E>> chunksOf(List<? extends E> elements) {
  		return chunksOf(elements, MAX_INCOMING_REQUEST_BATCH_SIZE);
  	}
  
  	/**
  	 * Creates chunks of batch collections that honor the given batch limit using the given elements.
  	 *
  	 * @param elements  the elements to add (may be larger than the actual batch size).
  	 * @param batchSize Sets a custom limit for the batch size of a chunk.
  	 * @return chunks of batch collections using the given elements.
  	 */
  	public static <E> List<BatchCollection<E>> chunksOf(List<? extends E> elements, int batchSize) {
  		final List<BatchCollection<E>> collections = new ArrayList<BatchCollection<E>>();
  		for (int i = 0, length = elements.size(); i < length; i += batchSize) {
  			List<? extends E> chunk = elements.subList(i, Math.min(i + batchSize, length));
  			collections.add(new BatchCollection<E>(chunk, batchSize));
  		}
  		return collections;
  	}
  
  	/**
  	 * Is a helper method that can be used to invoke a certain call on all batch chunks of a larger
  	 * input list.
  	 * <p/>
 	 * Using this method is safe with large lists even if the batch size is unknown as remote
 	 * exceptions are automatically caught and a request is retried with adjusted batch sizes.
 	 * <p/>
 	 * Example:<code><pre>
 	 * Collection&lt;FileIdentifier&gt; identifiers = ...
 	 * Collection&lt;FileDetails> details = BatchCollection.invokeOnChunksOf(identifiers,
 	 *   new BatchCollection.Invoker&lt;FileIdentifier, Collection&lt;FileDetails&gt;&gt;() {
 	 *     public Collection&lt;FileDetails&gt; invoke(BatchCollection&lt;FileIdentifier&gt; chunk) {
 	 *       return fileService.getFileDetailsList(BatchCollection.of(chunk));
 	 *	  }
 	 *   });</pre></code>
 	 *
 	 * @param elements The elements to convert to batch chunks.
 	 * @param invoker  The invoker implemented as anonymous inner class that walks all batch chunks
 	 *                 to produce a final result.
 	 * @param <E>      The type of the input collection elements.
 	 * @param <R>      The return type of collection or list elements.
 	 * @param <T>      The type of collection or list implementation that is returned by the invoked method.
 	 * @return The combined results of all single invocations.
 	 * @throws WebException May be thrown inside the invoker.
 	 */
 	@SuppressWarnings("unchecked")
 	public static <E, R, T extends Collection<R>> T invokeOnChunksOf(
 			Collection<? extends E> elements, Invoker<E, T> invoker) throws WebException {
 
 		T result = null;
 		final List<? extends E> listOfElements = elements instanceof List ?
 				(List<? extends E>) elements : new ArrayList<E>(elements);
 
 		while (true) {
 			try {
 				for (BatchCollection<E> currentChunk : chunksOf(listOfElements, defaultInvocationBatchSize)) {
 					Collection<R> r = invoker.invoke(currentChunk);
 					if (r != null) {
 						if (result == null)
 							result = (T) r;
 						else
 							result.addAll(r);
 					}
 				}
 				break;
 			} catch (BatchSizeExceededException e) {
 				defaultInvocationBatchSize = e.getAllowedBatchSize();
 			}
 		}
 
 		return result;
 	}
 
 	private static int defaultInvocationBatchSize = MAX_INCOMING_REQUEST_BATCH_SIZE;
 
 	/**
 	 * Returns the batch size that is used to build chunks within the method {@link #invokeOnChunksOf}.
 	 *
 	 * @return the batch size that is used to build chunks within the method {@link #invokeOnChunksOf}.
 	 */
 	public static int getDefaultInvocationBatchSize() {
 		return defaultInvocationBatchSize;
 	}
 
 	/**
 	 * Sets the batch size that is used to build chunks within the method {@link #invokeOnChunksOf}.
 	 *
 	 * @param defaultInvocationBatchSize the batch size that is used to build chunks
 	 *                                   within the method {@link #invokeOnChunksOf}.
 	 */
 	public static void setDefaultInvocationBatchSize(int defaultInvocationBatchSize) {
 		BatchCollection.defaultInvocationBatchSize = defaultInvocationBatchSize;
 	}
 
 	private int batchSize;
 	private Collection<E> backingStore;
 
 	/**
 	 * Creates a new modifiable instance.
 	 */
 	public BatchCollection() {
 		this(MAX_INCOMING_REQUEST_BATCH_SIZE);
 	}
 
 	/**
 	 * Creates a new modifiable instance with the given batch size limit.
 	 *
 	 * @param batchSize The non-default batch size limit to use.
 	 */
 	public BatchCollection(int batchSize) {
 		this.batchSize = batchSize;
 		backingStore = new LinkedList<E>();
 	}
 
 	BatchCollection(Collection<? extends E> elements) {
 		this(elements, MAX_INCOMING_REQUEST_BATCH_SIZE);
 	}
 
 	BatchCollection(Collection<? extends E> elements, int batchSize) {
 		assertNotNull("elements", elements);
 
 		this.batchSize = batchSize;
 		assertIsWithinLimit(elements.size());
 		backingStore = Collections.unmodifiableCollection(elements);
 	}
 
 	BatchCollection(E singleElement) {
 		assertNotNull("singleElement", singleElement);
 		backingStore = Collections.singleton(singleElement);
 	}
 
 	private void assertIsWithinLimit(int elementCountToAdd) {
 		int size = backingStore == null ? 0 : backingStore.size();
 		if (size + elementCountToAdd > batchSize)
 			throw new BatchSizeExceededException(batchSize);
 	}
 
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public boolean add(E e) {
 		assertIsWithinLimit(1);
 		return backingStore.add(e);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public boolean addAll(Collection<? extends E> c) {
 		assertIsWithinLimit(c.size());
 		return backingStore.addAll(c);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Iterator<E> iterator() {
 		return backingStore.iterator();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public int size() {
 		return backingStore.size();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public boolean isEmpty() {
 		return backingStore.isEmpty();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public boolean contains(Object o) {
 		return backingStore.contains(o);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Object[] toArray() {
 		return backingStore.toArray();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public <T> T[] toArray(T[] a) {
 		return backingStore.toArray(a);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public boolean containsAll(Collection<?> c) {
 		return backingStore.containsAll(c);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) return true;
 		if (o == null || getClass() != o.getClass()) return false;
 		BatchCollection that = (BatchCollection) o;
 		return backingStore.equals(that.backingStore);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public int hashCode() {
 		return backingStore.hashCode();
 	}
 }