package pt.ipleiria.estg.dei.aed.colecoes.iteraveis.lineares.naoordenadas.estruturas;

import pt.ipleiria.estg.dei.aed.colecoes.iteraveis.IteradorIteravel;
import pt.ipleiria.estg.dei.aed.colecoes.iteraveis.IteradorIteravelDuplo;
import pt.ipleiria.estg.dei.aed.colecoes.iteraveis.lineares.naoordenadas.ColecaoIteravelLinearNaoOrdenada;

import java.util.NoSuchElementException;

public class ListaDuplaNaoOrdenada<T> implements ColecaoIteravelLinearNaoOrdenada<T> {

    protected No noInicial;
    protected No noFinal;
    protected int numeroElementos;

    //ListaDuplaNaoOrdenada listaDNO = new ListaDuplaNaoOrdenada<>();

    @Override
    public void inserirNoInicio(T elem) {
        if (++numeroElementos == 1){    //CASO 1    inicialmente a lista esta vazia numeroElementos = 0
            noInicial = noFinal = new No(elem);
        }
        else {
            noInicial = new No(elem, true);
        }

    }

    @Override
    public void inserirNoFim(T elem) {
        noFinal = new No(elem);
        if (++numeroElementos == 1){    //CASO 1    inicialmente a lista esta vazia numeroElementos = 0
            noInicial = noFinal;
        }
    }

    @Override
    public void inserir(int indice, T elem) {
        if (numeroElementos == 0){
            inserirNoInicio(elem);
        }

        if (indice == 0){
            inserirNoInicio(elem);
        } else if (indice == numeroElementos){
            inserirNoFim(elem);
        } else {
            new No(elem, getNo(indice));
            numeroElementos++;
        }

    }

    private No getNo(int indice) {
        if (indice < 0 || indice > numeroElementos - 1){
            throw new IndexOutOfBoundsException("Índice inválido");
        }

        No cor = noInicial;
        if (indice < numeroElementos / 2){
            cor = noInicial;
            while (indice-- > 0){
                cor = cor.seguinte;
            }
        } else {
            cor = noFinal;
            while (++indice < numeroElementos){
                cor = cor.anterior;
            }
        }
        return cor;
    }

    @Override
    public T removerDoInicio() {
        if (numeroElementos == 0){
            return null;
        }

        No aux = noInicial;
        noInicial = noInicial.seguinte;
        if (--numeroElementos == 1){
            noFinal = null;
        } else {
            noInicial.anterior = null;
        }
        return aux.elemento;
    }


    //ACHO QUE NAO ESTA BEM---FALTA COPIAR O DO STOR
    @Override
    public T removerDoFim() {
        if (numeroElementos == 0){
            return null;
        }
        No aux = noFinal;
        noFinal = noFinal.anterior;
        if (--numeroElementos == 0){
            noFinal = null;
        } else {
            noFinal.seguinte = null;
        }
        return aux.elemento;
    }

    @Override
    public T remover(T elem) {
        if (numeroElementos == 0){
            return null;
        }

        if (noInicial.elemento.equals(elem)){
            return removerDoInicio();
        }

        if (noFinal.elemento.equals(elem)){
            return removerDoFim();
        }

        No no = getNo(elem);
        return no != null ? remover(no) : null;
    }

    //Devolve no com elem ou null caso contrário
    private No getNo(T elem) {
        No no = noInicial;
        while (no != null && !no.elemento.equals(elem)){
            no = no.seguinte;
        }
        return no;
    }

    @Override
    public T remover(int indice) {
        if (numeroElementos == 0){
            return null;
        }

        if (indice == 0){
            return removerDoInicio();
        }

        if (indice == numeroElementos-1){
            return removerDoFim();
        }

        return remover(getNo(indice));
    }

    public T remover(No no) {
        no.anterior.seguinte = no.seguinte;
        no.seguinte.anterior = no.anterior;
        numeroElementos--;

        return no.elemento;
    }

    @Override
    public T removerPorReferencia(T elem) {
        if (numeroElementos == 0){
            return null;
        }

        if (noInicial.elemento == elem){
            return removerDoInicio();
        }

        if (noFinal.elemento == elem){
            return removerDoFim();
        }

        No no = getNoPorReferencia(elem);
        return no != null ? remover(no) : null;
    }

    private No getNoPorReferencia(T elem) {
        No no = noInicial;
        while (no != null && no.elemento != elem){
            no = no.seguinte;
        }
        return no;
    }

    @Override
    public T consultar(int indice) {
        return getNo(indice).elemento;
    }

    @Override
    public boolean contem(T elem) {
        return getNo(elem) != null;
    }

    @Override
    public boolean contemReferencia(T elem) {
        return false;
    }

    @Override
    public IteradorIteravelDuplo<T> iterador() {
        return new Iterador();
    }

    @Override
    public int getNumeroElementos() {
        return 0;
    }

    protected class No{
        protected T elemento;
        protected No seguinte;
        protected No anterior;

        //Criacao de nó com elem e colocacao no final
        protected No(T elem) {
            elemento = elem;
            seguinte = null;
            anterior = noFinal;
            if (noFinal != null){
                noFinal.seguinte = this;
            }
        }

        //Criacao de nó com elem e colocacao no inicio (nao null)
        protected No(T elem, boolean estupido) {
            elemento = elem;
            seguinte = noInicial;
            anterior = null;
            noInicial.anterior = this;
        }

        //Criação de nó com elem e colocação antes de seg
        public No(T elem, No seg){
            elemento = elem;
            seguinte = seg;
            anterior = seg.anterior;
            seguinte.anterior = anterior.seguinte = this;
        }
    }

    protected class Iterador implements IteradorIteravelDuplo<T> {

        protected No anterior;
        protected No corrente;
        protected No proximo;

        public Iterador() {
            anterior = noFinal;
            corrente = null;
            proximo = noInicial;
        }

        @Override
        public void reiniciar() {

        }

        @Override
        public T corrente() {
            if (corrente == null){
                throw new NoSuchElementException("Elemento inválido");
            }
            return corrente.elemento;
        }

        @Override
        public boolean podeAvancar() {
            return proximo != null;
        }

        @Override
        public T avancar() {
            if (!podeAvancar()){
                throw new NoSuchElementException("Elemento Inválido");
            }
            anterior = corrente;
            corrente = proximo;
            proximo = proximo;
            return corrente.elemento;
        }

        @Override
        public boolean podeRecuar() {
            return anterior != null;
        }

        @Override
        public T recuar() {

            if (!podeRecuar()){
                throw new NoSuchElementException("Elemento Inválido");
            }

            proximo = corrente;
            corrente = anterior;
            anterior = anterior.anterior;
            return corrente.elemento;
        }
    }
}