import java.util.ArrayList;
import java.util.Iterator;
import java.time.LocalDate;
/**
 * Clase que crea colecciones que almacenan objetos de tipo Tarea.
 */
public class ListaTareas
{
    // Colección que almacena objetos de la clase Tarea.
    private ArrayList<Tarea> listaDeTareas;
    // Almacena el id para la siguiente tarea.
    private int id;

    /**
     * Constructor for objects of class ListaTareas
     */
    public ListaTareas()
    {
        listaDeTareas = new ArrayList<Tarea>();
        id = 0;
    }

    /**
     * Añade una tarea nueva a la coleccion listaDeTareas.
     */
    public void addTarea(String tarea)
    {
        if(id < 89){
            Tarea nuevaTarea = new Tarea(tarea, id);
            listaDeTareas.add(nuevaTarea);
            id++;
        }
    }

    /**
     * Permite ver todas las tareas numeradas
     * empezando en 1 pudiendo ver si estan
     * completadas o no.
     */
    public void verTareasNumeradas()
    {
        Iterator<Tarea> it = listaDeTareas.iterator();
        while(it.hasNext()){
            Tarea tarea = it.next();
            System.out.println(tarea.toString());
        }
    }

    /**
     * Permite fijar una tarea como hecha
     * indicando la posición de la misma.
     */
    public void setTareaHecha(int id)
    {
        int comprobanteId = esValidoElId(id);
        if(comprobanteId != -1){
            listaDeTareas.get(comprobanteId).setTareaHecha();
        }
    }

    ///**
    // * Comprueba si un indice es valido.
    // */
    //public boolean esValidoElIndice(int id)
    //{
    //    return  id >= 0 && id < this.id && !idEliminado.contains(String.valueOf(id));
    //}

    /**
     * Mostrar todas las tareas cuyo
     * nombre contenga un determinado texto.
     */
    public void mostrarTareasCoincidentes(String texto)
    {
        int numeroCabecera = 1;
        int tareasCoincidentes = 0;
        Iterator<Tarea> it = listaDeTareas.iterator();
        while(it.hasNext()){
            Tarea tarea = it.next();
            if(tarea.getNombreTarea().contains(texto)){
                System.out.println(numeroCabecera + " " + tarea.toString());
                tareasCoincidentes++;
            }
            numeroCabecera++;
        }
        if(tareasCoincidentes == 0){
            System.out.println("Error, no hay coincidencias.");
        }
        else{
            System.out.println("Tareas coincidentes: " + tareasCoincidentes);
        }
    }

    /**
     * Elimina una tarea indicando su numero.
     */
    public void eliminarTarea(int id)
    {
        int comprobanteId = esValidoElId(id);
        if(comprobanteId != -1){
            listaDeTareas.remove(comprobanteId);
        }
    }

    /**
     * Fija la prioridad de una tarea.
     */
    public void setPrioridad(int id, int prioridad)
    {
        int comprobanteId = esValidoElId(id);
        if(comprobanteId != -1){
            listaDeTareas.get(comprobanteId).setPrioridad(prioridad);
        }
    }

    /**
     * Se muestra por pantalla todos los elementos
     * de la colección ordenados de mayor a menor prioridad.
     */
    public void tareasOrdenadas()
    {
        int i = 0;
        int buscarPrioridad = 5;
        Tarea tareaLocal;
        while(buscarPrioridad >= 0){
            while(i < listaDeTareas.size()){
                tareaLocal = listaDeTareas.get(i);
                if(tareaLocal.getPrioridad() == buscarPrioridad){
                    System.out.println(tareaLocal);
                }
                i++;
            }
            i = 0;
            buscarPrioridad--;
        }
    }

    /**
     * Fija la fecha de vencimiento de una tarea.
     */
    public void fijarFechaVencimiento(int id, int dia, int mes, int anyo)
    {
        int comprobanteId = esValidoElId(id);
        if(comprobanteId != -1){
            listaDeTareas.get(comprobanteId).fijarFechaVencimiento(dia, mes, anyo);
        }
    }

