EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.model;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.lang.reflect.InvocationTargetException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

import java.util.UUID;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.commands.NotEnabledException;

import org.eclipse.core.commands.NotHandledException;

import org.eclipse.core.commands.common.NotDefinedException;

import org.eclipse.core.commands.operations.AbstractOperation;

import org.eclipse.core.commands.operations.IOperationHistory;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.core.runtime.jobs.ISchedulingRule;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.jface.action.IStatusLineManager;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.resource.ColorRegistry;

import org.eclipse.jface.resource.FontRegistry;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IViewPart;

import org.eclipse.ui.IViewReference;

import org.eclipse.ui.IWorkbench;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.handlers.IHandlerService;

import org.eclipse.ui.ide.undo.WorkspaceUndoUtil;

import org.eclipse.ui.progress.IProgressConstants;

import org.eclipse.ui.progress.IProgressService;

import org.eclipse.ui.progress.IWorkbenchSiteProgressService;

import org.eclipse.ui.themes.ITheme;

import org.eclipse.ui.themes.IThemeManager;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

import eu.etaxonomy.cdm.api.service.IProgressMonitorService;

import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;

import eu.etaxonomy.cdm.io.common.ExportDataWrapper;

import eu.etaxonomy.cdm.io.common.ExportResult;

import eu.etaxonomy.cdm.io.common.ExportResultType;

import eu.etaxonomy.cdm.io.common.ExportType;

import eu.etaxonomy.cdm.model.common.IEnumTerm;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.operation.IFeedbackGenerator;

import eu.etaxonomy.taxeditor.operation.IPostMoniteredOperationEnabled;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.operation.RemotingCdmHandler;

import eu.etaxonomy.taxeditor.operation.e4.RemotingCdmHandlerE4;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;

import eu.etaxonomy.taxeditor.ui.dialog.ReportTextDialog;

import eu.etaxonomy.taxeditor.view.AbstractCdmDataViewer;

import eu.etaxonomy.taxeditor.view.detail.DetailsViewPart;

import eu.etaxonomy.taxeditor.view.supplementaldata.SupplementalDataViewPart;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 *

 * @author n.hoffmann

 * @created 11.05.2009

 * @version 1.0

 */

public abstract class AbstractUtility {

    private static final Logger logger = Logger.getLogger(AbstractUtility.class);

    /** Constant <code>statusLineManager</code> */

    protected static IStatusLineManager statusLineManager;

    /** Constant <code>DATE_FORMAT_NOW="yyyyMMddHHmm"</code> */

   	public static final String DATE_FORMAT_NOW = "yyyyMMddHHmm";

    public static MPart getActivePart() {

        return EventUtility.getActivePart();

    }

    public static boolean closeAll() {

        if(getActivePage()!=null){

            return getActivePage().closeAllEditors(true);

        }

        return false;

    }

    public static Shell getShell() {

        return TaxeditorStorePlugin.getDefault().getWorkbench()

                .getActiveWorkbenchWindow().getShell();

    }

    public static IWorkbenchPage getActivePage() {

        try{

            return TaxeditorStorePlugin.getDefault().getWorkbench()

                    .getActiveWorkbenchWindow().getActivePage();

        } catch(NullPointerException npe){

            return null;

        }

    }

    public static Object getActiveE4Part() {

        //TODO merge with getActivePart()

        return getActivePart();

    }

    public static IWorkbench getWorkbench() {

        return TaxeditorStorePlugin.getDefault().getWorkbench();

    }

    public static IWorkbenchWindow getWorkbenchWindow() {

        if (getWorkbench().getWorkbenchWindowCount() > 1) {

            throw new IllegalStateException("More than one workbench window");

        }

        return getWorkbench().getWorkbenchWindows()[0];

    }

    public static IViewPart showView(String id) {

        try {

            return PlatformUI.getWorkbench().getActiveWorkbenchWindow()

                    .getActivePage()

                    .showView(id, null, IWorkbenchPage.VIEW_VISIBLE);

        } catch (PartInitException e) {

            MessagingUtils.messageDialog("Error opening view", AbstractUtility.class, "Could not open view: " + id, e);

            return null;

        }

    }

    public static void hideView(IViewPart view) {

        PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage()

        .hideView(view);

    }

