/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * All rights reserved. This program and the accompanying materials           
 * are made available under the terms of the Eclipse Public License v1.0       
 * which accompanies this distribution, and is available at                  
 * http://www.eclipse.org/legal/epl-v10.html                                 
 *                                                                            
 * Contributors:   
 * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation 
 */
package org.eclipse.osbp.vaaclipse.addons.softwarefactory.perspective;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Named;

import org.drools.event.process.ProcessCompletedEvent;
import org.eclipse.bpmn2.Bpmn2Package;
import org.eclipse.bpmn2.Process;
import org.eclipse.bpmn2.Task;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.annotations.Optional;
import org.eclipse.e4.core.di.extensions.EventUtils;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.SideValue;
import org.eclipse.e4.ui.model.application.ui.advanced.MAdvancedFactory;
import org.eclipse.e4.ui.model.application.ui.advanced.MPerspective;
import org.eclipse.e4.ui.model.application.ui.advanced.MPerspectiveStack;
import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;
import org.eclipse.e4.ui.model.application.ui.advanced.impl.AdvancedFactoryImpl;
import org.eclipse.e4.ui.model.application.ui.advanced.impl.AdvancedPackageImpl;
import org.eclipse.e4.ui.model.application.ui.basic.MPart;
import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainer;
import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainerElement;
import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
import org.eclipse.e4.ui.model.application.ui.basic.MStackElement;
import org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;
import org.eclipse.e4.ui.model.application.ui.basic.MTrimmedWindow;
import org.eclipse.e4.ui.model.application.ui.basic.MWindowElement;
import org.eclipse.e4.ui.model.application.ui.basic.impl.BasicFactoryImpl;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.osbp.bpm.api.AbstractBlipBPMFunctionProvider;
import org.eclipse.osbp.bpm.api.IBPMTaskClient;
import org.eclipse.osbp.bpm.api.IBPMTaskEventNotification;
import org.eclipse.osbp.bpm.api.IBlipBPMConstants;
import org.eclipse.osbp.bpm.api.IBlipBPMStartInfo;
import org.eclipse.osbp.bpm.api.IBlipBPMWorkloadModifiableItem;
import org.eclipse.osbp.dsl.common.datatypes.IDto;
import org.eclipse.osbp.eventbroker.EventBrokerMsg;
import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService;
import org.eclipse.osbp.ui.api.organization.IOrganizationViewPartProvider;
import org.eclipse.osbp.ui.api.themes.IThemeResourceService;
import org.eclipse.osbp.ui.api.themes.IThemeResourceService.ThemeResourceType;
import org.eclipse.osbp.ui.api.user.IUser;
import org.eclipse.osbp.utils.bpmn.views.BpmnView;
import org.eclipse.osbp.vaaclipse.addons.softwarefactory.maintoolbar.IMainToolbarProvider;
import org.eclipse.osbp.vaaclipse.publicapi.authentication.AuthenticationConstants;
import org.eclipse.osbp.vaadin.emf.api.IModelingContext;
import org.eclipse.osbp.xtext.action.ActionDSLPackage;
import org.eclipse.osbp.xtext.action.ActionToolbar;
import org.eclipse.osbp.xtext.blip.BlipItem;
import org.eclipse.osbp.xtext.blip.BlipUserTask;
import org.eclipse.osbp.xtext.chart.Chart;
import org.eclipse.osbp.xtext.chart.ChartDSLPackage;
import org.eclipse.osbp.xtext.chart.ChartPackage;
import org.eclipse.osbp.xtext.dialogdsl.Dialog;
import org.eclipse.osbp.xtext.dialogdsl.DialogDSLPackage;
import org.eclipse.osbp.xtext.dialogdsl.DialogPackage;
import org.eclipse.osbp.xtext.organizationdsl.Organization;
import org.eclipse.osbp.xtext.organizationdsl.OrganizationDSLPackage;
import org.eclipse.osbp.xtext.organizationdsl.OrganizationPackage;
import org.eclipse.osbp.xtext.perspective.Perspective;
import org.eclipse.osbp.xtext.perspective.PerspectiveBPMN;
import org.eclipse.osbp.xtext.perspective.PerspectiveChart;
import org.eclipse.osbp.xtext.perspective.PerspectiveDialog;
import org.eclipse.osbp.xtext.perspective.PerspectiveDslPackage;
import org.eclipse.osbp.xtext.perspective.PerspectiveElement;
import org.eclipse.osbp.xtext.perspective.PerspectiveGrid;
import org.eclipse.osbp.xtext.perspective.PerspectiveOrganization;
import org.eclipse.osbp.xtext.perspective.PerspectivePart;
import org.eclipse.osbp.xtext.perspective.PerspectivePartStack;
import org.eclipse.osbp.xtext.perspective.PerspectiveReport;
import org.eclipse.osbp.xtext.perspective.PerspectiveSashContainer;
import org.eclipse.osbp.xtext.perspective.PerspectiveSelection;
import org.eclipse.osbp.xtext.perspective.PerspectiveTable;
import org.eclipse.osbp.xtext.perspective.PerspectiveTopology;
import org.eclipse.osbp.xtext.perspective.PerspectiveView;
import org.eclipse.osbp.xtext.reportdsl.Report;
import org.eclipse.osbp.xtext.reportdsl.ReportDSLPackage;
import org.eclipse.osbp.xtext.reportdsl.ReportPackage;
import org.eclipse.osbp.xtext.table.Table;
import org.eclipse.osbp.xtext.table.TableDSLPackage;
import org.eclipse.osbp.xtext.table.TablePackage;
import org.eclipse.osbp.xtext.topologydsl.Topology;
import org.eclipse.osbp.xtext.topologydsl.TopologyDSLPackage;
import org.eclipse.osbp.xtext.topologydsl.TopologyPackage;
import org.jbpm.task.event.entity.TaskEventType;
import org.jbpm.task.event.entity.TaskUserEvent;
import org.jbpm.task.query.TaskSummary;
import org.jbpm.task.service.Operation;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The Class PerspectiveSupport. Available as injectable service to create and maintain perspectives coming from the perspective DSL model.
 */
