EDIT

/**

* 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.view.checklist.e4;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.SortedSet;

import java.util.TreeSet;

import java.util.UUID;

import javax.inject.Inject;

import org.apache.commons.collections4.map.LinkedMap;

import org.apache.log4j.Logger;

import org.eclipse.e4.ui.services.EMenuService;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.layout.GridLayoutFactory;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.nebula.widgets.nattable.NatTable;

import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;

import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;

import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;

import org.eclipse.nebula.widgets.nattable.data.IDataProvider;

import org.eclipse.nebula.widgets.nattable.data.IRowDataProvider;

import org.eclipse.nebula.widgets.nattable.data.ListDataProvider;

import org.eclipse.nebula.widgets.nattable.extension.e4.selection.E4SelectionListener;

import org.eclipse.nebula.widgets.nattable.extension.glazedlists.filterrow.DefaultGlazedListsFilterStrategy;

import org.eclipse.nebula.widgets.nattable.filterrow.FilterRowHeaderComposite;

import org.eclipse.nebula.widgets.nattable.freeze.CompositeFreezeLayer;

import org.eclipse.nebula.widgets.nattable.freeze.FreezeHelper;

import org.eclipse.nebula.widgets.nattable.freeze.FreezeLayer;

import org.eclipse.nebula.widgets.nattable.grid.GridRegion;

import org.eclipse.nebula.widgets.nattable.grid.data.DefaultColumnHeaderDataProvider;

import org.eclipse.nebula.widgets.nattable.grid.data.DefaultCornerDataProvider;

import org.eclipse.nebula.widgets.nattable.grid.data.DefaultRowHeaderDataProvider;

import org.eclipse.nebula.widgets.nattable.grid.layer.ColumnHeaderLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.CornerLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultColumnHeaderDataLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultRowHeaderDataLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.GridLayer;

import org.eclipse.nebula.widgets.nattable.grid.layer.RowHeaderLayer;

import org.eclipse.nebula.widgets.nattable.layer.AbstractLayer;

import org.eclipse.nebula.widgets.nattable.layer.DataLayer;

import org.eclipse.nebula.widgets.nattable.layer.ILayer;

import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;

import org.eclipse.nebula.widgets.nattable.sort.config.SingleClickSortConfiguration;

import org.eclipse.nebula.widgets.nattable.style.HorizontalAlignmentEnum;

import org.eclipse.nebula.widgets.nattable.style.theme.ModernNatTableThemeConfiguration;

import org.eclipse.nebula.widgets.nattable.util.GUIHelper;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Text;

import ca.odell.glazedlists.BasicEventList;

import ca.odell.glazedlists.EventList;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

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

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.preference.EditorPreferencePredicate;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.preference.wizard.AvailableDistributionWizard;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.StoreUtil;

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

/**

 * @author k.luther

 * @since 27.11.2018

 *

 */

public class DistributionEditor extends Composite {

    private static final String DISTRIBUTION_EDITOR = "Distribution Editor";

    private static final String LOADING_TAXA = Messages.ChecklistEditor_LOAD_TAXA;

    private static final String UNKNOWN = Messages.ChecklistEditor_UNKNOWN;

    private static final String ELEMENT_COUNT = Messages.ChecklistEditor_ELEMENT_COUNT;

    public static final String TYPE_FILTER_TEXT = "type filter text"; //$NON-NLS-1$

    static final String TAXON_COLUMN = "taxon_column"; //$NON-NLS-1$

    static final String RANK_COLUMN = "collector_column"; //$NON-NLS-1$

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

    @Inject

    private EMenuService menuService;

    private NatTable natTable;

    private Label statusLabel;

    private Label statusLabelSourceReference;

    private Reference defaultSource;

    private Map<Integer, NamedArea> areaToColumnIndexMap= new HashMap();

    private int firstDataColumnIndex;

    private ListDataProvider<TaxonDistributionDTO> bodyDataProvider;

