package org.richfaces.component;

import org.ajax4jsf.component.AjaxActionComponent;
import org.ajax4jsf.component.AjaxComponent;
import org.ajax4jsf.context.AjaxContext;
import org.ajax4jsf.event.AjaxEvent;
import org.ajax4jsf.model.DataVisitor;
import org.ajax4jsf.model.ExtendedDataModel;
import org.ajax4jsf.renderkit.RendererUtils;
import org.richfaces.component.event.*;
import org.richfaces.component.model.DateRange;

import javax.el.ELContext;
import javax.el.ValueExpression;
import javax.faces.component.UIComponent;
import javax.faces.component.UIComponentBase;
import javax.faces.context.FacesContext;
import javax.faces.el.MethodBinding;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.FacesEvent;
import javax.faces.model.*;
import javax.servlet.jsp.jstl.sql.Result;
import java.io.IOException;
import java.sql.ResultSet;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;

public abstract class UISchedule extends UIComponentBase implements ScheduleCommonViewAttributes, ScheduleListenerEventsProducer, AjaxComponent {

    public static final String COMPONENT_TYPE = "org.richfaces.Schedule";
    public static final String COMPONENT_FAMILY = "org.richfaces.Schedule";
    /**
     * Values of view attribute.
     */
    public static final String VIEW_MONTH = "month";
    public static final String VIEW_BASIC_WEEK = "basicWeek";
    public static final String VIEW_AGENDA_WEEK = "agendaWeek";
    public static final String VIEW_BASIC_DAY = "basicDay";
    public static final String VIEW_AGENDA_DAY = "agendaDay";
    /**
     * Values of weekMode attribute.
     */
    public static final String WEEK_MODE_FIXED = "fixed";
    public static final String WEEK_MODE_LIQUID = "liquid";
    public static final String WEEK_MODE_VARIABLE = "variable";
    private DataModel model;

    public abstract Object getValue();

    public abstract void setValue(Object value);

    public abstract String getVar();

    public abstract void setVar(String value);

    public abstract Date getDate();

    public abstract void setDate(Date date);

    public abstract String getSwitchType();

    public abstract void setSwitchType(String switchType);

    public abstract String getView();

    public abstract void setView(String defaultView);

    public abstract String getHeaderLeft();

    public abstract void setHeaderLeft(String headerLeft);

    public abstract String getHeaderCenter();

    public abstract void setHeaderCenter(String headerCenter);

    public abstract String getHeaderRight();

    public abstract void setHeaderRight(String headerRight);

    public abstract Integer getFirstDay();

    public abstract void setFirstDay(Integer firstDay);

    public abstract Boolean getIsRTL();

    public abstract void setIsRTL(Boolean isrtl);

    public abstract Boolean getShowWeekends();

    public abstract void setShowWeekends(Boolean showWeekends);

    public abstract String getWeekMode();

    public abstract void setWeekMode(String weekMode);

    public abstract Integer getHeight();

    public abstract void setHeight(Integer height);

    public abstract Integer getContentHeight();

    public abstract void setContentHeight(Integer contentHeight);

    public abstract Double getAspectRatio();

    public abstract void setAspectRatio(Double aspectRatio);

    public abstract Boolean getAllDayByDefault();

    public abstract void setAllDayByDefault(Boolean allDayByDefault);

    public abstract Boolean getAllDaySlot();

    public abstract void setAllDaySlot(Boolean allDaySlot);

    public abstract String getAllDayText();

    public abstract void setAllDayText(String allDayText);

    public abstract String getAxisFormat();

    public abstract void setAxisFormat(String axisFormat);

    public abstract Integer getSlotMinutes();

    public abstract void setSlotMinutes(Integer slotMinutes);

    public abstract Integer getDefaultEventMinutes();

    public abstract void setDefaultEventMinutes(Integer defaultEventMinutes);

    public abstract Integer getFirstHour();

    public abstract void setFirstHour(Integer firstHour);

    public abstract String getMinTime();

    public abstract void setMinTime(String minTime);

    public abstract String getMaxTime();

    public abstract void setMaxTime(String maxTime);

    public abstract Boolean getEditable();

    public abstract void setEditable(Boolean editable);

    public abstract Boolean getSelectable();

