package fr.moresmau.jp.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import fr.moresmau.jp.func.Mapper;

/**
 * an infinite list. You only have to provide the getNext() method. The data is stored in an ArrayList.
 * @author JP Moresmau
 *
 * @param <E>
 */
public abstract class InfiniteList<E> implements Iterable<E> {
	/**
	 * the underlying list
	 */
	private ArrayList<E> data=new ArrayList<E>();
		
	/**
	 * default constructor
	 */
	public InfiniteList(){
		// NOOP
	}
	
	/**
	 * constructor precalculating some values
	 * @param precalculate the numbers of values to precalculate
	 */
	public InfiniteList(int precalculate){
		ensureCalculated(precalculate-1);
	}
	
	/**
	 * @return the underlying array list
	 */
	protected ArrayList<E> getData(){
		return data;
	}
	
	/**
	 * @return the next element in the list
	 */
	protected abstract E getNext();
	
	/**
	 * calculates the next element
	 */
	private void calculateNext(){
		E next=getNext();
		data.add(next);
	}
	
	/**
	 * ensure that the object as the given index has been calculated 
	 * @param index the index we want to be able to read
	 */
	private void ensureCalculated(int index){
		while (index>=data.size()){
			calculateNext();
		}
		
	}
	
	/**
	 * @return the number of elements calculated
	 */
	public int getCalculatedLength(){
		return data.size();
	}
	
	/**
	 * take the first n elements from the list
	 * @param size
	 * @return an unmodifiable list of size size
	 */
	public List<E> take(int size){
		if (size<0){
			throw new IllegalArgumentException("index<0");
		}
		return take(0,size);
	}
	
	
	/**
	 * take a sublist
	 * @param start the start index 
	 * @param end the end index
	 * @return an unmodifiable sublit of size end-start
	 */
	public List<E> take(int start,int end){
		if (end<start){
			throw new IllegalArgumentException("end<start");
		}
		ensureCalculated(end);
		return Collections.unmodifiableList(data.subList(start, end));
	}
	
	
	/**
	 * get the element at the nth index
	 * @param index the index
	 * @return the object at index
	 */
	public E get(int index) {
		if (index<0){
			throw new IllegalArgumentException("index<0");
		}
		ensureCalculated(index);
		return data.get(index);
	}
	
	
	/* (non-Javadoc)
	 * @see java.lang.Iterable#iterator()
	 */
	public Iterator<E> iterator() {
		return new Iterator<E>(){
			private int index=0;
			
			public boolean hasNext() {
				return true;
			}
			
			public E next() {
				return InfiniteList.this.get(index++);
			}
			
			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}

	/**
	 * get another infinite list, obtained by applying a function to every element of the original list
	 * @param <E2> the resulting type of the map operation
	 * @param mapper the mapper
	 * @return the infinite list resulting from the mapping
	 */
	public <E2> InfiniteList<E2> map(final Mapper<E,E2> mapper){
		return new InfiniteList<E2>(){
			
			@Override
			protected E2 getNext() {
				return mapper.map(InfiniteList.this.get(getData().size()));
			}
		};
	}
	
	/**
	 * returns another infinite list that is the result of filtering this list
	 * here, you're not event garanteed to have a result from get, since if the filter always returns false we will loop till we find a match... 
	 * @param filter the filter to apply
	 * @return the new list
	 */
	public InfiniteList<E> filter(final Mapper<E,Boolean> filter){
		return new FilteredInfiniteList<E>(this,filter);
	}
	
	/**
	 * An infinite list built from filtering another list
	 * @author JP Moresmau
	 *
	 * @param <Ef> the type of the list
	 */
	private class FilteredInfiniteList<Ef> extends InfiniteList<Ef> {
		private Iterator<Ef> innerIterator;
		private Mapper<Ef,Boolean> innerFilter;
		
		/**
		 * constructs a filtered list
		 * @param il the original list
		 * @param filter the filter
		 */
		private FilteredInfiniteList(InfiniteList<Ef> il,Mapper<Ef,Boolean> filter){
			super();
			this.innerIterator=il.iterator();
			this.innerFilter=filter;
		}
		
		@Override
		protected Ef getNext() {
			Ef e=innerIterator.next();
			while(!innerFilter.map(e)){
				e=innerIterator.next();
			}
			return e;
		}
	}
}