    private LinkedMap<String, String> propertyToLabelMap = new LinkedMap<>();

    private boolean isShowRank;

    private Integer countNodes;

    private Text searchText;

    EventList<TaxonDistributionDTO> taxonList;

    Map<UUID,Map<NamedArea,Set<DescriptionElementBase>>> taxonDistributionMap = new HashMap<>();

    List<TaxonDistributionDTO> descriptionsToSave = new ArrayList<>();

    SortedSet<DefinedTermBase> areas;

    DistributionEditorPart part;

    BodyLayerStack<TaxonDistributionDTO> bodyLayerStack;

    private FreezeLayer freezeLayer;

    private ConfigRegistry configRegistry;

    private AbstractLayer topMostLayer;

    private SelectionLayer selectionLayer;

 //  private FixedSummaryRowLayer summaryRowLayer;

    /**

     * @param parent

     * @param style

     */

    public DistributionEditor(Composite parent, DistributionEditorPart part) {

        super(parent, SWT.NULL);

        this.part = part;

        this.setLayout(new GridLayout());

        GridLayoutFactory.fillDefaults().applyTo(parent);

        Composite topComposite = new Composite(parent, SWT.NONE);

        createTopComposite(topComposite);

        Composite bottomComposite = new Composite(parent, SWT.NONE);

        GridLayoutFactory.fillDefaults().applyTo(bottomComposite);

        natTable = new NatTable(parent, false);

        parent.pack();

//       // natTable = new NatTable(parent, viewportLayer);

//        natTable = new NatTable(parent, false);

        createStatusBar(parent);

    }

    public boolean isShowRank() {

        return isShowRank;

    }

    public void setShowRank(boolean isShowRank) {

        this.isShowRank = isShowRank;

    }

    public int getFirstDataColumnIndex() {

        return firstDataColumnIndex;

    }

    public void setFirstDataColumnIndex(int firstDataColumnIndex) {

        this.firstDataColumnIndex = firstDataColumnIndex;

    }

    public LinkedMap<String, String> getPropertyToLabelMap() {

        return propertyToLabelMap;

    }

    public void setPropertyToLabelMap(LinkedMap<String, String> propertyToLabelMap) {

        this.propertyToLabelMap = propertyToLabelMap;

    }

    public Map<Integer, NamedArea> getAreaToColumnIndexMap() {

        return areaToColumnIndexMap;

    }

    public void setAreaToColumnIndexMap(Map<Integer, NamedArea> areaToColumnIndexMap) {

        this.areaToColumnIndexMap = areaToColumnIndexMap;

    }

    public List<TaxonDistributionDTO> getDescriptionsToSave() {

        return descriptionsToSave;

    }

    public void setDescriptionsToSave(List<TaxonDistributionDTO> descriptionsToSave) {

        this.descriptionsToSave = descriptionsToSave;

    }

    private void createStatusBar(Composite composite) {

        GridData gridData = new GridData();

        gridData.horizontalSpan = 1;

        gridData.grabExcessHorizontalSpace = true;

        gridData.horizontalAlignment = GridData.FILL;

        statusLabel = new Label(composite, SWT.LEFT);

        statusLabel.setText(ELEMENT_COUNT + (taxonList != null ? taxonList.size() : UNKNOWN));

        statusLabel.setLayoutData(gridData);

        statusLabelSourceReference = new Label(composite, SWT.RIGHT);

        statusLabelSourceReference.setLayoutData(gridData);

        if (defaultSource != null){

            statusLabelSourceReference.setText("Default Source Reference: " + defaultSource.getAbbrevTitle() != null? defaultSource.getAbbrevTitle() : defaultSource.getAbbrevTitleCache());

        }

    }

