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

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

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

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

import org.eclipse.core.runtime.IProgressMonitor;

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.workbench.modeling.ESelectionService;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.PartInitException;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

import eu.etaxonomy.cdm.api.application.CdmChangeEvent;

import eu.etaxonomy.cdm.api.application.CdmChangeEvent.Action;

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.IMultiPageTaxonEditorPage;

import eu.etaxonomy.taxeditor.editor.ISecuredEditor;

import eu.etaxonomy.taxeditor.editor.ITaxonEditor;

import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;

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

import eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor;

import eu.etaxonomy.taxeditor.editor.name.container.AbstractGroupedContainer;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.DataChangeBridge;

import eu.etaxonomy.taxeditor.model.IDataChangeBehavior;

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

/**

 *

 * @author pplitzner

 * @date Aug 24, 2017

 *

 */

public class MultiPageTaxonEditorE4

        implements IPartContentHasFactualData, IConversationEnabled, IPostOperationEnabled, IDirtyMarkable,

        IPartContentHasDetails, IPartContentHasSupplementalData, ISecuredEditor, IPartContentHasMedia, ITaxonEditor {

    /** Constant <code>ID="eu.etaxonomy.taxeditor.editor.taxon"{trunked}</code> */

    public static final String ID = "eu.etaxonomy.taxeditor.editor.taxon"; //$NON-NLS-1$

    private ConversationHolder conversation;

    private IDataChangeBehavior dataChangeBehavior;

    private IUndoContext undoContext;

    private TaxonEditorInputE4 input;

    @Inject

    private ESelectionService selService;

    @Inject

    private MDirtyable dirty;

    private ISelectionChangedListener selectionChangedListener;

    @Inject

    public MultiPageTaxonEditorE4() {

        undoContext = new UndoContext();

    }

    /** {@inheritDoc} */

    @PreDestroy

    public void dispose() {

        input.dispose();

        conversation.unregisterForDataStoreChanges(this);

        conversation.close();

    }

    /** {@inheritDoc} */

    @Override

    protected void addPages() {

        input = getEditorInput();

        conversation = input.getConversationHolder();

        conversation.registerForDataStoreChanges(this);

        try {

            addPage(Page.NAME.getIndex(), new TaxonNameEditor(this),

                    getEditorInput());

        } catch (PartInitException e) {

            MessagingUtils.error(getClass(), e);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void pageChange(int newPageIndex) {

        if(getCurrentPage()==-1){

            return;

        }

        super.pageChange(newPageIndex);

    }

    /** {@inheritDoc} */

    @Persist

    public void doSave(IProgressMonitor monitor) {

        monitor.beginTask(Messages.MultiPageTaxonEditor_SAVING_EDITOR, 4);

        try {

            if (!conversation.isBound()) {

                conversation.bind();

            }

            monitor.worked(1);

            for (IEditorPart editorPage : getPages()) {

                if (editorPage instanceof TaxonNameEditor) {

                    if (((TaxonNameEditor) editorPage).checkForEmptyNames()) {

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

                                Messages.MultiPageTaxonEditor_NO_NAME_SPECIFIED_MESSAGE);

                        return;

                    }

                }

                editorPage.doSave(monitor);

                monitor.worked(1);

            }

            // commit the conversation and start a new transaction immediately

            input.merge();

            conversation.commit(true);

            CdmApplicationState.getCurrentDataChangeService()

            .fireChangeEvent(new CdmChangeEvent(Action.Update, input.getTaxonNode() , MultiPageTaxonEditorE4.class), true);

            monitor.worked(1);

            this.setDirty(false);

            monitor.worked(1);

        } catch (Exception e) {

            setFocus();

            MessagingUtils.operationDialog(this, e, TaxeditorEditorPlugin.PLUGIN_ID,Messages.MultiPageTaxonEditor_SAVING_TAXON, Messages.MultiPageTaxonEditor_SAVING_TAXON_MESSAGE);

            disableEditor(true);

        } finally {

            monitor.done();

        }

    }

    private void disableEditor(boolean isOnError) {

        for (IMultiPageTaxonEditorPage editorPage : getPages()) {

            if(isOnError){

                editorPage.setOnError();

            }else {

                editorPage.setDisabled();

            }

        }

        conversation.unregisterForDataStoreChanges(this);

        conversation.close();

        setDirty(false);

    }

    private void setDirty(boolean dirty) {

        this.dirty.setDirty(dirty);

    }

    public boolean isDirty() {

        return dirty.isDirty();

    }

    public void init(IEditorInput input)

            throws PartInitException {

        if (!(input instanceof TaxonEditorInputE4)) {

            throw new PartInitException(

                    Messages.MultiPageTaxonEditor_INVALID_INPUT);

        }

        this.input = (TaxonEditorInputE4) input;

        setPartName();

    }

    /**

     * Calls <code>MultiPageEditorPart.setPartName(String partName)</code> with

     * text appropriate to the state of the taxon: any taxon that has been saved

     * will by necessity have a name to display; a new taxon should display

     * "New taxon" in the editor tab.

     */

    protected void setPartName() {

        String partName = null;

        TaxonName name = getTaxon().getName();

        if (name != null) {

            partName = name.getTitleCache();

        }

        if (partName == null || partName.equals("")) { //$NON-NLS-1$

            partName = (Messages.MultiPageTaxonEditor_NEW_TAXON);

        }

        //FIXME E4 migrate

//        setPartName(partName);

    }

    /**

     * {@inheritDoc}

     *

     * Editor pages call this in their postOperation to notify the

     * MultiPageTaxonEditor of unsaved changes

     */

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

            setDirty(true);

        }

        if (element instanceof TaxonBase) {

            TaxonNameEditor page = (TaxonNameEditor) getPage(Page.NAME);

            AbstractGroupedContainer container = page.getContainer((TaxonBase) element);

            if (container != null) {

                container.refresh();

            }

        }

        if (element instanceof TaxonRelationship) {

            TaxonNameEditor page = (TaxonNameEditor) getPage(Page.NAME);

            AbstractGroupedContainer container = page.getContainer(((TaxonRelationship) element).getFromTaxon());

            if (container != null) {

                container.refresh();

            }

        }

        //refresh part title

        //TODO: refresh taxon node in taxon navigator

        setPartName();

    }

    @Override

    public void forceDirty() {

        changed(null);

    }

    /**

     * The accepted taxon that is the input for this editor

     *

     * @return the accepted taxon

     */

    @Override

    public Taxon getTaxon() {

        return input.getTaxon();

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    public void setConversationHolder(ConversationHolder conversation) {

        this.conversation = conversation;

    }

    public IUndoContext getUndoContext() {

        return undoContext;

    }

    public void setUndoContext(IUndoContext undoContext) {

        this.undoContext = undoContext;

    }

    /** {@inheritDoc} */

    @Focus

    public void setFocus() {

        // logger.warn("Setting focus to editor");

        // bind the conversation

        getConversationHolder().bind();

        input.bind();

        // pass focus to the active editor page

        //FIXME E4 migrate

//        getActiveEditor().setFocus();

    }

    /** {@inheritDoc} */

    @Override

    public void update(CdmDataChangeMap events) {

        if (dataChangeBehavior == null) {

            dataChangeBehavior = new MultiPageTaxonEditorDataChangeBehaviourE4(this);

        }

        DataChangeBridge.handleDataChange(events, dataChangeBehavior);

    }

    /** {@inheritDoc} */

    @Override

    public boolean postOperation(CdmBase objectAffectedByOperation) {

    		setDirty(true);

        for (IEditorPart editor : this.getPages()) {

            if (editor instanceof IPostOperationEnabled) {

                ((IPostOperationEnabled) editor).postOperation(objectAffectedByOperation);

            } else {

                MessagingUtils.warn(getClass(), Messages.MultiPageTaxonEditor_POST_OP_NOT_ENABLED + editor);

            }

        }

        MessagingUtils.warn(getClass(), Messages.MultiPageTaxonEditor_POST_OP_CALLED);

        return false;

    }

    /**

     * Returns an <code>IEditorPart</code> implementation by type

     *

     * @param page

     *            the page type

     * @return a {@link eu.etaxonomy.taxeditor.editor.IMultiPageTaxonEditorPage}

     *         object.

     */

    public IMultiPageTaxonEditorPage getPage(Page page) {

        for (IEditorPart editor : this.getPages()) {

            if (editor.getClass().equals(page.getClazz())) {

                return (IMultiPageTaxonEditorPage) editor;

            }

        }

        return null;

    }

    /**

     * Return a list of <code>AbstractTaxonEditor</code>s registered with this

     * <code>MultiPageTaxonEditor</code>.

     *

     * @return a {@link java.util.List} object.

     */

    public List<IMultiPageTaxonEditorPage> getPages() {

        ArrayList<IMultiPageTaxonEditorPage> editors = new ArrayList<IMultiPageTaxonEditorPage>();

        for (int i = 0; i < this.getPageCount(); i++) {

            editors.add((IMultiPageTaxonEditorPage) this.getEditor(i));

        }

        return editors;

    }

    /**

     * Refreshes a certain page of the MultipageTaxonEditor

     *

     * @param page

     *            a {@link eu.etaxonomy.taxeditor.editor.Page} object.

     * @return a boolean.

     */

    public boolean redraw(Page page) {

        return redraw(page, true);

    }

    /**

     * Refreshes a certain page of the MultipageTaxonEditor and sets focus to

     * that page

     *

     * @param page

     *            a {@link eu.etaxonomy.taxeditor.editor.Page} object.

     * @param focus

     *            a boolean.

     * @return a boolean.

     */

    public boolean redraw(Page page, boolean focus) {

        IMultiPageTaxonEditorPage editorPage = getPage(page);

        return editorPage != null && editorPage.redraw(focus);

    }

    /**

     * <p>

     * onComplete

     * </p>

     *

     * @return a boolean.

     */

    @Override

    public boolean onComplete() {

        return false;

    }

    /**

     * Reloads the data for this

     */

    public void reload() {

        if (isDirty()) {

            MessagingUtils.warningDialog(Messages.MultiPageTaxonEditor_UNSAVED_DATA, getClass(), Messages.MultiPageTaxonEditor_UNSAVED_DATA_MESSAGE);

        } else {

            TaxonEditorInputE4 input = getEditorInput();

            UUID uuid = input.getTaxonNode().getUuid();

            conversation.clear();

            try {

                TaxonEditorInputE4 newInput = TaxonEditorInputE4.NewInstance(uuid);

                setInput(newInput);

                for (IMultiPageTaxonEditorPage editorPart : getPages()) {

                    editorPart.redraw();

                }

            } catch (Exception e) {

                MessagingUtils.messageDialog(Messages.MultiPageTaxonEditor_REFRESH_ERROR, getClass(), Messages.MultiPageTaxonEditor_REFRESH_ERROR_MESSAGE, e);

            }

        }

    }

    @Override

    public String toString() {

        return String.format("%s[%s]", this.getClass().getSimpleName(), getEditorInput()); //$NON-NLS-1$

    }

    @Override

    public boolean permissionsSatisfied() {

        IEditorPart activeEditor = getActiveEditor();

        if(activeEditor != null && ISecuredEditor.class.isAssignableFrom(activeEditor.getClass())){

            return ((ISecuredEditor)activeEditor).permissionsSatisfied();

        }

        return true;

    }

    @Override

    public boolean canAttachMedia() {

        return true;

    }

    public TaxonEditorInputE4 getEditorInput() {

        return input;

    }

}