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.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

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.wizard.WizardDialog;

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

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

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

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

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.export.command.ExportCommandHandler;

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

import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsEventLayer;

import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsSortModel;

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

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.data.FixedSummaryRowHeaderLayer;

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.DefaultRowHeaderDataLayer;

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

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

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

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

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

import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;

import org.eclipse.nebula.widgets.nattable.layer.stack.DefaultBodyLayerStack;

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

import org.eclipse.nebula.widgets.nattable.sort.SortHeaderLayer;

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.summaryrow.FixedSummaryRowLayer;

import org.eclipse.nebula.widgets.nattable.summaryrow.SummaryRowLayer;

import org.eclipse.nebula.widgets.nattable.ui.binding.UiBindingRegistry;

import org.eclipse.nebula.widgets.nattable.ui.matcher.MouseEventMatcher;

import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuAction;

import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuBuilder;

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.Menu;

import org.eclipse.swt.widgets.Text;

import ca.odell.glazedlists.EventList;

import ca.odell.glazedlists.SortedList;

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

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

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

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

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.descriptiveDataSet.matrix.CharacterMatrixLabelStyleConfiguration;

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

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.preference.Resources;

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

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;

    List<NamedArea> areas = new ArrayList();

    DistributionEditorPart part;

    private DefaultBodyLayerStack bodyLayer;

    private FreezeLayer freezeLayer;

    private ConfigRegistry configRegistry;

    private AbstractLayer topMostLayer;

    private FixedSummaryRowLayer summaryRowLayer;

    /**

     * @param parent

     * @param style

     */

    public DistributionEditor(Composite parent, DistributionEditorPart part) {

        super(parent, SWT.NULL);

        this.setLayout(new GridLayout());

        this.part = part;

        createTopComposite(parent);

        natTable = new NatTable(this, 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;

    }

    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 + (countNodes != null ? countNodes : UNKNOWN));

        statusLabel.setLayoutData(gridData);

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

//        GridData sourceGrid = new GridData();

//        sourceGrid.horizontalAlignment = GridData.HORIZONTAL_ALIGN_END;

//        //sourceGrid.grabExcessHorizontalSpace = false;

//        sourceGrid.horizontalSpan = 1;

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

        //FIXME: this is for DEBUG ONLY

        //        natTable.addConfiguration(new DebugMenuConfiguration(natTable));

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

        // to sort on a single click

        natTable.addConfiguration(new SingleClickSortConfiguration());

        natTable.addConfiguration(new CharacterMatrixLabelStyleConfiguration());

        // 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 CellEditorDataConversionConfiguration(this));

//        //register aggregation configuration