    public static IViewPart getView(String id, boolean restore) {

    	IWorkbench workbench = PlatformUI.getWorkbench();

        IWorkbenchWindow activeWorkbenchWindow = workbench.getActiveWorkbenchWindow();

    	IViewReference[] references = null;

    	if(activeWorkbenchWindow!=null && activeWorkbenchWindow.getActivePage()!=null){

    	    references = activeWorkbenchWindow.getActivePage().getViewReferences();

    	}

    	else if(workbench.getWorkbenchWindows().length>0 && workbench.getWorkbenchWindows()[0].getActivePage()!=null){

    		references = workbench.getWorkbenchWindows()[0].getActivePage().getViewReferences();

    	}

    	if(references!=null){

    		for (IViewReference reference : references) {

    			if (reference.getId().equals(id)) {

    				return reference.getView(restore);

    			}

    		}

    	}

        return null;

    }

    public static Object getService(Class api) {

        return TaxeditorStorePlugin.getDefault().getWorkbench().getService(api);

    }

    public static ITheme getCurrentTheme() {

        IThemeManager themeManager = TaxeditorStorePlugin.getDefault()

                .getWorkbench().getThemeManager();

        return themeManager.getCurrentTheme();

    }

    /**

     * Fonts registered to the plugin may be obtained with the Eclipse themeing

     * functionality. Thus fonts are chooseable by the user via

     * Preferences->General->Appearance->Colors and Fonts

     *

     * @return the FontRegistry for the current theme

     */

    public static FontRegistry getFontRegistry() {

        return getCurrentTheme().getFontRegistry();

    }

    public static Font getFont(String symbolicName) {

        return getFontRegistry().get(symbolicName);

    }

    /**

     * Color registered to the plugin may be obtained with the Eclipse themeing

     * functionality. Thus colors are editable by the user via

     * Preferences->General->Appearance->Colors and Fonts

     *

     * @return the ColorRegistry for the current theme

     */

    public static ColorRegistry getColorRegistry() {

        return getCurrentTheme().getColorRegistry();

    }

    public static Color getColor(String symbolicName) {

        return getColorRegistry().get(symbolicName);

    }

    public static IStatus executeOperation(final AbstractPostOperation operation) {

        if (getOperationHistory() == null) {

            throw new IllegalArgumentException(

                    "There is no operation history for this context");

        }

        final IAdaptable uiInfoAdapter = WorkspaceUndoUtil

                .getUIInfoAdapter(getShell());

        IRunnableWithProgress runnable = new IRunnableWithProgress() {

            @Override

            public void run(IProgressMonitor monitor)

                    throws InvocationTargetException, InterruptedException {

                String operationlabel = operation.getLabel();

                monitor.beginTask(operationlabel, 100);

                IStatus status = Status.CANCEL_STATUS;

                try {

                    operation.addContext(IOperationHistory.GLOBAL_UNDO_CONTEXT);

                    status = getOperationHistory().execute(operation, monitor,

                            uiInfoAdapter);

                } catch (ExecutionException e) {

                    MessagingUtils.operationDialog(this, e, TaxeditorStorePlugin.PLUGIN_ID, operationlabel, null);

                } finally {

                    monitor.done();

                }

                String statusString = status.equals(Status.OK_STATUS) ? "completed"

                        : "cancelled";

                setStatusLine(operationlabel + " " + statusString + ".");

            }

        };

        try {

            runInUI(runnable, null);

        } catch (Exception e) {

            MessagingUtils.messageDialog("Error executing operation", AbstractUtility.class, "An error occured while executing " + operation.getLabel(), e);

        }

        IPostOperationEnabled postOperationEnabled = operation

                .getPostOperationEnabled();

        if (postOperationEnabled != null) {

            postOperationEnabled.onComplete();

        }

        return Status.OK_STATUS;

    }

    public static IStatus executeOperation(final AbstractOperation operation, final RemotingCdmHandlerE4 handler) {

        return executeOperation_internal(operation, handler);

    }

    public static IStatus executeOperation(final AbstractOperation operation, final RemotingCdmHandler handler) {

        return executeOperation_internal(operation, handler);

    }

