EDIT

/**

* Copyright (C) 2007 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.bulkeditor.e4;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.e4.core.services.events.IEventBroker;

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.services.EMenuService;

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

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

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

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

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

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

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

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

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.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.stack.DefaultBodyLayerStack;

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

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

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

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.swt.SWT;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Menu;

import ca.odell.glazedlists.BasicEventList;

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

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

import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade;

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

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.occurrence.FieldUnit;

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

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

import eu.etaxonomy.taxeditor.bulkeditor.BulkEditorQuery;

import eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput;

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.IDerivedUnitFacadePart;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasFactualData;

import eu.etaxonomy.taxeditor.model.IPartContentHasMedia;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

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

/**

 *

 * @author pplitzner

 * @since Sep 8, 2017

 *

 */

public class BulkEditorE4 implements IPartContentHasDetails, IConversationEnabled, IPostOperationEnabled,

        IDirtyMarkable, IDerivedUnitFacadePart, IPartContentHasFactualData,

        IPartContentHasSupplementalData, IPartContentHasMedia, IE4SavablePart, ITaxonEditor {

    public static final String TYPE_PROPERTY = "Type";

    @Inject

	private MDirtyable dirty;

    private AbstractBulkEditorInput<?> input;

    private Composite topComposite;

    private TableViewer viewer;

    private ConversationHolder conversation;

    @Inject

    private ESelectionService selService;

    @Inject

    private IEventBroker eventBroker;

    private ISelectionChangedListener selectionChangedListener;

    @Inject

    private MPart thisPart;

    private BulkEditorQuery lastQuery = null;

    private Composite bottomComposite;

    @Inject

    private EMenuService menuService;

    private NatTable natTable;

    private SelectionLayer selectionLayer;

    private ListDataProvider<CdmBase> bodyDataProvider;

    @Inject

    public BulkEditorE4() {

	}

	@SuppressWarnings("unused")

    public void init(AbstractBulkEditorInput<?> input){

	    this.input = input;

	    this.conversation = input.getConversation();

	    new BulkEditorSearchE4(this, topComposite, SWT.NONE);

	    //layout needed because the search bar is added after @PostConstuct method

	    topComposite.getParent().layout();

	    thisPart.setLabel(input.getEditorName());

//	    //create columns

//	    Table table = viewer.getTable();

//	    String[] titles = {input.getName(), "Type"};

//	    int[] bounds = {500, 100};

//

//	    ColumnViewerEditorActivationStrategy activationSupport = new ColumnViewerEditorActivationStrategy(viewer) {

//            @Override

//            protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {

//                // Enable editor only with mouse double click

//                if (event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION) {

//                    EventObject source = event.sourceEvent;

//                    if (source instanceof MouseEvent && ((MouseEvent)source).button == 3) {

//                        return false;

//                    }

//

//                    return true;

//                }

//

//                return false;

//            }

//        };

//        TableViewerFocusCellManager focusCellManager = new TableViewerFocusCellManager(viewer, new BulkEditorFocusCellOwnerDrawHighLighter(viewer));

//

//        TableViewerEditor.create(viewer, focusCellManager, activationSupport, ColumnViewerEditor.TABBING_HORIZONTAL |

//                ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR |

//                ColumnViewerEditor.TABBING_VERTICAL |

//                ColumnViewerEditor.KEYBOARD_ACTIVATION );

//

//	    CellEditor[] editors = new CellEditor[titles.length];

//	    for (int i = 0; i < titles.length; i++) {

//	        TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);

//	        editors[i] = new TextCellEditor(table);

//

//	        column.getColumn().setText(titles[i]);

//	        column.getColumn().setWidth(bounds[i]);

//	        column.getColumn().setResizable(true);

//	        column.getColumn().setMoveable(true);

//

//	    }

//

//	    table.setHeaderVisible(true);

//	    table.setLinesVisible(true);

//

//	    viewer.setCellEditors(editors);

//	    viewer.setColumnProperties(titles);

//

//	    //content and label provider (NOTE: has to be set AFTER creating cell editors

//	    viewer.setContentProvider(new ArrayContentProvider());

//        BulkEditorLabelProvider labelProvider = new BulkEditorLabelProvider(this);

//        viewer.setLabelProvider(labelProvider);

//

//

//        //allow text selection

//        viewer.setCellModifier(new ICellModifier() {

//            @Override

//            public void modify(Object element, String property, Object value) {

//            }

//            @Override

//            public Object getValue(Object element, String property) {

//                ITableLabelProvider tableLabelProvider = null;

//                if(viewer.getLabelProvider() instanceof ITableLabelProvider){

//                    tableLabelProvider = (ITableLabelProvider) viewer.getLabelProvider();

//                }

//                Object[] columnProperties = viewer.getColumnProperties();

//                for (int i=0;i<columnProperties.length;i++) {

//                    if(columnProperties[i].equals(property) && tableLabelProvider!=null){

//                        return tableLabelProvider.getColumnText(element, i);

//                    }

//                }

//                return "";

//            }

//            @Override

//            public boolean canModify(Object element, String property) {

//                return true;

//            }

//        });

        if(input.getEntityUuid()!=null){

            performSearch(new BulkEditorQuery(input.getEntityUuid().toString(), null));

        }

        //++++NatTable++++

        Map<String, String> propertyToLabels = new HashMap<>();

        propertyToLabels.put(getEditorInput().getName(), getEditorInput().getName());

        propertyToLabels.put(TYPE_PROPERTY, TYPE_PROPERTY);

        String[] propertyNames = new String[] { getEditorInput().getName(), TYPE_PROPERTY };

        bodyDataProvider = new ListDataProvider<CdmBase>(getEditorInput().getModel(),

                new BulkEditorPropertyAccessor(getEditorInput()));

        DefaultColumnHeaderDataProvider colHeaderDataProvider = new DefaultColumnHeaderDataProvider(

                propertyNames, propertyToLabels);

        DefaultRowHeaderDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(

                bodyDataProvider);

        DataLayer dataLayer = new DataLayer(bodyDataProvider);

        GlazedListsEventLayer<CdmBase> eventLayer = new GlazedListsEventLayer<>(dataLayer, getEditorInput().getModel());

        DefaultBodyLayerStack bodyLayer = new DefaultBodyLayerStack(eventLayer);

        selectionLayer = bodyLayer.getSelectionLayer();

        ColumnHeaderLayer columnHeaderLayer = new ColumnHeaderLayer(

                new DataLayer(colHeaderDataProvider),

                bodyLayer, bodyLayer.getSelectionLayer());

        RowHeaderLayer rowHeaderLayer = new RowHeaderLayer(new DataLayer(rowHeaderDataProvider, 50, 20),

                bodyLayer, bodyLayer.getSelectionLayer());

        DefaultCornerDataProvider cornerDataProvider = new DefaultCornerDataProvider(

                colHeaderDataProvider, rowHeaderDataProvider);

        CornerLayer cornerLayer = new CornerLayer(new DataLayer(

                cornerDataProvider), rowHeaderLayer, columnHeaderLayer);

        GridLayer gridLayer = new GridLayer(bodyLayer, columnHeaderLayer,

                rowHeaderLayer, cornerLayer);

        dataLayer.setColumnPercentageSizing(true);

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

        //create context menu

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

        // get the menu registered by EMenuService

        final Menu e4Menu = natTable.getMenu();

        // remove the menu reference from NatTable instance

        natTable.setMenu(null);

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

        natTable.addConfiguration(new DefaultNatTableStyleConfiguration());

        natTable.addConfiguration(

                new AbstractUiBindingConfiguration() {

            @Override

            public void configureUiBindings(

                    UiBindingRegistry uiBindingRegistry) {

                // add NatTable menu items

                // and register the DisposeListener

                new PopupMenuBuilder(natTable, e4Menu)

                    .build();

                // register the UI binding

                uiBindingRegistry.registerMouseDownBinding(

                        new MouseEventMatcher(

                                SWT.NONE,

                                GridRegion.BODY,

                                MouseEventMatcher.RIGHT_BUTTON),

                        new PopupMenuAction(e4Menu));

            }

        });

        natTable.configure();

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

        //full row selection

        bodyLayer.getSelectionLayer().setSelectionModel(new RowSelectionModel<CdmBase>(bodyLayer.getSelectionLayer(), bodyDataProvider, new IRowIdAccessor<CdmBase>() {

            @Override

            public Serializable getRowId(CdmBase rowObject) {

                return getEditorInput().getModel().indexOf(rowObject);

            }

        }));

        //propagate selection

        selectionChangedListener = (event -> selService.setSelection(AbstractUtility.getElementsFromSelectionChangedEvent(event)));

        RowSelectionProvider<CdmBase> selectionProvider = new RowSelectionProvider<CdmBase>(selectionLayer, bodyDataProvider, true);

        selectionProvider.addSelectionChangedListener(selectionChangedListener);

	}

	/** {@inheritDoc} */

	@PostConstruct

	public void createPartControl(Composite parent) {

		parent.setLayout(new GridLayout());

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

		topComposite.setLayout(new GridLayout());

		GridData gridData = new GridData(SWT.FILL, SWT.TOP, true, false);

		topComposite.setLayoutData(gridData);

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

		bottomComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

		bottomComposite.setLayout(new GridLayout());

//		viewer = new TableViewer(bottomComposite, SWT.MULTI | SWT.FULL_SELECTION);

//		createColumns(viewer);

        //propagate selection

        selectionChangedListener = (event -> selService.setSelection(AbstractUtility.getElementsFromSelectionChangedEvent(event)));

//        viewer.addSelectionChangedListener(selectionChangedListener);

        //create context menu

//        menuService.registerContextMenu(viewer.getControl(), "eu.etaxonomy.taxeditor.bulkeditor.popupmenu.bulkeditor"); //$NON-NLS-1$

	}

	@Override

	@Persist

	public void save(IProgressMonitor monitor) {

	    save(monitor, true);

	}

	@Focus

	public void setFocus() {

	    //make sure to bind again if maybe in another view the conversation was unbound

	    eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, this);

	}

	@PreDestroy

	public void dispose() {

	    if(conversation!=null){

	        conversation.unregisterForDataStoreChanges(this);

	        conversation.close();

	    }

	    if(input!=null){

	        input.dispose();

	    }

	}

	public void save(IProgressMonitor monitor, boolean resetMerge) {

	    if (!input.getCdmEntitySession().isActive()){

            input.getCdmEntitySession().bind();

        }

	    input.saveModel(resetMerge);

	    List<CdmBase> saveCandidates = getEditorInput().getSaveCandidates();

	    IStructuredSelection selection = getSelection();

        dirty.setDirty(false);

        getEditorInput().resetSaveCandidates();

        getEditorInput().dispose();

        getEditorInput().bind();

        conversation.commit(true);

        if (lastQuery != null){

            performSearch(lastQuery);

            setSelection(selection);

        }

//        viewer.refresh();

	}

	/** {@inheritDoc} */

    public void performSearch(BulkEditorQuery query) {

        if (query != null) {

            // TODO check if dirty, prompt save

            if (isDirty()) {

                String[] labels = {Messages.BulkEditorE4_SAVE_AND_SEARCH, Messages.BulkEditorE4_DONT_SAVE,Messages.BulkEditorE4_CANCEL};

                MessageDialog dialog =new MessageDialog(topComposite.getShell(), Messages.BulkEditorE4_SAVE_CHANGES_TITLE, null, Messages.BulkEditorE4_SAVE_CHANGES_MESSAGE, MessageDialog.QUESTION,labels, 0);

                int result = dialog.open();

                if (result == 0) {

                    save(new NullProgressMonitor());

                } else if (result == 2){

                    return;

                }

            }

            dirty.setDirty(false);

//            getEditorInput().dispose();

//            getEditorInput().bind();

            getEditorInput().performSearch(query);

            lastQuery = query;

//            viewer.setInput(model);

            refresh();

        }

    }

    public void refresh() {

        refresh(true);

    }

    public void refresh(boolean resetInput) {

        if(resetInput){

//            viewer.setInput(getEditorInput().getModel());

        }

//        viewer.refresh();

    }

