/*

 * Copyright 2007 Future Earth, info@future-earth.eu

 *

 * Licensed under the Apache License, Version 2.0 (the "License"); you may not

 * use this file except in compliance with the License. You may obtain a copy of

 * the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

 * License for the specific language governing permissions and limitations under

 * the License.

 */



package eu.future.earth.gwt.client.date.weeklist;



import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.List;



import org.cobogw.gwt.user.client.CSS;



import com.allen_sauer.gwt.dnd.client.drop.AbstractDropController;

import com.google.gwt.core.client.GWT;

import com.google.gwt.event.shared.HandlerRegistration;

import com.google.gwt.user.client.DOM;

import com.google.gwt.user.client.ui.AbsolutePanel;

import com.google.gwt.user.client.ui.Grid;

import com.google.gwt.user.client.ui.HTML;

import com.google.gwt.user.client.ui.HorizontalPanel;

import com.google.gwt.user.client.ui.ScrollPanel;

import com.google.gwt.user.client.ui.VerticalPanel;



import eu.future.earth.gwt.client.FtrGwtDateCss;

import eu.future.earth.gwt.client.date.DateEvent;

import eu.future.earth.gwt.client.date.DateEvent.DateEventActions;

import eu.future.earth.gwt.client.date.DateEventListener;

import eu.future.earth.gwt.client.date.DatePanel;

import eu.future.earth.gwt.client.date.DateRenderer;

import eu.future.earth.gwt.client.date.DateUtils;

import eu.future.earth.gwt.client.date.EventPanel;

import eu.future.earth.gwt.client.date.HasDateEventHandlers;

import eu.future.earth.gwt.client.date.PanelType;

import eu.future.earth.gwt.client.date.week.DayEventElement;

import eu.future.earth.gwt.client.date.week.DayHeader;

import eu.future.earth.gwt.client.date.week.whole.DayEventpanel;

import eu.future.earth.gwt.client.date.week.whole.DayPanelParent;

import eu.future.earth.gwt.client.date.week.whole.WholeDayDragController;

import eu.future.earth.gwt.client.date.week.whole.WholeDayPanelDropController;



public class WeekListPanel<T> extends VerticalPanel implements DateEventListener<T>, DatePanel<T>, HasDateEventHandlers<T>, DayPanelParent<T> {



	private AbsolutePanel wholeDayDragPanel = new AbsolutePanel();



	private WholeDayDragController wholeDayDragController = null;



	private List<AbstractDropController> dropControllers = new ArrayList<AbstractDropController>();



	private ArrayList<DayEventElement<T>> dayList = new ArrayList<DayEventElement<T>>();



	private HorizontalPanel headerPanel = new HorizontalPanel();



	private VerticalPanel topPanelDays = new VerticalPanel();



	private Grid labels = new Grid();



	private Grid dayEvents = new Grid();



	// private Grid mainPanel = new Grid(1, 2);



	private Grid daysGrid = new Grid();



	private WeekListPanelDragController weekDragController = null;



	private AbsolutePanel dragPanel = new AbsolutePanel();



	private ScrollPanel scroller = new ScrollPanel(dragPanel);



	private Calendar current = new GregorianCalendar();



	private int daysShown = 7;



	private int firstDayOfWeek = Calendar.MONDAY;



	public WeekListPanel(DateRenderer<T> newRenderer) {

		this(DateUtils.countDays(newRenderer), newRenderer);

	}



	public int getTopScrollable() {

		return daysGrid.getAbsoluteTop();

	}



	public WeekListPanel(int newNumberOfDays, DateRenderer<T> newRenderer) {

		this(newNumberOfDays, newRenderer, true);

	}



	private boolean showDayLabel = true;



