EDIT

    @SuppressWarnings("unused")

    private void createBottomToolbar() {

        new CharacterMatrixBottomToolbar(this, SWT.NONE);

    }

/**

* Copyright (C) 2018 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.descriptiveDataSet.matrix;

import java.util.Collection;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import java.util.stream.Collectors;

import org.eclipse.core.runtime.ICoreRunnable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.SubMonitor;

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

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

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

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.window.Window;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.RowLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

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

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

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

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

import eu.etaxonomy.cdm.api.service.description.AggregationMode;

import eu.etaxonomy.cdm.api.service.description.StructuredDescriptionAggregationConfiguration;

import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO;

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

import eu.etaxonomy.cdm.filter.TaxonNodeFilter;

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

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.persistence.dto.DescriptiveDataSetBaseDto;

import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;

import eu.etaxonomy.cdm.persistence.dto.TermDto;

import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;

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

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.operation.IFeedbackGenerator;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

import eu.etaxonomy.taxeditor.ui.dialog.configurator.StructuredAggregationConfigurationWizard;

import eu.etaxonomy.taxeditor.ui.dialog.selection.TaxonSelectionDialog;

/**

 * @author pplitzner

 * @since Jul 9, 2018

 */

public class CharacterMatrixBottomToolbar extends Composite{

    private CharacterMatrix matrix;

    public CharacterMatrixBottomToolbar(CharacterMatrix matrix, int style) {

        super(matrix, style);

        this.matrix = matrix;

        init();

    }

