EDIT

/**

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

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.Set;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.workbench.modeling.ESelectionService;

import org.eclipse.jface.layout.GridDataFactory;

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

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

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

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

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

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

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

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

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

import org.eclipse.nebula.widgets.nattable.edit.EditConfigAttributes;

import org.eclipse.nebula.widgets.nattable.edit.editor.IComboBoxDataProvider;

import org.eclipse.nebula.widgets.nattable.export.command.ExportCommand;

import org.eclipse.nebula.widgets.nattable.export.command.ExportCommandHandler;

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

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

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

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

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

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

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

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

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

import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEvent;

import org.eclipse.nebula.widgets.nattable.reorder.ColumnReorderLayer;

import org.eclipse.nebula.widgets.nattable.reorder.RowReorderLayer;

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

import org.eclipse.nebula.widgets.nattable.selection.event.CellSelectionEvent;

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

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

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

import org.eclipse.nebula.widgets.nattable.viewport.ViewportLayer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import ca.odell.glazedlists.EventList;

import ca.odell.glazedlists.GlazedLists;

import ca.odell.glazedlists.SortedList;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;

/**

 * @author pplitzner

 * @since Nov 26, 2017

 *

 */

public class CharacterMatrix implements IE4SavablePart, IPartContentHasDetails, IConversationEnabled, IDirtyMarkable{

    private WorkingSet workingSet;

    private Composite parent;

    private ConversationHolder conversation;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    @Inject

    private MPart thisPart;

    private NatTable natTable;

    private List<Feature> features;

    @PostConstruct

    public void create(Composite parent) {

        if(CdmStore.isActive() && conversation==null){

            conversation = CdmStore.createConversation();

        }

        else{

            return;

        }

        parent.setLayout(new GridLayout());

        this.parent = parent;

    }