@SuppressWarnings("restriction")
public class PerspectiveSupport implements IBPMTaskEventNotification {

	/** The log. */
	private static Logger log = LoggerFactory.getLogger(PerspectiveSupport.class);

	/**
	 * Removes the perspective from stack if it is closed.
	 */
	private static final String TAG__REMOVE_ON_CLOSE = "remove_on_close";

	/**
	 * The perspective is not visible in the open perspective dialog.
	 */
	private static final String TAG__NOT_IN_OPEN_PERSPECTIVE_DIALOG = "not_in_open_perspective_dialog";

	/** The event broker. */
	@Inject
	private IEventBroker eventBroker;

	/** The app model. */
	@Inject
	private MApplication appModel;

	/** The eclipse context. */
	@Inject
	private IEclipseContext eclipseContext;

	@Inject
	private IModelingContext modelingContext;

	/** The theme resource service. */
	@Inject
	private IThemeResourceService themeResourceService;

	/** The current user. */
	@Inject
	private IUser user;

	/** The task client. */
	@Inject
	private IBPMTaskClient taskClient;

	/** The task provider */
	private AbstractBlipBPMFunctionProvider taskProvider;

	/** The dsl metadata service. */
	@Inject
	private IDSLMetadataService dslMetadataService;

	/** The toolbar provider. */
	@Inject
	@Named("MainToolbar")
	private IMainToolbarProvider toolbarProvider;

	@Inject
	@Optional
	private IOrganizationViewPartProvider optionalOrgURIProvider;

	/** The dispatch action. */
	private EventHandler dispatchAction;

	/** The do open perspective. */
	private EventHandler doOpenPerspective;

	/** The do close perspective. */
	private EventHandler doClosePerspective;

	/** The do logout. */
	private EventHandler doLogout;

	/** The basic factory. */
	private BasicFactoryImpl basicFactory;

	/** The advanced factory. */
	private MAdvancedFactory advancedFactory;

	/** The current perspective stack. */
	private MPerspectiveStack currentPerspectiveStack = null;

	/** The trimmed window. */
	private MTrimmedWindow trimmedWindow = null;

	/** The trim bar. */
	private MTrimBar trimBar = null;

	/** The model service. */
	private EModelService modelService;

	/** The perspectives. */
	private Map<String, MPerspective> perspectives = new HashMap<>();

	/** The perspective tasks. */
	private Map<Long, String> perspectiveTasks = new HashMap<>();

	/**
	 * Inits the PerspectiveSupport.
	 */
	@PostConstruct
	protected void init() {
		perspectives.clear();
		perspectiveTasks.clear();
		basicFactory = BasicFactoryImpl.init();
		advancedFactory = AdvancedFactoryImpl.init();
		modelService = eclipseContext.get(EModelService.class);
		subscribe();
	}