    /**
     * Muestra por pantalla el listado de
     * tareas con fecha de vencimiento hoy.
     */
    public void mostrarHoy()
    {
        int index = 0;
        LocalDate ahora = LocalDate.now();
        Iterator<Tarea> it = listaDeTareas.iterator();
        while(it.hasNext()){
            Tarea tarea = it.next();
            if(tarea.devolverFechaVencimiento() != null){
                if(tarea.devolverFechaVencimiento().isEqual(ahora)){
                    System.out.println((index + 1) + " " + tarea.toString());
                }
            }
            index++;
        }
    }

    /**
     * Muestra por pantallas el listado
     * de tareas con fechas vencidas.
     */
    public void mostrarVencidas()
    {
        int index = 0;
        LocalDate ahora = LocalDate.now();
        Iterator<Tarea> it = listaDeTareas.iterator();
        while(it.hasNext()){
            Tarea tarea = it.next();
            if(tarea.devolverFechaVencimiento() != null){
                if(tarea.devolverFechaVencimiento().isBefore(ahora)){
                    System.out.println((index + 1) + " " + tarea.toString());
                }
            }
            index++;
        }
    }

    /**
     * Muestra la tarea con mas alta prioridad,
     * si hay varias empatadas muestra todas.
     */
    public void verTareaMasPrioritaria()
    {
        int i = 0;
        int buscarPrioridad = 5;
        boolean encontrado = false;
        Tarea tareaLocal;
        while(buscarPrioridad >= 0 && !encontrado){
            while(i < listaDeTareas.size()){
                tareaLocal = listaDeTareas.get(i);
                if(tareaLocal.getPrioridad() == buscarPrioridad){
                    System.out.println((i + 1) + " " + tareaLocal.toString());
                    encontrado = true;
                }
                i++;
            }
            i = 0;
            buscarPrioridad--;
        }
    }

    /**
     * Muestra la tarea con mayor prioridad.
     * En caso de empate muestra solo la ultima.
     */
    public void verTareaMasPrioritaria2()
    {
        if(listaDeTareas.size() > 0){
            int prioridadMaxima = listaDeTareas.get(0).getPrioridad();
            Tarea tareaGuardada = listaDeTareas.get(0);
            for(Tarea tarea : listaDeTareas){
                if(tarea.getPrioridad() >= prioridadMaxima){
                    tareaGuardada = tarea;
                    prioridadMaxima = tarea.getPrioridad();
                }
            }
            System.out.println(tareaGuardada);
        }
    }

    /**
     * Devuelve la posicion dentro del ArrayList
     * de la tarea con el id que se ha pasado por
     * parametro, o -1 en caso de que no exista
     * ninguna tarea con dicho id.
     */
    public int esValidoElId(int id)
    {
        int index = 0;
        int indexGuardado = -1;
        for(Tarea tarea : listaDeTareas){
            if(tarea.getId() == id){
                indexGuardado = index;
            }
            index++;
        }
        return indexGuardado;
    }

    /**
     * Devuelve el id de la tarea mas antigua
     * de nuestra lista que aun no esta completada.
     */
    public int tareaMasViejaPendiente()
    {
        int index = 0;
        int id = -1;
        boolean buscando = true;
        while(index < listaDeTareas.size() && buscando){
            if(!listaDeTareas.get(index).getTareaHecha()){
                buscando = false;
                id = listaDeTareas.get(index).getId();
            }
            index++;
        }
        return id;
    }

    /**
     * Devuelve el numero de tareas sin terminar.
     */
    public int numeroTareasSinTerminar()
    {
        int contador = 0;
        for(Tarea tarea : listaDeTareas){
            if(!tarea.getTareaHecha()){
                contador++;
            }
        }
        return contador;
    }

    /**
     * Devuelve true en caso de que haya dos tareas
     * con la misma descripcion o false en caso contrario.
     */
    public boolean hayTareasDuplicadas()
    {
        boolean buscando = true;
        int indexAConsultar = 0;
        int indexConsultado = 1;
        while(buscando && indexAConsultar < listaDeTareas.size()){
            String consultando = listaDeTareas.get(indexAConsultar).getNombreTarea();
            while(buscando && indexConsultado < listaDeTareas.size()){
                if(consultando.equals(listaDeTareas.get(indexConsultado).getNombreTarea())){
                    buscando = false;
                }
                indexConsultado++;
            }
            indexAConsultar++;
            indexConsultado = indexAConsultar + 1;
        }
        return !buscando;
    }
}