    private void init() {

        setLayout(new RowLayout());

        GridDataFactory.fillDefaults().grab(true, false).applyTo(this);

//        /**

//         * Add description button

//         */

//        Button btnAddDescription = new Button(this, SWT.PUSH);

//        btnAddDescription.setImage(ImageResources.getImage(ImageResources.ADD_ICON_GREEN));

//        btnAddDescription.addSelectionListener(new SelectionAdapter() {

//            @Override

//            public void widgetSelected(SelectionEvent e) {

//                if(StoreUtil.promptCheckIsDirty(matrix.getPart())){

//                    return;

//                }

//                SpecimenSelectionDialog dialog = new SpecimenSelectionDialog(matrix.getShell(), matrix, null);

//                if(dialog.open()==Window.OK){

//                    Collection<SpecimenNodeWrapper> wrappers = dialog.getSpecimen();

//                    if(wrappers.stream().anyMatch(wrapper->wrapper.getTaxonDescriptionUuid()==null)

//                            && !MessagingUtils.confirmDialog(

//                                    "Create Taxon Association",

//                                    "Some specimens are not linked with taxon via IndividualsAssociation yet.\n"

//                                    + "Do you want to create this association?")){

//                        return;

//                    }

//                    addRowsToMatrix(wrappers, matrix.getDescriptiveDataSet().getUuid());

//                    wrappers.forEach(wrapper->matrix.getSpecimenCache().remove(wrapper));

//                }

//            }

//        });

        /**

         * Remove description button

         */

//        Button btnRemoveDescription = new Button(this, SWT.PUSH);

//        btnRemoveDescription.setImage(ImageResources.getImage(ImageResources.ACTIVE_DELETE_ICON));

//        btnRemoveDescription.addSelectionListener(new SelectionAdapter() {

//            @Override

//            public void widgetSelected(SelectionEvent e) {

//                if(StoreUtil.promptCheckIsDirty(matrix.getPart())){

//                    return;

//                }

//                if(!MessagingUtils.confirmDialog(Messages.CharacterMatrixBottomToolbar_CONFIRM_DELETE_TITLE, Messages.CharacterMatrixBottomToolbar_CONFIRM_DELETE_MESSAGE)){

//                    return;

//                }

//                int[] fullySelectedRowPositions = matrix.getBodyLayer().getSelectionLayer().getFullySelectedRowPositions();

//                List<RowWrapperDTO> toRemove = new ArrayList<>();

//                for (int i : fullySelectedRowPositions) {

//                    Object rowObject = matrix.getBodyDataProvider().getRowObject(i);

//                    if(rowObject instanceof RowWrapperDTO){

//                        toRemove.add((RowWrapperDTO) rowObject);

//                    }

//                }

//                toRemove.forEach(rowToRemove -> {

//                    matrix.putDescriptionToDelete(rowToRemove.getDescription().getUuid());

//                    matrix.getDescriptions().remove(rowToRemove);

//                    matrix.setDirty();

////                    CdmStore.getService(IDescriptiveDataSetService.class).removeDescription(

////                            rowToRemove.getDescription().getUuid(), matrix.getDescriptiveDataSet().getUuid());

//                });

//            }

//        });

        /**

         * Aggregate button

         */

        Button btnAggregate = new Button(this, SWT.PUSH);

        btnAggregate.setText(Messages.CharacterMatrixBottomToolbar_AGGREGATE);

        btnAggregate.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                if(StoreUtil.promptCheckIsDirty(matrix.getPart())){

                    return;

                }

                aggregatDescriptiveDataSet(matrix.getDescriptiveDataSet().getUuid());

            }

        });

        /**

         * Key generation button

         */

        Button btnGenerateKey = new Button(this, SWT.PUSH);

        btnGenerateKey.setText("Generate Polytomous Key");

        btnGenerateKey.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                if(StoreUtil.promptCheckIsDirty(matrix.getPart())){

                    return;

                }

                Set<TaxonNodeDto> nodeDtos = matrix.getDescriptiveDataSet().getSubTreeFilter();

                TaxonNodeDto parentDto = CdmStore.getService(ITaxonNodeService.class).findCommonParentDto(nodeDtos);

                UUID taxonUuid = parentDto.getTaxonUuid();

                int response = MessagingUtils.confirmDialog(

                        "Choose taxonomic scope",

                        String.format("The common parent taxon of this dataset is :\n%s\n\n"

                                + "Do you want to use this as the taxonomic scope for the polytomous key?"

                                , parentDto.getTaxonTitleCache()), "Yes", "Choose different taxon", "Cancel");

                if(response==2){

                    return;

                }

                else if(response==1){

                    Taxon taxon = TaxonSelectionDialog.selectTaxon(getShell(), null);

                    if(taxon==null){

                        return;

                    }

                    taxonUuid = taxon.getUuid();

                }

                generateKey(matrix.getDescriptiveDataSet().getUuid(), taxonUuid);

            }

        });

    }

    private void aggregatDescriptiveDataSet(UUID descriptiveDataSetUuid){

        StructuredDescriptionAggregationConfiguration config = StructuredDescriptionAggregationConfiguration.NewInstance(

                null, null);

        IStructuredSelection sel = matrix.getSelection();

        Object o = sel.getFirstElement();

        TaxonNodeFilter filter = TaxonNodeFilter.NewRankInstance(matrix.getDescriptiveDataSet().getMinRank().getUuid(),

                matrix.getDescriptiveDataSet().getMaxRank().getUuid());

        for (TermDto namedArea : matrix.getDescriptiveDataSet().getGeoFilter()) {

            filter = filter.orArea(namedArea.getUuid());

        }

//        for (TaxonNode taxonNode : matrix.getDescriptiveDataSet().getTaxonSubtreeFilter()) {

//            filter = filter.orSubtree(taxonNode);

//        }

        if (o instanceof TaxonNodeDto){

            filter = filter.orSubtree(CdmStore.getService(ITaxonNodeService.class).load(((TaxonNodeDto)o).getUuid()));

        }else{

            for (TaxonNodeDto taxonNode : matrix.getDescriptiveDataSet().getSubTreeFilter()) {

                filter = filter.orSubtree(taxonNode.getUuid());

            }

        }

        config.setTaxonNodeFilter(filter);

        config.setDatasetUuid(matrix.getDescriptiveDataSet().getUuid());

        config.setAggregationMode(AggregationMode.byWithinTaxonAndToParent());

        config.setAdaptBatchSize(false);

        StructuredAggregationConfigurationWizard aggregationWizard = new StructuredAggregationConfigurationWizard(config, this.matrix.getDescriptiveDataSet(), null);

        WizardDialog dialog = new WizardDialog(AbstractUtility.getShell(),

                aggregationWizard);

        int open = dialog.open();

        if (open != Window.OK){

            return;

        }

        UUID monitorUuid =  CdmApplicationState.getLongRunningTasksService().invoke(config);

        String jobLabel = "Aggregate Descriptive Dataset";

        Job job = Job.create(jobLabel, (ICoreRunnable) monitor -> {

            SubMonitor subMonitor = SubMonitor.convert(monitor);

            subMonitor.beginTask(jobLabel, IProgressMonitor.UNKNOWN);

            IRemotingProgressMonitor remotingMonitor;

            try {

                remotingMonitor = CdmStore.getProgressMonitorClientManager()

                        .pollMonitor(jobLabel,

                                monitorUuid,

                                50,

                                null,

                                (List<IFeedbackGenerator>)null,

                                subMonitor);

                Object resultObject = remotingMonitor.getResult();

                if(resultObject instanceof Exception){

                    MessagingUtils.errorDialog("Aggregation failed", this, "Aggregation was not successfull", TaxeditorEditorPlugin.PLUGIN_ID, (Exception)resultObject, true, true);

                }

                else if(resultObject instanceof UpdateResult){

                    DescriptiveDataSet dataSet = (DescriptiveDataSet) ((UpdateResult) resultObject).getCdmEntity();

//                    dataSet = matrix.getCdmEntitiySession().load(dataSet, true);

                    DescriptiveDataSetBaseDto dto = CdmStore.getService(IDescriptiveDataSetService.class).getDescriptiveDataSetDtoByUuid(dataSet.getUuid());

                    // update local dataset

                    matrix.setDescriptiveDataSet(dto);

                    matrix.loadDescriptions(false, false);

                }

            } catch (InterruptedException e) {

                return;

            }

            monitor.done();

        });

        job.addJobChangeListener(new JobChangeAdapter(){

            @Override

            public void done(IJobChangeEvent event) {

                CharacterMatrixBottomToolbar.this.getDisplay().asyncExec(()->{

                    matrix.redraw();

                });

            }

        });

        job.schedule();

    }

    private void addRowsToMatrix(Collection<SpecimenRowWrapperDTO> wrappers, UUID descriptiveDataSetUuid){

        UUID monitorUuid =  CdmApplicationState.getLongRunningTasksService().addRowWrapperToDataset(wrappers, descriptiveDataSetUuid);

        String jobLabel = "Add specimens to matrix";

        Job job = Job.create(jobLabel, (ICoreRunnable) monitor -> {

            SubMonitor subMonitor = SubMonitor.convert(monitor);

            subMonitor.beginTask(jobLabel, IProgressMonitor.UNKNOWN);

            IRemotingProgressMonitor remotingMonitor;

            try {

                remotingMonitor = CdmStore.getProgressMonitorClientManager()

                        .pollMonitor(jobLabel,

                                monitorUuid,

                                50,

                                null,

                                (List)null,

                                subMonitor);

                Object resultObject = remotingMonitor.getResult();

                if(resultObject instanceof Exception){

                    MessagingUtils.errorDialog("Adding specimens failed", this, "Adding specimens was not successfull", TaxeditorEditorPlugin.PLUGIN_ID, (Exception)resultObject, true, true);

                }

                else if(resultObject instanceof UpdateResult){

                    UpdateResult result = (UpdateResult)resultObject;

                    if(!result.getExceptions().isEmpty()){

                        MessagingUtils.warningDialog(Messages.CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_TITLE, this,

                                String.format(Messages.CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_MESSAGE, result.getExceptions()

                                        .stream().map(ex->ex.toString())

                                        .collect(Collectors.joining("\n"))));

                    }

                    DescriptiveDataSet dataSet = (DescriptiveDataSet) result.getCdmEntity();

//                    dataSet = matrix.getCdmEntitiySession().load(dataSet, true);

                    // update local dataset

                    DescriptiveDataSetBaseDto dto = CdmStore.getService(IDescriptiveDataSetService.class).getDescriptiveDataSetDtoByUuid(dataSet.getUuid());

                    // update local dataset

                    matrix.setDescriptiveDataSet(dto);

//                    matrix.setDescriptiveDataSet(dataSet);

                    matrix.loadDescriptions(false, false);

                }

            } catch (InterruptedException e) {

                return;

            }

            monitor.done();

        });

        job.addJobChangeListener(new JobChangeAdapter(){

            @Override

            public void done(IJobChangeEvent event) {

                CharacterMatrixBottomToolbar.this.getDisplay().asyncExec(()->{

                    matrix.redraw();

                });

            }

        });

        job.schedule();

    }

    private void generateKey(UUID datasetUuid, UUID taxonUuid) {

        UUID monitorUuid =  CdmApplicationState.getLongRunningTasksService().generatePolytomousKey(datasetUuid, taxonUuid);

        String jobLabel = "Generate polytomous key";

        Job job = Job.create(jobLabel, (ICoreRunnable) monitor -> {

            SubMonitor subMonitor = SubMonitor.convert(monitor);

            subMonitor.beginTask(jobLabel, IProgressMonitor.UNKNOWN);

            IRemotingProgressMonitor remotingMonitor;

            try {

                remotingMonitor = CdmStore.getProgressMonitorClientManager()

                        .pollMonitor(jobLabel,

                                monitorUuid,

                                50,

                                null,

                                (List)null,

                                subMonitor);

                Object resultObject = remotingMonitor.getResult();

                if(resultObject instanceof Exception){

                    MessagingUtils.errorDialog("Key generation failed", this, "Generating the polytomous key was not successfull", TaxeditorEditorPlugin.PLUGIN_ID, (Exception)resultObject, true, true);

                }

            } catch (InterruptedException e) {

                return;

            }

            monitor.done();

        });

        job.schedule();

    }

}

        matrixPart.getMatrix().redraw();

    public static String CharacterMatrixBottomToolbar_AGGREGATE;

    public static String CharacterMatrixBottomToolbar_AGGREGATION_MESSAGE;

    public static String CharacterMatrixBottomToolbar_AGGREGATION_TITLE;

    public static String CharacterMatrixBottomToolbar_CANCEL;

    public static String CharacterMatrixBottomToolbar_CHOOSE_TAXON;

    public static String CharacterMatrixBottomToolbar_CONFIRM_DELETE_MESSAGE;

    public static String CharacterMatrixBottomToolbar_CONFIRM_DELETE_TITLE;

    public static String CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_MESSAGE;

    public static String CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_TITLE;

    public static String CharacterMatrixBottomToolbar_YES;

    public static String CharacterMatrixPart_COULD_NOT_OPEN;