	/**
	 * Prepare perspective contexts.
	 */
	private void prepareContext() {
		log.debug("analyze app model");
		if (appModel != null) {
			trimmedWindow = null;
			if (appModel.getChildren().isEmpty()) {
				trimmedWindow = BasicFactoryImpl.eINSTANCE.createTrimmedWindow();
				trimmedWindow.setToBeRendered(true);
				trimmedWindow.setVisible(true);
				appModel.getChildren().add(trimmedWindow);
			} else {
				trimmedWindow = (MTrimmedWindow) appModel.getChildren().get(0);
			}
			// find perspective stack
			if (trimmedWindow.getChildren().isEmpty()) {
				// create perspective stack
				currentPerspectiveStack = advancedFactory.createPerspectiveStack();
				currentPerspectiveStack.setElementId(PerspectiveConstants.E4Constants.PERSPECTIVESTACK);
				currentPerspectiveStack.setToBeRendered(true);
				currentPerspectiveStack.setVisible(true);
			} else {
				for (MWindowElement element : trimmedWindow.getChildren()) {
					if (element instanceof MPerspectiveStack) { // NOSONAR
						currentPerspectiveStack = (MPerspectiveStack) element;
						break;
					}
				}
			}

			// find trimbar
			trimBar = null;
			if (trimmedWindow.getTrimBars().isEmpty()) {
				// create trimbar
				trimBar = basicFactory.createTrimBar();
				trimBar.setElementId(PerspectiveConstants.E4Constants.TRIMBAR);
				trimBar.setToBeRendered(true);
				trimBar.setVisible(true);
				trimBar.setSide(SideValue.TOP);
				trimmedWindow.getTrimBars().add(trimBar);
			} else {
				trimBar = trimmedWindow.getTrimBars().get(0);
			}
		}

		// handle toolbar
		((EObject) currentPerspectiveStack).eAdapters().add(new AdapterImpl() {
			@Override
			public void notifyChanged(Notification notification) {
				if (notification.getEventType() == Notification.SET
						&& notification.getFeatureID(MElementContainer.class) == AdvancedPackageImpl.PERSPECTIVE_STACK__SELECTED_ELEMENT) {
					log.debug("perspective stack changed selection");
					if (notification.getNewValue() == null && notification.getOldValue() != null
							&& PerspectiveSupport.isPerspectiveElementId(((MPerspective) notification.getOldValue()).getElementId())) {
						closePerspective(PerspectiveSupport.fromPerspectiveElementId(((MPerspective) notification.getOldValue()).getElementId()), true);
					} else {
						// perspective changed
						if (notification.getNewValue() != notification.getOldValue()) {
							if (notification.getOldValue() != null) {
								// deactivate old perspective - hide its toolBar
								String perspectiveId = PerspectiveSupport.fromPerspectiveElementId(((MPerspective) notification.getOldValue()).getElementId());
								toolbarProvider.setActive(perspectiveId, false);
							}
							if (notification.getNewValue() != null) {
								// activate new perspective - show its toolbar
								String perspectiveId = PerspectiveSupport.fromPerspectiveElementId(((MPerspective) notification.getNewValue()).getElementId());
								toolbarProvider.setActive(perspectiveId, true);
							}
						}
					}
				}
			}
		});
	}

	/**
	 * Checks if is our perspective element id.
	 *
	 * @param elementId
	 *            the element id
	 * @return true, if is perspective element id
	 */
	protected static boolean isPerspectiveElementId(String perspectiveId) {
		if (perspectiveId.startsWith(PerspectiveConstants.E4Constants.PERSPECTIVE_PREFIX)) {
			return true;
		}
		return false;
	}

	/**
	 * converts a name to a perspective element id.
	 *
	 * @param perspectiveId
	 *            the perspective id
	 * @return the string
	 */
	protected static String toPerspectiveElementId(String perspectiveId) {
		return PerspectiveConstants.E4Constants.PERSPECTIVE_PREFIX + perspectiveId;
	}

	/**
	 * converts from perspective element id to a name.
	 *
	 * @param elementId
	 *            the element id
	 * @return the string
	 */
	protected static String fromPerspectiveElementId(String elementId) {
		return elementId.substring(PerspectiveConstants.E4Constants.PERSPECTIVE_PREFIX.length());
	}

	/**
	 * Creates a new perspective.
	 *
	 * @param perspectiveModel
	 *            the perspective model
	 */
	public void openPerspectiveEvent(String perspectiveId) {
		PerspectiveFound perspectiveFound = findPerspective(perspectiveId);
		openPerspective(perspectiveFound, -1L);
	}

	/**
	 * Creates a new perspective suitable for the given task it was called from.
	 *
	 * @param perspectiveModel
	 *            the perspective model
	 * @param humanTask
	 * @param taskSummary
	 */
	private void openPerspective(PerspectiveFound perspectiveFound, Long taskId) {
		if (perspectiveFound.perspective != null) {
			prepareContext();
			// bring to top if already contained in model
			for (MPerspective perspective : currentPerspectiveStack.getChildren()) {
				if ((PerspectiveSupport.toPerspectiveElementId(perspectiveFound.perspective.getName())).equals(perspective.getElementId())) {
					modelService.bringToTop(perspective);
					return;
				}
			}

			log.debug("open perspective with " + perspectiveFound.perspective.getName());
			log.debug("add perspective");
			MPerspective perspective = createPerspective(perspectiveFound.perspective, perspectiveFound.perspective.getName());
			if (taskId != -1L) {
				registerContext(perspective.getTransientData(), perspectiveFound);
				// create the toolbar
				if (perspectiveFound.perspective.getToolbarTypeJvm() != null) {
					String toolBarId = perspectiveFound.perspective.getToolbarTypeJvm().getQualifiedName().replace("Action", "");
					toolbarProvider.addToolbar(perspectiveFound.perspective.getName(), findToolbar(toolBarId));
					// we cannot subscribe earlier as the toolbar id is unknown
					// before
					eventBroker.subscribe(EventBrokerMsg.ACTION_BUTTON_EXECUTE_PREFIX + toolbarProvider.getToolbarId(), dispatchAction);
				}
			}
			currentPerspectiveStack.getChildren().add(perspective);
			currentPerspectiveStack.setSelectedElement(perspective);
			modelService.bringToTop(perspective);

			perspectives.put(perspectiveFound.perspective.getName(), perspective);
			perspectiveTasks.put(taskId, perspectiveFound.perspective.getName());
			// get notified from bpm
			taskClient.subscribeProcessCompletedEventNotification(this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Release, this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Complete, this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Delegated, this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Fail, this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Skipped, this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Release, this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Stop, this);
			taskClient.subscribeTaskEventNotification(TaskEventType.Suspended, this);
		}
	}

