package net.sourceforge.fenixedu.domain.precedences;

import java.lang.reflect.Constructor;
import java.util.Iterator;
import java.util.List;

import net.sourceforge.fenixedu.domain.CurricularCourse;
import net.sourceforge.fenixedu.domain.RootDomainObject;
import net.sourceforge.fenixedu.domain.curriculum.CurricularCourseEnrollmentType;
import net.sourceforge.fenixedu.domain.exceptions.DomainException;

/**
 * @author David Santos in Jun 9, 2004
 */

public class Precedence extends Precedence_Base {

    public Precedence() {
        super();
        setRootDomainObject(RootDomainObject.getInstance());
    }

    public Precedence(CurricularCourse curricularCourseToAddPrecedence, String className,
            CurricularCourse precedentCurricularCourse, Integer number) {
        this();
        setCurricularCourse(curricularCourseToAddPrecedence);

        Class[] parameters = { Integer.class, Precedence.class, CurricularCourse.class };
        Object[] arguments = { number, this, precedentCurricularCourse };

        Constructor constructor;
        try {
            constructor = Class.forName(className).getConstructor(parameters);
            constructor.newInstance(arguments);
        } catch (Exception e) {
            throw new DomainException("error.manager.impossible.insertPrecedence");
        }

    }

    public CurricularCourseEnrollmentType evaluate(PrecedenceContext precedenceContext) {
        List restrictions = getRestrictions();

        int size = restrictions.size();

        CurricularCourseEnrollmentType evaluate = ((Restriction) restrictions.get(0)).evaluate(precedenceContext);

        for (int i = 1; i < size; i++) {
            Restriction restriction = (Restriction) restrictions.get(i);
            evaluate = evaluate.and(restriction.evaluate(precedenceContext));
        }

        return evaluate;
    }

    public void delete() {

        Iterator<Restriction> restrictionIterator = getRestrictionsIterator();

        while (restrictionIterator.hasNext()) {
            Restriction restriction = restrictionIterator.next();

            restrictionIterator.remove();
            restriction.delete();
        }

        removeCurricularCourse();
        removeRootDomainObject();
        super.deleteDomainObject();
    }

    public void mergePrecedences(Precedence sourcePrecedence) {

        Iterator<Restriction> restrictionsIterator = sourcePrecedence.getRestrictionsIterator();

        while (restrictionsIterator.hasNext()) {
            Restriction restriction = restrictionsIterator.next();

            restrictionsIterator.remove();
            restriction.setPrecedence(this);
        }

        sourcePrecedence.delete();
    }
}