package es.ubu.inf.edat.pr06;

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

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

	public ListaEnlazada() {
		primero = null;
		ultimo = null;
		lista = new LinkedList<E>();
		contador = 0; //Variable para saber cuantas elementos hay en la lista.
	}

	@Override
	public E get(int arg0) {
		return lista.get(arg0);
	}

	@Override
	public int size() {
		return contador;
	}

	public boolean add(E objeto) {
		Nodo nuevo = new Nodo(objeto);
		if (lista.size() == 0) {
			primero = nuevo;
			ultimo = nuevo;
		} else {
			ultimo.setSiguiente(nuevo);
			nuevo.setSiguiente(null);
			ultimo = nuevo;
		}
		
		contador++;
		System.out.println(contador);
		return true;
	}

	public void add(int i, E e) {
		throw new UnsupportedOperationException();
	}

	public E remove(int posicion) {
		E aux = ultimo.getDato();
		Nodo aux2 = null;

		if (lista.size() == 0) {
			throw new UnsupportedOperationException("Lista vacia");
		} else if (primero == ultimo) {
			primero = null;
			ultimo = null;
			if (posicion < 0 || posicion >= size())
				throw new IndexOutOfBoundsException();
		} else {
			aux2 = primero;
			for (int i = 0; i < posicion; i++) {
				aux2 = aux2.getSiguiente();
				if (i == posicion - 1) {
					aux2.setSiguiente(primero);
					ultimo = aux2;
				}
			}
		}

		contador--;
		return aux;
	}

	public void clear() {
		primero = null;
		ultimo = null;
	}

	private class Nodo {
		private E dato;
		private Nodo siguiente;

		public Nodo(E dato) {
			this.dato = dato;
		}

		public E getDato() {
			return dato;
		}

		public void setDato(E objeto) {
			this.dato = objeto;
		}

		public Nodo getSiguiente() {
			return siguiente;
		}

		public void setSiguiente(Nodo siguiente) {
			this.siguiente = siguiente;
		}

	}

	@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;

			@Override
			public boolean hasNext() {
				if (actual == null)
					return false;
				else
					return true;
			}

			@Override
			public E next() {
				if (contador == 0) {
					throw new UnsupportedOperationException("Lista vacia");
				} else if (primero == ultimo) {
					aux = lista.get(0);
				} else {
					if (actual!=null) {
						aux = actual.getDato();
						actual.getSiguiente();
					}

				}

				contador2++;
				return aux;
			}

			@Override
			public boolean hasPrevious() {
				if (actual == primero)
					return false;
				else
					return true;
			}

			@Override
			public int nextIndex() {
				return contador2;
			}

			@Override
			public E previous() {
				Nodo anterior = primero;

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

				}

				contador2--;
				return aux;
			}

			@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();
			}

		};
	}
}