	/**
	 * Close perspective.
	 *
	 * @param perspectiveId
	 *            of the perspective to close
	 * @param suspendTask
	 *            is true if task should be set to susupended
	 */
	private void closePerspective(String perspectiveId, boolean suspendTask) {
		if (perspectiveTasks.containsValue(perspectiveId)) {
			for (Long taskId : perspectiveTasks.keySet()) {
				if (perspectiveTasks.get(taskId).equals(perspectiveId)) {
					closePerspective(taskId);
					break;
				}
			}
		}
	}

	/**
	 * Close perspective an remove from PerspectiveStack.
	 *
	 * @param taskId
	 *            of the perspective to close
	 * @param suspendTask
	 *            is true if task should be set to susupended
	 */
	private void closePerspective(long taskId) {
		if (perspectiveTasks.containsKey(taskId)) {
			modelService.resetPerspectiveModel(perspectives.get(perspectiveTasks.get(taskId)), trimmedWindow);
			modelService.removePerspectiveModel(perspectives.get(perspectiveTasks.get(taskId)), trimmedWindow);
			toolbarProvider.removeToolbar(perspectiveTasks.get(taskId));
			perspectives.remove(taskId);
			perspectiveTasks.remove(taskId);
		}
	}

	/**
	 * Add the perspective identified by perspectiveId to PerspectiveStack.
	 *
	 * @param perspectiveModel
	 *            - the model everything is based on
	 * @param perspectiveId
	 *            - unique identifier for a perspective in the model
	 * @return the m perspective
	 */
	private MPerspective createPerspective(Perspective perspectiveModel, String perspectiveId) {
		MPerspective perspective = advancedFactory.createPerspective();

		perspective.getTags().add(TAG__REMOVE_ON_CLOSE);
		perspective.getTags().add(TAG__NOT_IN_OPEN_PERSPECTIVE_DIALOG);

		perspective.setElementId(PerspectiveSupport.toPerspectiveElementId(perspectiveId));
		perspective.setLabel(perspectiveModel.getName());
		perspective.setVisible(true);
		perspective.setToBeRendered(true);
		perspective.setIconURI(themeResourceService.getThemeURI(perspectiveModel.getIconURI(), ThemeResourceType.ICON));
		perspective.setAccessibilityPhrase(perspectiveModel.getAccessibilityPhrase());
		if (perspectiveModel.isDescription()) {
			perspective.setTooltip(perspectiveModel.getDescriptionValue().replace("\"", ""));
		}

		// iterate over all elements
		traverseModel(perspective, perspectiveModel);
		if (isUseDesigner(perspectiveModel, perspective) && !perspective.getChildren().isEmpty()) {
			MPartSashContainerElement firstElement = perspective.getChildren().get(0);
			if (firstElement instanceof MPartSashContainer) {
				// create placeholder for designer
				//
				MPlaceholder designerPH = MAdvancedFactory.INSTANCE.createPlaceholder();
				MUIElement area = modelService.find("org.eclipse.osbp.model.area.designer", currentPerspectiveStack);
				designerPH.setRef(area);
				designerPH.setContainerData("40");
				designerPH.setVisible(modelingContext.isDesignMode());
				designerPH.setToBeRendered(modelingContext.isDesignMode());
				designerPH.getTags().add("designer:autoVisible");

				((MPartSashContainer) firstElement).getChildren().add(designerPH);
			}
		}
		return perspective;
	}

	protected boolean isUseDesigner(Perspective perspectiveModel, MPerspective perspective) {
		return true;
	}

	/**
	 * Because the startup of the bundles doesn't allow injecting the taskProvider via the preferred way, get the taskProvider later on manually!
	 * 
	 * @return the task provider
	 */
	private AbstractBlipBPMFunctionProvider getTaskProvider() {
		if (taskProvider == null) {
			IEclipseContext appCtx = appModel.getContext();
			taskProvider = appCtx.get(AbstractBlipBPMFunctionProvider.class);
		}
		return taskProvider;
	}

