package logica;

import orm.*;

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;

public class Listas {
    /**
     * Entrega una lista con los datos de las actividades de una asignatura.
     * Tiene 2 indices, el primero muestra la fecha, el segundo muestra el tipo.
     *
     * @param asignatura Asignatura a la que pertenecen las activiadades
     * @return La lista con los datos de las actividades de la asignatura
     */
    public static String[][] listaActividades(Asignatura asignatura) {
        if (asignatura != null) {
            Actividad[] actividades = Search.buscarActividades(asignatura);
            if (actividades != null) {
                String[][] lista = new String[actividades.length][2];
                for (int x = 0; x < lista.length; x++) {
                    SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
                    lista[x][0] = format.format(actividades[x].getFecha());
                    lista[x][1] = actividades[x].getTipo();
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Entrega la lista de cursos del sistema
     *
     * @return Retorna la lista de cursos con el formato nivel-letra
     */
    public static String[] listaCursos() {
        Curso[] cursos = Search.buscarCursos();
        if (cursos != null) {
            String[] lista = new String[cursos.length];
            for (int x = 0; x < lista.length; x++) {
                lista[x] = cursos[x].getNivel() + "-" + cursos[x].getLetra();
            }
            return lista;
        } else {
            return null;
        }
    }

    /**
     * Genera una lista con los profesores del colegio
     *
     * @return La lista con los ruts de los profesores del colegio.
     */
    public static String[] listaProfesor() {
        Profesor[] profesores = Search.buscarProfesores();
        if (profesores != null) {
            String[] lista = new String[profesores.length];
            for (int x = 0; x < lista.length; x++) {
                lista[x] = profesores[x].getRut();
            }
            return lista;
        }
        return null;
    }

    /**
     * Entrega la lista de los profesores de un curso del sistema.
     *
     * @param curso Curso al que le hace clase los profesores
     * @return Lista con los ruts de los profesores del sistema.
     */
    public static String[] listaProfesores(Curso curso) {
        if (curso != null) {
            Profesor[] profesores = Search.buscarProfesores(curso);
            if (profesores != null) {
                String[] lista = new String[profesores.length];
                for (int x = 0; x < lista.length; x++) {
                    lista[x] = profesores[x].getRut();
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera la lista de profesores con nombre y rut
     *
     * @return Retorna la lista, en el primer indice muestra el nombre de un profesor y en el segundo almacena el rut.
     */
    public static String[][] listaProfesores() {
        Profesor[] profesores = Search.buscarProfesores();
        if (profesores != null) {
            String[][] list = new String[profesores.length][2];
            for (int x = 0; x < list.length; x++) {
                list[x][0] = profesores[x].getNombre();
                list[x][1] = profesores[x].getRut();
            }
            return list;
        }
        return null;
    }

    /**
     * Genera la lista de estudiantes de un curso.
     *
     * @param curso Curso del cual se quiere la lista de estudiantes
     * @return La lista con los estudiantes, en el primer indice se encuentra el nombre y en el segundo el rut.
     */
    public static String[][] listaEstudiantes(Curso curso) {
        if (curso != null) {
            Estudiante[] estudiantes = Search.buscarEstudiantes(curso);
            if (estudiantes != null) {
                String[][] lista = new String[estudiantes.length][2];
                for (int x = 0; x < lista.length; x++) {
                    lista[x][0] = estudiantes[x].getNombre();
                    lista[x][1] = estudiantes[x].getRut();
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera la lista de apoderados del sistema
     *
     * @return La lista con los apoderados del sistema, en el primer indice se encuentra el nombre y en el segundo el rut.
     */
    public static String[][] listaApoderados() {
        Apoderado[] apoderados = Search.buscarApoderados();
        if (apoderados != null) {
            String[][] lista = new String[apoderados.length][2];
            for (int x = 0; x < lista.length; x++) {
                lista[x][0] = apoderados[x].getNombre();
                lista[x][1] = apoderados[x].getRut();
            }
            return lista;
        } else {
            return null;
        }
    }

    /**
     * Genera la lista de estudiantes de un apoderado.
     *
     * @param apoderado Apoderado al cual pertencen los estudiantes que se buscan.
     * @return La lista de estudiantes del apoderado, en el primer indice se encontrara el nombre, y en el segundo el rut.
     */
    public static String[][] listaEstudiantes(Apoderado apoderado) {
        if (apoderado != null) {
            Estudiante[] estudiantes = Search.buscarEstudiantes(apoderado);
            if (estudiantes != null) {
                String[][] lista = new String[estudiantes.length][3];
                for (int x = 0; x < lista.length; x++) {
                    lista[x][0] = estudiantes[x].getNombre();
                    lista[x][1] = estudiantes[x].getRut();
                    lista[x][2] = estudiantes[x].getCurso_id_fk().getNivel() + "-" + estudiantes[x].getCurso_id_fk().getLetra();
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera la lista de anotaciones de un estudiante
     *
     * @param estudiante Estudiante al que pertenecen estas anotaciones
     * @return Retorna la lista generada, en el primer indice almacenara el nombre y en el segundo el rut.
     */
    public static String[][] listaAnotaciones(Estudiante estudiante) {
        if (estudiante != null) {
            Anotacion[] anotaciones = Search.buscarAnotaciones(estudiante);
            if (anotaciones != null) {
                String[][] lista = new String[anotaciones.length][3];
                for (int x = 0; x < lista.length; x++) {
                    lista[x][0] = anotaciones[x].getProfesor_id_fk().getRut();
                    lista[x][1] = anotaciones[x].getDescripcion();
                    if (anotaciones[x].getPositiva()) {
                        lista[x][2] = "Positiva";
                    } else {
                        lista[x][2] = "Negativa";
                    }
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera la lista de asistencias de un estudiante.
     *
     * @param estudiante Estudiante al que pertencen las asistencias
     * @return Retorna la lista de asistencias del estudiante indicando la fecha y si asistio o no.
     */
    public static String[][] listaAsistencia(Estudiante estudiante) {
        if (estudiante != null) {
            Asistencia[] asistencias = Search.buscarAsistencias(estudiante);
            if (asistencias != null) {
                String[][] lista = new String[asistencias.length][2];
                for (int x = 0; x < lista.length; x++) {
                    SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");
                    lista[x][0] = format.format(asistencias[x].getDia());
                    if (asistencias[x].getAsistio()) {
                        lista[x][1] = "Si";
                    } else {
                        lista[x][1] = "No";
                    }
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera la lista de notas de un estudiante en una asignatura.
     *
     * @param estudiante Estudiante al que pertencen las notas
     * @param asignatura Asignatura al que pertenecen las notas del estudiante.
     * @return La lista generada solo tienen un indice apesar de que entrege un array doble.
     */
    public static String[][] listaNotas(Estudiante estudiante, Asignatura asignatura) {
        if (estudiante != null && asignatura != null) {
            Nota[] notas = Search.buscarNotas(estudiante);
            if (notas != null) {
                ArrayList<Nota> notasAsignatura = new ArrayList<>();
                for (Nota nota : notas) {
                    if (nota.getAsignatura_id_fk().equals(asignatura)) {
                        notasAsignatura.add(nota);
                    }
                }
                String[][] lista = new String[notasAsignatura.size()][1];
                DecimalFormat df = new DecimalFormat("#.#");
                df.setRoundingMode(RoundingMode.CEILING);
                for (int x = 0; x < lista.length; x++) {
                    lista[x][0] = df.format(notasAsignatura.get(x).getValor());
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera la lista de asignaturas presente en un curso
     *
     * @param curso Curso al que se le buscaran sus asignaturas.
     * @return La lista con los nombres de las asignaturas
     */
    public static String[] listaAsignaturas(Curso curso) {
        if (curso != null) {
            Asignatura[] asignaturas = Search.buscarAsignaturas(curso);
            if (asignaturas != null) {
                String[] lista = new String[asignaturas.length];
                for (int x = 0; x < lista.length; x++) {
                    lista[x] = asignaturas[x].getNombre();
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera una lista con las asignaturas y el profesor de estas de un curso
     *
     * @param curso Curso al que pertencen las asignaturas
     * @return La lista generada, en el primer indice esta el nombre de la asignatura y en el segundo el rut del profesor
     */
    public static String[][] listaAsignaturasProfesor(Curso curso) {
        if (curso != null) {
            Asignatura[] asignaturas = Search.buscarAsignaturas(curso);
            if (asignaturas != null) {
                String[][] lista = new String[asignaturas.length][2];
                for (int x = 0; x < lista.length; x++) {
                    lista[x][0] = asignaturas[x].getNombre();
                    lista[x][1] = asignaturas[x].getProfesor_id_fk().getNombre();
                }
                return lista;
            }
        }
        return null;
    }

    /**
     * Genera la lista de asignaturas que imparte un profesor
     * @param profesor Profesor que imparte las asignaturas
     * @return Retorna la lista generada, en el primer indice el nombre de la asignatura y en el segundo el curso en el que la imparte
     */
    public static String[][] listaAsignaturas(Profesor profesor) {
        if (profesor != null) {
            Asignatura[] asignaturas = Search.buscarAsignaturas(profesor);
            if (asignaturas != null) {
                String[][] lista = new String[asignaturas.length][2];
                for (int x = 0; x < lista.length; x++) {
                    lista[x][0] = asignaturas[x].getNombre();
                    lista[x][1] = asignaturas[x].getCurso_id_fk().getNivel() + "-" + asignaturas[x].getCurso_id_fk().getLetra();
                }
                return lista;
            }
        }
        return null;
    }
}