	public WeekListPanel(int newNumberOfDays, DateRenderer<T> newRenderer, boolean newShowDayLabel) {

		super();

		showDayLabel = newShowDayLabel;

		super.setWidth("100%");

		daysShown = newNumberOfDays;

		labels.resize(1, newNumberOfDays);

		daysGrid.resize(1, newNumberOfDays);

		dayEvents.resize(1, newNumberOfDays);



		renderer = newRenderer;

		if (renderer.enableDragAndDrop()) {

			weekDragController = new WeekListPanelDragController(dragPanel);

			wholeDayDragController = new WholeDayDragController(wholeDayDragPanel);

		}



		dragPanel.add(daysGrid);

		headerPanel.setWidth("100%");

		headerPanel.setStyleName(FtrGwtDateCss.WEEK_HEADER);

		// mainPanel.setWidth("100%");

		// mainPanel.setCellPadding(0);

		// mainPanel.setCellSpacing(0);



		topPanelDays.setWidth("100%");

		labels.setWidth("100%");

		dayEvents.setWidth("100%");

		daysGrid.setWidth("100%");

		daysGrid.setStyleName(FtrGwtDateCss.WEEK_BODY);

		CSS.setProperty(daysGrid, CSS.A.HEIGHT, "100%");

		CSS.setProperty(daysGrid, CSS.A.BORDER_COLOR, "#d0e4f6");

		CSS.setProperty(daysGrid, CSS.A.BORDER_STYLE, CSS.V.BORDER_STYLE.SOLID);

		CSS.setProperty(daysGrid, CSS.A.BORDER_WIDTH, "1px");

		daysGrid.setCellPadding(0);

		daysGrid.setCellSpacing(0);



		dragPanel.setWidth("100%");

		super.add(headerPanel);

		super.setCellVerticalAlignment(headerPanel, VerticalPanel.ALIGN_BOTTOM);

		super.add(scroller);



		headerSpaceBefore = new HTML("&nbsp;");

		headerPanel.add(headerSpaceBefore);

		headerPanel.add(topPanelDays);



		headerSpaceAfter = new HTML("&nbsp;");

		headerPanel.add(headerSpaceAfter);

		headerPanel.setSpacing(0);

		if (showDayLabel) {

			topPanelDays.add(labels);

		}

		if (renderer.showWholeDayEventView()) {

			topPanelDays.add(wholeDayDragPanel);

			wholeDayDragPanel.add(dayEvents);

			wholeDayDragPanel.setStyleName(FtrGwtDateCss.DATE_DAY_FULL);

			wholeDayDragPanel.setWidth("100%");



			dayEvents.setStyleName(FtrGwtDateCss.WEEK_HEADER_EVENTS);

			dayEvents.setCellPadding(0);

			dayEvents.setCellSpacing(0);



			dayEvents.setWidth("100%");

		}



		topPanelDays.setSpacing(0);



		super.setSpacing(0);

		current.setFirstDayOfWeek(firstDayOfWeek);

		current.setTime(new Date()); 

		current.set(Calendar.HOUR_OF_DAY, 0);

		current.set(Calendar.MINUTE, 0);

		current.set(Calendar.SECOND, 0);

		current.set(Calendar.MILLISECOND, 0);

		buildPanel();



	}



	private DateRenderer<T> renderer = null;



	public DateRenderer<T> getRenderer() {

		return renderer;

	}



	public void setRenderer(DateRenderer<T> renderer) {

		this.renderer = renderer;

		buildPanel();

	}



	private Date firstLogical = null;



	private Date lastLogical = null;



	@SuppressWarnings("unchecked")