	/**
	 * Register context.
	 *
	 * @param map
	 *            the map
	 * @param task
	 *            the task
	 */
	private void registerContext(Map<String, Object> map, PerspectiveFound perspectiveFound) {
		String workloadDtoFqn = null;
		IDto workloadDto = null;
		IBlipBPMStartInfo startInfo = null;
		IBlipBPMWorkloadModifiableItem task = null;
		Class<?> operativeDtoClass = null;
		String operativeDtoFqn = null;
		List<IDto> operativeDtos = null;

		if (taskClient != null) {
			workloadDtoFqn = taskClient.getWorkloadDtoFqn(perspectiveFound.taskSummary);
			workloadDto = taskClient.getWorkloadDto(perspectiveFound.taskSummary);
			if ((getTaskProvider() != null) && (perspectiveFound.blipTask != null)) {
				startInfo = getTaskProvider().getStartInfo(perspectiveFound.taskSummary);
			}
			if (startInfo != null) {
				task = startInfo.getWorkloadMofifiableBpmItemForBlipId(perspectiveFound.blipTask.getName());
			}
			if (task != null) {
				operativeDtos = task.getOperativeDtos(workloadDto);
				operativeDtoClass = task.getOperativeDtoClass();
				if (operativeDtoClass != null) {
					operativeDtoFqn = operativeDtoClass.getCanonicalName();
				} else {
					operativeDtoClass = null;
				}
			}
		}
		map.put(IBlipBPMConstants.VARIABLE_PROCESS_START_INFO, startInfo);
		map.put(IBlipBPMConstants.VARIABLE_PROCESS_WORKLOAD_DTO_FQN, workloadDtoFqn);
		map.put(IBlipBPMConstants.VARIABLE_PROCESS_WORKLOAD_DTO, workloadDto);
		map.put(IBlipBPMConstants.VARIABLE_TASK_JBPM_SUMMARY, perspectiveFound.taskSummary);
		map.put(IBlipBPMConstants.VARIABLE_TASK_BLIP_ITEM, perspectiveFound.blipTask);
		map.put(IBlipBPMConstants.VARIABLE_TASK_BPM2_ITEM, perspectiveFound.bpmTask);
		map.put(IBlipBPMConstants.VARIABLE_TASK_START_INFO, task);
		map.put(IBlipBPMConstants.VARIABLE_TASK_OPERATIVE_DTO_CLASS, operativeDtoClass);
		map.put(IBlipBPMConstants.VARIABLE_TASK_OPERATIVE_DTO_FQN, operativeDtoFqn);
		map.put(IBlipBPMConstants.VARIABLE_TASK_OPERATIVE_DTOS, operativeDtos);
	}

	/**
	 * for every model element that can hold children, traverse recursively the model.
	 * 
	 * @param parent
	 *            - the parent e4 node to which the next child is added
	 * @param modelElement
	 *            - the current element which is traversed
	 */
	private void traverseModel(MElementContainer<?> parent, EObject modelElement) {
		if (modelElement instanceof Perspective) {
			log.debug("traverse model perspective");
			Perspective perspectiveModel = (Perspective) modelElement;
			for (PerspectiveElement element : perspectiveModel.getElements()) {
				addElement(parent, element);
			}
		} else if (modelElement instanceof PerspectiveSashContainer) {
			log.debug("traverse model sashcontainer");
			PerspectiveSashContainer sashModel = (PerspectiveSashContainer) modelElement;
			for (PerspectiveElement element : sashModel.getElements()) {
				addElement(parent, element);
			}
		} else if (modelElement instanceof PerspectivePartStack) {
			log.debug("traverse model perspectivestack");
			PerspectivePartStack stackModel = (PerspectivePartStack) modelElement;
			for (PerspectiveElement element : stackModel.getElements()) {
				addElement(parent, element);
			}
		}
	}

	/**
	 * for PerspectiveSashContainer create an e4 element by it's factory.
	 * 
	 * @param parent
	 *            - the parent e4 node to which the next child is added
	 * @param element
	 *            - the current element which is traversed
	 */
	@SuppressWarnings("unchecked")
	private void addElementPerspectiveSashContainer(MElementContainer<?> parent, EObject element) {
		PerspectiveSashContainer sashModel = (PerspectiveSashContainer) element;
		MPartSashContainer sashContainer = basicFactory.createPartSashContainer();
		sashContainer.setAccessibilityPhrase(sashModel.getAccessibilityPhrase());
		if (sashModel.getContainerData() != null) {
			sashContainer.setContainerData(sashModel.getContainerData().replace("\"", ""));
		} else {
			sashContainer.setContainerData("50");
		}

		sashContainer.setElementId(sashModel.getElementId());
		if ("HORIZONTAL".equals(sashModel.getOrientation().getName())) {
			sashContainer.setHorizontal(true);
		} else {
			sashContainer.setHorizontal(false);
		}
		sashContainer.setVisible(true);
		sashContainer.setParent((MElementContainer<MUIElement>) parent);
		if (parent instanceof MPerspective) {
			((MPerspective) parent).getChildren().add(sashContainer);
		} else if (parent instanceof MPartSashContainer) {
			((MPartSashContainer) parent).getChildren().add(sashContainer);
		}
		// go deeper
		traverseModel(sashContainer, element);
		// set selected references
		for (MPartSashContainerElement child : sashContainer.getChildren()) {
			if (sashModel.getSelectedElement() != null && child.getElementId().equals(sashModel.getSelectedElement().getElementId())) {
				sashContainer.setSelectedElement(child);
				break;
			}
		}
	}