    private void applyStyles(){

        ModernNatTableThemeConfiguration configuration = new ModernNatTableThemeConfiguration();

        configuration.summaryRowHAlign = HorizontalAlignmentEnum.CENTER;

        // NOTE: Getting the colors and fonts from the GUIHelper ensures that

        // they are disposed properly (required by SWT)

        configuration.cHeaderBgColor = GUIHelper.getColor(211, 211, 211);

        configuration.rHeaderBgColor = GUIHelper.getColor(211, 211, 211);

        natTable.addConfiguration(configuration);

    }

    private void configureNatTable(ConfigRegistry configRegistry,

            AbstractLayer topMostLayer) {

        /**

         * CONFIGURATION

         */

        natTable.setConfigRegistry(configRegistry);

        applyStyles();

        //add default configuration because autoconfigure is set to false in constructor

        natTable.addConfiguration(new DefaultNatTableStyleConfiguration());

        // override the default sort configuration and change the mouse bindings

        // to sort on a single click

        natTable.addConfiguration(new SingleClickSortConfiguration());

        natTable.addConfiguration(new FilterRowConfiguration(this));

        // add the header menu configuration for adding the column header menu

        // with hide/show actions

        natTable.addConfiguration(new DistributionEditorHeaderMenuConfiguration(natTable));

        // add custom configuration for data conversion and add column labels to viewport layer

        topMostLayer.addConfiguration(new DistributionCellEditorDataConversionConfiguration(this));

        natTable.configure();

    }

    public void createTable(){

        /**

         * layers

         */

        createLayers();

        /**

         * configuration

         */

        configureNatTable( configRegistry, topMostLayer);

        /**

         * handlers and listeners

         */

        registerHandlersAndListeners(topMostLayer);

        FreezeHelper.freeze(freezeLayer, bodyLayerStack.getViewPortLayer(),

                new PositionCoordinate(bodyLayerStack.getViewPortLayer(), 0, 0),

                new PositionCoordinate(bodyLayerStack.getViewPortLayer(), 0, -1));

        //grab all space

        GridDataFactory.fillDefaults().grab(true, true).applyTo(natTable);

        this.layout();

      //  boolean ok = natTable.doCommand(new ClientAreaResizeCommand(natTable));

      //  System.out.println(ok);

    }

    private void createLayers() {

        DistributionColumnAccessor columnPropertyAccessor = new DistributionColumnAccessor(this);

        DistributionEditorConfigLabelAccumulator labelAccumulator = new DistributionEditorConfigLabelAccumulator(this);

        bodyLayerStack = new BodyLayerStack<>(taxonList, columnPropertyAccessor, new TaxonDistributionDtoComparator(), labelAccumulator);

        bodyDataProvider = bodyLayerStack.getBodyDataProvider();

        propertyToLabelMap.put(TAXON_COLUMN, Messages.ChecklistEditor_TAXON);

        if (isShowRank){

            propertyToLabelMap.put(RANK_COLUMN, Messages.ChecklistEditor_RANK);

        }

        configRegistry = new ConfigRegistry();

        initLabels();

        this.selectionLayer = bodyLayerStack.getSelectionLayer();

        freezeLayer = new FreezeLayer(selectionLayer);

        final CompositeFreezeLayer compositeFreezeLayer = new CompositeFreezeLayer(

                freezeLayer,  bodyLayerStack.getViewPortLayer(), selectionLayer);

        // as the selection mouse bindings are registered for the region label

        // GridRegion.BODY

        // we need to set that region label to the viewport so the selection via mouse

        // is working correctly

        compositeFreezeLayer.setRegionName(GridRegion.BODY);

        IDataProvider columnHeaderDataProvider =

                new DefaultColumnHeaderDataProvider(propertyToLabelMap.values().toArray(new String[] {}), propertyToLabelMap);

        DataLayer columnHeaderDataLayer = new DefaultColumnHeaderDataLayer(columnHeaderDataProvider);

        ILayer columnHeaderLayer = new ColumnHeaderLayer(

            columnHeaderDataLayer,

            compositeFreezeLayer,

            selectionLayer);

        FilterRowHeaderComposite<TaxonDistributionDTO> filterRowHeaderLayer =

                new FilterRowHeaderComposite<>(

                        new DefaultGlazedListsFilterStrategy<>(

                                bodyLayerStack.getFilterList(),

                                columnPropertyAccessor,

                                configRegistry),

                        columnHeaderLayer,

                        columnHeaderDataLayer.getDataProvider(),

                        configRegistry);

     // build the row header layer stack

        IDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(bodyDataProvider);

        DataLayer rowHeaderDataLayer = new DefaultRowHeaderDataLayer(rowHeaderDataProvider);

        ILayer rowHeaderLayer = new RowHeaderLayer(

            rowHeaderDataLayer,

            compositeFreezeLayer,

            selectionLayer);

        IDataProvider cornerDataProvider =

                new DefaultCornerDataProvider(

                    columnHeaderDataProvider,

                    rowHeaderDataProvider);

        DataLayer cornerDataLayer = new DataLayer(cornerDataProvider);

        ILayer cornerLayer = new CornerLayer(

            cornerDataLayer,

            rowHeaderLayer,

            filterRowHeaderLayer);

        GridLayer gridLayer = new GridLayer(

                compositeFreezeLayer,

                filterRowHeaderLayer,

                rowHeaderLayer,

                cornerLayer);

        natTable.setLayer(gridLayer);

        topMostLayer = compositeFreezeLayer;

    }