	public void buildPanel() {

		if (renderer.enableDragAndDrop()) {

			for (AbstractDropController dropController : dropControllers) {

				if (dropController instanceof WeekListDayDropController<?>) {

					final WeekListDayDropController<T> real = (WeekListDayDropController<T>) dropController;

					weekDragController.unregisterDropController(real);

				} else {

					if (renderer.showWholeDayEventView()) {

						if (dropController instanceof WholeDayPanelDropController<?>) {

							final WholeDayPanelDropController<T> real = (WholeDayPanelDropController<T>) dropController;

							wholeDayDragController.unregisterDropController(real);

						}

					}

				}

			}



			for (int i = 0; i < dayList.size(); i++) {

				final DayEventElement<T> result = dayList.get(i);

				result.destroy();

				result.clearEvents();

			}

			dropControllers.clear();

		}

		dayList.clear();



		labels.clear();

		dayEvents.clear();

		daysGrid.clear();



		DOM.removeElementAttribute(scroller.getElement(), "style");



		DOM.setStyleAttribute(scroller.getElement(), "overflow", "auto");

		DOM.setStyleAttribute(scroller.getElement(), "overflowY", "auto");

		DOM.setStyleAttribute(scroller.getElement(), "position", "relative");



		DOM.setStyleAttribute(scroller.getElement(), "overflowX", "hidden");

		scroller.setStyleName(FtrGwtDateCss.WEEK_SCROLLER);



		headerSpaceAfter.setWidth("16px");

		headerPanel.setCellWidth(headerSpaceAfter, "16px");



		// mainPanel.getCellFormatter().setStyleName(0, 0, FtrGwtDateCss.HOUR_MAIN_PANEL);

		// mainPanel.getCellFormatter().setHorizontalAlignment(0, 0, ALIGN_RIGHT);

		Calendar helperCal = new GregorianCalendar();

		helperCal.setTime(current.getTime());

		helperCal.setFirstDayOfWeek(getFirstDayOfWeek());

		if (daysShown > 1) {

			helperCal.set(Calendar.DAY_OF_WEEK, getFirstDayOfWeek());

		}

		firstLogical = helperCal.getTime();

		final Calendar today = new GregorianCalendar();

		final String colWide = (100 / daysShown) + "%";

		for (int i = 0; i < daysShown; i++) {

			if (renderer.showDay(helperCal.get(Calendar.DAY_OF_WEEK))) {



				final Date currentDate = helperCal.getTime();



				final WeekListDayPanel<T> dayPanel = new WeekListDayPanel<T>(renderer);



				if (DateUtils.isSameDay(today, helperCal)) {

					dayPanel.addStyleName(FtrGwtDateCss.DATE_DAY_TODAY);

				}

				dayPanel.setDay(helperCal);

				dayPanel.addDateEventHandler(this);

				daysGrid.setWidget(0, i, dayPanel);

				if (renderer.enableDragAndDrop()) {

					final WeekListDayDropController<T> dayController = new WeekListDayDropController<T>(dayPanel, this);

					dropControllers.add(dayController);

					weekDragController.registerDropController(dayController);

				}

				daysGrid.getCellFormatter().setWidth(0, i, colWide);

				// Set the headers

				final DayHeader<T> label = new DayHeader<T>(currentDate, renderer);

				labels.setWidget(0, i, label);

				labels.getCellFormatter().setWidth(0, i, colWide);

				label.addDateEventHandler(this);

				if (renderer.showWholeDayEventView()) {

					final DayEventpanel<T> eventPanel = new DayEventpanel<T>(renderer, currentDate, this);

					dayEvents.setWidget(0, i, eventPanel);

					if (renderer.enableDragAndDrop()) {

						final WholeDayPanelDropController<T> dayController = new WholeDayPanelDropController<T>(eventPanel);

						dropControllers.add(dayController);

						wholeDayDragController.registerDropController(dayController);

					}

					dayEvents.getCellFormatter().setWidth(0, i, colWide);

					eventPanel.addDateEventHandler(this);

					eventPanel.setDay(helperCal);

					dayList.add(eventPanel);

				}

				dayList.add(dayPanel);

			} else {

				i--;

			}

			helperCal.add(Calendar.DAY_OF_WEEK, 1);

		}

		lastLogical = helperCal.getTime();

		int topNeeds = getTopPanelNeeds();

		topPanelDays.setHeight(topNeeds + "px");

		scroller.setHeight((headerPanel.getOffsetHeight()) + "px");

	}



	public void setDate(Date activeday) {

		GWT.log("Setting to " + activeday, null);

		final Calendar test = new GregorianCalendar();

		test.setTime(activeday);

		test.set(Calendar.HOUR_OF_DAY, 0);

		test.set(Calendar.MINUTE, 0);

		test.set(Calendar.SECOND, 0);

		test.set(Calendar.MILLISECOND, 0);

		if (DateUtils.isSameDay(test, current)) {

			return;

		}

		current.setTime(activeday);

		current.set(Calendar.HOUR_OF_DAY, 0);

		current.set(Calendar.MINUTE, 0);

		current.set(Calendar.SECOND, 0);

		current.set(Calendar.MILLISECOND, 0);

		// buildPanel();

		modifyDate();

	}



	@SuppressWarnings("unchecked")

