EDIT

/**

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

import java.util.HashSet;

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.core.contexts.ContextInjectionFactory;

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

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

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

import org.eclipse.jface.util.LocalSelectionTransfer;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.DND;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Tree;

import org.eclipse.ui.IMemento;

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.definedterm.DefinedTermSorter;

import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoContentProvider;

import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoLabelProvider;

import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;

import eu.etaxonomy.taxeditor.event.EventUtility;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

import eu.etaxonomy.taxeditor.model.IContextListener;

import eu.etaxonomy.taxeditor.model.IDirtyMarkable;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.model.IPartContentHasSupplementalData;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.store.AppModelId;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.ui.element.LayoutConstants;

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

/**

 *

 * @author pplitzner

 * @since Aug 22, 2017

 *

 */

public class DefinedTermEditorE4 implements IConversationEnabled, IDirtyMarkable, IPostOperationEnabled,

IPartContentHasDetails, IPartContentHasSupplementalData, IE4SavablePart, IContextListener {

	public static final String OPEN_COMMAND_ID = "eu.etaxonomy.taxeditor.store.openDefinedTermEditor"; //$NON-NLS-1$

	protected TreeViewer viewer;

	protected ConversationHolder conversation;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    private ISelectionChangedListener selectionChangedListener;

	private final int dndOperations = DND.DROP_COPY | DND.DROP_MOVE;

    private TermEditorInput input =null;

    @Inject

    private MPart thisPart;

    private Set<TermBase> changedTerms = new HashSet<>();

	@Inject

	public DefinedTermEditorE4() {

	    CdmStore.getContextManager().addContextListener(this);

	}

	@PostConstruct

	public void createPartControl(Composite parent, EMenuService menuService,

	        IEclipseContext context) {

	    if (CdmStore.isActive()){

            if(conversation == null){

                conversation = CdmStore.createConversation();

            }

        }

        else{

            return;

        }

	    FillLayout layout = new FillLayout();

	    layout.marginHeight = 0;

	    layout.marginWidth = 0;

	    layout.type = SWT.VERTICAL;

	    parent.setLayout(layout);

	    viewer = new TreeViewer(new Tree(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.MULTI));

	    viewer.getControl().setLayoutData(LayoutConstants.FILL());

	    viewer.setContentProvider(new TermDtoContentProvider());

	    viewer.setLabelProvider(new TermDtoLabelProvider());

	    viewer.setComparator(new DefinedTermSorter());

	    Transfer[] transfers = new Transfer[] { LocalSelectionTransfer.getTransfer() };

	    viewer.addDragSupport(dndOperations, transfers, new DefinedTermDragListenerE4(viewer));

	    DefinedTermDropAdapterE4 dropListener = new DefinedTermDropAdapterE4(this);

	    ContextInjectionFactory.inject(dropListener, context);

        viewer.addDropSupport(dndOperations, transfers, dropListener);

	    //propagate selection

	    selectionChangedListener = (event -> selService.setSelection(event.getSelection()));

	    viewer.addSelectionChangedListener(selectionChangedListener);

	    //create context menu

	    menuService.registerContextMenu(viewer.getControl(), AppModelId.POPUPMENU_EU_ETAXONOMY_TAXEDITOR_STORE_POPUPMENU_TERMEDITOR);

	}

	@Override

	public boolean postOperation(Object objectAffectedByOperation) {

	    if(objectAffectedByOperation instanceof TermVocabularyDto

	            || objectAffectedByOperation instanceof TermVocabulary){

	        input.initialiseVocabularies();

	    }

	    viewer.refresh();

		if(objectAffectedByOperation != null){

			StructuredSelection selection = new StructuredSelection(objectAffectedByOperation);

            viewer.setSelection(selection);

			viewer.expandToLevel(objectAffectedByOperation, 1);

		}

		return true;

	}

	public void init(TermEditorInput input){

	    this.input = input;

        input.initialiseVocabularies();

        viewer.setInput(input.getVocabularies());

        thisPart.setLabel(input.getName());

	}

	@Override

    @Persist

	public void save(IProgressMonitor monitor) {

		getConversationHolder().commit();

		for(TermBase term:changedTerms){

            if(term.isInstanceOf(DefinedTermBase.class)){

                CdmStore.getService(ITermService.class).merge((DefinedTermBase) term);

            }

            else if(term.isInstanceOf(TermVocabulary.class)){

                CdmStore.getService(IVocabularyService.class).merge((TermVocabulary) term);

            }

		}

        changedTerms.clear();

		setDirty(false);

		input.initialiseVocabularies();

		viewer.refresh();

		EventUtility.postEvent(WorkbenchEventConstants.REFRESH_SUPPLEMENTAL, true);

	}

	@Override

    public boolean isDirty() {

		return dirty.isDirty();

	}

	@Focus

	public void setFocus() {

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

	        viewer.getControl().setFocus();

	    }

	    if(conversation!=null){

	        conversation.bind();

	    }

		if(input!=null){

		    input.bind();

		}

	}

	@Override

	public void update(CdmDataChangeMap changeEvents) {

	}

	@Override

	public ConversationHolder getConversationHolder() {

		return conversation;

	}

	@Override

	public void changed(Object element) {

	    if(element instanceof DefinedTermBase){

	        DefinedTermBase definedTermBase = (DefinedTermBase) element;

            TermDto termDto = TermDto.fromTerm(definedTermBase);

	        viewer.update(termDto, null);

	        changedTerms.add(definedTermBase);

	    }

	    else if(element instanceof TermVocabulary){

	        TermVocabulary vocabulary = (TermVocabulary)element;

	        TermVocabularyDto vocabularyDto = new TermVocabularyDto(vocabulary.getUuid(), vocabulary.getRepresentations());

	        viewer.update(vocabularyDto, null);

	        changedTerms.add(vocabulary);

	    }

		setDirty(true);

		viewer.update(element, null);

	}

	@Override

	public void forceDirty() {

	    changed(null);

	}

	public void setDirty(boolean dirty) {

		this.dirty.setDirty(dirty);

	}

	@Override

	public boolean onComplete() {

		return false;

	}

	public TreeViewer getViewer() {

		return viewer;

	}

	@PreDestroy

	public void dispose() {

	    if(conversation!=null){

	        conversation.unregisterForDataStoreChanges(this);

	        conversation.close();

	        conversation = null;

	    }

	    if(input!=null){

	        input.dispose();

	    }

	    this.dirty.setDirty(false);

	}

    public TermEditorInput getDefinedTermEditorInput() {

        return input;

    }

    @Override

    public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {

    }

    @Override

    public void contextStop(IMemento memento, IProgressMonitor monitor) {

        //close view when workbench closes

        try{

            thisPart.getContext().get(EPartService.class).hidePart(thisPart);

        }

        catch(Exception e){

            //nothing

        }

    }

    @Override

    public void contextStart(IMemento memento, IProgressMonitor monitor) {

    }

    @Override

    public void contextRefresh(IProgressMonitor monitor) {

    }

    @Override

    public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {

    }

}