import java.util.ArrayList;
import java.time.LocalDate;
/**
 * Write a description of class ListaTareas here.
 *
 * @author (your name)
 * @version (a version number or a date)
 */
public class ListaTareas
{
    private ArrayList<Tarea> listaDeTareas;

    private int contadorId;

    public ListaTareas()
    {
        listaDeTareas = new ArrayList<Tarea>();
        contadorId = 10;
    }

    public void addTarea(String descripcionTarea)
    {
        Tarea tarea = new Tarea(descripcionTarea, contadorId);
        listaDeTareas.add(tarea);
        contadorId++;
    }

    public void mostrarTareas()
    {
        int posicion = 1;
        for (Tarea tarea : listaDeTareas) {
            System.out.println(posicion + ". " + tarea.toString());
            posicion++;
        }
    }

    public void marcarComoCompletadaPos(int posicionTarea)
    {
        int posicionReal = posicionTarea - 1;
        if (posicionReal >= 0 && posicionReal < listaDeTareas.size()) {
            listaDeTareas.get(posicionReal).marcarComoCompletada();
        }
    }

    public void mostrarCoincidentes(String textoABuscar)
    {
        int posicion = 0;
        while (posicion < listaDeTareas.size()) {
            Tarea tareaActual = listaDeTareas.get(posicion);
            if (tareaActual.getDescripcion().contains(textoABuscar)) {
                System.out.println((posicion + 1) + tareaActual.toString());
            }
            posicion++;
        }
    }

    public void eliminarTarea(int posicionTarea)
    {
        int posicionReal = posicionTarea - 1;
        if (posicionReal >= 0 && posicionReal < listaDeTareas.size()) {
            listaDeTareas.remove(posicionReal);
        }
    }

    public void establecerNuevaPrioridad(int posicion, int prioridad)
    {
        int posicionReal = posicion - 1;
        if(posicionReal >= 0 && posicionReal < listaDeTareas.size()) {
            if(prioridad >= 0 && prioridad <= 5) {
                listaDeTareas.get(posicionReal).cambiarPrioridad(prioridad);
            }
        }
    }

    public void setFechaVencimiento(int posicion, int anno, int mes, int dia)
    {
        int posicionReal = posicion - 1;
        if(posicionReal >= 0 && posicionReal < listaDeTareas.size()) {
            listaDeTareas.get(posicionReal).fijarFechaDeVencimiento(anno, mes, dia);
        }
    }

    public void mostrarHoy()
    {
        int posicion = 1;
        LocalDate Hoy = LocalDate.now();
        for (Tarea tarea: listaDeTareas) {
            if(tarea.getFecha() != null) {
                if(tarea.getFecha().isEqual(Hoy)) {
                System.out.println(posicion + ". " + tarea.toString());
               }
            }
            posicion++;
        }
    }

    public void mostrarVencidas()
    {
        int posicion = 1;
        LocalDate Hoy = LocalDate.now();
        for (Tarea tarea: listaDeTareas) {
            if(tarea.getFecha() != null) {
                if(tarea.getFecha().isBefore(Hoy)) {
                System.out.println(posicion + ". " + tarea.toString());
               }
            }
            posicion++;
        }
    }

    public void verTareaMasPrioritaria()
    {
        int prioridadMaxima = 0;
        int contador = 0;
        for (Tarea tarea: listaDeTareas) {
            if (prioridadMaxima < tarea.getPrioridad()) {
                prioridadMaxima = tarea.getPrioridad();
            }
        }

        while (contador < listaDeTareas.size()) {
            Tarea tareaActual = listaDeTareas.get(contador);
            if (tareaActual.getPrioridad() == prioridadMaxima) {
                System.out.println((contador + 1) + ". " + tareaActual.toString());
            }
            contador++;
        }
    }

    public void verTareaMasPrioritaria2()
    {
        if (listaDeTareas.size() > 0) {
            Tarea tareaMasPrioritaria = listaDeTareas.get(0);
            for (Tarea tareaActual : listaDeTareas) {
                if (tareaActual.getPrioridad() >= tareaMasPrioritaria.getPrioridad()) {
                    tareaMasPrioritaria = tareaActual;
                }
            }
            System.out.println(tareaMasPrioritaria);
        }
    }
    // A partir de esta línea son metodos con Id.
    public void marcarComoCompletadaId(int numeroId)
    {
        for (Tarea tarea : listaDeTareas) {
            if (numeroId == tarea.getId()) {
                tarea.marcarComoCompletada();
            }
        }
    }

