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.editor.name.e4;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.apache.commons.lang.StringUtils;

import org.eclipse.core.commands.operations.IUndoContext;

import org.eclipse.core.commands.operations.UndoContext;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

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

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

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.di.UIEventTopic;

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

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

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

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.DropTarget;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.ISelectionListener;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchPartReference;

import org.eclipse.ui.forms.ManagedForm;

import org.eclipse.ui.forms.widgets.FormToolkit;

import org.eclipse.ui.forms.widgets.ScrolledForm;

import org.eclipse.ui.forms.widgets.TableWrapLayout;

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

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

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.CdmDataTransfer;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.ISecuredEditor;

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.editor.e4.TaxonEditorInputE4;

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

import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroupE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AbstractGroupedContainerE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedGroupE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.AcceptedNameContainerE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.ContainerFactoryE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.HomotypicalSynonymGroupE4;

import eu.etaxonomy.taxeditor.editor.name.e4.container.MisappliedGroupE4;

import eu.etaxonomy.taxeditor.editor.name.e4.dnd.NameEditorDropTargetListenerE4;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartChangeListener;

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.model.MessagingUtils;

import eu.etaxonomy.taxeditor.model.TaxeditorPartService;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.preference.Resources;

import eu.etaxonomy.taxeditor.security.RequiredPermissions;

import eu.etaxonomy.taxeditor.store.CdmStore;

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

/**

 *

 * @author pplitzner

 * @date Aug 24, 2017

 *

 */