    public abstract void setSelectable(Boolean selectable);

    public abstract Boolean getSelectHelper();

    public abstract void setSelectHelper(Boolean selectHelper);

    public abstract Boolean getUnselectAuto();

    public abstract void setUnselectAuto(Boolean unselectAuto);

    public abstract String getUnselectCancel();

    public abstract void setUnselectCancel(String unselectCancel);

    public abstract Boolean getDisableDragging();

    public abstract void setDisableDragging(Boolean disableDragging);

    public abstract Boolean getDisableResizing();

    public abstract void setDisableResizing(Boolean disableResizing);

    public abstract Integer getDragRevertDuration();

    public abstract void setDragRevertDuration(Integer dragRevertDuration);

    public abstract Double getDragOpacity();

    public abstract void setDragOpacity(Double dragOpacity);

    public abstract String getStyleClass();

    public abstract void setStyleClass(String styleClass);

    public abstract String getOnItemSelected();

    public abstract void setOnItemSelected(String onItemSelect);

    public abstract String getOnItemSelectedComplete();

    public abstract void setOnItemSelectedComplete(String onItemSelectedComplete);

    public abstract String getOnItemDragStart();

    public abstract void setOnItemDragStart(String onItemDragStart);

    public abstract String getOnItemDragStop();

    public abstract void setOnItemDragStop(String onItemDragStop);

    public abstract String getOnItemDrop();

    public abstract void setOnItemDrop(String onItemDrop);

    public abstract String getOnItemDropComplete();

    public abstract void setOnItemDropComplete(String onItemDropComplete);

    public abstract String getOnItemResizeStart();

    public abstract void setOnItemResizeStart(String onItemResizeStart);

    public abstract String getOnItemResizeStop();

    public abstract void setOnItemResizeStop(String onItemResizeStop);

    public abstract String getOnItemResized();

    public abstract void setOnItemResized(String onItemMouseover);

    public abstract String getOnItemResizedComplete();

    public abstract void setOnItemResizedComplete(String setOnItemResizedComplete);

    public abstract String getOnItemMouseover();

    public abstract void setOnItemMouseover(String onItemMouseover);

    public abstract String getOnItemMouseout();

    public abstract void setOnItemMouseout(String onItemMouseout);

    public abstract String getOnViewChanged();

    public abstract void setOnViewChanged(String onViewChanged);

    public abstract String getOnViewChangedComplete();

    public abstract void setOnViewChangedComplete(String onViewDisplayComplete);

    public abstract String getOnDateSelected();

    public abstract void setOnDateSelected(String onDaySelected);

    public abstract String getOnDateSelectedComplete();

    public abstract void setOnDateSelectedComplete(String setOnDateSelectedComplete);

    public abstract String getOnDateRangeSelected();

    public abstract void setOnDateRangeSelected(String onDateRangeSelected);

    public abstract String getOnDateRangeSelectedComplete();

    public abstract void setOnDateRangeSelectedComplete(String onDateRangeSelectedComplete);

    public abstract String getOnDateRangeChanged();

    public abstract void setOnDateRangeChanged(String onDateRangeChanged);

    public abstract String getOnDateRangeChangedComplete();

    public abstract void setOnDateRangeChangedComplete(String onDateRangeChangedComplete);

    // TODO do we use MethodBinding or MethodExpression?

    public abstract MethodBinding getItemMoveListener();

    public abstract void setItemMoveListener(MethodBinding listener);

    public abstract MethodBinding getItemSelectedListener();

    public abstract void setItemSelectedListener(MethodBinding listener);

    public abstract MethodBinding getItemResizeListener();

    public abstract void setItemResizeListener(MethodBinding listener);

    public abstract MethodBinding getViewChangedListener();

    public abstract void setViewChangedListener(MethodBinding listener);

    public abstract MethodBinding getDateRangeChangedListener();

    public abstract void setDateRangeChangedListener(MethodBinding listener);

    public abstract MethodBinding getDateRangeSelectedListener();

    public abstract void setDateRangeSelectedListener(MethodBinding listener);

    public abstract MethodBinding getDateSelectedListener();

    public abstract void setDateSelectedListener(MethodBinding listener);

    public abstract String getWidgetVar();

    public abstract void setWidgetVar(String widgetVar);