//        summaryRowLayer.addConfiguration(new AggregationConfiguration(this));

      //+++CONTEXT MENU+++

        menuService.registerContextMenu(natTable, "eu.etaxonomy.taxeditor.editor.popupmenu.charactermatrix"); //$NON-NLS-1$

        // get the menu registered by EMenuService

        final Menu e4Menu = natTable.getMenu();

        // remove the menu reference from NatTable instance

        natTable.setMenu(null);

        natTable.addConfiguration(

                new AbstractUiBindingConfiguration() {

            @Override

            public void configureUiBindings(

                    UiBindingRegistry uiBindingRegistry) {

                // add e4 menu to NatTable

                new PopupMenuBuilder(natTable, e4Menu)

                    .build();

                // register the UI binding for header, corner and body region

                uiBindingRegistry.registerMouseDownBinding(

                        new MouseEventMatcher(

                                SWT.NONE,

                                null,

                                MouseEventMatcher.RIGHT_BUTTON),

                        new PopupMenuAction(e4Menu));

            }

        });

        natTable.configure();

    }

    public void createTable(boolean freezeSupplementalColumns){

        /**

         * layers

         */

        createLayers();

        /**

         * configuration

         */

        configureNatTable( configRegistry, topMostLayer);

        /**

         * handlers and listeners

         */

        registerHandlersAndListeners(topMostLayer);

        //grab all space

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

        //update label to current data set

//        toolbar.getWsLabel().setText(descriptiveDataSet.getLabel());

//        toolbar.getWsLabel().setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

//        toolbar.getWsLabel().getParent().layout();

        //initial freeze of supplemental columns

//        freezeSupplementalColumns(freezeSupplementalColumns);

        this.layout();

        natTable.doCommand(new ClientAreaResizeCommand(natTable));

    }

    private void createLayers() {

        SortedList sortedList = new SortedList(taxonList, new TaxonDistributionDtoComparator());

        /**

         * data provider

         */

        DistributionColumnAccessor columnPropertyAccessor = new DistributionColumnAccessor(this);

        bodyDataProvider = new ListDataProvider(sortedList, columnPropertyAccessor);

        propertyToLabelMap.put(TAXON_COLUMN, Messages.CharacterMatrix_TAXON);

        if (isShowRank){

            propertyToLabelMap.put(RANK_COLUMN, Messages.CharacterMatrix_COLLECTOR_NO);

        }

        configRegistry = new ConfigRegistry();

        /**

         * BODY layer

         *

         *

        CompositeLayer

         - (top) SummaryRowLayer

         - (bottom) ViewportLayer

             ^

        ViewportLayer

             ^

        TreeLayer (default visible)

             ^

        CompositeFreezeLayer

         - viewportLayer

         - selectionLayer

         - freezeLayer

             ^

        FreezeLayer

             ^

        SelectionLayer

             ^

        ColumnHideShowLayer

             ^

        ColumnReorderLayer

             ^

        DataLayer

         *

         */

        DataLayer bodyDataLayer = new DataLayer(bodyDataProvider);

        //register labels

//        CharacterMatrixConfigLabelAccumulator labelAccumulator = new CharacterMatrixConfigLabelAccumulator(this);

//        bodyDataLayer.setConfigLabelAccumulator(labelAccumulator);

        propertyToLabelMap.put(TAXON_COLUMN, Messages.CharacterMatrix_TAXON);

        initLabels();

   //     layer for event handling of GlazedLists and PropertyChanges

        GlazedListsEventLayer eventLayer = new GlazedListsEventLayer<>(bodyDataLayer, taxonList);

        bodyLayer = new DefaultBodyLayerStack(eventLayer);

        final SelectionLayer selectionLayer = bodyLayer.getSelectionLayer();

        freezeLayer = new FreezeLayer(selectionLayer);

        final CompositeFreezeLayer compositeFreezeLayer = new CompositeFreezeLayer(

                freezeLayer, bodyLayer.getViewportLayer(), selectionLayer);

        topMostLayer = compositeFreezeLayer;

        summaryRowLayer = new FixedSummaryRowLayer(bodyDataLayer, topMostLayer, configRegistry, false);

        //register labels with summary prefix for summary layer

        ColumnOverrideLabelAccumulator summaryColumnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);

        summaryRowLayer.setConfigLabelAccumulator(summaryColumnLabelAccumulator);

        int n = 1;

        if (isShowRank){

            n++;

        }

        for(int i=0;i<areas.size();i++){

            NamedArea namedArea = areas.get(i);

            summaryColumnLabelAccumulator.registerColumnOverrides(

                    i+n,

                    SummaryRowLayer.DEFAULT_SUMMARY_COLUMN_CONFIG_LABEL_PREFIX+namedArea.getLabel());

        }

        // because the horizontal dependency is the ViewportLayer

        // we need to set the composite dependency to false

        summaryRowLayer.setHorizontalCompositeDependency(false);

        CompositeLayer composite = new CompositeLayer(1, 2);

        composite.setChildLayer("SUMMARY", summaryRowLayer, 0, 0); //$NON-NLS-1$

        composite.setChildLayer(GridRegion.BODY, topMostLayer, 0, 1);

        /**

         * column header layer

         */

        IDataProvider columnHeaderDataProvider = new DefaultColumnHeaderDataProvider(

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

        DataLayer columnHeaderDataLayer = new DataLayer(columnHeaderDataProvider);

        ColumnHeaderLayer columnHeaderLayer = new ColumnHeaderLayer(columnHeaderDataLayer, topMostLayer, selectionLayer);

        // add the SortHeaderLayer to the column header layer stack

        // as we use GlazedLists, we use the GlazedListsSortModel which

        // delegates the sorting to the SortedList

        final SortHeaderLayer<TaxonDistributionDTO> sortHeaderLayer = new SortHeaderLayer<>(

                columnHeaderLayer,

                new GlazedListsSortModel<>(sortedList,

                        columnPropertyAccessor,

                        configRegistry,

                        columnHeaderDataLayer));

        /**

         * row header layer

         */

        IDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(bodyDataProvider);

        DefaultRowHeaderDataLayer rowHeaderDataLayer = new DefaultRowHeaderDataLayer(rowHeaderDataProvider);

        FixedSummaryRowHeaderLayer fixedSummaryRowHeaderLayer = new FixedSummaryRowHeaderLayer(rowHeaderDataLayer,

                composite, selectionLayer);

        fixedSummaryRowHeaderLayer.setSummaryRowLabel("\u2211"); //$NON-NLS-1$

        /**

         * corner layer

         */

        ILayer cornerLayer = new CornerLayer(

                new DataLayer(new DefaultCornerDataProvider(columnHeaderDataProvider, rowHeaderDataProvider)),

                fixedSummaryRowHeaderLayer, sortHeaderLayer);

        /**

         * GRID layer (composition of all other layers)

         */

        GridLayer gridLayer = new GridLayer(composite, sortHeaderLayer, null, cornerLayer);

        natTable.setLayer(gridLayer);

    }

    /**

     * @param parent

     * @return

     */

    private Text createSearchBar(Composite parent) {

        final Text searchText = new Text(parent, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH | SWT.CANCEL);

        GridData gridData = new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL);

        searchText.setLayoutData(gridData);

        searchText.setForeground(EditorUtil.getColor(Resources.SEARCH_VIEW_FOREGROUND));

        searchText.setText(TYPE_FILTER_TEXT);

        searchText.setToolTipText(Messages.ChecklistEditor_SEARCH_TOOLTIP);

        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){

                    //TODO!!!!

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

    }

    /**

     * @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) {

        this.taxonList.addAll(taxonList);

    }

    public Collection<DescriptionElementBase> getDistributions() {

        Collection<DescriptionElementBase> descElements = new HashSet();

//TODO: only for edited taxa

        taxonList.forEach(taxonDto->taxonDto.getDistributionMap()

                .forEach((area, descriptionElements)->descElements.addAll(descriptionElements)));

        return descElements;

    }

    private void initLabels() {

        int index = 1;

        if (isShowRank){

            index++;

        }

        for (NamedArea area: areas) {

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

            //TODO: adapt to preference

            String areaLabel = area.getLabel();

            String property = areaLabel;

            propertyToLabelMap.put(property, areaLabel);

        }

    }

    private void registerHandlersAndListeners(AbstractLayer topMostLayer) {

        // add the ExportCommandHandler to the ViewportLayer in order to make

        // exporting work

        topMostLayer.registerCommandHandler(new ExportCommandHandler(topMostLayer));

        //selection listener

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

                bodyLayer.getSelectionLayer(), bodyDataProvider, part);

        bodyLayer.getSelectionLayer().addLayerListener(selectionListener);

        selectionListener.setFullySelectedRowsOnly(false);

        //register handler for view configuration menu

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

    }

    /**

     * @return

     */

    public IRowDataProvider<TaxonDistributionDTO> getBodyDataProvider() {

        return bodyDataProvider;

    }

}