	private void modifyDate() {

		if (dayList != null) {

			for (int i = 0; i < dayList.size(); i++) {

				final DayEventElement<T> result = dayList.get(i);

				result.clearEvents();

			}

		}

		Calendar helperCal = new GregorianCalendar();

		helperCal.setFirstDayOfWeek(getFirstDayOfWeek());

		helperCal.setTime(current.getTime());

		if (daysShown > 1) {

			helperCal.set(Calendar.DAY_OF_WEEK, helperCal.getFirstDayOfWeek());

		}

		GWT.log("Start on " + helperCal.getTime(), null);

		firstLogical = helperCal.getTime();

		final Calendar today = new GregorianCalendar();

		for (int i = 0; i < daysShown; i++) {

			if (renderer.showDay(helperCal.get(Calendar.DAY_OF_WEEK))) {

				WeekListDayPanel<T> dayPanel = (WeekListDayPanel<T>) daysGrid.getWidget(0, i);

				dayPanel.setDay(helperCal);

				if (DateUtils.isSameDay(today, helperCal)) {

					dayPanel.addStyleName(FtrGwtDateCss.DATE_DAY_TODAY);

				} else {

					dayPanel.removeStyleName(FtrGwtDateCss.DATE_DAY_TODAY);

				}

				final DayHeader<T> label = (DayHeader<T>) labels.getWidget(0, i);

				label.setDate(helperCal.getTime());

				if (renderer.showWholeDayEventView()) {

					final DayEventpanel<T> eventPanel = (DayEventpanel<T>) dayEvents.getWidget(0, i);

					eventPanel.setDay(helperCal);

				}

			}

			helperCal.add(Calendar.DAY_OF_WEEK, 1);

		}

		lastLogical = helperCal.getTime();



	}



	public int getDaysShown() {

		return daysShown;

	}



	public PanelType getType() {

		return PanelType.WEEK_LIST;

	}



	public int getFirstDayOfWeek() {

		return firstDayOfWeek;

	}



	public void setDaysShown(int newDaysShown) {

		if (daysShown == newDaysShown) {

			return;

		}

		this.daysShown = newDaysShown;

		buildPanel();

	}



	public void setFirstDayOfWeek(int newFirstDayOfWeek) {

		if (firstDayOfWeek == newFirstDayOfWeek) {

			return;

		}

		this.firstDayOfWeek = newFirstDayOfWeek;

		current.setFirstDayOfWeek(firstDayOfWeek);

		buildPanel();

	}



	@SuppressWarnings("unchecked")

	private void createPanel(DayEventElement<T> result, T newEvent, boolean partOfBatch) {

		final EventPanel<T> entry = (EventPanel<T>) renderer.createPanel(newEvent, getType());

		if (entry != null) {

			if (renderer.showWholeDayEventView()) {

				if (wholeDayDragController != null && entry.isDraggable()) {

					wholeDayDragController.makeDraggable(entry, entry.getDraggableItem());

				}

			}

			result.addEvent(entry, partOfBatch);

			entry.addParentDateEventHandler(this);

		}

	}



	public void notifyReady(DateEventActions action, T data, boolean reload) {

		if (reload) {

			loadData();

		}

		switch (action) {

		case ADD_DONE: {

			addEventData(data);

			break;

		}

		case REMOVE_DONE: {

			removeEventData(data);

			break;

		}

		case UPDATE_DONE: {

			updateEventData(data);

			break;

		}

		default:

			break;

		}

		DateEvent.fire(this, action, data);

	}



	public void loadData() {

		clearData();

		renderer.getEventsForRange(getFirstDateShow(), getLastDateShow(), this, true);

	}



	public void handleDateEvent(DateEvent<T> newEvent) {

		switch (newEvent.getCommand()) {

		case DRAG_DROP: {

			renderer.updateEvent(renderer.createUpdateHandler(this, newEvent.getData()));

			break;

		}

		case UPDATE: {

			renderer.updateEvent(renderer.createUpdateHandler(this, newEvent.getData()));

			break;

		}

		case REMOVE: {

			renderer.removeEvent(renderer.createRemoveHandler(this, newEvent.getData()));

			break;

		}

		case ADD: {

			renderer.addEvent(renderer.createAddHandler(this, newEvent.getData()));

			break;

		}

		case ADD_DONE: {

			addEventData(newEvent.getData());

			DateEvent.fire(this, newEvent.getDate(), newEvent.getCommand(), newEvent.getData());

			break;

		}

		case REMOVE_DONE: {

			removeEventData(newEvent.getData());

			DateEvent.fire(this, newEvent.getDate(), newEvent.getCommand(), newEvent.getData());

			break;

		}

		case UPDATE_DONE: {

			updateEventData(newEvent.getData());

			DateEvent.fire(this, newEvent.getDate(), newEvent.getCommand(), newEvent.getData());

			break;

		}

		case EDIT: {

			renderer.editAfterClick(newEvent.getData(), this);

			break;

		}

		case RELOAD: {

			loadData();

			DateEvent.fire(this, newEvent.getDate(), newEvent.getCommand(), newEvent.getData());

			break;

		}

		default:

			DateEvent.fire(this, newEvent.getDate(), newEvent.getCommand(), newEvent.getData());

			break;

		}

	}