    private static IStatus executeOperation_internal(final AbstractOperation operation, final Object handler) {

        if (getOperationHistory() == null) {

            throw new IllegalArgumentException(

                    "There is no operation history for this context");

        }

        final IAdaptable uiInfoAdapter = WorkspaceUndoUtil

                .getUIInfoAdapter(getShell());

        IRunnableWithProgress runnable = new IRunnableWithProgress() {

            @Override

            public void run(IProgressMonitor monitor)

                    throws InvocationTargetException, InterruptedException {

                String operationlabel = operation.getLabel();

                monitor.beginTask(operationlabel, 100);

                IStatus status = Status.CANCEL_STATUS;

                try {

                    operation.addContext(IOperationHistory.GLOBAL_UNDO_CONTEXT);

                    status = getOperationHistory().execute(operation, monitor,

                            uiInfoAdapter);

                    if(handler instanceof RemotingCdmHandler) {

                        ((RemotingCdmHandler) handler).postOperation(status);

                    }

                    else if(handler instanceof RemotingCdmHandlerE4) {

                        ((RemotingCdmHandlerE4) handler).postOperation(status);

                    }

                } catch (ExecutionException e) {

                    MessagingUtils.operationDialog(this, e, TaxeditorStorePlugin.PLUGIN_ID, operationlabel, null);

                } finally {

                    monitor.done();

                }

                String statusString = status.equals(Status.OK_STATUS) ? "completed"

                        : "cancelled";

                setStatusLine(operationlabel + " " + statusString + ".");

            }

        };

        try {

            runInUI(runnable, null);

        } catch (Exception e) {

            MessagingUtils.messageDialog("Error executing operation", AbstractUtility.class, "An error occured while executing " + operation.getLabel(), e);

        }

        return Status.OK_STATUS;

    }

    /**

     * Executes a remoting monitored operation

     *

     * @param label for the operation

     * @param uuid of the remoting monitor already started on the server

     * @param pollInterval in milliseconds

     * @param cancelable flag which determines whether the operation can be cancelled

     * @param postOp callback for running post operation logic

     * @return

     */

    public static IStatus executeMoniteredExport(final String label,

            final UUID uuid,

            final int pollInterval,

            final boolean cancelable,

            final IPostMoniteredOperationEnabled postOp,

            final IFeedbackGenerator feedbackGenerator,

            String urlString,

            boolean createZip) {

        try {

            // get the remoting monitor the first time to make sure that the

            // operation is valid

            final IProgressMonitorService progressMonitorService = CdmApplicationState.getCurrentAppConfig().getProgressMonitorService();

            final IRemotingProgressMonitor firstRemotingMonitor = progressMonitorService.getRemotingMonitor(uuid);

            if(firstRemotingMonitor == null) {

                throw new IllegalStateException("Remoting progress monitor is null");

            }

            Job job = new Job(label) {

                @Override

                public IStatus run(IProgressMonitor monitor) {

                    // run the monitor until the operation is finished

                	monitor.beginTask("Start", 100);

                    IRemotingProgressMonitor remotingMonitor;

                    try {

                        remotingMonitor = CdmStore.getProgressMonitorClientManager().pollMonitor(label,

                                uuid,

                                pollInterval,

                                postOp,

                                feedbackGenerator,

                                monitor);

                    } catch (Exception ex) {

                        return new Status(Status.ERROR, TaxeditorStorePlugin.PLUGIN_ID, "Operation Interrupted", ex);

                    }

                    final StringBuilder reportSb = new StringBuilder();

                    if (remotingMonitor.getResult() instanceof ExportResult){

                    	ExportResult result = (ExportResult)remotingMonitor.getResult();

	                    reportSb.append(result.createReport());

	                    if(!StringUtils.isBlank(reportSb.toString())) {

	                        Display.getDefault().asyncExec(new Runnable() {

	                            @Override

	                            public void run() {

	                                // display reports with possibility to save

	                                ReportTextDialog dialog = new ReportTextDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());

	                                dialog.setTitle(label + " Report");

	                                dialog.setReportText(reportSb.toString());

	                                dialog.open();

	                            }

	                        });

	                    }

	                    if (urlString != null){

	                    	 ExportDataWrapper data = result.getExportData();

	                         try{

	                             if (result.getExportData().getType().equals(ExportResultType.BYTE_ARRAY)){

	                                 byte[] exportData = (byte[])data.getExportData();

	                                 if(exportData != null){

	                                     File file = new File(urlString);

	                                     FileOutputStream stream = new FileOutputStream(file);

	                                     Writer out = new BufferedWriter(new OutputStreamWriter(

	                                 			stream, "UTF8"));

	                                 	stream.write(exportData);

	                                    out.flush();

	                                    stream.close();

	                                 }

	                             } else if (result.getExportData().getType().equals(ExportResultType.MAP_BYTE_ARRAY)){

	                                 Map<String, byte[]> resultMap = (Map<String, byte[]>)data.getExportData();

	                                 Set<String> keySet = resultMap.keySet();

	                                 SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_NOW);

	                                 Calendar cal = Calendar.getInstance();

	                                 String fileEnding = ".csv";

	                                 if (createZip){

	                            		 File file = new File(urlString+File.separator +  sdf.format(cal.getTime())+ ".zip");

	                                     FileOutputStream stream = new FileOutputStream(file);

	                                     ZipOutputStream zos = new ZipOutputStream(stream);

	                                     for (String key: keySet){

	                                    	byte[] fileData = resultMap.get(key);

	                                    	ZipEntry entry = new ZipEntry( key + fileEnding);

	         								zos.putNextEntry(entry);

	         								zos.write(fileData);

	         								zos.closeEntry();

	                                     }

	                                     zos.close();

	                            	 }else{

	                            		if(result.getExportType().equals(ExportType.DWCA)){

	                                        File file = new File(urlString);

	                                        FileOutputStream stream = new FileOutputStream(file);

	                                        ZipOutputStream zos = new ZipOutputStream(stream);

	                                        for (String key: keySet){

             	                               	byte[] fileData = resultMap.get(key);

             	                               	ZipEntry entry = new ZipEntry( key + fileEnding);

             	    								zos.putNextEntry(entry);

             	    								zos.write(fileData);

             	    								zos.closeEntry();

	                                         }

	                                         zos.close();

	                                      }else{

		                            		 for (String key: keySet){

		                            			 byte[] fileData = resultMap.get(key);

		                            			 File file = new File(urlString+File.separator + key + fileEnding);

		                                         FileOutputStream stream = new FileOutputStream(file);

		                                         Writer out = new BufferedWriter(new OutputStreamWriter(

		                                     			stream, "UTF8"));

		                                         stream.write(fileData);

		                                         stream.close();

		                                     }

	                                      }

	                            	 }

	                            }else{

	                                 logger.error("This kind of result data is not supported yet." + result.getExportData().getType().toString());

	                             }

	                         } catch(Exception e){

	                             logger.error(e.getStackTrace());

	                         }

	                    }

                    }

                    return Status.OK_STATUS;

                }

                @Override

                protected void canceling() {

                    CdmStore.getCurrentApplicationConfiguration().getProgressMonitorService().cancel(uuid);

                }

            };

