/*
 * Created on 5/Mai/2003
 * 
 *  
 */
package net.sourceforge.fenixedu.applicationTier.Factory;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;

import org.joda.time.Interval;
import org.joda.time.YearMonthDay;

import com.linkare.commons.metainfo.Linkare;

import net.sourceforge.fenixedu.applicationTier.Servico.exceptions.FenixServiceException;
import net.sourceforge.fenixedu.dataTransferObject.ISiteComponent;
import net.sourceforge.fenixedu.dataTransferObject.InfoClass;
import net.sourceforge.fenixedu.dataTransferObject.InfoExecutionCourseEditor;
import net.sourceforge.fenixedu.dataTransferObject.InfoExecutionPeriod;
import net.sourceforge.fenixedu.dataTransferObject.InfoLesson;
import net.sourceforge.fenixedu.dataTransferObject.InfoShift;
import net.sourceforge.fenixedu.dataTransferObject.InfoSiteClasses;
import net.sourceforge.fenixedu.dataTransferObject.InfoSiteTimetable;
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.SchoolClass;
import net.sourceforge.fenixedu.domain.Shift;
import net.sourceforge.fenixedu.persistenceTier.ExcepcaoPersistencia;

/**
 * @author Jo�o Mota
 * 
 * 
 */
public class PublicSiteComponentBuilder {

    private static PublicSiteComponentBuilder instance = null;

    public PublicSiteComponentBuilder() {
    }

    public static PublicSiteComponentBuilder getInstance() {
	if (instance == null) {
	    instance = new PublicSiteComponentBuilder();
	}
	return instance;
    }

    public ISiteComponent getComponent(ISiteComponent component, SchoolClass domainClass) throws FenixServiceException {

	if (component instanceof InfoSiteTimetable) {
	    return getInfoSiteTimetable((InfoSiteTimetable) component, domainClass);
	} else if (component instanceof InfoSiteClasses) {
	    return getInfoSiteClasses((InfoSiteClasses) component, domainClass);
	}

	return null;

    }

    /**
     * @param classes
     * @return
     * @throws ExcepcaoPersistencia
     */
    private ISiteComponent getInfoSiteClasses(InfoSiteClasses component, SchoolClass domainClass) throws FenixServiceException {
	ExecutionSemester executionSemester = domainClass.getExecutionPeriod();
	ExecutionDegree executionDegree = domainClass.getExecutionDegree();

	Set<SchoolClass> classes = executionDegree.findSchoolClassesByExecutionPeriodAndCurricularYear(executionSemester,
		domainClass.getAnoCurricular());
	List infoClasses = new ArrayList();
	for (final SchoolClass schoolClass : classes) {
	    infoClasses.add(copyClass2InfoClass(schoolClass));
	}

	component.setClasses(infoClasses);
	return component;
    }

    /**
     * @param timetable
     * @param site
     * @return
     */
    @Linkare(author = "Paulo Zenida", comments = "Filtering the lessons to be presented in the time table")
    private ISiteComponent getInfoSiteTimetable(InfoSiteTimetable component, SchoolClass domainClass)
	    throws FenixServiceException {
	List infoLessonList = null;

	List<Shift> shiftList = domainClass.getAssociatedShifts();
	infoLessonList = new ArrayList();

	ExecutionSemester executionSemester = domainClass.getExecutionPeriod();
	InfoExecutionPeriod infoExecutionPeriod = InfoExecutionPeriod.newInfoFromDomain(executionSemester);

	final Interval currentWeekInterval = getCurrentWeekInterval();
	for (final Iterator classIterator = shiftList.iterator(); classIterator.hasNext();) {
	    Shift shift = (Shift) classIterator.next();
	    List lessonList = shift.getAssociatedLessons();
	    Iterator lessonIterator = lessonList.iterator();
	    while (lessonIterator.hasNext()) {
		Lesson elem = (Lesson) lessonIterator.next();
		if(shouldIncludeLesson(currentWeekInterval, elem.getAllLessonDates())) {
		    infoLessonList.add(InfoLesson.newInfoFromDomain(elem));
		}
	    }
	}
	component.setInfoExecutionPeriod(infoExecutionPeriod);

	component.setLessons(infoLessonList);

	return component;
    }

    @Linkare(author = "Paulo Zenida")
    private boolean shouldIncludeLesson(final Interval currentWeekInterval, final SortedSet<YearMonthDay> lessonDates) {
	for (final YearMonthDay lessonDate : lessonDates) {
	    if(currentWeekInterval.contains(lessonDate.toDateMidnight())) {
		return true;
	    }
	}
	return false;
    }

    @Linkare(author = "Paulo Zenida")
    private static Interval getCurrentWeekInterval() {
	final Calendar beginDay = Calendar.getInstance();
	int dayOfWeek = beginDay.get(Calendar.DAY_OF_WEEK);
	int minimumDayOfWeek = beginDay.getMinimum(Calendar.DAY_OF_WEEK);
	int maximumDayOfWeek = beginDay.getMaximum(Calendar.DAY_OF_WEEK);
	beginDay.set(Calendar.DAY_OF_MONTH, beginDay.get(Calendar.DAY_OF_MONTH) - (dayOfWeek - minimumDayOfWeek));
	final Calendar endDay = Calendar.getInstance();
	endDay.set(Calendar.DAY_OF_MONTH, endDay.get(Calendar.DAY_OF_MONTH) + (maximumDayOfWeek - dayOfWeek));
	return new Interval(beginDay.getTimeInMillis(), endDay.getTimeInMillis());
    }

    private InfoExecutionCourseEditor copyIExecutionCourse2InfoExecutionCourse(ExecutionCourse executionCourse) {
	InfoExecutionCourseEditor infoExecutionCourse = null;
	if (executionCourse != null) {
	    infoExecutionCourse = new InfoExecutionCourseEditor();
	    infoExecutionCourse.setIdInternal(executionCourse.getIdInternal());
	    infoExecutionCourse.setNome(executionCourse.getNome());
	    infoExecutionCourse.setSigla(executionCourse.getSigla());
	    infoExecutionCourse.setInfoExecutionPeriod(copyIExecutionPeriod2InfoExecutionPeriod(executionCourse
		    .getExecutionPeriod()));
	}
	return infoExecutionCourse;
    }

    /**
     * @param shift
     * @return
     */
    private InfoShift copyIShift2InfoShift(Shift shift) {
	InfoShift infoShift = null;
	if (shift != null) {
	    infoShift = new InfoShift(shift);
	}
	return infoShift;
    }

    /**
     * @param taux
     * @return
     */
    private InfoClass copyClass2InfoClass(SchoolClass taux) {
	InfoClass infoClass = null;
	if (taux != null) {
	    infoClass = new InfoClass(taux);
	}
	return infoClass;
    }

    /**
     * @param period
     * @return
     */
    private InfoExecutionPeriod copyIExecutionPeriod2InfoExecutionPeriod(ExecutionSemester executionSemester) {
	return InfoExecutionPeriod.newInfoFromDomain(executionSemester);
    }

}