    public void init(WorkingSet workingSet) {

        this.workingSet = workingSet;

        thisPart.setLabel(workingSet.getLabel());

        //get features/columns stored in working set

        FeatureTree tree = workingSet.getDescriptiveSystem();

        features = new ArrayList<>(tree.getDistinctFeatures());

        Collections.sort(features);

        EventList<SpecimenDescription> descriptions = GlazedLists.eventList(getDescriptions(workingSet));

        SortedList<SpecimenDescription> sortedList = new SortedList<>(descriptions, null);

        /**

         * data provider

         */

        SpecimenColumnPropertyAccessor columnPropertyAccessor = new SpecimenColumnPropertyAccessor(features);

        IDataProvider bodyDataProvider = new ListDataProvider<SpecimenDescription>(sortedList, columnPropertyAccessor);

        /**

         * BODY layer

         */

        DataLayer bodyDataLayer = new DataLayer(bodyDataProvider);

        final ColumnOverrideLabelAccumulator columnLabelAccumulator =new ColumnOverrideLabelAccumulator(bodyDataLayer);

        bodyDataLayer.setConfigLabelAccumulator(columnLabelAccumulator);

        registerColumnLabels(columnLabelAccumulator);

        GlazedListsEventLayer<SpecimenDescription> eventLayer = new GlazedListsEventLayer<>(bodyDataLayer, sortedList);

        RowReorderLayer rowReorderLayer = new RowReorderLayer(eventLayer);

        ColumnReorderLayer columnReorderLayer = new ColumnReorderLayer(rowReorderLayer);

        SelectionLayer selectionLayer = new SelectionLayer(columnReorderLayer);

        ViewportLayer viewportLayer = new ViewportLayer(selectionLayer);

        /**

         * column header layer

         */

        IDataProvider columnHeaderDataProvider = new DefaultColumnHeaderDataProvider(

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

        DataLayer columnHeaderDataLayer = new DataLayer(columnHeaderDataProvider);

        ILayer columnHeaderLayer = new ColumnHeaderLayer(columnHeaderDataLayer, viewportLayer, selectionLayer);

        ConfigRegistry configRegistry = new ConfigRegistry();

        // 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<SpecimenDescription> sortHeaderLayer = new SortHeaderLayer<>(

                        columnHeaderLayer,

                        new GlazedListsSortModel<>(

                                sortedList,

                                columnPropertyAccessor,

                                configRegistry,

                                columnHeaderDataLayer));

        /**

         * row header layer

         */

        IDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(bodyDataProvider);

        DataLayer rowHeaderDataLayer = new DataLayer(rowHeaderDataProvider, 40, 20);

        ILayer rowHeaderLayer = new RowHeaderLayer(rowHeaderDataLayer, viewportLayer, selectionLayer);

        /**

         * corner layer

         */

        ILayer cornerLayer = new CornerLayer(

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

                rowHeaderLayer, sortHeaderLayer);

        /**

         * GRID layer (composition of all other layers)

         */

        GridLayer gridLayer = new GridLayer(viewportLayer, sortHeaderLayer, rowHeaderLayer, cornerLayer);

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

        natTable.setConfigRegistry(configRegistry);

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

        // add custom configuration for data conversion

        viewportLayer.addConfiguration(new AbstractRegistryConfiguration() {

            @Override

            public void configureRegistry(IConfigRegistry configRegistry) {

                features.forEach(feature -> registerColumnConfiguration(feature, configRegistry));

                }

            }

        );

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

        // exporting work

        viewportLayer.registerCommandHandler(new ExportCommandHandler(viewportLayer));

        //propagate single cell selection

        natTable.addLayerListener(new ILayerListener() {

            @Override

            public void handleLayerEvent(ILayerEvent event) {

                if(event instanceof CellSelectionEvent){

                    CellSelectionEvent cellSelectionEvent = (CellSelectionEvent)event;

                    Collection<ILayerCell> selectedCells = cellSelectionEvent.getSelectionLayer().getSelectedCells();

                    if(selectedCells.size()==1){

                        ILayerCell cell = selectedCells.iterator().next();

                        selService.setSelection(cell.getDataValue());

                    }

                }

            }

        });

        natTable.configure();

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

        //excel export

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

        addColumnButton.setText("Export");

        addColumnButton.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                natTable.doCommand(

                        new ExportCommand(

                                natTable.getConfigRegistry(),

                                natTable.getShell()));

            }

        });

        parent.layout();

    }

    private void registerColumnLabels(ColumnOverrideLabelAccumulator columnLabelAccumulator) {

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

            columnLabelAccumulator.registerColumnOverrides(i, getProperty(features.get(i)));

        }

    }

    private void registerColumnConfiguration(Feature feature, IConfigRegistry configRegistry) {

        //make cell editable

        configRegistry.registerConfigAttribute(

                EditConfigAttributes.CELL_EDITABLE_RULE,

                IEditableRule.ALWAYS_EDITABLE,

                DisplayMode.EDIT,

                getProperty(feature)

                );

        if(feature.isSupportsQuantitativeData()){

            //add display converter for string representation

            configRegistry.registerConfigAttribute(

                    CellConfigAttributes.DISPLAY_CONVERTER,

                    new QuantitativeDataDisplayConverter(),

                    DisplayMode.NORMAL,

                    getProperty(feature));

        }

        else if(feature.isSupportsCategoricalData()){

            //add display converter for string representation

            configRegistry.registerConfigAttribute(

                    CellConfigAttributes.DISPLAY_CONVERTER,

                    new CategoricalDataDisplayConverter(),

                    DisplayMode.NORMAL,

                    getProperty(feature));

            //add combo box cell editor

            CategoricalDataCellEditor comboBoxCellEditor = new CategoricalDataCellEditor(new IComboBoxDataProvider() {

                @Override

                public List<?> getValues(int columnIndex, int rowIndex) {

                    List<State> states = new ArrayList<>();

                    Feature feature = features.get(columnIndex);

                    if(feature.isSupportsCategoricalData()){

                        Set<TermVocabulary<State>> stateVocs = feature.getSupportedCategoricalEnumerations();

                        for (TermVocabulary<State> voc : stateVocs) {

                            states.addAll(voc.getTerms());

                        }

                    }

                    return states;

                }

            }, 5);

            //register editor

            configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR,

                    comboBoxCellEditor,

                    DisplayMode.EDIT,

                    getProperty(feature));

        }

    }

    private List<SpecimenDescription> getDescriptions(WorkingSet workingSet) {

        List<SpecimenDescription> descriptions = new ArrayList<>();

        Set<DescriptionBase> wsDescriptions = workingSet.getDescriptions();

        for (DescriptionBase descriptionBase : wsDescriptions) {

            if(descriptionBase instanceof SpecimenDescription){

                descriptions.add((SpecimenDescription) descriptionBase);

            }

        }

        return descriptions;

    }

    public List<Feature> getFeatures() {

        return features;

    }

    private String getProperty(Feature feature){

        return feature.getLabel();

    }

    @Persist

    @Override

    public void save(IProgressMonitor monitor) {

        CdmStore.getService(IWorkingSetService.class).merge(workingSet, true);

        conversation.commit();

        dirty.setDirty(false);

    }

    @Focus

    public void setFocus(){

        if(conversation!=null){

            conversation.bind();

        }

    }

    @PreDestroy

    public void dispose(){

        if(conversation!=null){

            conversation.close();

            conversation = null;

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void changed(Object element) {

        dirty.setDirty(true);

        natTable.refresh();

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void forceDirty() {

        dirty.setDirty(true);

    }

}