package org.richfaces.component;

import org.richfaces.component.event.ScheduleViewChangedEvent;
import org.richfaces.component.event.ScheduleDateRangeChangedEvent;
import org.richfaces.component.event.ScheduleItemResizeEvent;
import org.richfaces.component.event.ScheduleItemSelectedEvent;
import org.ajax4jsf.context.AjaxContext;
import org.ajax4jsf.model.DataVisitor;
import org.ajax4jsf.model.ExtendedDataModel;

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.*;

import org.richfaces.component.event.ScheduleDateRangeChangedListener;
import org.richfaces.component.event.ScheduleDateSelectedEvent;
import org.richfaces.component.event.ScheduleDateSelectedListener;
import org.richfaces.component.event.ScheduleItemSelectedListener;
import org.richfaces.component.event.ScheduleItemMoveEvent;
import org.richfaces.component.event.ScheduleItemMoveListener;
import org.richfaces.component.event.ScheduleItemResizeListener;
import org.richfaces.component.event.ScheduleListenerEventsProducer;
import org.richfaces.component.event.ScheduleViewChangedListener;
import org.richfaces.component.model.DateRange;

public abstract class UISchedule extends UIComponentBase implements ScheduleCommonViewAttributes, ScheduleListenerEventsProducer {

    public static final String COMPONENT_TYPE = "org.richfaces.Schedule";
    public static final String COMPONENT_FAMILY = "org.richfaces.Schedule";
    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";
    public static final String WEEK_MODE_FIXED = "fixed";
    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 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 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 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 getOnItemMouseover();

    public abstract void setOnItemMouseover(String onItemMouseover);

    public abstract String getOnItemMouseout();

    public abstract void setOnItemMouseout(String onItemMouseout);

    public abstract String getOnViewDisplay();

    public abstract void setOnViewDisplay(String onViewDisplay);

    public abstract String getOnDateSelected();

    public abstract void setOnDateSelected(String onDaySelected);

    // 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 getDateSelectedListener();

    public abstract void setDateSelectedListener(MethodBinding listener);

    @Override
    public void broadcast(FacesEvent event) throws AbortProcessingException {
        if (event instanceof ScheduleDateRangeChangedEvent) {
            super.broadcast(event);
            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.setResponseData(allow);
            super.broadcast(event);
        } 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.setResponseData(allow);
            super.broadcast(event);
        } else if (event instanceof ScheduleItemSelectedEvent) {
            super.broadcast(event);
            FacesContext facesContext = getFacesContext();
            MethodBinding expression = getItemSelectedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{event});
            }
        } else if (event instanceof ScheduleViewChangedEvent) {
            super.broadcast(event);
            FacesContext facesContext = getFacesContext();
            MethodBinding expression = getViewChangedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{event});
            }
        } else if (event instanceof ScheduleDateSelectedEvent) {
            super.broadcast(event);
            FacesContext facesContext = getFacesContext();
            MethodBinding expression = getDateSelectedListener();
            if (expression != null) {
                expression.invoke(facesContext, new Object[]{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 to did once 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 addDateSelectedListener(ScheduleDateSelectedListener listener) {
        addFacesListener(listener);
    }

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

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