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

import java.io.IOException;

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.eclipse.core.commands.ExecutionException;

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

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.Status;

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

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.ui.MDirtyable;

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

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.ide.undo.WorkspaceUndoUtil;

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.media.Media;

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

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

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

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

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

import eu.etaxonomy.cdm.model.permission.Group;

import eu.etaxonomy.cdm.model.permission.User;

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.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.bulkeditor.BulkEditorQuery;

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

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

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

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

import eu.etaxonomy.taxeditor.editor.IBulkEditor;

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants;

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

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;

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

/**

 * @author pplitzner

 * @since Sep 8, 2017

 */

public class BulkEditor implements IPartContentHasDetails, IPostOperationEnabled,

        IDirtyMarkable, IDerivedUnitFacadePart, IPartContentHasFactualData,

        IPartContentHasSupplementalData, IPartContentHasMedia, IE4SavablePart, ITaxonEditor, IBulkEditor {

    @Inject

	private MDirtyable dirty;

    private AbstractBulkEditorInput input;

    @Inject

    private IEventBroker eventBroker;

    @Inject

    IEclipseContext context;

    @Inject

    private MPart thisPart;

    private BulkEditorQuery lastQuery = null;

    private BulkEditorComposite bulkEditorComposite;

    private Set<AbstractPostOperation> operations = new HashSet<>();

    @Inject

    public BulkEditor() {

	}

    public void init(AbstractBulkEditorInput<?> input){

	    this.input = input;

	    thisPart.setLabel(input.getEditorName());

	    bulkEditorComposite.init(input);

	}

	@PostConstruct

	public void createPartControl(Composite parent, IEclipseContext context) {

	    bulkEditorComposite = new BulkEditorComposite(this, parent, SWT.NONE);

	    ContextInjectionFactory.inject(bulkEditorComposite, context);

	}

	@Override

	@Persist

	public void save(IProgressMonitor monitor) {

	    save(monitor, true);

	}

    public void save(IProgressMonitor monitor, boolean resetMerge) {

    	IStructuredSelection selection = getLastSelection();

    	for(AbstractPostOperation<?> entry:operations){

            IStatus status = Status.CANCEL_STATUS;

            final IAdaptable uiInfoAdapter = WorkspaceUndoUtil

                    .getUIInfoAdapter(AbstractUtility.getShell());

            String operationlabel = entry.getLabel();

            try {

                entry.addContext(IOperationHistory.GLOBAL_UNDO_CONTEXT);

                status = entry.execute(new NullProgressMonitor(), uiInfoAdapter);

            } catch (ExecutionException e) {

                MessagingUtils.operationDialog(AbstractUtility.class, e, TaxeditorStorePlugin.PLUGIN_ID, operationlabel, null);

            }

            IPostOperationEnabled postOperationEnabled = entry

                    .getPostOperationEnabled();

            if (postOperationEnabled != null) {

                postOperationEnabled.onComplete();

            }

            //AbstractUtility.executeOperation(entry,sync);

        }

        operations.clear();

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

            input.getCdmEntitySession().bind();

        }

        input.saveModel(resetMerge);

        dirty.setDirty(false);

        input.dispose();

        input.bind();

        if (lastQuery != null){

            bulkEditorComposite.performSearch(lastQuery, selection);

        }

    }

	private IStructuredSelection getLastSelection() {

		return new StructuredSelection(this.bulkEditorComposite.getLastSelectedObject());

	}

	@Override

    @Focus

	public void setFocus() {

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

        if(input!=null && input.getCdmEntitySession()!= null) {

            input.getCdmEntitySession().bind();

        }

	    //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(input!=null){

	        input.dispose();

	    }

	    dirty.setDirty(false);

	    //save table settings

	    if(bulkEditorComposite.getNatTableState()!=null){

            try (FileOutputStream tableStateStream =

                    new FileOutputStream(bulkEditorComposite.getStatePropertiesFile())) {

                bulkEditorComposite.getNatTableState().store(tableStateStream, null);

            } catch (IOException ioe) {

                ioe.printStackTrace();

            }

        }

	}

    @Optional

    @Inject

    private void updateAfterSearch(@UIEventTopic(WorkbenchEventConstants.BULK_EDITOR_SEARCH_FINISHED)IStructuredSelection selection){

        if(selection!=null){

            setSelection(selection);

        }

    }

    public void refresh(){

        bulkEditorComposite.refresh();

    }

    public IStructuredSelection getSelection(){

        return bulkEditorComposite.getSelection();

    }

    public IStructuredSelection getCellSelection(){

        return bulkEditorComposite.getCellSelection();

    }

    @Override

    public void setSelection(IStructuredSelection selection){

        bulkEditorComposite.setSelection(selection);

    }

    public void setDirty(boolean isDirty){

        dirty.setDirty(isDirty);

    }

    public void setDirty(){

        setDirty(true);

    }

    @Override

    public boolean isDirty() {

        return dirty.isDirty();

    }

    public AbstractBulkEditorInput getEditorInput() {

        return input;

    }

    public void copyDataToClipboard() {

        bulkEditorComposite.copyDataToClipboard();

    }

    @Override

    public boolean canAttachMedia() {

        return true;

    }

    @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) {

            if (element instanceof DescriptionBase){

                if (element instanceof TaxonNameDescription){

                    TaxonName changedName = ((TaxonNameDescription)element).getTaxonName();

                    if (getEditorInput() instanceof TaxonEditorInput){

                        IStructuredSelection sel = getSelection();

                        Object firstElement = sel.getFirstElement();

                        if (firstElement instanceof TaxonBase){

                            getEditorInput().addSaveCandidate((TaxonBase)firstElement);

                        }

                    }else{

                        getEditorInput().addSaveCandidate(changedName);

                    }

                    input.replaceInModel(changedName);

                }else if (element instanceof TaxonDescription){

                    Taxon changedTaxon = ((TaxonDescription)element).getTaxon();

                    getEditorInput().addSaveCandidate(changedTaxon);

                    input.replaceInModel(changedTaxon);

                }

            }else if (element instanceof DescriptionElementBase){

                if (((DescriptionElementBase)element).getInDescription() instanceof TaxonNameDescription){

                    TaxonName changedName = ((TaxonNameDescription)((DescriptionElementBase)element).getInDescription()).getTaxonName();

                    //check whether the bulk editor is taxon or name bulk editor

                    if (getEditorInput() instanceof TaxonEditorInput){

                        IStructuredSelection sel = getSelection();

                        Object firstElement = sel.getFirstElement();

                        if (firstElement instanceof TaxonBase){

                            getEditorInput().addSaveCandidate((TaxonBase)firstElement);

                        }

                    }else{

                        getEditorInput().addSaveCandidate(changedName);

                    }

                    input.replaceInModel(changedName);

                }else if (((DescriptionElementBase)element).getInDescription() instanceof TaxonDescription){

                    Taxon changedTaxon = ((TaxonDescription)((DescriptionElementBase)element).getInDescription()).getTaxon();

                    getEditorInput().addSaveCandidate(changedTaxon);

                    input.replaceInModel(changedTaxon);

                }else if (((DescriptionElementBase)element).getInDescription() instanceof SpecimenDescription){

                    SpecimenOrObservationBase changedSpecimen = ((SpecimenDescription)((DescriptionElementBase)element).getInDescription()).getDescribedSpecimenOrObservation();

                    getEditorInput().addSaveCandidate(changedSpecimen);

                    input.replaceInModel(changedSpecimen);

                }

            }else if (element instanceof Media && input instanceof MediaEditorInput){

            	getEditorInput().addSaveCandidate((Media)element);

                input.replaceInModel((Media)element);

            }else if (element instanceof Media ) {

                IStructuredSelection sel = getSelection();

                Object firstElement = sel.getFirstElement();

                if (firstElement instanceof TaxonBase){

                    TaxonBase changedTaxon = (TaxonBase)sel.getFirstElement();

                    getEditorInput().addSaveCandidate(changedTaxon);

                    input.replaceInModel(changedTaxon);

                }else if (firstElement instanceof SpecimenOrObservationBase){

                    SpecimenOrObservationBase changedSpecimen = (SpecimenOrObservationBase)sel.getFirstElement();

                    getEditorInput().addSaveCandidate(changedSpecimen);

                    input.replaceInModel(changedSpecimen);

                }

            }else if(element instanceof Group){

                 Group oldGroup = ((GroupEditorInput)input).getEntityFromModel((Group)element);

                 ((GroupEditorInput)input).getSaveUserCandidates().addAll(oldGroup.getMembers());

                 getEditorInput().addSaveCandidate((Group)element);

                 input.replaceInModel((CdmBase) element);

            }else if(element instanceof TaxonName && input instanceof TaxonEditorInput){

                IStructuredSelection sel = this.getSelection();

                TaxonBase taxonBase = null;

                if (sel.getFirstElement() instanceof TaxonBase){

                    taxonBase = HibernateProxyHelper.deproxy(sel.getFirstElement(), TaxonBase.class);

                }

                getEditorInput().addSaveCandidate(taxonBase);

                input.replaceInModel( taxonBase);

            }else if(element instanceof TypeDesignationBase ){

                IStructuredSelection sel = this.getSelection();

                TaxonName name = null;

                TaxonBase taxon = null;

                if (sel.getFirstElement() instanceof TaxonName){

                    name = HibernateProxyHelper.deproxy(sel.getFirstElement(), TaxonName.class);

                }else if (sel.getFirstElement() instanceof TaxonBase) {

                	taxon = HibernateProxyHelper.deproxy(sel.getFirstElement(), TaxonBase.class);

                }

                if (name != null) {

                	getEditorInput().addSaveCandidate(name);

                	input.replaceInModel( name);

                }else {

                	getEditorInput().addSaveCandidate(taxon);

                	input.replaceInModel(taxon);

                }

            }

            else{

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

                input.replaceInModel((CdmBase) element);

            }

        }

        dirty.setDirty(true);

        setSelection(new StructuredSelection(element));

    }

    @Override

    public void forceDirty() {

        dirty.setDirty(true);

    }

    @Override

    public boolean postOperation(Object objectAffectedByOperation) {

        return false;

    }

    @Override

    public boolean onComplete() {

        return false;

    }

    public BulkEditorQuery getLastQuery() {

       return lastQuery;

    }

    public void setLastQuery(BulkEditorQuery lastQuery) {

       this.lastQuery = lastQuery;

    }

    @Override

    public Taxon getTaxon() {

        IStructuredSelection selection = getSelection();

        if(selection.size()==1) {

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

            if(object instanceof Taxon){

                return (Taxon) object;

            }

        }

        return null;

    }

    @Override

    public void update() {

        input.performSearch(lastQuery, getSelection());

    }

    @Override

    public void addOperation(AbstractPostOperation operation) {

        operations.add(operation);

    }

    @Inject

    @Optional

    private void updateView(@UIEventTopic(WorkbenchEventConstants.REFRESH_NAME_EDITOR) List<CdmBase> cdmBases) {

        if (getEditorInput() instanceof TaxonEditorInput){

            for (CdmBase cdmBase: cdmBases){

                if (getEditorInput().getModel().contains(cdmBase)){

                    input.performSearch(lastQuery, getSelection());

                    break;

                }

            }

        }

    }

    @Inject

    @Optional

    private void updatefromDelete(@UIEventTopic(WorkbenchEventConstants.REMOVE_USER) User user) {

        if (input instanceof GroupEditorInput){

            ((GroupEditorInput)input).getSaveUserCandidates().add(user);

        }

    }

    @Override

    public TaxonNode getTaxonNode() {

        return null;

    }

}