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 org.apache.commons.collections4.map.LinkedMap;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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.command.ClientAreaResizeCommand;

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.layer.config.DefaultColumnHeaderStyleConfiguration;

import org.eclipse.nebula.widgets.nattable.painter.cell.TextPainter;

import org.eclipse.nebula.widgets.nattable.painter.cell.decorator.BeveledBorderDecorator;

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

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

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.compare.term.OrderedTermComparator;

import eu.etaxonomy.cdm.compare.term.TermIdInVocabularyComparator;

import eu.etaxonomy.cdm.compare.term.TermLanguageComparator;

import eu.etaxonomy.cdm.compare.term.TermSymbol1Comparator;

import eu.etaxonomy.cdm.compare.term.TermSymbol2Comparator;

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

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.metadata.TermOrder;

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.IDistributionEditor;

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

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.ImageResources;

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.ui.dialog.selection.ReferenceSelectionDialog;

/**

 * @author k.luther

 * @since 27.11.2018

 */

public class DistributionEditor extends Composite implements IDistributionEditor{

    @SuppressWarnings("unused")

    private static final Logger logger = LogManager.getLogger();

    private static final String DISTRIBUTION_EDITOR = "Distribution Editor"; //$NON-NLS-1$

    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$

    static final String SYNONYM_COLUMN = "synonym_column";//$NON-NLS-1$

    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 = false;

    private Text searchText;

    private Button button3;

    private Button button2;

    protected EventList<TaxonDistributionDTO> taxonList;

    private String actualNameCache;

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

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

    protected SortedSet<NamedArea> areas;

    protected DistributionEditorPart part;

    private BodyLayerStack<TaxonDistributionDTO> bodyLayerStack;

    private FreezeLayer freezeLayer;

    private ConfigRegistry configRegistry;

    private AbstractLayer topMostLayer;

    private SelectionLayer selectionLayer;

    public DistributionEditor(Composite parent, DistributionEditorPart part) {

        super(parent, SWT.NULL);

        isShowRank = PreferencesUtil.getBooleanValue(PreferencePredicate.ShowRankInDistributionEditor.getKey());

        this.part = part;

        this.setLayout(new GridLayout());

        GridLayoutFactory.fillDefaults().applyTo(parent);

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

        createTopComposite(topComposite);

        natTable = new NatTable(parent, false);

        parent.pack();

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

        GridLayoutFactory.fillDefaults().applyTo(bottomComposite);

        createStatusBar(bottomComposite);

    }

    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;

    }

    @Override

    public String getActualNameCache() {

        return actualNameCache;

    }

    public void setActualNameCache(String actualNameCache) {

        this.actualNameCache = actualNameCache;

    }

    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 = 2;

        gridData.grabExcessHorizontalSpace = true;

        gridData.horizontalAlignment = GridData.FILL;

        GridLayout gridLayout = new GridLayout();

        gridLayout.numColumns = 3;

        composite.setLayoutData(gridData);

        composite.setLayout(gridLayout);

        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(Messages.DistributionEditor_defaultSource + (defaultSource.getAbbrevTitle() != null? defaultSource.getAbbrevTitle() : defaultSource.getAbbrevTitleCache()));

        }

        button3 = new Button(composite, SWT.PUSH );

        button3.setEnabled(false);

        GridData gridData3 = new GridData();

        gridData3.horizontalAlignment = SWT.RIGHT;

        button3.setLayoutData(gridData3);

        //button3.setText(Messages.ChecklistEditor_REMOVE_DEFAULT_SOURCE);

        button3.setImage(ImageResources.getImage(ImageResources.TRASH_ICON));

        button3.setToolTipText(Messages.ChecklistEditor_REMOVE_DEFAULT_SOURCE_TOOLTIP);

        button3.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent event) {

                defaultSource = null;

                String defaultSourceStr = (defaultSource == null) ? "" : Messages.DistributionEditor_defaultSource + defaultSource.getTitleCache(); //$NON-NLS-1$

                if (defaultSourceStr.length()> 100){

                    defaultSourceStr = defaultSourceStr.substring(0, 98) + "..."; //$NON-NLS-1$

                }

                statusLabelSourceReference.setText(defaultSourceStr);

                button3.setBackground(AbstractUtility.getColor(Resources.COLOR_CONTROL_SELECTED));

                button3.setEnabled(false);

                button2.setText(Messages.ChecklistEditor_DEFAULT_SOURCE);

            }

        });

    }

    private void applyStyles(){

        CdmModernNatTableThemeConfiguration configuration = new CdmModernNatTableThemeConfiguration();

//        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);

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

        natTable.addConfiguration(new DefaultNatTableStyleConfiguration());

        natTable.addConfiguration(new DefaultColumnHeaderStyleConfiguration() {

            {

                TextPainter painter = new TextPainter();

                painter.setCalculateByTextLength(true);

                painter.setWrapText(false);

                cellPainter = new BeveledBorderDecorator(painter);

            }

        });

//        applyStyles();

        // 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));

        applyStyles();

        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();

        natTable.doCommand(new ClientAreaResizeCommand(natTable));

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

    }

    private void createLayers() {

        DistributionColumnAccessor columnPropertyAccessor = new DistributionColumnAccessor(this);

        DistributionEditorConfigLabelAccumulator labelAccumulator = new DistributionEditorConfigLabelAccumulator(this);

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

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

        bodyDataProvider = bodyLayerStack.getBodyDataProvider();

        propertyToLabelMap.put(TAXON_COLUMN, Messages.ChecklistEditor_TAXON);

        if (isShowRank){

            propertyToLabelMap.put(RANK_COLUMN, Messages.ChecklistEditor_RANK);

            propertyToLabelMap.put(SYNONYM_COLUMN, Messages.ChecklistEditor_SYNONYMS);

        }else{

            propertyToLabelMap.put(SYNONYM_COLUMN, Messages.ChecklistEditor_SYNONYMS);

        }

        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;

    }

    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(AbstractUtility.getShell(),

                        availableDistributionWizard);

                int open = dialog.open();

                if(open == 0){

                    reload();

                }

            }

        });

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

        GridData gridData3 = new GridData();

        gridData3.horizontalAlignment = SWT.RIGHT;

        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) ? "" : Messages.DistributionEditor_defaultSource + defaultSource.getTitleCache(); //$NON-NLS-1$

                if (defaultSourceStr.length()> 100){

                    defaultSourceStr = defaultSourceStr.substring(0, 98) + "..."; //$NON-NLS-1$

                }

                statusLabelSourceReference.setText(defaultSourceStr);

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