	/**
	 * for addElementPerspectivePartStack create an e4 element by it's factory.
	 * 
	 * @param parent
	 *            - the parent e4 node to which the next child is added
	 * @param element
	 *            - the current element which is traversed
	 */
	@SuppressWarnings("unchecked")
	private void addElementPerspectivePartStack(MElementContainer<?> parent, EObject element) {
		PerspectivePartStack stackModel = (PerspectivePartStack) element;
		MPartStack stack = basicFactory.createPartStack();
		stack.setAccessibilityPhrase(stackModel.getAccessibilityPhrase());
		if (stackModel.getContainerData() != null) {
			stack.setContainerData(stackModel.getContainerData().replace("\"", ""));
		} else {
			stack.setContainerData("50");
		}
		stack.setElementId(stackModel.getElementId());
		stack.setVisible(true);
		stack.setParent((MElementContainer<MUIElement>) parent);
		if (parent instanceof MPerspective) {
			((MPerspective) parent).getChildren().add(stack);
		} else if (parent instanceof MPartSashContainer) {
			((MPartSashContainer) parent).getChildren().add(stack);
		}
		// go deeper
		traverseModel(stack, element);
		// set selected references
		for (MStackElement child : stack.getChildren()) {
			if (stackModel.getSelectedElement() != null && child.getElementId().equals(stackModel.getSelectedElement().getElementId())) {
				stack.setSelectedElement(child);
				break;
			}
		}
	}

	/**
	 * for addElementPerspectivePart create an e4 element by it's factory.
	 * 
	 * @param parent
	 *            - the parent e4 node to which the next child is added
	 * @param element
	 *            - the current element which is traversed
	 */
	@SuppressWarnings("unchecked")
	private void addElementPerspectivePart(MElementContainer<?> parent, EObject element) {
		PerspectivePart partModel = (PerspectivePart) element;
		MPart part = basicFactory.createPart();
		part.setAccessibilityPhrase(partModel.getAccessibilityPhrase());
		if (partModel.getContainerData() != null) {
			part.setContainerData(partModel.getContainerData().replace("\"", ""));
		} else {
			part.setContainerData("50");
		}

		part.setElementId(partModel.getElementId());
		part.setIconURI(partModel.getIconURI());
		if (partModel.isDescription()) {
			part.setTooltip(partModel.getDescriptionValue().replace("\"", ""));
		}
		part.setLabel(partModel.getElementId());
		part.setVisible(true);
		part.setCloseable(partModel.isIsClosable());

		part.getPersistedState().put(PerspectiveConstants.E4Constants.OSBP_NS_URI, getNsURI(partModel.getView()));
		part.getPersistedState().put(PerspectiveConstants.E4Constants.OSBP_FQN, getFQN(partModel.getView()));

		String flavor = getFlavor(partModel.getView());
		if (flavor != null) {
			part.getPersistedState().put(PerspectiveConstants.E4Constants.OSBP_FLAVOR, flavor);
		}

		part.setParent((MElementContainer<MUIElement>) parent);
		if (parent instanceof MPerspective) {
			((MPerspective) parent).getChildren().add(part);
		} else if (parent instanceof MPartSashContainer) {
			((MPartSashContainer) parent).getChildren().add(part);
		} else if (parent instanceof MPartStack) {
			((MPartStack) parent).getChildren().add(part);
		}
		if (partModel.getView() != null) {
			part.setContributionURI(getContributionURI(partModel.getView()));
		}
	}

	/**
	 * for every model element create an e4 element by it's factory.
	 * 
	 * @param parent
	 *            - the parent e4 node to which the next child is added
	 * @param element
	 *            - the current element which is traversed
	 */
	private void addElement(MElementContainer<?> parent, EObject element) {
		if (element instanceof PerspectiveSashContainer) {
			addElementPerspectiveSashContainer(parent, element);
		} else if (element instanceof PerspectivePartStack) {
			addElementPerspectivePartStack(parent, element);
		} else if (element instanceof PerspectivePart) {
			addElementPerspectivePart(parent, element);
		}
	}

	/**
	 * create the view connected to a part.
	 * 
	 * @param viewModel
	 *            - the model of the view
	 * @return null or the classURI
	 */
	private String getContributionURI(PerspectiveView viewModel) { // NOSONAR
		if (viewModel instanceof PerspectiveTable) {
			String className = ((PerspectiveTable) viewModel).getRefTypeJvm().getQualifiedName();
			return dslMetadataService.getClassURI(className, "table");
		} else if (viewModel instanceof PerspectiveSelection) {
			String className = ((PerspectiveSelection) viewModel).getRefTypeJvm().getQualifiedName();
			return dslMetadataService.getClassURI(className, "table");
		} else if (viewModel instanceof PerspectiveGrid) {
			String className = ((PerspectiveGrid) viewModel).getRefTypeJvm().getQualifiedName();
			return dslMetadataService.getClassURI(className, "table");
		} else if (viewModel instanceof PerspectiveChart) {
			String className = ((PerspectiveChart) viewModel).getRefTypeJvm().getQualifiedName();
			return dslMetadataService.getClassURI(className, "chart");
		} else if (viewModel instanceof PerspectiveReport) {
			String className = ((PerspectiveReport) viewModel).getRefTypeJvm().getQualifiedName();
			return dslMetadataService.getClassURI(className, "report");
		} else if (viewModel instanceof PerspectiveOrganization) {
			if (optionalOrgURIProvider != null) {
				return optionalOrgURIProvider.getViewPartURI();
			} else {
				return null;
			}
		} else if (viewModel instanceof PerspectiveTopology) {
			String className = ((PerspectiveTopology) viewModel).getRefTypeJvm().getQualifiedName();
			return dslMetadataService.getClassURI(className, "topology");
		} else if (viewModel instanceof PerspectiveDialog) {
			String className = ((PerspectiveDialog) viewModel).getRefTypeJvm().getQualifiedName();
			return dslMetadataService.getClassURI(className, "dialog");
		} else if (viewModel instanceof PerspectiveBPMN) {
			String className = BpmnView.class.getCanonicalName();
			return dslMetadataService.getClassURI(className, "bpmn");
		}
		return null;
	}

