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

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.i18n.client.DateTimeFormat;
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 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;

public class MonthPanel<T> extends AbsolutePanel implements DateEventListener<T>, DatePanel<T>, HasDateEventHandlers<T> {

	private ArrayList<MonthPanelDropController<T>> dropControllers = new ArrayList<MonthPanelDropController<T>>();

	private Calendar current = new GregorianCalendar();

	private Calendar helperCal = new GregorianCalendar(); // NOPMD;

	private Grid monthPanels = new Grid(7, 7);

	private List<MonthPanelDayPanel<T>> panels = new ArrayList<MonthPanelDayPanel<T>>();

	private List<HandlerRegistration> registrations = new ArrayList<HandlerRegistration>();

	public int getFirstDayOfWeek() {
		return firstDayOfWeek;
	}

	public void setFirstDayOfWeek(int newFirstDayOfWeek) {
		if (firstDayOfWeek == newFirstDayOfWeek) {
			return;
		}
		this.firstDayOfWeek = newFirstDayOfWeek;
		current.setFirstDayOfWeek(firstDayOfWeek);
		buildPanel();
	}

	private int firstDayOfWeek = Calendar.MONDAY;

	private MonthPanelDragController dragController = null;

	private DateRenderer<T> renderer = null;

	public MonthPanel(DateRenderer<T> newRenderer) {
		super();
		setRenderer(newRenderer);
		// firstDayOfWeek = newRenderer.
		setStyleName(FtrGwtDateCss.MONTH_PANEL);
		monthPanels.setStyleName(FtrGwtDateCss.MONTH_PANEL);
		monthPanels.setCellSpacing(0);
		monthPanels.setCellPadding(0);
		this.add(monthPanels, 2, 0);
	}

	int maxWi = 70;

	public void setPixelSize(int width, int newHeight) {
		if (newHeight > 0) {
			super.setHeight(newHeight + "px");
		}
		if (width > 8) {
			super.setWidth(width + "px");
			monthPanels.setWidth(width - 3 + "px");
			maxWi = ((width - 7) / 7);
			if (maxWi > 0) {
				for (MonthPanelDayPanel<T> result : panels) {
					result.setWidth(maxWi);
				}
			}
		}
	}

	public final void setRenderer(DateRenderer<T> newRenderer) {
		renderer = newRenderer;
		if (renderer.enableDragAndDrop()) {
			if (dragController != null) {
				for (int i = 0; i < dropControllers.size(); i++) {
					final MonthPanelDropController<T> real = dropControllers.get(i);
					dragController.unregisterDropController(real);
				}
			}
			dragController = new MonthPanelDragController(this);
		}
		buildPanel();
	}

	public void setDate(Date newDate) {
		if (DateUtils.isSameDay(current.getTime(), newDate)) {
			return;
		}
		current.setTime(newDate);
		buildPanel();
	}

	private int xPos = 0; // NOPMD;

	private int yPos = 0; // NOPMD;

	private Date firstShow = null;

	private Date lastShow = null;

	private Date firstLogical = null;

	private Date lastLogical = null;

