package org.gcube.portlets.user.td.monitorwidget.client.background;

import java.util.ArrayList;
import java.util.List;

import org.gcube.portlets.user.td.gwtservice.shared.exception.TDGWTSessionExpiredException;
import org.gcube.portlets.user.td.gwtservice.shared.monitor.OperationMonitor;
import org.gcube.portlets.user.td.gwtservice.shared.task.State;
import org.gcube.portlets.user.td.gwtservice.shared.task.ValidationsTasksMetadata;
import org.gcube.portlets.user.td.gwtservice.shared.task.WorkerState;
import org.gcube.portlets.user.td.gwtservice.shared.task.WorkerStateParser;
import org.gcube.portlets.user.td.monitorwidget.client.details.tree.MonitorBaseDto;
import org.gcube.portlets.user.td.monitorwidget.client.details.tree.MonitorFolderDto;
import org.gcube.portlets.user.td.monitorwidget.client.details.tree.MonitorTreeDataGenerator;
import org.gcube.portlets.user.td.monitorwidget.client.details.tree.MonitorValidationJobSDto;
import org.gcube.portlets.user.td.monitorwidget.client.resources.ResourceBundle;
import org.gcube.portlets.user.td.monitorwidget.client.utils.UtilsGXT3;
import org.gcube.portlets.user.td.widgetcommonevent.client.event.SessionExpiredEvent;
import org.gcube.portlets.user.td.widgetcommonevent.client.type.SessionExpiredType;
import org.gcube.portlets.user.td.widgetcommonevent.shared.TRId;

import com.allen_sauer.gwt.log.client.Log;
import com.google.gwt.cell.client.AbstractCell;
import com.google.gwt.cell.client.Cell.Context;
import com.google.gwt.event.logical.shared.SelectionEvent;
import com.google.gwt.event.logical.shared.SelectionHandler;
import com.google.gwt.resources.client.ImageResource;
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
import com.google.gwt.safehtml.shared.SafeHtmlUtils;
import com.google.web.bindery.event.shared.EventBus;
import com.sencha.gxt.cell.core.client.ProgressBarCell;
import com.sencha.gxt.core.client.ToStringValueProvider;
import com.sencha.gxt.core.client.ValueProvider;
import com.sencha.gxt.core.client.dom.ScrollSupport.ScrollMode;
import com.sencha.gxt.core.client.util.Margins;
import com.sencha.gxt.data.shared.IconProvider;
import com.sencha.gxt.data.shared.ModelKeyProvider;
import com.sencha.gxt.data.shared.TreeStore;
import com.sencha.gxt.widget.core.client.FramedPanel;
import com.sencha.gxt.widget.core.client.container.MarginData;
import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer;
import com.sencha.gxt.widget.core.client.container.VerticalLayoutContainer.VerticalLayoutData;
import com.sencha.gxt.widget.core.client.event.CollapseItemEvent;
import com.sencha.gxt.widget.core.client.event.CollapseItemEvent.CollapseItemHandler;
import com.sencha.gxt.widget.core.client.event.ExpandItemEvent;
import com.sencha.gxt.widget.core.client.event.ExpandItemEvent.ExpandItemHandler;
import com.sencha.gxt.widget.core.client.grid.ColumnConfig;
import com.sencha.gxt.widget.core.client.grid.ColumnModel;
import com.sencha.gxt.widget.core.client.menu.Item;
import com.sencha.gxt.widget.core.client.menu.Menu;
import com.sencha.gxt.widget.core.client.menu.MenuItem;
import com.sencha.gxt.widget.core.client.treegrid.TreeGrid;

/**
 * 
 * @author "Giancarlo Panichi" <a
 *         href="mailto:g.panichi@isti.cnr.it">g.panichi@isti.cnr.it</a>
 * 
 */