    /**

     * @param parent

     * @return

     */

    private Text createSearchBar(Composite parent) {

        Button button1 = new Button(parent, SWT.PUSH );

        GridData gridData2 = new GridData();

        gridData2.horizontalSpan = 1;

        gridData2.horizontalAlignment = SWT.RIGHT;

        button1.setLayoutData(gridData2);

        button1.setText(Messages.ChecklistEditor_DIST_STATUS);

        button1.setToolTipText(Messages.ChecklistEditor_DIST_STATUS_TOOLTIP);

        button1.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent event) {

                AvailableDistributionWizard availableDistributionWizard = new AvailableDistributionWizard();

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

                        availableDistributionWizard);

                int open = dialog.open();

                if(open == 0){

                    reload();

                }

            }

        });

        Button button2 = new Button(parent, SWT.PUSH );

        GridData gridData3 = new GridData();

        gridData2.horizontalSpan = 1;

        button2.setLayoutData(gridData3);

        button2.setText(Messages.ChecklistEditor_DEFAULT_SOURCE);

        button2.setToolTipText(Messages.ChecklistEditor_DEFAULT_SOURCE_TOOLTIP);

        button2.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent event) {

                defaultSource = ReferenceSelectionDialog.select(AbstractUtility.getShell(), null);

                String defaultSourceStr = (defaultSource == null) ? "" : "Default Source Reference: " + defaultSource.getTitleCache();

                if (defaultSourceStr.length()> 100){

                    defaultSourceStr = defaultSourceStr.substring(0, 98) + "...";

                }

                statusLabelSourceReference.setText(defaultSourceStr);

                button2.setBackground(EditorUtil.getColor(Resources.COLOR_CONTROL_SELECTED));

            }

        });

        parent.pack();

        return searchText;

    }

    /**

    * This method should only be called for adding new Distribution columns and reloading the table.<br>

    * It will hide the old distribution column and load the newly added columns.<br>

    * <p>

    * <b>Notice:</b> for data update please use <b>refresh()</b>

    *

    */

   @SuppressWarnings({ "unchecked", "rawtypes" })

   public void reload(){

       this.areaToColumnIndexMap.clear();

       this.areas.clear();

       this.propertyToLabelMap.clear();

       createTable();

       natTable.redraw();

    }

    /**

     * @param parent

     */

    private void createTopComposite(Composite parent) {

        GridLayout gridLayout = new GridLayout(3, false);

        gridLayout.marginWidth = 0;

        gridLayout.marginHeight = 0;

        parent.setLayout(gridLayout);

        searchText = createSearchBar(parent);

    }

    public void loadDistributions(List<TaxonDistributionDTO> taxonList) {

        if (this.taxonList == null){

            this.taxonList = new BasicEventList<>();

        }

       taxonList.stream().forEach(wrapper->DistributionEditor.this.taxonList.add(wrapper));

       statusLabel.setText(ELEMENT_COUNT + (taxonList != null ? taxonList.size() : UNKNOWN));

       createTaxonDistributionMap();

    }

    protected void createTaxonDistributionMap() {

        Iterator<TaxonDistributionDTO> iterator = this.taxonList.iterator();

           while (iterator.hasNext()){

               TaxonDistributionDTO dto = iterator.next();

               TaxonDescriptionDTO descriptionDto = dto.getDescriptionsWrapper();

               for (TaxonDescription desc: descriptionDto.getDescriptions()){

                   if(this.part.getCdmEntitySession()!=null){

                       this.part.getCdmEntitySession().load(desc, true);

                   }

                   for (DescriptionElementBase descElement: desc.getElements()){

                       if (descElement instanceof Distribution){

                           Map<NamedArea, Set<DescriptionElementBase>> distributionsMap = taxonDistributionMap.get(dto.getTaxonUuid());

                           if (distributionsMap == null){

                               distributionsMap = new HashMap();

                               taxonDistributionMap.put(dto.getTaxonUuid(), distributionsMap);

                           }

                           Set<DescriptionElementBase> distributions = distributionsMap.get(((Distribution) descElement).getArea());

                           if (distributions == null){

                               distributions = new HashSet();

                               distributionsMap.put(((Distribution)descElement).getArea(), distributions);

                           }

                           distributions.add(descElement);

                       }

                   }

               }

           }

    }

    private void initLabels() {

        int index = 1;

        if (isShowRank){

            index++;

        }

        loadNamedAreas();

        for (DefinedTermBase area: areas) {

            this.areaToColumnIndexMap.put(index++, (NamedArea)area);

            String areaLabel;

            //TODO: adapt to preference

            Representation rep = area.getPreferredRepresentation(CdmStore.getDefaultLanguage());

            String label = rep.getLabel();

            if (label == null){

                label = area.getTitleCache();

            }

            if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

                if (area.getIdInVocabulary() != null){

                    areaLabel = area.getIdInVocabulary();

                } else{

                    areaLabel = label;

                }

            }else if (PreferencesUtil.isShowSymbol1InChecklistEditor()){

                if (area.getSymbol() != null){

                    areaLabel = area.getSymbol();

                } else{

                    areaLabel = label;

                }

            }else if (PreferencesUtil.isShowSymbol2InChecklistEditor()){

                if (area.getSymbol2() != null){

                    areaLabel = area.getSymbol2();

                } else{

                    areaLabel = label;

                }

            }else{

                areaLabel = label;

            }

            //String areaLabel = area.getLabel();

            String property = areaLabel;

            propertyToLabelMap.put(property, areaLabel);

        }

    }

    private SortedSet<DefinedTermBase> loadNamedAreas() {

        //IPreferenceStore preferenceStore = PreferencesUtil.getPreferenceStore();

        String valuesAreas = PreferencesUtil.getStringValue(EditorPreferencePredicate.AvailableDistributionAreaTerms.getKey());

        String values = PreferencesUtil.getStringValue(PreferencePredicate.AvailableDistributionAreaVocabularies.getKey());

        if (values != null && values != "") { //$NON-NLS-1$

            String[] split = values.split(";"); //$NON-NLS-1$

            List<String> listValue = Arrays.asList(split);

            List<DefinedTermBase> termlist = new ArrayList<DefinedTermBase>();

            Set<UUID> uuidList = new HashSet<UUID>();

            UUID uuid;

            for(String s : listValue){

                uuid = UUID.fromString(s);

                uuidList.add(uuid);

            }

            IVocabularyService service =  CdmStore.getService(IVocabularyService.class);

            List<TermVocabulary> vocs = service.find(uuidList);

            split = valuesAreas.split(";");

            listValue = Arrays.asList(split);

            for (TermVocabulary voc: vocs){

                termlist.addAll(service.getTerms(voc, null, null, null, null).getRecords());

            }

            List<DefinedTermBase> filteredList = new ArrayList();

            for (DefinedTermBase area: termlist){

                if (listValue.contains(area.getUuid().toString())) {

                    filteredList.add(area);

                }

            }

            if (PreferencesUtil.isSortNamedAreaByOrderInVocabulary()){

                areas =  getTermsOrderedByVocabularyOrder(filteredList);

            } else if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

                areas = getTermsOrderedByIdInVocabulary(filteredList);

            }else{

                areas =  getTermsOrderedByLabels(filteredList, CdmStore.getDefaultLanguage());

            }

        }

        return null;

    }

    public SortedSet<DefinedTermBase> getTermsOrderedByLabels(List<DefinedTermBase> listTerm,Language language){

        TermLanguageComparator<?> comp = new TermLanguageComparator<>();

        comp.setCompareLanguage(language);

        SortedSet<DefinedTermBase> result = new TreeSet(comp);

        if(listTerm != null){

            result.addAll(listTerm);

        }

        return result;

    }

    public SortedSet<DefinedTermBase> getTermsOrderedByIdInVocabulary(List<DefinedTermBase> namedAreas) {

        TermIdInVocabularyComparator<?> comp = new TermIdInVocabularyComparator<>();

        SortedSet<DefinedTermBase> result = new TreeSet(comp);

        if(namedAreas != null){

            result.addAll(namedAreas);

        }

        return result;

    }

    public SortedSet<DefinedTermBase> getTermsOrderedByVocabularyOrder(List<DefinedTermBase> listAreas){

        HashMap<TermVocabulary<DefinedTermBase>, List<DefinedTermBase>> vocs = new HashMap<>();

        OrderedTermComparator<?> comp = new OrderedTermComparator<>();

        boolean allOrderedTerms = true;

        List<TermVocabulary> alreadyOrderIndexNull = new ArrayList<>();

        for (DefinedTermBase term: listAreas){

            if (!(term instanceof OrderedTermBase)){

                allOrderedTerms = false;

                break;

            }else if (((OrderedTermBase)term).getOrderIndex() == 0){

                if(alreadyOrderIndexNull.contains(term.getVocabulary())) {

                    allOrderedTerms = false;

                    break;

                }else{

                    alreadyOrderIndexNull.add(term.getVocabulary());

                }

            }

        }

        if (allOrderedTerms){

            SortedSet<DefinedTermBase> result = new TreeSet(comp.reversed());

            result.addAll(listAreas);

            return result;

        }else{

            return getTermsOrderedByLabels(listAreas, PreferencesUtil.getGlobalLanguage());

        }

    }

    private void registerHandlersAndListeners(AbstractLayer topMostLayer) {

        //selection listener

        E4SelectionListener selectionListener = new DistributionCellSelectionListener(part.getSelectionService(),

                selectionLayer, bodyDataProvider, part);

        selectionLayer.addLayerListener(selectionListener);

        selectionListener.setFullySelectedRowsOnly(false);

        //register handler for view configuration menu

      //  natTable.registerCommandHandler(toolbar.getDisplayPersistenceDialogCommandHandler());

    }

    /**

     * @return

     */

    public IRowDataProvider<TaxonDistributionDTO> getBodyDataProvider() {

        return bodyDataProvider;

    }

    public void setDirty() {

        part.setDirty();

    }

    public Reference getDefaultSource(){

        return defaultSource;

    }

//    /**

//     * @param result

//     */

//    public void reloadDistributions() {

//       loadDistributions(taxonList);

//

//    }

}