//                EventUtility.postEvent(WorkbenchEventConstants.REFRESH_DETAILS, true);

                button3.setEnabled(true);

                button2.setText(Messages.ChecklistEditor_SWITCH_DEFAULT_SOURCE);

            }

        });

        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>

    *

    */

   public void reload(){

       this.areaToColumnIndexMap.clear();

       this.areas.clear();

       this.propertyToLabelMap.clear();

       createTable();

       natTable.redraw();

    }

    private void createTopComposite(Composite parent) {

        GridLayout gridLayout = new GridLayout(3, false);

        gridLayout.marginWidth = 0;

        gridLayout.marginHeight = 0;

        GridData gridData2 = new GridData();

        gridData2.horizontalSpan = 1;

        gridData2.horizontalAlignment = SWT.RIGHT;

        gridData2.horizontalIndent = 3;

        parent.setLayoutData(gridData2);

        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.size());

       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 = 2;

        if (isShowRank){

            index++;

        }

        loadNamedAreas();

        if (areas == null){

            areas = new TreeSet<>();

        }

        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 = area.getUuid().toString();

            propertyToLabelMap.put(property, areaLabel);

        }

    }

    private SortedSet<NamedArea> loadNamedAreas() {

        //IPreferenceStore preferenceStore = PreferencesUtil.getPreferenceStore();

        String valuesAreas = PreferencesUtil.getStringValue(PreferencePredicate.AvailableDistributionAreaTerms.getKey(), true);

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

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

        String[] split;

        List<String> listValue;

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

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

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

            listValue = Arrays.asList(split);

            UUID uuid;

            for(String s : listValue){

                uuid = UUID.fromString(s);

                uuidList.add(uuid);

            }

        }

        List<TermVocabulary<NamedArea>> vocs = new ArrayList<>();

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

        if (uuidList.isEmpty()){

            List<TermVocabulary<NamedArea>> vocList = CdmStore.getService(IVocabularyService.class).findByTermType(TermType.NamedArea, null);

            vocs.addAll(vocList);

        }else{

            vocs= (List)service.find(uuidList);

        }

        for (TermVocabulary<NamedArea> voc: vocs){

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

        }

        List<NamedArea> filteredList = new ArrayList<>();

        if (valuesAreas != null && valuesAreas != "") {

            split = valuesAreas.split(";"); //$NON-NLS-1$

            listValue = Arrays.asList(split);

            for (NamedArea area: termlist){

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

                    filteredList.add(area);

                }

            }

        }else{

            filteredList.addAll(termlist);

        }

        TermOrder sortOrder = PreferencesUtil.getSortNamedAreasInDistributionEditor();

        if (sortOrder.equals(TermOrder.Natural)){

            areas =  getTermsOrderedByVocabularyOrder(filteredList);

        } else if (sortOrder.equals(TermOrder.IdInVoc)){

            areas = getTermsOrderedByIdInVocabulary(filteredList);

        }else{

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

        }

        return null;

    }

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

        TermLanguageComparator<T> comp = new TermLanguageComparator<>(Language.DEFAULT(), language);

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

        if(listTerm != null){

            result.addAll(listTerm);

        }

        return result;

    }

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

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

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

        if(namedAreas != null){

            result.addAll(namedAreas);

        }

        return result;

    }

    public <T extends DefinedTermBase<T>> SortedSet<T> getTermsOrderedBySymbol(List<T> namedAreas) {

        TermSymbol1Comparator<T> comp = new TermSymbol1Comparator<>();

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

        if(namedAreas != null){

            result.addAll(namedAreas);

        }

        return result;

    }

    public <T extends DefinedTermBase<T>> SortedSet<T> getTermsOrderedBySymbol2(List<T> namedAreas) {

        TermSymbol2Comparator<T> comp = new TermSymbol2Comparator<>();

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

        if(namedAreas != null){

            result.addAll(namedAreas);

        }

        return result;

    }

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

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

        boolean allOrderedTerms = true;

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

        for (T 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<T> result = new TreeSet<>(comp);

            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());

    }

    public IRowDataProvider<TaxonDistributionDTO> getBodyDataProvider() {

        return bodyDataProvider;

    }

    public void setDirty() {

        part.setDirty();

    }

    @Override

    public Reference getDefaultSource(){

        return defaultSource;

    }

//    /**

//     * @param result

//     */

//    public void reloadDistributions() {

//       loadDistributions(taxonList);

//

//    }

}