//    public TableViewer getViewer() {

//        return viewer;

//    }

    public IStructuredSelection getSelection(){

        List<CdmBase> selection = new ArrayList<>();

        int[] fullySelectedRowPositions = selectionLayer.getFullySelectedRowPositions();

        for (int i : fullySelectedRowPositions) {

            Object rowObject = bodyDataProvider.getRowObject(i);

            if(rowObject instanceof CdmBase){

                selection.add((CdmBase) rowObject);

            }

        }

        return new StructuredSelection(selection);

    }

    public void setSelection(IStructuredSelection selection){

        Object[] objects = selection.toArray();

        for (Object object : objects) {

            if(object instanceof CdmBase){

                selectionLayer.selectRow(0, bodyDataProvider.indexOfRowObject((CdmBase) object), false, false);

            }

        }

    }

    public void setDirty(){

        dirty.setDirty(true);

    }

    public boolean isDirty() {

        return dirty.isDirty();

    }

    public AbstractBulkEditorInput getEditorInput() {

        return input;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean canAttachMedia() {

        return true;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void changed(Object element) {

        if(element instanceof DerivedUnitFacade){

            DerivedUnit derivedUnit = ((DerivedUnitFacade) element).innerDerivedUnit();

            if(derivedUnit!=null){

                getEditorInput().addSaveCandidate(derivedUnit);

            }

            FieldUnit fieldUnit = ((DerivedUnitFacade) element).innerFieldUnit();

            if(fieldUnit!=null){

                getEditorInput().addSaveCandidate(fieldUnit);

            }

        }

        else if (element instanceof CdmBase) {

            getEditorInput().addSaveCandidate((CdmBase)element);

        }

        dirty.setDirty(true);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void forceDirty() {

        dirty.setDirty(true);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean postOperation(CdmBase objectAffectedByOperation) {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean onComplete() {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    /**

     * @return

     */

    public BulkEditorQuery getLastQuery() {

       return lastQuery;

    }

    /**

     * @param object

     */

    public void setLastQuery(BulkEditorQuery lastQuery) {

       this.lastQuery = lastQuery;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Taxon getTaxon() {

        ISelection selection = viewer.getSelection();

        if(selection instanceof IStructuredSelection

                && ((IStructuredSelection) selection).size()==1) {

            Object object = ((IStructuredSelection) selection).iterator().next();

            if(object instanceof Taxon){

                return (Taxon) object;

            }

        }

        return null;

    }

}