    /**
     * Metodo que devuelve el índice de una tarea en funcion de su id, en caso de que exista.
     * Devuelve -1 en caso de que no exista.
     */
    public int getPosicion(int numeroId)
    {
        int posicionDeTarea = -1;
        int contador = 0;
        for (Tarea tarea : listaDeTareas) {
           if (numeroId == tarea.getId()) {
                posicionDeTarea = contador;
            }
           contador++;
        }
        return posicionDeTarea;
    }

    public void eliminarTareaId(int numeroId)
    {
        if (listaDeTareas.size() >= 0) {
            if (getPosicion(numeroId) <= listaDeTareas.size() && getPosicion(numeroId) != -1) {
                listaDeTareas.remove(getPosicion(numeroId));
            }
        }
    }

    public void marcarCompletadaConId(int numeroId)
    {
        int posicionReal = getPosicionById(numeroId);
        if (posicionReal >= 0 && posicionReal < listaDeTareas.size()) {
            listaDeTareas.get(posicionReal).marcarComoCompletada();
        }
    }

    public int getPosicionById(int idBuscada)
    {
        int posicionBuscada = -1;
        int posicionActual = 0;
        boolean buscando = true;
        while ((posicionActual < listaDeTareas.size()) && (buscando)) {
            if (idBuscada == listaDeTareas.get(posicionActual).getId()) {
                posicionBuscada = posicionActual;
                buscando = false;
            }
            posicionActual++;
        }
        return posicionBuscada;
    }

    public void eliminarTareaConId(int numeroId)
    {
        int posicionReal = getPosicionById(numeroId);
        if (posicionReal >= 0 && posicionReal < listaDeTareas.size()) {
            listaDeTareas.remove(posicionReal);
        }
    }

    public void establecerNuevaPrioridadConId(int numeroId, int prioridad)
    {
        int posicionReal = getPosicionById(numeroId);
        if(posicionReal >= 0 && posicionReal < listaDeTareas.size()) {
            if(prioridad >= 0 && prioridad <= 5) {
                listaDeTareas.get(posicionReal).cambiarPrioridad(prioridad);
            }
        }
    }

    /**
     * Implementar un metodo llamado "tareaMasViejaPendiente" que
     * nos devuelva el id de la tarea mas antigua de nuestra lista
     * que aun no esta completada. En caso de que no haya tareas
     * sin completar devuelve -1.
     */
    public int tareaMasViejaPendiente()
    {
        int posicionBuscada = -1;
        int posicionActual = 0;
        boolean buscando = true;
        while (posicionActual < listaDeTareas.size() && buscando) {
            Tarea tareaActual = listaDeTareas.get(posicionActual);
            if (listaDeTareas.get(posicionActual).estaTerminada() == false) {
                posicionBuscada = tareaActual.getId();
                buscando = false;
            }
            posicionActual++;
        }
        return posicionBuscada;
    }

    /**
     * Implementar un metodo llamado "numeroTareasSinTerminar"
     * que nos devuelva el numero de tareas sin termiar.
     */
    public int numeroTareasSinTerminar()
    {
        int contador = 0;
        int tareasSinTerminar = 0;
        while (contador < listaDeTareas.size()) {
            Tarea tareaActual = listaDeTareas.get(contador);
            if (!listaDeTareas.get(contador).estaTerminada()) {
                tareasSinTerminar++;
            }
            contador++;
        }
        return tareasSinTerminar;
    }

    /**
     * Implementar un metodo llamado "hayTareasDuplicadas" que
     * devuelve true en caso de que haya dos tareas con la misma
     * descripcion o false en caso contrario.
     */
    public boolean hayTareasDuplicadas()
    {
        int contador = 0;
        int contadorDeCoincidencias = 0;
        boolean hayTareasDuplicadas = false;
        while (contador < listaDeTareas.size()) {
            Tarea tareaActual = listaDeTareas.get(contador);
            for (Tarea tarea : listaDeTareas) {
                if (tareaActual.getDescripcion() == tarea.getDescripcion()) {
                    contadorDeCoincidencias++;
                    if (contadorDeCoincidencias > listaDeTareas.size()) {
                        hayTareasDuplicadas = true;
                    }
                }
            }
            contador++;
        }
        return hayTareasDuplicadas;
    }

    public void prueba()
    {
        for (Tarea tarea : listaDeTareas) {
            System.out.println(tarea.getDescripcion());
        }
    }
}