CharacterMatrixBottomToolbar_AGGREGATE=Aggregate

CharacterMatrixBottomToolbar_AGGREGATION_MESSAGE=The aggregated description will be stored at the common parent taxon of this dataset:\n%s\n\nDo you want to use this taxon?

CharacterMatrixBottomToolbar_AGGREGATION_TITLE=Choose location for the aggregated description

CharacterMatrixBottomToolbar_CANCEL=Cancel

CharacterMatrixBottomToolbar_CHOOSE_TAXON=Choose taxon

CharacterMatrixBottomToolbar_CONFIRM_DELETE_MESSAGE=Do you really want to delete the selected element?

CharacterMatrixBottomToolbar_CONFIRM_DELETE_TITLE=Confirm delete

CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_MESSAGE=Could not create rows for the following description:\n\n%s

CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_TITLE=Errors during row creation

CharacterMatrixBottomToolbar_YES=Yes

CharacterMatrixBottomToolbar_AGGREGATE=Aggregation

CharacterMatrixBottomToolbar_AGGREGATION_MESSAGE=Die aggregierte Beschreibung wird an das gemeinsame, n?chst-h?here Taxon dieses Datasets gehangen:\n%s\n\nSoll dieses Taxon verwenden werden?

CharacterMatrixBottomToolbar_AGGREGATION_TITLE=W?hlen Sie den Speicherort f?r die aggregierte Beschreibung

CharacterMatrixBottomToolbar_CANCEL=Abbrechen

CharacterMatrixBottomToolbar_CHOOSE_TAXON=Taxon w?hlen

CharacterMatrixBottomToolbar_CONFIRM_DELETE_MESSAGE=Wollen Sie wirklich das ausgew?hlte Element l?schen?

CharacterMatrixBottomToolbar_CONFIRM_DELETE_TITLE=L?schen best?tigen

CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_MESSAGE=Konnte keine Zeilen f?r die folgenden Beschreibungen erzeugen:\n\n%s

CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_TITLE=Fehler bei der Erstellung der Zeilen

CharacterMatrixBottomToolbar_YES=Ja