package pt.utl.ist.scripts.runOnce.executionCourse;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import net.sourceforge.fenixedu.domain.CurricularCourse;
import net.sourceforge.fenixedu.domain.Department;
import net.sourceforge.fenixedu.domain.ExecutionCourse;
import net.sourceforge.fenixedu.domain.ExecutionDegree;
import net.sourceforge.fenixedu.domain.ExecutionSemester;
import net.sourceforge.fenixedu.domain.Lesson;
import net.sourceforge.fenixedu.domain.Professorship;
import net.sourceforge.fenixedu.domain.ShiftType;
import net.sourceforge.fenixedu.domain.degreeStructure.Context;
import pt.utl.ist.fenix.tools.spreadsheet.SheetData;
import pt.utl.ist.fenix.tools.spreadsheet.SpreadsheetBuilder;
import pt.utl.ist.fenix.tools.spreadsheet.WorkbookExportFormat;
import pt.utl.ist.scripts.commons.AtomicScript;

public class GenerateCoursesWithoutRoomsXLS extends AtomicScript {

    @Override
    protected void run() throws Exception {
        final ExecutionSemester actualSemester = ExecutionSemester.readActualExecutionSemester();
        final ExecutionSemester previousSemester = actualSemester.getPreviousExecutionPeriod();

        final Set<Lesson> lessons = new HashSet<Lesson>();
        lessons.addAll(getLessonsWithoutRoom(previousSemester));
        lessons.addAll(getLessonsWithoutRoom(actualSemester));

        SpreadsheetBuilder builder = new SpreadsheetBuilder();
        builder.addSheet("Listagem", generateSheet(lessons));
        builder.build(WorkbookExportFormat.EXCEL, "./executionCoursesWithLessonsWithoutRooms.xls");
    }

    private Set<String> getResponsibles(ExecutionCourse course) {
        Set<String> profs = new HashSet<String>();
        for (Professorship prof : course.getProfessorshipsSet()) {
            if (prof != null && prof.isResponsibleFor()) {
                profs.add(prof.getPerson().getName());
            }
        }
        return profs;
    }

    private SheetData<Lesson> generateSheet(Collection<Lesson> lessons) {
        SheetData<Lesson> sheet = new SheetData<Lesson>(lessons) {

            @Override
            protected void makeLine(Lesson lesson) {
                final ExecutionCourse executionCourse = lesson.getExecutionCourse();
                final ExecutionSemester executionSemester = executionCourse.getExecutionPeriod();
                final Set<String> responsibleFors = getResponsibles(executionCourse);
                final Collection<Department> departments = executionCourse.getDepartments();
                final Collection<ShiftType> shiftTypes = lesson.getShift().getTypes();
                final String lessonDate =
                        String.format("[%s] %s - %s", lesson.getDiaSemana(), lesson.getInicioString(), lesson.getFimString());
                Transformer transfProfs = new Transformer() {

                    @Override
                    public String getValue(Object obj) {
                        return ((Professorship) obj).getPerson().getName();
                    }

                };

                Transformer transfDepartments = new Transformer() {

                    @Override
                    public String getValue(Object obj) {
                        return ((Department) obj).getName();
                    }

                };

                Transformer transfExecutionDegrees = new Transformer() {

                    @Override
                    public String getValue(Object obj) {
                        return ((ExecutionDegree) obj).getDegreeName();
                    }
                };
                Set<String> degreeAndYear = new HashSet<String>();
                for (ExecutionDegree executionDegree : executionCourse.getExecutionDegrees()) {
                    final CurricularCourse curricularCourseFor =
                            executionCourse.getCurricularCourseFor(executionDegree.getDegreeCurricularPlan());
                    for (Context context : curricularCourseFor.getParentContexts()) {
                        final String label =
                                String.format("%s - %sº", executionDegree.getDegreeName(), context.getCurricularYear());
                        degreeAndYear.add(label);
                    }
                }
                addCell("Semestre", executionSemester.getName());
                addCell("Nome Disciplina", executionCourse.getName());
                addCell("Responsável Disciplina", explode(responsibleFors));
                addCell("Curso-Ano", explode(degreeAndYear));
                addCell("Departamentos", explode(departments, transfDepartments));
                addCell("Horário", lessonDate);
                addCell("Tipo Aula", shiftTypes.iterator().next().getSiglaTipoAula());
            }
        };
        return sheet;
    }

    private Collection<Lesson> getLessonsWithoutRoom(final ExecutionSemester semester) {
        Set<Lesson> lessons = new HashSet<Lesson>();
        for (ExecutionCourse course : semester.getAssociatedExecutionCourses()) {
            for (Lesson lesson : course.getLessons()) {
                if (lesson.getSala() == null) {
                    lessons.add(lesson);
                }
            }
        }
        return lessons;
    }

    public abstract class Transformer {
        public abstract String getValue(Object obj);
    }

    public static String explode(Collection objs, Transformer transformer) {
        String result = new String();
        for (Object obj : objs) {
            result += transformer.getValue(obj) + ",";
        }
        if (!result.isEmpty()) {
            result = result.substring(0, result.length() - 1);
        }
        return result;
    }

    public static String explode(Collection<String> objs) {
        String result = new String();
        for (String obj : objs) {
            result += obj + ",";
        }
        if (!result.isEmpty()) {
            result = result.substring(0, result.length() - 1);
        }
        return result;
    }

    static public void main(String... args) {
        process(new GenerateCoursesWithoutRoomsXLS());
    }

}