public class MonitorBackgroundPanel extends FramedPanel implements
		MonitorBackgroundUpdaterListener {
	protected static final int STATUS_POLLING_DELAY = 5000;
	protected static final String WIDTH = "640px";
	protected static final String HEIGHT = "520px";
	protected static final int CC1WIDTH = 100;
	protected static final int CC2WIDTH = 60;
	protected static final int CC3WIDTH = 100;
	protected MonitorBackgroundDialog parent;

	protected ArrayList<MonitorBackgroundEventUIListener> monitorBackgroundEventUIListeners = new ArrayList<MonitorBackgroundEventUIListener>();

	protected MonitorBackgroundPanel thisPanel;

	protected Menu contextMenu;
	protected MenuItem infoItem;
	protected MenuItem abortItem;
	protected MenuItem hiddenItem;

	protected TRId trId;
	protected VerticalLayoutContainer con;
	protected ValidationsTasksMetadata validationsTasksMetadata;

	protected MonitorTreeDataGenerator gen;
	protected TreeStore<MonitorBaseDto> store;
	protected TreeGrid<MonitorBaseDto> tree;
	protected ArrayList<OperationMonitor> operationMonitorList;

	protected EventBus eventBus;
	protected MonitorBackgroundUpdater monitorBackgroundUpdater;

	class KeyProvider implements ModelKeyProvider<MonitorBaseDto> {
		@Override
		public String getKey(MonitorBaseDto item) {
			return (item instanceof MonitorFolderDto ? "f-" : "v-")
					+ item.getId();
		}
	}

	public MonitorBackgroundPanel(EventBus eventBus) {
		super();
		this.eventBus = eventBus;
		forceLayoutOnResize = true;
		init();
		create();
	}

	public MonitorBackgroundPanel(MonitorBackgroundDialog parent,
			EventBus eventBus) {
		super();
		this.eventBus = eventBus;
		this.parent = parent;
		forceLayoutOnResize = true;
		init();
		create();
	}

	protected void init() {
		setWidth(WIDTH);
		setHeight(HEIGHT);
		setHeaderVisible(false);
		setBodyBorder(false);
		setResize(true);

	}

	protected void create() {
		con = new VerticalLayoutContainer();
		con.setScrollMode(ScrollMode.AUTO);

		store = new TreeStore<MonitorBaseDto>(new KeyProvider());

		addChildrensToStore();

		ColumnConfig<MonitorBaseDto, String> cc1 = new ColumnConfig<MonitorBaseDto, String>(
				new ToStringValueProvider<MonitorBaseDto>("task"), CC1WIDTH,
				"Task");
		cc1.setHeader("Task");
		cc1.setCell(new AbstractCell<String>() {

			@Override
			public void render(Context context, String value, SafeHtmlBuilder sb) {
				sb.appendHtmlConstant("<span title='"
						+ SafeHtmlUtils.htmlEscape(value) + "'>" + value
						+ "</span>");

			}
		});

		ColumnConfig<MonitorBaseDto, String> cc2 = new ColumnConfig<MonitorBaseDto, String>(
				new ValueProvider<MonitorBaseDto, String>() {

					@Override
					public String getValue(MonitorBaseDto object) {
						String state = null;
						if (object instanceof MonitorValidationJobSDto) {
							state = ((MonitorValidationJobSDto) object)
									.getWorkerState().toString();

						}
						if (object instanceof MonitorFolderDto) {
							state = ((MonitorFolderDto) object).getState();
						}
						return state;
					}

					@Override
					public void setValue(MonitorBaseDto object, String value) {
						if (object instanceof MonitorValidationJobSDto) {
							WorkerState workerState = WorkerStateParser.parse(value);
							((MonitorValidationJobSDto) object)
									.setWorkerState(workerState);

						}
						if (object instanceof MonitorFolderDto) {
							((MonitorFolderDto) object).setState(value);
						}
					}

					@Override
					public String getPath() {
						return "status";
					}
				}, CC2WIDTH, "Status");
		cc2.setHeader("Status");

		ColumnConfig<MonitorBaseDto, Double> cc3 = new ColumnConfig<MonitorBaseDto, Double>(
				new ValueProvider<MonitorBaseDto, Double>() {

					@Override
					public Double getValue(MonitorBaseDto object) {
						Double d = null;
						if (object instanceof MonitorValidationJobSDto) {
							Float f = ((MonitorValidationJobSDto) object).getProgress();
							d = new Double(f);
						}
						if (object instanceof MonitorFolderDto) {
							Float f = ((MonitorFolderDto) object).getProgress();
							d = new Double(f);
						}

						return d;
					}

					@Override
					public void setValue(MonitorBaseDto object, Double value) {
						if (object instanceof MonitorValidationJobSDto) {
							((MonitorValidationJobSDto) object)
									.setProgress(value.floatValue());
						}
						if (object instanceof MonitorFolderDto) {
							((MonitorFolderDto) object).setProgress(value
									.floatValue());
						}
					}

					@Override
					public String getPath() {
						return "progress";
					}
				}, CC3WIDTH, "Progress");
		cc3.setHeader("Progress");

		ProgressBarCell progress = new ProgressBarCell() {
			@Override
			public boolean handlesSelection() {
				return true;
			}
		};
		progress.setProgressText("{0}% Complete");
		progress.setWidth(100);

		cc3.setCell(progress);

		List<ColumnConfig<MonitorBaseDto, ?>> l = new ArrayList<ColumnConfig<MonitorBaseDto, ?>>();
		l.add(cc1);
		l.add(cc2);
		l.add(cc3);
		ColumnModel<MonitorBaseDto> cm = new ColumnModel<MonitorBaseDto>(l);

		tree = new TreeGrid<MonitorBaseDto>(store, cm, cc1);
		tree.getView().setAutoFill(true);
		tree.setBorders(false);
		tree.setLoadMask(true);
		tree.setColumnResize(true);
		tree.getView().setAutoExpandColumn(cc1);
		tree.getElement().setAttribute("height", "auto");

		IconProvider<MonitorBaseDto> iconProvider = new IconProvider<MonitorBaseDto>() {

			@Override
			public ImageResource getIcon(MonitorBaseDto model) {
				ImageResource img = null;
				if (model instanceof MonitorFolderDto) {
					String type = ((MonitorFolderDto) model).getType();
					if (type.compareTo("job") == 0) {
						img = ResourceBundle.INSTANCE.cog();
					} else {
						if (type.compareTo("task") == 0) {
							img = ResourceBundle.INSTANCE.basket();
						} else {

						}
					}
				} else {
					img = ResourceBundle.INSTANCE.tableValidation();
				}
				return img;
			}
		};
		tree.setIconProvider(iconProvider);

		tree.addExpandHandler(new ExpandItemHandler<MonitorBaseDto>() {

			@Override
			public void onExpand(ExpandItemEvent<MonitorBaseDto> event) {
				forceLayout();

			}
		});

		tree.addCollapseHandler(new CollapseItemHandler<MonitorBaseDto>() {

			@Override
			public void onCollapse(CollapseItemEvent<MonitorBaseDto> event) {
				forceLayout();

			}
		});

		createContextMenu();

		con.add(tree, new VerticalLayoutData(1, -1, new Margins(0)));

		add(con, new MarginData(0));

		addMonitor();

		forceLayout();

	}

	protected void addMonitor() {
		monitorBackgroundUpdater = new MonitorBackgroundUpdater();

		monitorBackgroundUpdater.addListener(this);

		addMonitorBackgroundEventUIListener(monitorBackgroundUpdater);
		monitorBackgroundUpdater.scheduleRepeating(STATUS_POLLING_DELAY);
		monitorBackgroundUpdater.run();
	}

	public void addMonitorBackgroundEventUIListener(
			MonitorBackgroundEventUIListener listener) {
		monitorBackgroundEventUIListeners.add(listener);
	}

	public void removeMonitorBackgroundEventUIListener(
			MonitorBackgroundEventUIListener listener) {
		monitorBackgroundEventUIListeners.remove(listener);
	}

	public void update() {
		forceLayout();
	}

	public void close() {
		if (parent != null) {
			parent.close();
		}
		monitorBackgroundUpdater.cancel();

	}

	protected void requestOperationOnKey(Context context) {
		String key = (String) context.getKey();
		@SuppressWarnings("unused")
		MonitorBaseDto d = store.findModelWithKey(key);

	}

	private void addChildrensToStore() {
		gen = new MonitorTreeDataGenerator();
		try {
			MonitorFolderDto root = gen.getRoot(operationMonitorList);
			Log.debug("root childrens " + root.getChildrens().size());
			for (MonitorBaseDto base : root.getChildrens()) {
				Log.debug("Check children: " + base);

				store.add(base);

			}
		} catch (Throwable e) {
			Log.error("Error adding childrens to store :"
					+ e.getLocalizedMessage());
			e.printStackTrace();
		}
	}

	protected void createContextMenu() {
		contextMenu = new Menu();

		infoItem = new MenuItem();
		infoItem.setText("Info");
		infoItem.setIcon(ResourceBundle.INSTANCE.information());
		infoItem.addSelectionHandler(new SelectionHandler<Item>() {

			@Override
			public void onSelection(SelectionEvent<Item> event) {
				MonitorBaseDto selected = tree.getSelectionModel()
						.getSelectedItem();
				Log.debug(selected.toString());
				requestMoreInfo(selected);
			}
		});

		abortItem = new MenuItem();
		abortItem.setText("Abort");
		abortItem.setIcon(ResourceBundle.INSTANCE.basketDelete());
		abortItem.addSelectionHandler(new SelectionHandler<Item>() {

			@Override
			public void onSelection(SelectionEvent<Item> event) {
				MonitorBaseDto selected = tree.getSelectionModel()
						.getSelectedItem();
				Log.debug(selected.toString());
				requestBacgroundAbort(selected);

			}

		});

		hiddenItem = new MenuItem();
		hiddenItem.setText("Hidden");
		hiddenItem.setIcon(ResourceBundle.INSTANCE.basketRemove());
		hiddenItem.addSelectionHandler(new SelectionHandler<Item>() {

			@Override
			public void onSelection(SelectionEvent<Item> event) {
				MonitorBaseDto selected = tree.getSelectionModel()
						.getSelectedItem();
				Log.debug(selected.toString());
				requestBacgroundHidden(selected);

			}

		});

		contextMenu.add(infoItem);
		contextMenu.add(abortItem);
		contextMenu.add(hiddenItem);

		tree.setContextMenu(contextMenu);

	}

	protected void requestMoreInfo(MonitorBaseDto selected) {
		for (OperationMonitor operationMonitor : operationMonitorList) {
			if (operationMonitor.getTaskId().compareTo(selected.getId()) == 0) {
				Log.debug("Found Task Id: " + operationMonitor.getTaskId());
				MonitorBackgroundInfoDialog monitorBackgroundInfoDialog = new MonitorBackgroundInfoDialog(
						operationMonitor, eventBus);
				monitorBackgroundInfoDialog.show();
				return;
			}
		}

	}

	protected void requestBacgroundAbort(MonitorBaseDto selected) {
		for (OperationMonitor operationMonitor : operationMonitorList) {
			if (operationMonitor.getTaskId().compareTo(selected.getId()) == 0) {
				Log.debug("Found Task Id: " + operationMonitor.getTaskId());
				if (operationMonitor.getTask().getState() == State.IN_PROGRESS
						|| operationMonitor.getTask().getState() == State.INITIALIZING
						|| operationMonitor.getTask().getState() == State.VALIDATING_RULES) {
					fireRequestAborted(operationMonitor.getTaskId());
				}
				return;
			}
		}
	}

	protected void requestBacgroundHidden(MonitorBaseDto selected) {
		for (OperationMonitor operationMonitor : operationMonitorList) {
			if (operationMonitor.getTaskId().compareTo(selected.getId()) == 0) {
				Log.debug("Found Task Id: " + operationMonitor.getTaskId());
				fireRequestHidden(operationMonitor.getTaskId());
				return;
			}
		}
	}

	@Override
	public void operationMonitorListUpdated(
			ArrayList<OperationMonitor> operationMonitorList) {
		this.operationMonitorList = operationMonitorList;
		store.clear();
		store.commitChanges();
		addChildrensToStore();
		store.commitChanges();
		// tree.expandAll();
		forceLayout();

	}

	@Override
	public void retrieveOperationMonitorListFailed(Throwable caught) {
		if (caught instanceof TDGWTSessionExpiredException) {
			eventBus.fireEvent(new SessionExpiredEvent(
					SessionExpiredType.EXPIREDONSERVER));
		} else {
			UtilsGXT3.alert("Error", "Error retrieving tasks in bacground: "
					+ caught.getLocalizedMessage());

		}

	}

	// UI event Fire
	protected void fireRequestAborted(String taskId) {
		for (MonitorBackgroundEventUIListener listener : monitorBackgroundEventUIListeners) {
			listener.requestAborted(taskId);

		}
	}

	protected void fireRequestHidden(String taskId) {
		for (MonitorBackgroundEventUIListener listener : monitorBackgroundEventUIListeners) {
			listener.requestHidden(taskId);

		}
	}

	protected void fireRequestResume(String taskId) {
		for (MonitorBackgroundEventUIListener listener : monitorBackgroundEventUIListeners) {
			listener.requestResume(taskId);

		}
	}

}