	/**
	 * Returns the FQN for the content of the view.
	 * 
	 * @param viewModel
	 *            - the model of the view
	 * @return null or the FQN
	 */
	private String getFQN(PerspectiveView viewModel) { // NOSONAR
		if (viewModel instanceof PerspectiveTable) {
			Table object = ((PerspectiveTable) viewModel).getRef();
			TablePackage pkg = (TablePackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveSelection) {
			Table object = ((PerspectiveSelection) viewModel).getRef();
			TablePackage pkg = (TablePackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveGrid) {
			Table object = ((PerspectiveGrid) viewModel).getRef();
			TablePackage pkg = (TablePackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveChart) {
			Chart object = ((PerspectiveChart) viewModel).getRef();
			ChartPackage pkg = (ChartPackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveReport) {
			Report object = ((PerspectiveReport) viewModel).getRef();
			ReportPackage pkg = (ReportPackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveOrganization) {
			Organization object = ((PerspectiveOrganization) viewModel).getRef();
			OrganizationPackage pkg = (OrganizationPackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveTopology) {
			Topology object = ((PerspectiveTopology) viewModel).getRef();
			TopologyPackage pkg = (TopologyPackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveDialog) {
			Dialog object = ((PerspectiveDialog) viewModel).getRef();
			DialogPackage pkg = (DialogPackage) object.eContainer();
			return pkg == null ? "" : toFQN(pkg.getName(), object.getName());
		} else if (viewModel instanceof PerspectiveBPMN) {
			// TODO Right now PerspectiveBPMN has no attributes
		}
		return null;
	}

	/**
	 * Return the NS-URI for the content of the view. Used as a content type marker.
	 *
	 * @param viewModel
	 *            the view model
	 * @return the ns uri
	 */
	private String getNsURI(PerspectiveView viewModel) { // NOSONAR
		if (viewModel instanceof PerspectiveTable) {
			return TableDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveSelection) {
			return TableDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveGrid) {
			return TableDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveChart) {
			return ChartDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveReport) {
			return ReportDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveOrganization) {
			return OrganizationDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveTopology) {
			return TopologyDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveDialog) {
			return DialogDSLPackage.eNS_URI;
		} else if (viewModel instanceof PerspectiveBPMN) {
			return Bpmn2Package.eNS_URI;
		}
		return null;
	}

	private String getFlavor(PerspectiveView viewModel) { // NOSONAR
		if (viewModel instanceof PerspectiveTable) {
			return "table";
		} else if (viewModel instanceof PerspectiveGrid) {
			return "grid";
		}
		return null;
	}

	/**
	 * To fqn.
	 *
	 * @param pkg
	 *            the pkg
	 * @param name
	 *            the name
	 * @return the string
	 */
	private String toFQN(String pkg, String name) {
		return pkg + "." + name;
	}

	/**
	 * Subscribe.
	 */
	protected void subscribe() {
		createEventHandlers();
		eventBroker.subscribe(EventBrokerMsg.OPEN_PERSPECTIVE, doOpenPerspective);
		eventBroker.subscribe(EventBrokerMsg.CLOSE_PERSPECTIVE, doClosePerspective);
		eventBroker.subscribe(AuthenticationConstants.Events.Authentication.PRE_LOGOUT, doLogout);
	}

	/**
	 * Unsubscribe.
	 */
	@PreDestroy
	protected void unsubscribe() {
		eventBroker.unsubscribe(dispatchAction);
		taskClient.unsubscribeTaskEventNotification(this);
	}

	/**
	 * Creates the event handlers.
	 */
	private void createEventHandlers() {
		dispatchAction = new EventHandler() {
			@Override
			public void handleEvent(Event event) {
				EventBrokerMsg msg = (EventBrokerMsg) event.getProperty(EventUtils.DATA);
				log.debug("dispatch action received in PerspectiveSupport for " + msg.getName());
				if ("delegate".equalsIgnoreCase(msg.getName())) {
					// UI.getCurrent().addWindow(selectUserWindow.init(getAllUsers(),
					// eventBroker, EventBrokerMsg.TASK_DELEGATED, msg));
				} else {
					taskClient.operations(msg.getLong(), user, null, Operation.valueOf(msg.getName()));
				}
			}
		};
		doOpenPerspective = new EventHandler() {
			@Override
			public void handleEvent(Event event) {
				PerspectiveFound perspectiveFound = null;
				EventBrokerMsg msg = (EventBrokerMsg) event.getProperty(EventUtils.DATA);
				if (msg.getName() != null) { // called by menu
					log.debug("open perspective with id " + msg.getName());
					perspectiveFound = findPerspective(msg.getName());
					if (perspectiveFound == null) {
						log.error("the perspective " + msg.getName() + " doesn't exist. Either blip model or perspective model must be modified.");
						return;
					}
				} else if (msg.getObject1() != null) { // called by bpm task
														// client
					log.debug("open perspective with taskId " + msg.getLong());
					perspectiveFound = findPerspective((TaskSummary) msg.getObject1());
					if (perspectiveFound != null) {
						eventBroker.post(EventBrokerMsg.BPMNCHART_EVENT, new EventBrokerMsg(perspectiveFound.taskSummary.getProcessId(), perspectiveFound.taskSummary.getName()));
						// notify orgachart with current user's position
						eventBroker.post(EventBrokerMsg.ORGCHART_SELECT, user.getPosition());
					}
				}
				if (perspectiveFound != null) {
					openPerspective(perspectiveFound, msg.getLong());
				}
			}
		};
		doClosePerspective = new EventHandler() {
			@Override
			public void handleEvent(Event event) {
				EventBrokerMsg msg = (EventBrokerMsg) event.getProperty(EventUtils.DATA);
				log.debug("close perspective " + msg.getName());
				// awaits a Long object as taskId
				closePerspective(msg.getLong());
			}
		};
		doLogout = new EventHandler() {
			@Override
			public void handleEvent(Event event) {
				log.debug("logout pending");
				suspendAllTasks();
			}
		};
	}

	/**
	 * Suspend all pending tasks while user pressed logout or closed browser.
	 * 
	 */
	private void suspendAllTasks() {
		for (Long taskId : perspectiveTasks.keySet()) {
			log.debug("suspend task " + taskId);
			taskClient.operations(taskId, user, null, Operation.Suspend);
		}
	}

	/**
	 * Tries to find the perspective model using the perspective builder service.
	 *
	 * @param perspectiveId
	 *            - the id of the perspective used in the model
	 * @return the perspective
	 */
	protected PerspectiveFound findPerspective(String perspectiveId) {
		log.debug("find perspective model by id");
		return new PerspectiveFound(null, (Perspective) dslMetadataService.getMetadata(perspectiveId, PerspectiveDslPackage.Literals.PERSPECTIVE), null, null);
	}

	private final class PerspectiveFound {
		public final TaskSummary taskSummary;
		public final Perspective perspective;
		public final BlipItem blipTask;
		public final Task bpmTask;

		protected PerspectiveFound(TaskSummary taskSummary, Perspective perspective, BlipItem blipTask, Task bpmTask) {
			this.taskSummary = taskSummary;
			this.perspective = perspective;
			this.blipTask = blipTask;
			this.bpmTask = bpmTask;
		}
	}

	/**
	 * Tries to find the perspective model using the perspective builder service.
	 *
	 * @param task
	 *            the task
	 * @return the perspective
	 */
	protected PerspectiveFound findPerspective(TaskSummary taskSummary) {
		log.debug("find perspective model by task");
		for (EObject eObj : dslMetadataService.getAll(PerspectiveDslPackage.Literals.PERSPECTIVE)) {
			// assumed that all packages of any dsl inherit LPackage
			if (eObj instanceof Perspective) {
				Perspective perspective = (Perspective) eObj;
				if ((perspective.getProcess() != null) && (perspective.getUserTask() != null)) {
					Process process = perspective.getProcess().getProcess();
					BlipUserTask blipTask = perspective.getUserTask();
					if ((process != null) && (process.getId().equals(taskSummary.getProcessId()))) {
						Task bpmTask = blipTask.getTask();
						if ((bpmTask != null) && taskSummary.getName().equals(bpmTask.getName())) {
							if (taskClient != null) {
								IDto wd = taskClient.getWorkloadDto(taskSummary);
								System.err.println();
							}
							return new PerspectiveFound(taskSummary, perspective, blipTask, bpmTask);
						}
					}
				}
			}
		}
		return null;
	}

	/**
	 * Tries to find the action toolbar model using the action builder service.
	 *
	 * @param toolbarId
	 *            the toolbar id
	 * @return the action toolbar
	 */
	protected ActionToolbar findToolbar(String toolbarId) {
		log.debug("find toolbar model");
		return (ActionToolbar) dslMetadataService.getMetadata(toolbarId, ActionDSLPackage.Literals.ACTION_TOOLBAR);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.bpm.api.IBPMTaskEventNotification#notifyTaskEvent(org .jbpm.task.event.entity.TaskEventType, org.jbpm.task.event.entity.TaskUserEvent)
	 */
	@Override
	public void notifyTaskEvent(TaskEventType type, TaskUserEvent event) {
		closePerspective(event.getTaskId());
	}

	@Override
	public void notifyProcessCompletedEvent(ProcessCompletedEvent event) {
		// NOP
	}

	// protected String getFQN(EObject obj, String name) {
	// while(obj != null && !(obj instanceof PerspectivePackage)) {
	// obj = obj.eContainer();
	// }
	// if(obj != null) {
	// String key = I18NKeyGenerator.key(name);
	// return ((PerspectivePackage) obj).getName()+"."+key;
	// }
	// return name;
	// }
}