public class TaxonNameEditorE4 implements IConversationEnabled, IDirtyMarkable, IPartContentHasDetails,

        IPartContentHasSupplementalData, IPartContentHasMedia, IPartContentHasFactualData, IPartChangeListener,

        ISelectionListener, ISecuredEditor, IPostOperationEnabled, IE4SavablePart, ITaxonEditor, IDropTargetableE4 {

	private Taxon taxon;

	private ManagedForm managedForm;

	private ScrolledForm scrolledForm;

	private Composite parent;

	private ISelectionProvider simpleSelectionProvider;

	private TaxonBase selection;

	private ConversationHolder conversation;

	private AcceptedGroupE4 acceptedGroup;

	private List<HomotypicalSynonymGroupE4> heterotypicSynonymGroups = new ArrayList<>();

	private MisappliedGroupE4 misappliedGroup;

	private DropTarget target;

	private TaxonBase objectAffectedByLastOperation;

	@Inject

	private EMenuService menuService;

	@Inject

	private ESelectionService selService;

	@Inject

	private IEclipseContext context;

	@Inject

	private MDirtyable dirty;

	private MPart thisPart;

    private TaxonEditorInputE4 input;

    private UndoContext undoContext;

    @Inject

    private IEventBroker eventBroker;

	@Inject

	public TaxonNameEditorE4() {

	    undoContext = new UndoContext();

	}

	@PostConstruct

    public void createPartControl(Composite parent, MPart thisPart) {

	    this.thisPart = thisPart;

        createManagedForm(parent);

		TaxeditorPartService.getInstance().addListener(

				TaxeditorPartService.PART_ACTIVATED, this);

	}

	protected void createManagedForm(Composite composite) {

		managedForm = new ManagedForm(composite) {

			@Override

			public void dirtyStateChanged() {

			    dirty.setDirty(true);

			}

			@Override

			public boolean setInput(Object input) {

				if (input instanceof AbstractGroupedContainerE4) {

				    TaxonBase newSelection = ((AbstractGroupedContainerE4) input).getData();

				    if(selection!=newSelection || TaxonNameEditorE4.this.isDirty()){

				        selection = newSelection;

				        selService.setSelection(new StructuredSelection(selection));

				    }

				}else if(input == null){

					selection = null;

                    selService.setSelection(new StructuredSelection());

				}

				return super.setInput(input);

			}

		};

		scrolledForm = managedForm.getForm();

		parent = scrolledForm.getBody();

		parent.setData(taxon);

		TableWrapLayout layout = new TableWrapLayout();

		layout.leftMargin = 0;

		layout.rightMargin = 0;

		layout.topMargin = 0;

		layout.bottomMargin = 0;

		layout.verticalSpacing = 0;

		layout.horizontalSpacing = 0;

		parent.setLayout(layout);

		parent.setBackground(AbstractUtility

				.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));

	}

	public void createOrUpdateNameComposites(boolean accepted, boolean heterotypicGroups, boolean misappliedNames) {

	    if (accepted){

	        ContainerFactoryE4.createOrUpdateAcceptedTaxonsHomotypicGroup(this);

	    }

	    if (heterotypicGroups){

	        ContainerFactoryE4.createOrUpdateHeterotypicSynonymyGroups(this);

	    }

	    if (misappliedNames){

	        ContainerFactoryE4.createOrUpdateMisapplicationsGroup(this);

	    }

		// Redraw composite

		managedForm.reflow(true);

		managedForm.refresh();

	}

	@Override

    public Taxon getTaxon() {

		return HibernateProxyHelper.deproxy(taxon);

	}

	public void setDirty() {

		managedForm.dirtyStateChanged();

	}

	@Focus

	public void setFocus() {

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

        if(conversation!=null && !conversation.isBound()){

            conversation.bind();

        }

	    if(input!=null){

	        if (getSelectedContainer() == null) {

	            throw new IllegalStateException(

	                    Messages.TaxonNameEditor_THERE_SHOULD_ALWAYS_BE);

	        }

	        getSelectedContainer().setSelected();

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

	            input.bind();

	        }

	        // check permissions

	        boolean doEnable = permissionsSatisfied();

	        managedForm.getForm().setEnabled(doEnable);

	    }

        eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, this);

	}

	@Override

	public boolean permissionsSatisfied() {

		TaxonNode taxonNode = input.getTaxonNode();

		boolean doEnable = CdmStore.currentAuthentiationHasPermission(taxonNode, RequiredPermissions.TAXONNODE_EDIT);

		return doEnable;

	}

	@Override

    public ConversationHolder getConversationHolder() {

		return conversation;

	}

	/** {@inheritDoc} */

	@Override

    public void update(CdmDataChangeMap events) {

		// redraw();

	}

	/**

	 * Redraws this editor return true on success

	 *

	 * @return a boolean.

	 */

    public boolean redraw() {

		return redraw(true, true, true, true);

	}

	/**

	 * {@inheritDoc}

	 *

	 * Redraws the editor controls

	 */

    public boolean redraw(boolean focus, boolean accepted, boolean heterotypic, boolean misappliedNames) {

		createOrUpdateNameComposites(accepted, heterotypic, misappliedNames);

		if (focus) {

			setFocus();

		}

		return true;

	}

	@Override

    public boolean postOperation(CdmBase objectAffectedByOperation) {

		changed(objectAffectedByOperation);

		redraw(true, true,true, true);

		if (objectAffectedByOperation instanceof TaxonBase) {

			objectAffectedByLastOperation = (TaxonBase) objectAffectedByOperation;

		}

		return true;

	}

	public ManagedForm getManagedForm() {

		return managedForm;

	}

	/**

	 * <p>

	 * checkForEmptyNames

	 * </p>

	 *

	 * @return true if there are empty names

	 */

	public boolean checkForEmptyNames() {

		for (AbstractGroupedContainerE4 container : getGroupedContainers()) {

			if (container.getName() == null

					|| StringUtils.isEmpty(container.getName().getTitleCache())) {

				return true;

			}

		}

		return false;

	}

	public Set<AbstractGroupedContainerE4> getEmptyContainers() {

		Set<AbstractGroupedContainerE4> containersWithEmptyNames = new HashSet<>();

		for (AbstractGroupedContainerE4 container : getGroupedContainers()) {

			if (container.getName() == null

					|| StringUtils.isEmpty(container.getName().getTitleCache())) {

				containersWithEmptyNames.add(container);

			}

		}

		return containersWithEmptyNames;

	}

	/** {@inheritDoc} */

	@Override

    @Persist

	public void save(IProgressMonitor monitor) {

	    monitor.beginTask(Messages.TaxonNameEditor_SAVING_NAMES, getGroupedContainers().size());

	    if (!conversation.isBound()) {

	        conversation.bind();

	    }

	    conversation.commit(true);

	    monitor.worked(1);

	    // check for empty names

	    if (checkForEmptyNames()) {

	        MessageDialog.openWarning(AbstractUtility.getShell(), Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED,

	                Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED_MESSAGE);

	        return;

	    }

	    for (AbstractGroupedContainerE4 container : getGroupedContainers()) {

	        monitor.subTask(Messages.TaxonNameEditor_SAVING_COMPOSITES

	                + container.getTaxonBase().getTitleCache());

	        container.persistName();

	        // In case the progress monitor was canceled throw an exception.

	        if (monitor.isCanceled()) {

	            throw new OperationCanceledException();

	        }

	     // Otherwise declare this step as done.

	        monitor.worked(1);

	    }

	    input.merge();

	    // commit the conversation and start a new transaction immediately

        conversation.commit(true);

        dirty.setDirty(false);

	    // Stop the progress monitor.

	    monitor.done();

	}

	public void init(TaxonEditorInputE4 input) {

		if (this.input != null){

			this.input.dispose();

//			this.acceptedGroup = null;

//			this.heterotypicSynonymGroups.clear();

//			this.misappliedGroup = null;

		}

		if (!(input != null)) {

            MessagingUtils.error(this.getClass(), new Exception(Messages.TaxonNameEditor_INVALID_INPUT));

            return;

        }

		if (input.getAdapter(Taxon.class) != null) {

			taxon = CdmBase.deproxy(input.getAdapter(Taxon.class), Taxon.class);

		} else {

		    MessagingUtils.error(this.getClass(), new Exception(Messages.TaxonNameEditor_INVALID_INPUT_TAXON_NULL));

		    return;

		}

		this.input = input;

		conversation = input.getConversationHolder();

        createOrUpdateNameComposites(true, true, true);

        createDragSupport();

        setPartName();

        //set initial selection

        TaxonBase initiallySelectedTaxonBase = input.getInitiallySelectedTaxonBase();

        if(initiallySelectedTaxonBase!=null){

            selService.setSelection(new StructuredSelection(initiallySelectedTaxonBase));

            getContainer(initiallySelectedTaxonBase).setSelected();

        }

	}

   private void createDragSupport() {

       // Listen for names being dragged outside of existing homotypic groups -

       // user wants to create a new group

       Transfer[] types = new Transfer[] { CdmDataTransfer.getInstance() };

       int operations = DND.DROP_MOVE;

       if (target == null) {

           target = new DropTarget(parent, operations);

           target.setTransfer(types);

           target.addDropListener(new NameEditorDropTargetListenerE4(this));

       }

   }

	public AcceptedNameContainerE4 getAcceptedNameContainer() {

		return getAcceptedGroup().getAcceptedNameContainer();

	}

	public HomotypicalSynonymGroupE4 getHomotypicalGroupContainer(

			HomotypicalGroup homotypicalGroup) {

		for (HomotypicalSynonymGroupE4 group : getHeterotypicSynonymGroups()) {

			if (group.getGroup().equals(homotypicalGroup)) {

				return group;

			}

		}

		return null;

	}

	/**

	 * <p>

	 * getDirtyNames

	 * </p>

	 *

	 * @return a Set containing all composites that have been edited

	 */

	public Set<AbstractGroupedContainerE4> getDirtyNames() {

		Set<AbstractGroupedContainerE4> dirtyNames = new HashSet<>();

		for (AbstractGroupedContainerE4 composite : getGroupedContainers()) {

			if (composite.isDirty()) {

				dirtyNames.add(composite);

			}

		}

		return dirtyNames;

	}

	public List<AbstractGroupedContainerE4> getGroupedContainers() {

		List<AbstractGroupedContainerE4> groupedComposites = new ArrayList<>();

		for (AbstractGroupE4 group : getAllGroups()) {

		    if (group!= null){

		        groupedComposites.addAll(group.getGroupedContainers());

		    }

		}

		return groupedComposites;

	}

	public List<AbstractGroupE4> getAllGroups() {

		List<AbstractGroupE4> allGroups = new ArrayList<>();

		allGroups.add(getAcceptedGroup());

		heterotypicSynonymGroups = getHeterotypicSynonymGroups();

		if (heterotypicSynonymGroups != null) {

			allGroups.addAll(heterotypicSynonymGroups);

		}

		if (misappliedGroup != null) {

			allGroups.add(misappliedGroup);

		}

		return allGroups;

	}

	@Override

	public IEclipseContext getContext() {

	    return context;

	}

	public boolean isDirty() {

		return dirty.isDirty();

	}

	@PreDestroy

	public void dispose() {

        if(conversation!=null){

            conversation.unregisterForDataStoreChanges(this);

            conversation.close();

        }

        if(input!=null){

            input.dispose();

        }

        eventBroker.post(WorkbenchEventConstants.CURRENT_ACTIVE_EDITOR, null);

	}

	/** {@inheritDoc} */

	@Override

    public void selectionChanged(IWorkbenchPart part, ISelection selection) {

	    System.err.println("Bla");

	}

	public AbstractGroupedContainerE4 getSelectedContainer() {

		return (selection != null) ? getContainer(selection)

				: getAcceptedNameContainer();

	}

    @Override

    public void dragEntered() {

        // TODO change this

        getControl().setBackground(

                AbstractUtility.getColor(Resources.COLOR_DRAG_ENTER));

    }

    @Override

    public void dragLeft() {

        getControl().setBackground(

                AbstractUtility.getColor(Resources.COLOR_COMPOSITE_BACKGROUND));

    }

	public void setMisapplicationsGroup(MisappliedGroupE4 misappliedGroup) {

		this.misappliedGroup = misappliedGroup;

	}

	public FormToolkit getToolkit() {

		return managedForm.getToolkit();

	}

	public List<HomotypicalSynonymGroupE4> getHeterotypicSynonymGroups() {

		return heterotypicSynonymGroups;

	}

	public void addHeterotypicSynonymGroup(HomotypicalSynonymGroupE4 group) {

		heterotypicSynonymGroups.add(group);

	}

	public AcceptedGroupE4 getAcceptedGroup() {

		return acceptedGroup;

	}

	public void setAcceptedGroup(AcceptedGroupE4 acceptedGroup) {

		this.acceptedGroup = acceptedGroup;

	}

	public MisappliedGroupE4 getMisappliedGroup() {

		return misappliedGroup;

	}

	public boolean isActive() {

		return this.equals(AbstractUtility.getActivePart());

	}

    @Override

    public boolean onComplete() {

		getContainer(objectAffectedByLastOperation).setSelected();

		return true;

	}

	/** {@inheritDoc} */

	@Override

    public void partChanged(Integer eventType, IWorkbenchPartReference partRef) {

		if (!partRef.getPart(false).equals(this)) {

			// getSelectedObject().colorSelected(AbstractGroupedContainer.SELECTED_NO_FOCUS);

		}

	}

	public void removeGroup(AbstractGroupE4 group) {

		if (group != null) {

			group.dispose();

			//if (heterotypicSynonymGroups != null) {

			heterotypicSynonymGroups.remove(group);

			//}

		}

	}

	public AbstractGroupedContainerE4 getContainer(TaxonBase taxonBase) {

		@SuppressWarnings("rawtypes")

        List<AbstractGroupedContainerE4> groupedContainers = getGroupedContainers();

		for (AbstractGroupedContainerE4 container : groupedContainers) {

			if (container.getData().equals(taxonBase)

					&& container.getNameViewer().getTextWidget() != null) {

				return container;

			}

		}

		return getAcceptedNameContainer();

	}

    public void setOnError() {

		Color disabledColor =  AbstractUtility.getColor(Resources.COLOR_EDITOR_ERROR);

		setEnabled(false, disabledColor);

	}

	public void setDisabled(){

		Color disabledColor =  AbstractUtility.getColor(Resources.COLOR_TEXT_DISABLED_BACKGROUND);

		setEnabled(false, disabledColor);

	}

	protected void setEnabled(boolean enabled, Color background) {

		for(AbstractGroupedContainerE4 groupedContainer : getGroupedContainers()){

			groupedContainer.setEnabled(enabled);

		}

		// send an empty selection to the current provider - TODO only on error ???

		if (!enabled) {

			getManagedForm().setInput(null);

			for (AbstractGroupedContainerE4 groupedContainer : getGroupedContainers()) {

				groupedContainer.setBackground(background);

			}

		}

		getControl().setBackground(background);

	}

    @Override

    public void changed(Object element) {

        // setDirty(true);

        // if the attribute is null then do not set the dirty flag -> hotfix for the problem that for tasks done in service methods the changes are saved automatically

        if (element != null){

            dirty.setDirty(true);

            //refresh part title

            //TODO: refresh taxon node in taxon navigator

            setPartName();

        }

        if (element instanceof TaxonBase) {

            AbstractGroupedContainerE4 container = getContainer((TaxonBase) element);

            if (container != null) {

                container.refresh();

            }

        }

        if (element instanceof TaxonRelationship) {

            AbstractGroupedContainerE4 container = getContainer(((TaxonRelationship) element).getFromTaxon());

            if (container != null) {

                container.refresh();

            }

        }

    }

    public void setPartName(){

        thisPart.setLabel(this.taxon.getName().getFullTitleCache());

    }

    @Override

    public void forceDirty() {

        setDirty();

    }

    public IUndoContext getUndoContext() {

        return undoContext;

    }

    @Override

    public Composite getControl(){

        return managedForm.getForm().getBody();

    }

    public EMenuService getMenuService() {

        return menuService;

    }

    public ESelectionService getSelectionService() {

        return selService;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean canAttachMedia() {

        return true;

    }

    public TaxonEditorInputE4 getEditorInput() {

        return input;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public TaxonNameEditorE4 getEditor() {

        return this;

    }

    @Inject

    @Optional

    private void updateView(@UIEventTopic(WorkbenchEventConstants.REFRESH_NAME_EDITOR)boolean refresh){

        if(refresh){

            this.redraw(false, false, false, true);

        }

    }

    @Inject

    @Optional

    private void updatefromDelete(@UIEventTopic(WorkbenchEventConstants.DELETE_DERIVATIVE)DeleteResult result,

            EPartService partService, MApplication application){

        if(taxon.getName()==null){

            return;

        }

        Set<DerivedUnit> typeDesignationSpecimens = new HashSet<>();

        this.taxon.getName().getSpecimenTypeDesignations().forEach(designation->typeDesignationSpecimens.add(designation.getTypeSpecimen()));

        //check if any deleted object was a type specimen

        if(result.getUpdatedObjects().stream()

                //filter only DerivedUnits

                .filter(cdmBase->cdmBase.isInstanceOf(DerivedUnit.class))

                //deproxy from CdmBase to DerivedUnit

                .map(unit->HibernateProxyHelper.deproxy(unit, DerivedUnit.class))

                //check for match in type designations

                .anyMatch(unit->typeDesignationSpecimens.contains(unit))){

                EditorUtil.updateEditor(this.input.getTaxonNode(), this);

        }

    }

}