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.editor.view.descriptive.e4.handler;

import java.util.List;

import javax.inject.Named;

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 org.eclipse.e4.ui.services.IServiceConstants;

import org.eclipse.jface.viewers.IStructuredSelection;

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

import eu.etaxonomy.cdm.model.description.DescriptionBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.TaxonNameDescription;

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

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

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

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

import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.editor.view.descriptive.operation.CreateDescriptionElementOperation;

import eu.etaxonomy.taxeditor.model.FeatureNodeContainer;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 *

 * @author pplitzner

 * @date 15.08.2017

 *

 */

public class DynamicFeatureMenuE4 {

    /** {@inheritDoc} */

    @AboutToShow

    public void aboutToShow(List<MMenuElement> items, @Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection) {

        Language globalLanguage = PreferencesUtil.getGlobalLanguage();

        MMenu menu = MMenuFactory.INSTANCE.createMenu();

        menu.setLabel(Messages.DynamicFeatureMenuE4_new);

        items.add(menu);

        Object selectedElement = selection.getFirstElement();

        if (selectedElement instanceof DescriptionBase<?>) {

            FeatureTree<?> featureTree = getFeatureTree((DescriptionBase<?>) selectedElement);

            for (FeatureNode<?> childNode : featureTree.getRootChildren()) {

                createMenuItem(menu, childNode.getTerm(), globalLanguage);

            }

        } else if (selectedElement instanceof FeatureNodeContainer) {

            FeatureNode<?> featureNode = ((FeatureNodeContainer) selectedElement)

                    .getFeatureNode();

            // add the feature to the menu

            createMenuItem(menu, featureNode.getTerm(), globalLanguage);

            // add possible children to the menu

            for (FeatureNode<?> childNode : featureNode.getChildNodes()) {

                createMenuItem(menu, childNode.getTerm(), globalLanguage);

            }

        } else if (selectedElement instanceof DescriptionElementBase) {

            Feature feature = ((DescriptionElementBase) selectedElement)

                    .getFeature();

            createMenuItem(menu, feature, globalLanguage);

        }

    }

    private void createMenuItem(MMenu menu, final DefinedTermBase feature, Language globalLanguage) {

        final DefinedTermBase deproxiedFeature = HibernateProxyHelper.deproxy(feature, DefinedTermBase.class);

        String label = deproxiedFeature.getLabel(globalLanguage);

        if (label == null){

            label = deproxiedFeature.getLabel();

        }

        if(label == null){

            label = deproxiedFeature.generateTitle();

        }

        if(label == null){

            label = deproxiedFeature.toString();

        }

        MHandledMenuItem menuItem = MMenuFactory.INSTANCE.createHandledMenuItem();

        menuItem.setLabel(label);

        MCommand mCommand = MCommandsFactory.INSTANCE.createCommand();

        mCommand.setElementId(CreateDescriptionElementOperation.ID);

        mCommand.setCommandName(label);

        //	        try {

        //	            mCommand.setCommandName(command.getName());

        //	        } catch (NotDefinedException e) {

        //	            e.printStackTrace();

        //	        }

        //set params

        menuItem.getTransientData().put(CreateDescriptionElementOperation.ID+".feature.uuid", deproxiedFeature.getUuid());

        menuItem.setCommand(mCommand);

        menu.getChildren().add(menuItem);

    }

	/**

	 * Retrieves the feature tree associated with the given description

	 *

	 * TODO as of now this is always the same thing because feature trees may

	 * not be associated to descriptions yet.

	 *

	 * @param description

	 * @return

	 */

	private FeatureTree<?> getFeatureTree(DescriptionBase description) {

		FeatureTree<?> featureTree = null;

		// TODO change this to the feature tree associated with this taxon

		// description

		if (description.hasStructuredData()) {

			featureTree = PreferencesUtil

					.getDefaultFeatureTreeForStructuredDescription();

		} else {

			featureTree = PreferencesUtil

					.getDefaultFeatureTreeForTextualDescription();

		}

		if (featureTree == null) {

		    featureTree = TermEditorInput.getDefaultFeatureTree();

		    		}

		if (description instanceof TaxonNameDescription){

		    List<Feature> terms = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));

		    terms.remove(Feature.PROTOLOGUE());

		    featureTree = FeatureTree.NewInstance(terms);

		}

		return featureTree;

	}

}