EDIT

/**

* Copyright (C) 2009 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.editor.definedterm.e4;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.List;

import java.util.Set;

import org.eclipse.e4.ui.di.AboutToShow;

import org.eclipse.e4.ui.model.application.commands.MCommand;

import org.eclipse.e4.ui.model.application.commands.MCommandsFactory;

import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;

import org.eclipse.e4.ui.model.application.ui.menu.MMenu;

import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;

import org.eclipse.e4.ui.model.application.ui.menu.MMenuFactory;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 *

 * Menu to dynamically generate menu (sub-menu) contribution items

 * for term types which when clicked open the defined term editor for the chosen term type

 *

 * @author pplitzner

 * @since Aug 23, 2017

 *

 */

public class DefinedTermMenuE4 {

    private static final String COMMAND_ID = "eu.etaxonomy.taxeditor.store.openDefinedTermEditor";

    /** {@inheritDoc} */

    @AboutToShow

    public void aboutToShow(List<MMenuElement> items) {

        if(CdmStore.isActive()){

            //add Feature and NamedArea to top level

            addChildTermsToMenuManager(items, TermType.Feature, true);

            addChildTermsToMenuManager(items, TermType.NamedArea);

            MMenu otherMenu = MMenuFactory.INSTANCE.createMenu();

            otherMenu.setLabel(Messages.DefinedTermMenu_OTHERS);

            items.add(otherMenu);

            items.add(MMenuFactory.INSTANCE.createMenuSeparator());

            List<TermType> ttList = new ArrayList<TermType>(EnumSet.allOf(TermType.class));

            Collections.sort(ttList,new SortByTermTypeMessage());

            for (TermType tt : ttList)

            {

                //skip Feature and NamedArea as they have already been added to top level

                if(tt.equals(TermType.Feature) || tt.equals(TermType.NamedArea)){

                    continue;

                }

                // if term type has a parent, do not add it

                // it will be added in the recursive call

                if(tt.getKindOf() == null) {

                    addChildTermsToMenuManager(otherMenu.getChildren(), tt);

                }

            }

        }

	}

    private void addChildTermsToMenuManager(List<MMenuElement> items, TermType termType) {

        addChildTermsToMenuManager(items, termType, false);

    }

    private void addChildTermsToMenuManager(List<MMenuElement> items, TermType termType, boolean skipChildren) {

        //FIXME : need a better way to find out if a term type can be editable (ticket 3853)

        if(termType.getEmptyDefinedTermBase() != null) {

            Set<TermType> children = termType.getGeneralizationOf();

            // term type has no children, so create menu item

            if(skipChildren || children.isEmpty()) {

                items.add(createMenuItem(termType));

            }

            else{

                MMenu subMenu = MMenuFactory.INSTANCE.createMenu();

                subMenu.setLabel(termType.getMessage(PreferencesUtil.getGlobalLanguage()));

                items.add(subMenu);

                // term type has children, so create sub menu

                subMenu.getChildren().add(createDefaultMenuItem(termType));

                subMenu.getChildren().add(MMenuFactory.INSTANCE.createMenuSeparator());

                // add child items to the sub menu

                for(TermType tt : children) {

                    addChildTermsToMenuManager(subMenu.getChildren(), tt);

                }

            }

        }

    }

	private MHandledMenuItem createMenuItem(TermType termType) {

	    MHandledMenuItem menuItem = MMenuFactory.INSTANCE.createHandledMenuItem();

        menuItem.setLabel(termType.getMessage());

        MCommand mCommand = MCommandsFactory.INSTANCE.createCommand();

        mCommand.setElementId(COMMAND_ID);

        //set params

        menuItem.getTransientData().put(COMMAND_ID+".termTypeUuid", termType.getUuid());

        menuItem.setCommand(mCommand);

        return menuItem;

	}

	private MHandledMenuItem createDefaultMenuItem(TermType termType) {

        MHandledMenuItem menuItem = MMenuFactory.INSTANCE.createHandledMenuItem();

        menuItem.setLabel(String.format(Messages.DefinedTermMenu_OTHER_S, termType.getMessage()));

        MCommand mCommand = MCommandsFactory.INSTANCE.createCommand();

        mCommand.setElementId(COMMAND_ID);

        //set params

        menuItem.getTransientData().put(COMMAND_ID+".termTypeUuid", termType.getUuid());

        menuItem.setCommand(mCommand);

        return menuItem;

	}

	private class SortByTermTypeMessage implements Comparator<TermType> {

	    @Override

        public int compare(TermType t1, TermType t2) {

	        if (t1.equals(t2)){

	            return 0;

	        }

	        int result = t1.getMessage().compareTo(t2.getMessage());

	        if (result == 0){

	            return t1.compareTo(t2);

	        }

	        return result;

	    }

	}

}