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

import java.util.Set;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import javax.inject.Named;

import org.eclipse.e4.core.di.annotations.Optional;

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

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

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

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

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

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

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.Viewer;

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

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.IDistributionEditor;

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.view.e4.details.DetailsViewerE4;

import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;

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

/**

 * @author pplitzner

 * @since Aug 10, 2017

 *

 */

public abstract class AbstractCdmEditorPartE4

        implements IConversationEnabled, IDirtyMarkable, ISelectionElementEditingPart, IPostOperationEnabled{

    private DelaySelection delaySelection = null;

    /**

     * This is the monitor for the DelaySelection runnable.

     * If it is <code>true</code> then it is currently delaying a selection.

     */

    private boolean isInDelay;

    /**

     * This class invokes internal_selectionChanged() in a separate thread.

     * This allows an asynchronous and/or delayed handling of selection changes

     */

    private class DelaySelection implements Runnable{

        private Object selection;

        private MPart activePart;

        private MPart thisPart;

        public DelaySelection(Object selection, MPart activePart, MPart thisPart) {

            super();

            this.selection = selection;

            this.activePart= activePart;

            this.thisPart = thisPart;

        }

        @Override

        public void run() {

            try{

                selectionChanged_internal(selection, activePart, thisPart);

            }

            finally{

                isInDelay = false;

            }

        }

        public synchronized void setSelection(Object selection) {

            this.selection = selection;

        }

        public synchronized void setActivePart(MPart activePart) {

            this.activePart = activePart;

        }

        public synchronized void setThisPart(MPart thisPart) {

            this.thisPart = thisPart;

        }

    }

    protected Viewer viewer;

    protected MPart thisPart;

    protected MPart selectionProvidingPart;

    protected Object previousSelection;

    protected ISelectionChangedListener selectionChangedListener;

    public ISelectionChangedListener getSelectionChangedListener() {

        return selectionChangedListener;

    }

    @Inject

    protected ESelectionService selService;

    protected abstract void selectionChanged_internal(Object selection, MPart activePart, MPart thisPart);

    @Inject

    public void selectionChanged(

            @Optional@Named(IServiceConstants.ACTIVE_SELECTION)Object selection,

            @Optional@Named(IServiceConstants.ACTIVE_PART)MPart activePart,

            MPart thisPart, UISynchronize sync, EPartService partService){

        if(activePart==thisPart && EventUtility.getActiveEditorPart(partService)==null){

            showEmptyPage();

            return;

        }

        if(previousSelection==null ||

                previousSelection!=selection){//skip redundant rendering of details view

            if(delaySelection==null){

                delaySelection = new DelaySelection(selection, activePart, thisPart);

            }

            delaySelection.setSelection(selection);

            delaySelection.setActivePart(activePart);

            delaySelection.setThisPart(thisPart);

            if(!isInDelay){

                isInDelay = true;

                sync.asyncExec(delaySelection);

                previousSelection = selection;

            }

        }

    }

    /** {@inheritDoc} */

    @Override

    public void changed(Object object) {

        if(selectionProvidingPart!=null){

            Object part = selectionProvidingPart.getObject();

            if(part instanceof IDirtyMarkable){

                ((IDirtyMarkable) part).changed(object);

            }

        }

    }

    public Viewer getViewer() {

        return viewer;

    }

    protected void showViewer(IStructuredSelection selection, MPart activePart, Viewer viewer){

        if(viewer!=null && viewer.getControl()!=null && !viewer.getControl().isDisposed()){

            Object element = selection.getFirstElement();

            Object part = createPartObject(activePart);

            if(selection.getFirstElement()!=null){

                if (element instanceof Taxon){

                    Taxon taxon = HibernateProxyHelper.deproxy(element, Taxon.class);

                    if (taxon.isMisapplication()){

                        if(part instanceof ITaxonEditor){

                            Taxon accepted = ((ITaxonEditor) part).getTaxon();

                            //                			Taxon accepted= ((ITaxonEditor)activePart).getTaxon();

                            Set<TaxonRelationship> rels =  taxon.getTaxonRelations(accepted);

                            if (rels.iterator().hasNext()){

                                TaxonRelationship rel = rels.iterator().next();

                                if (rel.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) && !rel.getFromTaxon().equals(((ITaxonEditor) part).getTaxon())){

                                    viewer.setInput(rel);

                                    return;

                                }

                            }

                        }

                    }

                }

                if (element instanceof Distribution && part instanceof IDistributionEditor){

                    ((DetailsViewerE4)viewer).setInput(element, part);

                }else{

                    viewer.setInput(element);

                }

                selectionProvidingPart = activePart;

            }

        }

    }

    protected Object createPartObject(MPart activePart) {

        Object partObject = activePart;

        Object wrappedPart = WorkbenchUtility.getE4WrappedPart(activePart);

        if(wrappedPart!=null){

            partObject = wrappedPart;

        }

        return partObject;

    }

    protected void showEmptyPage() {

        if(viewer!=null && viewer.getControl()!=null && !viewer.getControl().isDisposed()){

            viewer.setInput(null);

            viewer.getControl().setEnabled(false);

        }

        selectionProvidingPart = null;

        if(thisPart!=null){

            thisPart.setLabel(getViewName());

        }

    }

    protected IStructuredSelection createSelection(Object selection) {

        if(selection==null){

            return null;

        }

        IStructuredSelection structuredSelection;

        if(!(selection instanceof IStructuredSelection)){

            structuredSelection = new StructuredSelection(selection);

        }

        else{

            structuredSelection = (IStructuredSelection) selection;

        }

        return structuredSelection;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ConversationHolder getConversationHolder() {

        if(selectionProvidingPart != null && selectionProvidingPart instanceof IConversationEnabled) {

            return ((IConversationEnabled) selectionProvidingPart).getConversationHolder();

        }

        return null;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean postOperation(CdmBase objectAffectedByOperation) {

        changed(objectAffectedByOperation);

        return true;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean onComplete() {

        viewer.refresh();

        return true;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Object getSelectionProvidingPart() {

        return selectionProvidingPart;

    }

    @PreDestroy

    private void dispose() {

    }

    @PersistState

    private void persistState(){

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void forceDirty() {

    }

    protected abstract String getViewName();

}