package es.ubu.inf.edat.pr06;

import java.util.AbstractList;
import java.util.Iterator;
import java.util.ListIterator;

/**
 * Esta clase sirve para realizar inserciones en una lista enlazada.
 * 
 * @author <A HREF="mailto:abg0060@alu.ubu.es">Alberto Barriuso Gallo</A>
 * @author <A HREF="mailto:dca0016@alu.ubu.es">David Cuesta Arnáiz</A>
 * @version 1.0
 * @date 15/04/2013
 * 
 * */

public class ListaEnlazada<E> extends AbstractList<E> {
	private int contador;
	private Nodo ultimo;
	private Nodo primero;

	/**
	 * Constructor de la clase.
	 */
	public ListaEnlazada() {
		primero = null;
		ultimo = null;
		contador = 0; // Variable para saber cuantas elementos hay en la lista.
	}

	/**
	 * Método que devuelve el elemento solicitado.
	 */
	@Override
	public E get(int arg0) {
		Nodo aux = primero;
		int contadorGet = 0;
		while (aux != null && contadorGet < arg0) {
			aux = aux.getSiguiente();
			contadorGet++;
		}
		return aux.getDato();
	}

	/**
	 * Método que devuelve el tamaño de la lista.
	 */
	@Override
	public int size() {
		return contador;
	}

	/**
	 * Método para añadir un objeto a la lista.
	 */
	public boolean add(E objeto) {
		Nodo nuevo = new Nodo(objeto);
		if (size() == 0) {
			primero = nuevo;
			ultimo = nuevo;
		} else {
			ultimo.setSiguiente(nuevo);
			nuevo.setSiguiente(null);
			ultimo = nuevo;
		}

		contador++;
		return true;
	}

	/**
	 * Método que añade un elemento en la posicion pasada. Método no soportada.
	 */
	public void add(int i, E e) {
		throw new UnsupportedOperationException();
	}

	/**
	 * Método que elimina un objeto en una posicion determinada.
	 */
	public E remove(int posicion) {
		E aux = ultimo.getDato();
		Nodo aux1 = null; // Nodos auxiliares.
		Nodo aux2 = null;

		if (size() == 0) {
			throw new UnsupportedOperationException("Lista vacia");
		} else if (contador == 1) {
			primero = null;
			ultimo = null;
			if (posicion < 0 || posicion >= size())
				throw new IndexOutOfBoundsException();
		} else {
			aux1 = primero;

			for (int i = 0; i < posicion; i++) {
				aux2 = aux1;
				aux1 = aux1.getSiguiente();
				if (i == posicion - 1) {
					aux2.setSiguiente(aux1.getSiguiente());
					ultimo = aux2;
				}
			}
		}

		contador--;
		return aux;
	}

	/**
	 * Metodo que remueve toda la coleccion.
	 */
	public void clear() {
		primero = null;
		ultimo = null;
	}

	/**
	 * Clase inner de Nodo , en el que se basa toda la lista. Formada por un
	 * dato y la posicion del siguiente nodo.
	 */
	private class Nodo {
		private E dato;
		private Nodo siguiente;

		/**
		 * Constructor de la clase Nodo.
		 * 
		 * @param dato
		 *            dato que le pasas por referncia.
		 */
		public Nodo(E dato) {
			this.dato = dato;
		}

		/**
		 * Método que devuelve el dato del Nodo.
		 * 
		 * @return dato
		 */
		public E getDato() {
			return dato;
		}

		/**
		 * Método para poner un dato.
		 * 
		 * @param objeto
		 *            objeto pasado
		 */
		public void setDato(E objeto) {
			this.dato = objeto;
		}

		/**
		 * Método para poner la direccion del siguiente elemento
		 * 
		 * @return direccion del siguiente elemento.
		 */
		public Nodo getSiguiente() {
			return siguiente;
		}

		/**
		 * Método para poner la direccion del siguiente elemento.
		 * 
		 * @param siguiente
		 *            direccion del siguiente elemento.
		 */
		public void setSiguiente(Nodo siguiente) {
			this.siguiente = siguiente;
		}

	}

	/**
	 * Clase Iterador.
	 */
	@Override
	public Iterator<E> iterator() {

		return new ListIterator<E>() {
			private int contador2 = 0; // Variable para saber la posicion
										// actual.
			private E aux = null;
			private Nodo actual = primero;

			/**
			 * Método hasNext que nos dice si hay un elemento.
			 */
			@Override
			public boolean hasNext() {
				if (actual == null)
					return false;
				else
					return true;
			}

			/**
			 * Método que nos devuelve el siguiente objeto.
			 */
			@Override
			public E next() {
				if (size() == 0) {
					throw new UnsupportedOperationException("Lista vacia");

				} else {
					if (actual != null) {
						aux = actual.getDato();
						actual = actual.getSiguiente();
					}

				}

				contador2++;
				return aux;
			}

			/**
			 * Método hasPrevious que nos dice si hay un elemento anterior.
			 */
			@Override
			public boolean hasPrevious() {
				if (actual == primero)
					return false;
				else
					return true;
			}

			/**
			 * Método que nos dice la posicion actual que esta recorriendo el iterador.
			 */
			@Override
			public int nextIndex() {
				return contador2;
			}

			/**
			 * Método que nos devuelve el dato anterior.
			 */
			@Override
			public E previous() {
				Nodo anterior = primero;

				if (size() == 0) {
					throw new UnsupportedOperationException("Lista vacia");
				} else if (primero == ultimo) {
					aux = get(0);
				} else {
					if (contador < size()) {
						aux = actual.getDato();
						while (anterior != actual) {
							anterior.getSiguiente();
						}
						actual.setSiguiente(anterior);
					}

				}

				contador2--;
				return aux;
			}

			/**
			 * Método que nos devuelve el dato anterior.
			 */
			@Override
			public int previousIndex() {
				return contador2;
			}

			
			// Métodos NO utilizados
			@Override
			public void set(E arg0) {
				throw new UnsupportedOperationException();

			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException();
			}

			@Override
			public void add(E arg0) {
				throw new UnsupportedOperationException();
			}

		};
	}
}