            // configure the job

            job.setProperty(IProgressConstants.KEEP_PROPERTY, true);

            job.setUser(true);

            // schedule job

            job.schedule();

        } catch (Exception e) {

            MessagingUtils.errorDialog("Error executing operation",

                    AbstractUtility.class,

                    "An error occured while executing " + label,

                    TaxeditorStorePlugin.PLUGIN_ID,

                    e,

                    true);

        }

        return Status.OK_STATUS;

    }

    public static IOperationHistory getOperationHistory() {

        return getWorkbench().getOperationSupport().getOperationHistory();

    }

    public static void setStatusLine(final String message) {

        Display.getDefault().asyncExec(new Runnable() {

            @Override

            public void run() {

                statusLineManager.setMessage(message);

            }

        });

    }

    public static IProgressMonitor getMonitor() {

        statusLineManager.setCancelEnabled(false);

        return statusLineManager.getProgressMonitor();

    }

    /**

     * Starts either the given {@link IProgressMonitor} if it's not

     * <code>null</code> or a new {@link NullProgressMonitor}.

     *

     * @param progressMonitor

     *            The {@link IProgressMonitor} or <code>null</code> if no

     *            progress should be reported.

     * @param taskName

     *            The name of the main task.

     * @param steps

     *            The number of steps this task is subdivided into.

     * @return The {@link IProgressMonitor}.

     */

    public static IProgressMonitor startMainMonitor(

            IProgressMonitor progressMonitor, String taskName, int steps) {

        IProgressMonitor newMonitor = progressMonitor;

        if (newMonitor == null) {

            newMonitor = new NullProgressMonitor();

        }

        newMonitor.beginTask(taskName == null ? "" : taskName, steps);

        newMonitor.subTask(" ");

        return newMonitor;

    }

    /**

     * Creates a {@link SubProgressMonitor} if the given

     * {@link IProgressMonitor} is not <code>null</code> and not a

     * {@link NullProgressMonitor}.

     *

     * @param progressMonitor

     *            The parent {@link IProgressMonitor} of the

     *            {@link SubProgressMonitor} to be created.

     * @param ticks

     *            The number of steps this subtask is subdivided into. Must be a

     *            positive number and must not be

     *            {@link IProgressMonitor#UNKNOWN}.

     * @return The {@link IProgressMonitor}.

     */

    public static IProgressMonitor getSubProgressMonitor(

            IProgressMonitor progressMonitor, int ticks) {

        if (progressMonitor == null) {

            return new NullProgressMonitor();

        }

        if (progressMonitor instanceof NullProgressMonitor) {

            return progressMonitor;

        }

        return new SubProgressMonitor(progressMonitor, ticks);

    }

    /**

     * Checks whether the user canceled this operation. If not canceled, the

     * given number of steps are declared as done.

     *

     * @param newMonitor

     *            a {@link org.eclipse.core.runtime.IProgressMonitor} object.

     * @param steps

     *            a int.

     */

    public static void workedChecked(IProgressMonitor newMonitor, int steps) {

        // In case the progress monitor was canceled throw an exception.

        if (newMonitor.isCanceled()) {

            throw new OperationCanceledException();

        }

        // Otherwise declare this step as done.

        newMonitor.worked(steps);

    }

    /**

     * Present a progress dialog to the user. This dialog will block the UI

     *

     * @param runnable

     *            an implementation of {@link IRunnableWithProgress}

     * @throws java.lang.InterruptedException

     *             if any.

     * @throws java.lang.reflect.InvocationTargetException

     *             if any.

     */

    public static void busyCursorWhile(IRunnableWithProgress runnable)

            throws InvocationTargetException, InterruptedException {

        getProgressService().busyCursorWhile(runnable);

    }

    public static void runInUI(IRunnableWithProgress runnable,

            ISchedulingRule rule) throws InvocationTargetException,

            InterruptedException {

        getProgressService().runInUI(getWorkbenchWindow(), runnable, rule);

    }

    public static void run(boolean fork, boolean cancelable,

            IRunnableWithProgress runnable) throws InvocationTargetException,

            InterruptedException {

        getProgressService().run(fork, cancelable, runnable);

    }

    public static IProgressService getProgressService() {

        IWorkbench workbench = PlatformUI.getWorkbench();

        return workbench.getProgressService();

    }

    public static IWorkbenchSiteProgressService getProgressService2() {

        return (IWorkbenchSiteProgressService) getService(IWorkbenchSiteProgressService.class);

    }

    public static String getPluginId() {

        return "eu.taxeditor";

    }

    public static Object getActiveE4Editor() {

        MPart activePart = EventUtility.getActivePart();

        if(activePart!=null && activePart.getObject()!=null

                && activePart.getObject() instanceof IE4SavablePart){

            return activePart.getObject();

        }

        return null;

    }

    public static DetailsViewPart getDetailsView() {

        return (DetailsViewPart) getView(DetailsViewPart.ID, false);

    }

    public static void refreshDetailsViewer() {

        if (getDetailsView() != null) {

            ((AbstractCdmDataViewer) getDetailsView().getViewer()).refresh();

        }

    }

    public static void reflowDetailsViewer() {

        if (getDetailsView() != null) {

            ((AbstractCdmDataViewer) getDetailsView().getViewer()).reflow();

        }

    }

    public static SupplementalDataViewPart getSupplementalDataView() {

        return (SupplementalDataViewPart) getView(SupplementalDataViewPart.ID,

                false);

    }

    public static void reflowSupplementalViewer() {

        if (getSupplementalDataView() != null) {

            ((AbstractCdmDataViewer) getSupplementalDataView().getViewer())

            .reflow();

        }

    }

    /**

     * Orders a Collection of {@link IEnumTerm}s according to the term

     * hierarchy. <br>

     * <br>

     * The returned map will be be ordered primarily by root elements,

     * secondarily by the child elements and their children resp., both ascending alphabetically. <br>

     * @param terms

     *            A {@link Collection} of {@link IEnumTerm}s for which the term

     *            hierarchy should be created

     * @return a map which holds the terms as keys and their string

     *         representation via {@link IEnumTerm#getMessage()} as values

     */

    public static <T extends IEnumTerm<T>> LinkedHashMap<T, String> orderTerms(Collection<T> terms) {

        TreeSet<TermNode<T>> parentElements = new TreeSet<TermNode<T>>();

        parentElements.addAll(getTermHierarchy(terms));

        // create list according to the type hierarchy (root elements alphabetically with recursive children also alphabetically)

        LinkedHashMap<T, String> result = new LinkedHashMap<T, String>();

        parseTermTree(parentElements, result, -1);

        return result;

    }

    private static<T extends IEnumTerm<T>> void parseTermTree(Collection<TermNode<T>> children, LinkedHashMap<T, String> result, int depth){

        depth++;

        for(TermNode<T> node:children){

            String indentString = "";

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

                indentString += "  ";

            }

            if(depth>0){

                indentString += "- ";

            }

            result.put(node.term, indentString + node.term.getMessage());

            parseTermTree(node.children, result, depth);

        }

    }

    private static<T extends IEnumTerm<T>> void addToParents(List<TermNode<T>> parents, Collection<T> terms){

        List<TermNode<T>> hasChildrenList = new ArrayList<TermNode<T>>();

        for(T term:terms){

            // only terms with parents

            if(term.getKindOf()!=null){

                TermNode<T> parentNode = new TermNode<T>(term.getKindOf());

                TermNode<T> childNode = new TermNode<T>(term);

                if(parents.contains(parentNode)){

                    // parent found in parent list -> add this term to parent's child list

                    parents.get(parents.indexOf(parentNode)).addChild(childNode);

                    if(!term.getGeneralizationOf().isEmpty()){

                        // has more children -> add to list which will be the parent for the next recursion

                        hasChildrenList.add(childNode);

                    }

                }

            }

        }

        if(!hasChildrenList.isEmpty()){

            addToParents(hasChildrenList, terms);

        }

    }

    private static<T extends IEnumTerm<T>> List<TermNode<T>> getTermHierarchy(Collection<T> terms){

        List<TermNode<T>> parents = new ArrayList<TermNode<T>>();

        // get root elements

        for(T term:terms){

            T parentTerm = term.getKindOf();

            if(parentTerm==null){

                // root element

                parents.add(new TermNode<T>(term));

            }

        }

        addToParents(parents, terms);

        return parents;

    }

    @SuppressWarnings("unchecked")

    /**

     * Recursively iterates over all term parents until no more parent is found i.e. the root node

     * @param term The term for which the parent should be found

     * @return the root terms of the term hierarchy

     */

    private static<T extends IEnumTerm<T>> T getParentFor(T term){

        // PP: cast should be safe. Why is Eclipse complaining??

        T parent = term.getKindOf();

        if(parent==null){

            return term;

        }

        else{

            return getParentFor(term.getKindOf());

        }

    }

    private static class TermNode<T extends IEnumTerm<T>> implements Comparable<TermNode<T>>{

        private final T term;

        private final TreeSet<TermNode<T>> children;

        public TermNode(T term) {

            super();

            this.term = term;

            this.children = new TreeSet<TermNode<T>>();

        }

        public void addChild(TermNode<T> child){

            this.children.add(child);

        }

        public TreeSet<TermNode<T>> getChildren() {

            return children;

        }

        public T getTerm() {

            return term;

        }

        @Override

        public int hashCode() {

            final int prime = 31;

            int result = 1;

            result = prime * result + ((term == null) ? 0 : term.hashCode());

            return result;

        }

        @Override

        public boolean equals(Object obj) {

            if (this == obj) {

                return true;

            }

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            TermNode other = (TermNode) obj;

            if (term == null) {

                if (other.term != null) {

                    return false;

                }

            } else if (!term.equals(other.term)) {

                return false;

            }

            return true;

        }

        @Override

        public int compareTo(TermNode<T> that) {

            return this.term.getMessage().compareTo(that.term.getMessage());

        }

    }

    public static void executeCommand(String commandId, Object source, String pluginId) {

        IHandlerService handlerService = (IHandlerService) AbstractUtility.getService(IHandlerService.class);

        Exception exception = null;

        try {

            handlerService.executeCommand(commandId, null);

        } catch (ExecutionException e) {

            exception = e;

        } catch (NotDefinedException e) {

            exception = e;

        } catch (NotEnabledException e) {

            exception = e;

        } catch (NotHandledException e) {

            exception = e;

        } finally {

            if(exception != null) {

                MessagingUtils.errorDialog("Error executing command",

                        source,

                        "Could not execute command with id " + commandId ,

                        pluginId,

                        exception,

                        true);

            }

        }

    }

    public static Object getElementsFromSelectionChangedEvent(SelectionChangedEvent event) {

        IStructuredSelection selection = (IStructuredSelection) event.getSelection();

        Object selectionToSet = selection;

        if(selection.size() == 1){

            selectionToSet = selection.getFirstElement();

        }