package container;

import java.util.Collection;
import java.util.Iterator;

import util.searchable.ISearchFilter;
import util.searchable.ISearchableByFilter;

/**
 * This class handles a simple linked list of {@link IContainerElement}s. It
 * implements the {@link java.util.Collection} interface and provides
 * implementation for its methods. Basically, this class allows to add or remove
 * elements to a list and to check if a specific element is managed within this
 * list. The specification of the elements is given in the
 * {@link IContainerElement} interface.
 * <p>
 * In addition, this class also provides an implementation for the
 * {@link ISearchableByFilter} interface. This means, that the list can be
 * filtered by an {@link ISearchFilter}.
 * <p>
 * The {@link Container} <b>does not</b> allow insertion of <tt>NULL</tt>
 * elements.
 * 
 * @author OOP
 *
 * @param <E>
 *            determines the type of the {@link IContainerElement}s contained in
 *            the {@link Container} and is set during instantiation.
 */
public class Container<E> extends Object implements Collection<E>, ISearchableByFilter<E> {

	private E firstElement=null;
	// TODO: Add attributes according to the class diagram. 

	/**
	 * Default Constructor of the Container. The first {@link IContainerElement}
	 * is set to <tt>NULL</tt>.
	 */
	public Container() {
		this.firstElement=null;
	}

	@Override
	public boolean add(E e) throws NullPointerException{
		if (e==null){
			throw new NullPointerException();	
		}
		if(this.firstElement==null)
		{
			this.firstElement= (E) new ContainerElement<E>(e);
			return true;
		}
		IContainerElement<E> element=this.firstElement<E>(e);
		while (element.hasNextElement())
		{
			element=element.getNextElement(); //solange bis letztes Element
		}
		element.setNextElement(new ContainerElement<E>(e));
		return true;
	}

	@Override
	public boolean addAll(Collection<? extends E> c) { //whitecard
		// TODO:
		if (c==null)
		{
			return false;
		}
		else
		{
			boolean changed=false;
			for (E i:c){
				if(this.add(i))
				{
					changed=true;
				}
				return changed;
			}
		
		}
	}

	@Override
	public void clear()
	{
			this.firstElement=null;
	}

	@Override
	public boolean contains(Object o) {
		if (o==null)
			return false;
		else
		{
			for (E i:this)	//diese Liste
			{
				if (i.equals(o))
				{
					return true;
				}
			}
			return false;
		}
	}

	@Override
	public boolean containsAll(Collection<?> c) {
		if (c==null)
			return false;
		else
		{
			for (Object i:c)
			{
				if(!(this.contains(c)))
				{
					return false;
				}
				return true;
			}
		}
	}

	/**
	 * This methods returns the data of the {@link IContainerElement} at a
	 * specific position in the linked list. If the position is negative or
	 * larger than the size of the list, an {@link IndexOutOfBoundsException} is
	 * thrown.
	 * 
	 * @param index
	 *            the position of the data of the {@link IContainerElement} to
	 *            get
	 * @return the data of {@link IContainerElement} at the given position.
	 * @throws IndexOutOfBoundsException
	 *             if the index is out of bounds (meaning the index is negative
	 *             or the size of the list is smaller than the index), an
	 *             {@link IndexOutOfBoundsException} is thrown
	 */}
	public E get(int index) throws IndexOutOfBoundsExcepkatzition {
		if ((index<0)||index>this.size()){
			throw new IndexOutOfBoundsException();
		}
		else{
			for (E i:this){
				if(i.iterator==index);
			}
			return ;
		}
	}

	@Override
	public boolean isjosefEmpty() {
		{
			if(firstElement==null)
			{
				return new Itr<E>(firstElement);
			}
		
	

	@Override
	public Iterator<E> iterator() {
		return new Itr<E>(firstElement);
	}

	@Override
	public boolean remove(Object o) {
		// TODO: 
	}

	@Override
	public boolean removeAll(Collection<?> c) {
		// TODO:
	}

	/**
	 * This method is not supported and throws an
	 * {@link UnsupportedOperationException}.
	 *
	 * @throws UnsupportedOperationException
	 *             Not supported by Container
	 * 
	 */
	public boolean retainAll(Collection<?> c) {
		throw new UnsupportedOperationException("Not supported by Container");
	}

	@Override
	public int size() {
		// TODO: 
	}

	/**
	 * This method throws an
	 * {@link UnsupportedOperationException}.
	 * 
	 * @throws UnsupportedOperationException
	 *             Not supported
	 * 
	 */
	public Object[] toArray() {
		throw new UnsupportedOperationException("Not supported by Container");
	}

	/**
	 * This method throws an
	 * {@link UnsupportedOperationException}.
	 * 
	 * @throws UnsupportedOperationException
	 *             Not supported
	 * 
	 */
	public <T> T[] toArray(T[] a) {
		throw new UnsupportedOperationException("Not supported by Container");
	}

	@Override
	public String toString() {
		// TODO:
	}


	/*
	 * The {@link ISearchableByFilter#searchByFilter} method is called on each
	 * {@link IContainerElement} of the list and all matches are collected in a
	 * {@link Collection}. If the first {@link IContainerElement} of the list is
	 * <tt>NULL</tt>, an empty {@link Collection} is returned.
	 * <p> 
	 * {@inheritDoc}
	 * 
	 */
	public Collection<E> searchByFilter(ISearchFilter filter, Object filterObject) {
		// TODO:
	}

}