	public HandlerRegistration addDateEventHandler(DateEventListener<? extends T> handler) {

		return addHandler(handler, DateEvent.getType());

	}



	public Date next() {

		if (daysShown > 1) {

			current.add(Calendar.DAY_OF_WEEK, 7);

		} else {

			current.add(Calendar.DAY_OF_WEEK, 1);

		}

		// current.add(Calendar.DAY_OF_WEEK, daysShown);

		// buildPanel();

		modifyDate();

		return current.getTime();

	}



	public Date prev() {

		if (daysShown > 1) {

			current.add(Calendar.DAY_OF_WEEK, -7);

		} else {

			current.add(Calendar.DAY_OF_WEEK, -1);

		}

		// buildPanel();

		modifyDate();

		return current.getTime();

	}



	public Date nextMore() {

		if (daysShown > 1) {

			current.add(Calendar.MONTH, 1);

		} else {

			current.add(Calendar.DAY_OF_WEEK, 7);

		}

		// buildPanel();

		modifyDate();

		return current.getTime();

	}



	public Date prevMore() {

		if (daysShown > 1) {

			current.add(Calendar.MONTH, -1);

		} else {

			current.add(Calendar.DAY_OF_WEEK, -7);

		}

		// buildPanel();

		modifyDate();

		return current.getTime();

	}



	public void updateEventData(T newEvent) {

		removeEventData(newEvent);

		addEventData(newEvent);

	}



	public void removeEventData(T newEvent) {

		for (DayEventElement<T> panel : dayList) {

			EventPanel<? extends T> removed = panel.removeEvent(newEvent);

			if (removed != null) {

				removed.clearParent();

				return;

			}

		}



	}



	public void addEventsByList(List<? extends T> events) {

		if (events != null) {

			for (int i = 0; i < events.size(); i++) {

				addEventData(events.get(i), true);

			}

		}



		for (DayEventElement<T> panel : dayList) {

			panel.repaintEvents();

		}

	}



	private void addEventData(T newEvent, boolean isPartOfBatch) {

		for (DayEventElement<T> panel : dayList) {

			if (panel.isDay(newEvent)) {

				createPanel(panel, newEvent, isPartOfBatch);

			}

		}

	}



	public void addEventData(T newEvent) {

		addEventData(newEvent, false);

	}



	private HTML headerSpaceBefore;



	private HTML headerSpaceAfter;



	public int getHeight() {

		return height;

	}



	public void repaint() {

		for (DayEventElement<T> panel : dayList) {

			panel.repaintEvents();

		}

	}



	private int width = 100;



	private int height = 400;



	public void setPixelSize(int newWidth, int newHeight) {

		width = newWidth;

		int topDragNeeds = getTopPanelNeeds();

		topPanelDays.setHeight(topDragNeeds + "px");



		height = newHeight;

		scroller.setHeight((height - headerPanel.getOffsetHeight()) + "px");

		super.setWidth(width + "px");

		int wi = width;

		if (wi < 0) {

			wi = this.getElement().getOffsetWidth();

		}

		int maxWi = wi / getDaysShown();

		for (int i = 0; i < dayList.size(); i++) {

			final DayEventElement<T> result = dayList.get(i);

			result.setElementWide(maxWi);

		}

		GWT.log("Panle " + width + " Result " + maxWi, null);

		repaint();

	}



	public int getTopPanelNeeds() {

		int max = 0;

		if (renderer.showWholeDayEventView()) {

			for (DayEventElement<T> panel : dayList) {

				if (panel instanceof DayEventpanel<?>) {

					final DayEventpanel<T> real = (DayEventpanel<T>) panel;

					final int newTest = real.neededHeight();

					if (newTest > max) {

						max = newTest;

					}

				}

			}

			wholeDayDragPanel.setHeight(max + "px");

		}

		return max + labels.getOffsetHeight();

	}



	public Date getFirstDateShow() {

		return firstLogical;

	}



	public Date getLastDateShow() {

		return lastLogical;

	}



	public Date getFirstDateLogical() {

		return firstLogical;

	}



	public Date getLastDateLogical() {

		return lastLogical;

	}



	public void clearData() {

		if (dayList != null) {

			for (DayEventElement<T> panel : dayList) {

				panel.clearEvents();

			}

		}

	}



	public void setEvents(List<? extends T> events) {

		clearData();

		addEventsByList(events);

	}



}