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

import java.util.Set;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import javax.inject.Named;

import org.apache.log4j.Logger;

import org.eclipse.e4.core.contexts.IEclipseContext;

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 org.eclipse.swt.SWTException;

import org.springframework.security.core.GrantedAuthority;

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

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

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

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

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.name.TaxonName;

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

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

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

import eu.etaxonomy.cdm.persistence.dto.TermDto;

import eu.etaxonomy.cdm.persistence.dto.TermNodeDto;

import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;

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

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.security.RequiredPermissions;

import eu.etaxonomy.taxeditor.store.CdmStore;

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

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 static final Logger logger = Logger.getLogger(AbstractCdmEditorPartE4.class);

	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;

    private boolean isEnabled = true;

    /**

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

    @Inject

    protected IEclipseContext context;

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

    protected boolean showEmptyIfNoActiveEditor(){

        return true;

    }

    @Inject

    public void selectionChanged(

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

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

            MPart thisPart, UISynchronize sync, EPartService partService){

        //multiple selections are not supported

        if(activePart!=null

                && thisPart!=null

                && !activePart.equals(thisPart)

                && selection instanceof IStructuredSelection

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

            showEmptyPage();

            return;

        }

        // no active editor found

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

            showEmptyPage();

            return;

        }

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

           try{

               viewer.getControl().setEnabled(isEnabled);

           }catch(SWTException e){

              logger.debug("Something went wrong for viewer.getControl().setEnabled(true) in " + this.getClass().getSimpleName(), e);

           }

        }

        if((previousSelection!=null && selection!=null)

               && (activePart != null &&  selectionProvidingPart != null && activePart.equals(selectionProvidingPart))

               && (previousSelection==selection

                    || previousSelection.equals(selection)

                    || new StructuredSelection(selection).equals(previousSelection))

                ) {

            return;

        }

        if(delaySelection==null){

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

        }else{

            delaySelection.setSelection(selection);

            delaySelection.setActivePart(activePart);

            delaySelection.setThisPart(thisPart);

        }

        if(!isInDelay){

            isInDelay = true;

            sync.asyncExec(delaySelection);

            previousSelection = selection;

        }

    }

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

    }

    public boolean isEnabled() {

        return isEnabled;

    }

    public void setEnabled(boolean isEnabled) {

        this.isEnabled = isEnabled;

    }

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

        if(CdmStore.getCurrentSessionManager().getActiveSession()==null){

            return;

        }

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

            Object element = selection.getFirstElement();

            Object part = createPartObject(activePart);

            if (viewer.getControl().isDisposed()){

                return;

            }

            viewer.getControl().setEnabled(true);

            if(element != null){

                if (element instanceof Taxon){

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

                    if (part instanceof ITaxonEditor){

                        TaxonNode node = ((ITaxonEditor) part).getTaxonNode();

                        if (node != null){

                            boolean doEnable = CdmStore.currentAuthentiationHasPermission(node,

                                    RequiredPermissions.TAXON_EDIT);

                            if (!doEnable){

                                 //check whether there are explicit TaxonNode rights

                                 boolean taxonnodePermissionExists = false;

                                 Collection<? extends GrantedAuthority> authorities = CdmStore.getCurrentAuthentiation().getAuthorities();

                                 for (GrantedAuthority grantedAuthority: authorities){

                                     if (grantedAuthority.getAuthority().startsWith("TAXONNODE")){

                                         taxonnodePermissionExists = true;

                                     }

                                 }

                                 if (!taxonnodePermissionExists){

                                     doEnable = true;

                                 }

                            }

                            //TODO: differ between the views

                            this.isEnabled = doEnable;

                        }

                    }

                    if (taxon.isMisapplication() || taxon.isProparteSynonym() ){

                        if(part instanceof ITaxonEditor){

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

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

                            if (rels != null && rels.iterator().hasNext() && !taxon.equals(accepted)){

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

                                if ((rel.getType().isMisappliedName() || rel.getType().isAnySynonym()) && !rel.getFromTaxon().equals(((ITaxonEditor) part).getTaxon())){

                                    viewer.setInput(rel);

                                    selectionProvidingPart = activePart;

                                    return;

                                }

                            }

                        }

                    }

                }

                //unwrap term DTOs

                if(element instanceof TermDto){

                    element = CdmStore.getService(ITermService.class).load(((TermDto) element).getUuid());

                }

                else if(element instanceof TermVocabularyDto){

                    element = CdmStore.getService(IVocabularyService.class).load(((TermVocabularyDto) element).getUuid());

                }

                selectionProvidingPart = activePart;

                if (viewer instanceof DetailsViewerE4){

                    if (selectionProvidingPart.getElementId().equals("eu.etaxonomy.taxeditor.editor.view.checklist.e4.DistributionEditorPart")){

                        ((DetailsViewerE4)viewer).setDetailsEnabled(false);

                    }else{

                        ((DetailsViewerE4)viewer).setDetailsEnabled(isEnabled);

                    }

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

                }

                else{

                    if(element instanceof TermNodeDto){

                        element = CdmStore.getService(ITermNodeService.class).load(((TermNodeDto) element).getUuid());

                    }

                    if (activePart.getObject() instanceof DetailsPartE4 && element instanceof TaxonName){

                        selectionProvidingPart = ((DetailsPartE4)activePart.getObject()).getSelectionProvidingPart();

                    }

                    viewer.setInput(element);

                    viewer.getControl().setEnabled(isEnabled);

                }

            }

        }

    }

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

            try{

	            if (!viewer.getControl().isDisposed()){

	                viewer.getControl().setEnabled(false);

	            }

            }catch(SWTException e){

            	if (PreferencesUtil.isShowUpWidgetIsDisposedMessages() && e.getMessage().equals("Widget is disposed")){

                    MessagingUtils.errorDialog("Widget is disposed",

                            null,

                            MessagingUtils.WIDGET_IS_DISPOSED_MESSAGE,

                            null,

                            e,

                            true);

                }

            }

        }

        reset();

        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;

    }

    @Override

    public ConversationHolder getConversationHolder() {

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

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

        }

        return null;

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        changed(objectAffectedByOperation);

        return true;

    }

    @Override

    public boolean onComplete() {

        viewer.refresh();

        return true;

    }

    @Override

    public MPart getSelectionProvidingPart() {

        return selectionProvidingPart;

    }

    @PreDestroy

    private void dispose() {

    }

    private void reset(){

        previousSelection = null;

        selectionProvidingPart = null;

        delaySelection = null;

        context.deactivate();

    }

    @PersistState

    private void persistState(){

    }

    @Override

    public void update(CdmDataChangeMap arg0) {

    }

    @Override

    public void forceDirty() {

    }

    protected abstract String getViewName();

}