	private void buildPanel() {
		if (renderer.enableDragAndDrop()) {
			for (int i = 0; i < dropControllers.size(); i++) {
				final MonthPanelDropController<T> real = dropControllers.get(i);
				dragController.unregisterDropController(real);
			}
			dropControllers.clear();
		}

		for (HandlerRegistration registration : registrations) {
			registration.removeHandler();
		}

		registrations.clear();
		monthPanels.clear();

		DOM.setStyleAttribute(monthPanels.getElement(), "width", "100%");
		DOM.setStyleAttribute(monthPanels.getElement(), "height", "100%");

		helperCal.setFirstDayOfWeek(firstDayOfWeek);
		xPos = 0;
		yPos = 0;
		final Calendar today = new GregorianCalendar();
		final DateTimeFormat dayFormatter = DateTimeFormat.getFormat("E");
		for (int i = firstDayOfWeek; i < 7 + firstDayOfWeek; i++) {
			helperCal.set(Calendar.DAY_OF_WEEK, i);
			monthPanels.setWidget(yPos, xPos, new HTML(dayFormatter.format(helperCal.getTime())));
			monthPanels.getCellFormatter().setHorizontalAlignment(yPos, xPos, HorizontalPanel.ALIGN_CENTER);
			monthPanels.getCellFormatter().setHeight(yPos, xPos, "9%");
			monthPanels.getColumnFormatter().setWidth(xPos, "12%");
			xPos++;
		}
		yPos++;

		// set logical first day of the month
		helperCal.setTime(current.getTime());
		helperCal.set(Calendar.DAY_OF_MONTH, 1);
		helperCal.set(Calendar.HOUR_OF_DAY, 0);
		helperCal.set(Calendar.MINUTE, 0);
		helperCal.set(Calendar.SECOND, 0);
		helperCal.set(Calendar.MILLISECOND, 0);
		firstLogical = helperCal.getTime();
		// set logical last day of the month
		helperCal.add(Calendar.MONTH, 1);
		helperCal.add(Calendar.MILLISECOND, -1);
		lastLogical = helperCal.getTime();
		// now loop over full weeks for showing days
		helperCal.setTime(current.getTime());
		helperCal.add(Calendar.DAY_OF_MONTH, -(helperCal.get(Calendar.DAY_OF_MONTH)));
		while (helperCal.get(Calendar.DAY_OF_WEEK) != helperCal.getFirstDayOfWeek()) {
			helperCal.add(Calendar.DAY_OF_MONTH, -1);
		}
		panels.clear();
		firstShow = helperCal.getTime();
		for (int y = 1; y < 7; y++) {
			for (int x = 0; x < 7; x++) {
				monthPanels.getCellFormatter().setHeight(y, x, "13%");
				final MonthPanelDayPanel<T> result = makeDayPanel(helperCal);
				panels.add(result);
				registrations.add(result.addDateEventHandler(this));
				if (DateUtils.isSameDay(today, helperCal)) {
					result.addStyleName(FtrGwtDateCss.DATE_DAY_TODAY);
				}

				monthPanels.setWidget(y, x, result);
				if (renderer.enableDragAndDrop() && dragController != null) {
					final MonthPanelDropController<T> dropController = new MonthPanelDropController<T>(result);
					dropControllers.add(dropController);
					dragController.registerDropController(dropController);
				}
				helperCal.add(Calendar.DAY_OF_MONTH, 1);
			}
		}
		lastShow = helperCal.getTime();
	}

	private MonthPanelDayPanel<T> makeDayPanel(Calendar calender) {
		return new MonthPanelDayPanel<T>(calender.get(Calendar.DAY_OF_MONTH), calender.getTime(), this, renderer);
	}

	@SuppressWarnings("unchecked")
	public void addEventData(T newEvent) {
		for (MonthPanelDayPanel<T> result : panels) {
			if (result.isDay(newEvent)) {
				final EventPanel<T> entry = (EventPanel<T>) renderer.createPanel(newEvent, getType());
				if (dragController != null && entry.isDraggable()) {
					dragController.makeDraggable(entry, entry.getDraggableItem());
				}
				entry.addParentDateEventHandler(this);
				result.addEvent(entry);
			}
		}
	}

	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 DateRenderer<T> getRenderer() {
		return renderer;
	}

	public Date next() {
		current.add(Calendar.MONTH, 1);
		buildPanel();
		return current.getTime();
	}

	public Date prev() {
		current.add(Calendar.MONTH, -1);
		buildPanel();
		return current.getTime();
	}

	public Date nextMore() {
		current.add(Calendar.YEAR, 1);
		buildPanel();
		return current.getTime();
	}

	public Date prevMore() {
		current.add(Calendar.YEAR, -1);
		buildPanel();
		return current.getTime();
	}

	public void updateEventData(T newEvent) {
		removeEventData(newEvent);
		addEventData(newEvent);
	}

	public void removeEventData(T newEvent) {
		for (MonthPanelDayPanel<T> result : panels) {
			EventPanel<T> removed = result.removeEvent(newEvent);
			if (removed != null) {
				removed.clearParent();
				return;
			}
		}
	}

	public Date getFirstDateShow() {
		return firstShow;
	}

	public Date getLastDateShow() {
		return lastShow;
	}

	public Date getFirstDateLogical() {
		return firstLogical;
	}

	public Date getLastDateLogical() {
		return lastLogical;
	}

	public void clearData() {
		for (MonthPanelDayPanel<T> result : panels) {
			result.clearEvents();
		}
	}

	public PanelType getType() {
		return PanelType.MONTH;
	}

	public void setEvents(List<? extends T> events) {
		clearData();
		addEventsByList(events);
	}

	public void addEventsByList(List<? extends T> events) {
		if (events != null) {
			for (int i = 0; i < events.size(); i++) {
				addEventData(events.get(i));
			}
		}
	}

}