    /**
     * React on various events.
     * Vetoable events are first broadcasted to listeners bound via EL to
     * component attribtues and then if no veto is raised then to the rest of
     * listeners.
     * In case of non vetoable events the order of broadcast is reverse.
     * Vetoable events are: ScheduleItemMoveEvent, ScheduleItemResizeEvent
     * Non-vetoable events: ScheduleDateRangeChangedEvent, ScheduleItemSelectedEvent,
     * ScheduleViewChangedEvent, ScheduleDateSelectedEvent,
     * ScheduleDateRangeSelectedEvent
     * In case of ScheduleDateRangeChangedEvent new items are returned
     * via response data map of ajaxContext.
     * In case of ScheduleItemMoveEvent and ScheduleItemResizeEvent, the
     * decision if veto was raised is sent back to client via response data map
     * of ajaxContext as boolean.
     *
     * @param event broadcasted event
     * @throws AbortProcessingException if broadcasting of particular event
     *                                  should stop
     */
    @Override
    public void broadcast(FacesEvent event) throws AbortProcessingException {
        if (event instanceof ScheduleDateRangeChangedEvent) {
            super.broadcast(event);
            new AjaxEvent(this).queue();
            ScheduleDateRangeChangedEvent calendarAjaxEvent = (ScheduleDateRangeChangedEvent) event;
            FacesContext facesContext = getFacesContext();
            AjaxContext ajaxContext = AjaxContext.getCurrentInstance(facesContext);
            MethodBinding expression = getDateRangeChangedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{event});
            }
            try {
                ajaxContext.getResponseDataMap().put("_ajax:scheduleData", getScheduleData(calendarAjaxEvent.getStartDate(), calendarAjaxEvent.getEndDate()));
            } catch (IOException ex) {
                getFacesContext().getExternalContext().log("Cannot get schedule data", ex);
            }
        } else if (event instanceof ScheduleItemMoveEvent) {
            FacesContext facesContext = getFacesContext();
            AjaxContext ajaxContext = AjaxContext.getCurrentInstance(facesContext);
            MethodBinding expression = getItemMoveListener();
            boolean allow = true;
            if (expression != null) {
                Object result = expression.invoke(facesContext, new Object[]{event});
                allow = ((Boolean) result);
            }
            ajaxContext.getResponseDataMap().put("_ajax:scheduleData", allow);
            super.broadcast(event);
            new AjaxEvent(this).queue();
        } else if (event instanceof ScheduleItemResizeEvent) {
            FacesContext facesContext = getFacesContext();
            AjaxContext ajaxContext = AjaxContext.getCurrentInstance(facesContext);
            MethodBinding expression = getItemResizeListener();
            boolean allow = true;
            if (expression != null) {
                Object result = expression.invoke(facesContext, new Object[]{event});
                allow = ((Boolean) result);
            }
            ajaxContext.getResponseDataMap().put("_ajax:scheduleData", allow);
            super.broadcast(event);
            new AjaxEvent(this).queue();
        } else if (event instanceof ScheduleItemSelectedEvent) {
            super.broadcast(event);
            new AjaxEvent(this).queue();
            FacesContext facesContext = getFacesContext();
            MethodBinding expression = getItemSelectedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{event});
            }
        } else if (event instanceof ScheduleViewChangedEvent) {
            super.broadcast(event);
            new AjaxEvent(this).queue();
            FacesContext facesContext = getFacesContext();
            MethodBinding expression = getViewChangedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{event});
            }
        } else if (event instanceof ScheduleDateSelectedEvent) {
            super.broadcast(event);
            new AjaxEvent(this).queue();
            FacesContext facesContext = getFacesContext();
            MethodBinding expression = getDateSelectedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{event});
            }
        } else if (event instanceof ScheduleDateRangeSelectedEvent) {
            super.broadcast(event);
            new AjaxEvent(this).queue();
            FacesContext facesContext = getFacesContext();
            MethodBinding expression = getDateRangeSelectedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{event});
            }
        } else if (event instanceof AjaxEvent) {
            FacesContext context = getFacesContext();
            // complete re-Render fields. AjaxEvent deliver before render
            // response.
            AjaxContext.getCurrentInstance(context).addRegionsFromComponent(this);
            // Put data for send in response
            Object data = getData();
            AjaxContext ajaxContext = AjaxContext.getCurrentInstance(context);
            if (null != data) {
                ajaxContext.setResponseData(data);
            }
            String focus = getFocus();
            if (null != focus) {
                // search for component in tree.
                // XXX - use more pourful search, as in h:outputLabel
                // component.
                UIComponent focusComponent = RendererUtils.getInstance().
                        findComponentFor(this, focus);
                if (null != focusComponent) {
                    focus = focusComponent.getClientId(context);
                }
                ajaxContext.getResponseDataMap().put(AjaxActionComponent.FOCUS_DATA_ID, focus);
            }
            ajaxContext.setOncomplete(getOncomplete());
        } else {
            super.broadcast(event);
        }
    }

    /**
     * Range is [startDate;endDate), which means that start date is inclusive
     * and end date is exclusive.
     *
     * @param startDate
     * @param endDate
     * @return
     * @throws IOException
     */
    public List<Map<String, Object>> getScheduleData(Date startDate, Date endDate) throws IOException {
        /**
         * Locale must be US because this is the format the javascript widget supports
         */
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.US);
        format.setLenient(false);
        DataModel dataModel = getDataModel();
        if (dataModel instanceof ExtendedDataModel) {
            DataVisitor visitor = new DataVisitor() {
                //TODO Is this fine? or should we stack rowKeys and not use dataModel later on. I'don't know business rules of extendedDataModel, just used it once to do pagination with underlying EntityQuery from Seam

                public void process(FacesContext context, Object rowKey, Object argument) throws IOException {
                }
            };
            ((ExtendedDataModel) dataModel).walk(getFacesContext(), visitor, new DateRange(startDate, endDate), null);
        }
        ELContext elContext = getFacesContext().getELContext();
        ValueExpression valueExpression = getFacesContext().getApplication().getExpressionFactory().createValueExpression(getFacesContext().getELContext(), "#{" + getVar() + "}", Object.class);
        List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
        for (int i = 0; i < dataModel.getRowCount(); i++) {
            dataModel.setRowIndex(i);
            valueExpression.setValue(elContext, dataModel.getRowData());
            Map<String, Object> firstDataElement = new HashMap<String, Object>();
// TODO shouldn't we check earlier if there is at most one renderable UIScheduleItem child?
            for (UIComponent child : getChildren()) {
                if (child instanceof UIScheduleItem) {
                    UIScheduleItem item = (UIScheduleItem) child;
                    if (!item.isRendered()) {
                        continue;
                    }
                    firstDataElement.put("id", item.getEventId());
                    firstDataElement.put("title", item.getTitle());
                    if (item.getAllDay() != null) {
                        firstDataElement.put("allDay", item.getAllDay());
                    }
                    firstDataElement.put("start", format.format(item.getStartDate()));
                    if (item.getEndDate() != null) {
                        firstDataElement.put("end", format.format(item.getEndDate()));
                    }
                    if (item.getUrl() != null) {
                        firstDataElement.put("url", item.getUrl());
                    }
                    if (item.getStyleClass() != null) {
                        firstDataElement.put("className", item.getStyleClass());
                    }
                    if (item.getEditable() != null) {
                        firstDataElement.put("editable", item.getEditable());
                    }
                    if (item.getData() != null) {
                        firstDataElement.put("data", item.getData());
                    }
                    data.add(firstDataElement);
                }
            }
        }
        valueExpression.setValue(elContext, null);
        return data;
    }

    public static Date getFirstDisplayedDay(UISchedule schedule) {
        Calendar calendar = Calendar.getInstance();
        Date date = schedule.getDate();
        if (date != null) {
            calendar.setTime(date);
        }
        int firstDayOfWeek = getFirstDay(schedule);
        calendar.setFirstDayOfWeek(firstDayOfWeek);
        String view = getView(schedule);
        boolean showWeekends = isShowWeekends(schedule);
        if (VIEW_MONTH.equals(view)) {
            calendar.set(Calendar.DATE, 1);
            if (!showWeekends) {
                int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
                if (dayOfWeek == Calendar.SUNDAY) {
                    calendar.add(Calendar.DATE, 1);
                } else if (dayOfWeek == Calendar.SATURDAY) {
                    calendar.add(Calendar.DATE, 2);
                }
            }
            if (!showWeekends && firstDayOfWeek == Calendar.SUNDAY) {
                firstDayOfWeek++;
            }
            /**
             * Following 1 line is a fix to what i believe is a bug of java.util.Calendar
             */
            calendar.get(Calendar.DAY_OF_WEEK);
            calendar.set(Calendar.DAY_OF_WEEK, firstDayOfWeek);
            return calendar.getTime();
        } else if (VIEW_AGENDA_WEEK.equals(view) || VIEW_BASIC_WEEK.equals(view)) {
            calendar.set(Calendar.DAY_OF_WEEK, firstDayOfWeek);
            if (!showWeekends) {
                int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
                if (dayOfWeek == Calendar.SUNDAY) {
                    calendar.add(Calendar.DATE, 1);
                } else if (dayOfWeek == Calendar.SATURDAY) {
                    calendar.add(Calendar.DATE, 2);
                }
            }
            return calendar.getTime();
        } else if (VIEW_AGENDA_DAY.equals(view) || VIEW_BASIC_DAY.equals(view)) {
            return calendar.getTime();
        } else {
            throw new IllegalStateException("Invalid view attribute: " + view);
        }
    }

    public static Date getLastDisplayedDate(UISchedule schedule) {
        Calendar calendar = Calendar.getInstance();
        int firstDayOfWeek = getFirstDay(schedule);
        String view = getView(schedule);
        boolean showWeekends = isShowWeekends(schedule);
        if (VIEW_MONTH.equals(view)) {
            if (WEEK_MODE_FIXED.equals(getWeekMode(schedule))) {
                calendar.setTime(getFirstDisplayedDay(schedule));
                calendar.add(Calendar.DAY_OF_YEAR, 7 * 6);
            } else {
                Date date = schedule.getDate();
                if (date != null) {
                    calendar.setTime(date);
                }

                if (!showWeekends && firstDayOfWeek == Calendar.SUNDAY) {
                    firstDayOfWeek++;
                }
                calendar.setFirstDayOfWeek(firstDayOfWeek);
                calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE));
                int dayOfWeek = firstDayOfWeek + 6;
                if (dayOfWeek > Calendar.SATURDAY) {
                    dayOfWeek -= 7;
                }
                /**
                 * Following 1 line is a fix to what i believe is a bug of java.util.Calendar
                 */
                calendar.get(Calendar.DAY_OF_WEEK);
                calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
                calendar.add(Calendar.DATE, 1);
            }
            return calendar.getTime();
        } else if (VIEW_AGENDA_WEEK.equals(view) || VIEW_BASIC_WEEK.equals(view)) {
            calendar.setFirstDayOfWeek(firstDayOfWeek);
            calendar.setTime(getFirstDisplayedDay(schedule));
            calendar.add(Calendar.DATE, 7);
            if (!showWeekends) {
                int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
                if (dayOfWeek - 1 == Calendar.SUNDAY) {
                    calendar.add(Calendar.DATE, -2);
                } else if (dayOfWeek - 1 == Calendar.SATURDAY) {
                    calendar.add(Calendar.DATE, -1);
                }
            }
            return calendar.getTime();
        } else if (VIEW_AGENDA_DAY.equals(view) || VIEW_BASIC_DAY.equals(view)) {
            calendar.setTime(getFirstDisplayedDay(schedule));
            calendar.add(Calendar.DATE, 1);
            return calendar.getTime();
        } else {
            throw new IllegalStateException("Invalid view attribute: " + view);
        }

    }

    /**
     * Here go static methods for getting value or default value of attributes.
     */
    /**
     * @param schedule
     * @return
     */
    public static boolean isShowWeekends(UISchedule schedule) {
        Boolean showWeekends = schedule.getShowWeekends();
        return showWeekends == null || schedule.getShowWeekends();
    }

    public static int getFirstDay(UISchedule schedule) {
        Integer firstDay = schedule.getFirstDay();
        if (firstDay == null) {
            firstDay = Calendar.SUNDAY;
        }
        return firstDay;
    }

    public static String getWeekMode(UISchedule schedule) {
        String weekMode = schedule.getWeekMode();
        if (weekMode == null) {
            weekMode = WEEK_MODE_FIXED;
        }
        return weekMode;
    }

    public static String getView(UISchedule schedule) {
        String view = schedule.getView();
        if (view == null) {
            view = VIEW_MONTH;
        }
        return view;
    }

    protected DataModel getDataModel() {
        // Return any previously cached DataModel instance
        if (this.model != null) {
            return (model);
        }

        // Synthesize a DataModel around our current value if possible
        Object current = getValue();
        if (current == null) {
            setDataModel(new ListDataModel(Collections.EMPTY_LIST));
        } else if (current instanceof DataModel) {
            setDataModel((DataModel) current);
        } else if (current instanceof List) {
            setDataModel(new ListDataModel((List) current));
        } else if (Object[].class.isAssignableFrom(current.getClass())) {
            setDataModel(new ArrayDataModel((Object[]) current));
        } else if (current instanceof ResultSet) {
            setDataModel(new ResultSetDataModel((ResultSet) current));
        } else if (current instanceof Result) {
            setDataModel(new ResultDataModel((Result) current));
        } else {
            setDataModel(new ScalarDataModel(current));
        }
        return (model);

    }

    public void setDataModel(DataModel model) {
        this.model = model;
    }

    public void addItemSelectedListener(ScheduleItemSelectedListener listener) {
        addFacesListener(listener);
    }

    public void removeItemSelectedListener(ScheduleItemSelectedListener listener) {
        removeFacesListener(listener);
    }

    public ScheduleItemSelectedListener[] getItemSelectedListeners() {
        return (ScheduleItemSelectedListener[]) getFacesListeners(ScheduleItemSelectedListener.class);
    }

    public void addItemMoveListener(ScheduleItemMoveListener listener) {
        addFacesListener(listener);
    }

    public void removeItemMoveListener(ScheduleItemMoveListener listener) {
        removeFacesListener(listener);
    }

    public ScheduleItemMoveListener[] getItemMoveListeners() {
        return (ScheduleItemMoveListener[]) getFacesListeners(ScheduleItemMoveListener.class);
    }

    public void addItemResizeListener(ScheduleItemResizeListener listener) {
        addFacesListener(listener);
    }

    public void removeItemResizeListener(ScheduleItemResizeListener listener) {
        removeFacesListener(listener);
    }

    public ScheduleItemResizeListener[] getItemResizeListeners() {
        return (ScheduleItemResizeListener[]) getFacesListeners(ScheduleItemResizeListener.class);
    }

    public void addViewChangedListener(ScheduleViewChangedListener listener) {
        addFacesListener(listener);
    }

    public void removeViewChangedListener(ScheduleViewChangedListener listener) {
        removeFacesListener(listener);
    }

    public ScheduleViewChangedListener[] getViewChangedListeners() {
        return (ScheduleViewChangedListener[]) getFacesListeners(ScheduleViewChangedListener.class);
    }

    public void addDateRangeChangedListener(ScheduleDateRangeChangedListener listener) {
        addFacesListener(listener);
    }

    public void removeDateRangeChangedListener(ScheduleDateRangeChangedListener listener) {
        removeFacesListener(listener);
    }

    public ScheduleDateRangeChangedListener[] getDateRangeChangedListeners() {
        return (ScheduleDateRangeChangedListener[]) getFacesListeners(ScheduleDateRangeChangedListener.class);
    }

    public void addDateRangeSelectedListener(ScheduleDateRangeSelectedListener listener) {
        addFacesListener(listener);
    }

    public void removeDateRangeSelectedListener(ScheduleDateRangeSelectedListener listener) {
        removeFacesListener(listener);
    }

    public ScheduleDateRangeSelectedListener[] getDateRangeSelectedListeners() {
        return (ScheduleDateRangeSelectedListener[]) getFacesListeners(ScheduleDateRangeSelectedListener.class);
    }

    public void addDateSelectedListener(ScheduleDateSelectedListener listener) {
        addFacesListener(listener);
    }

    public void removeDateSelectedListener(ScheduleDateSelectedListener listener) {
        removeFacesListener(listener);
    }

    public ScheduleDateSelectedListener[] getDateSelectedListeners() {
        return (ScheduleDateSelectedListener[]) getFacesListeners(ScheduleDateSelectedListener.class);
    }
}