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;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

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

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

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.forms.editor.FormEditor;

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.model.DataChangeBridge;

import eu.etaxonomy.taxeditor.model.IDataChangeBehavior;

import eu.etaxonomy.taxeditor.model.IDirtyMarkableSelectionProvider;

import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;

import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;

/**

 *

 * Generates the tabbed editor with <code>TaxonNameEditor</code> on top and tabs for

 *  "Descriptions", "Concepts", "Geography", etc.

 *

 * @author p.ciardelli

 * @author n.hoffmann

 * @created 15.05.2008

 * @version 1.0

 */

public class MultiPageTaxonEditor extends FormEditor implements IConversationEnabled, IPostOperationEnabled, IDirtyMarkableSelectionProvider, IPartContentHasDetails {	

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

	public static final String ID = "eu.etaxonomy.taxeditor.editor.taxon";

	private boolean dirty;

	private ConversationHolder conversation;

	private IDataChangeBehavior dataChangeBehavior;

	private IUndoContext undoContext;

	private TaxonEditorInput input;

	/**

	 * <p>Constructor for MultiPageTaxonEditor.</p>

	 */

	public MultiPageTaxonEditor() {

		super();		

		undoContext = new UndoContext();

	}

	/** {@inheritDoc} */

	@Override

	public void dispose() {

		conversation.unregisterForDataStoreChanges(this);

		conversation.close();

		super.dispose();		

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.forms.editor.FormEditor#addPages()

	 */

	/** {@inheritDoc} */

	@Override

	protected void addPages() {

		input = (TaxonEditorInput) getEditorInput();

		conversation = input.getConversationHolder();

		conversation.registerForDataStoreChanges(this);

		try {

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

//			setPageText(Page.NAME.getIndex(), Page.NAME.getTitle());

			// TODO lazy create

//			addPage(Page.DESCRIPTIVE.getIndex(), new TaxonDescriptionTreeEditor(this), getEditorInput());

//			setPageText(Page.DESCRIPTIVE.getIndex(), Page.DESCRIPTIVE.getTitle());

//			EditorUtil.showPropertySheet();

		} catch (PartInitException e) {

			EditorUtil.error(getClass(), e);

		}

	}

	/** {@inheritDoc} */

	@Override

	public void doSave(IProgressMonitor monitor) {

		monitor.beginTask("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(EditorUtil.getShell(), "No Name Specified", "An attempt was made to save a taxon or synonym with " +

						"an empty name. Operation was cancelled.");

						return;

					}

				}

				editorPage.doSave(monitor);

				monitor.worked(1);

			}

			// commit the conversation and start a new transaction immediately

			conversation.commit(true);

			monitor.worked(1);

			this.setDirty(false);

			monitor.worked(1);

		}catch(Exception e){

			EditorUtil.errorDialog("An error occurred while saving", getClass(), "An error occurred while saving the editor. Please close and reopen the taxon again.", e);

			disableEditor();

		}finally{

			monitor.done();

		}

	}

	private void disableEditor() {

		for(IMultiPageTaxonEditorPage editorPage : getPages()){

			editorPage.setDisabled();

		}

		setDirty(false);

		getSite().getSelectionProvider().setSelection(new StructuredSelection());

		getSite().setSelectionProvider(null);

	}

	private void setDirty(boolean dirty) {

		this.dirty = dirty;

		firePropertyChange(PROP_DIRTY);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.part.MultiPageEditorPart#isDirty()

	 */

	/**

	 * <p>isDirty</p>

	 *

	 * @return a boolean.

	 */

	public boolean isDirty() {

		return dirty;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.forms.editor.FormEditor#editorDirtyStateChanged()

	 */

	/** {@inheritDoc} */

	@Override

	public void editorDirtyStateChanged() {

		dirty = true;

		super.editorDirtyStateChanged();

	}

	/**

	 * {@inheritDoc}

	 *

	 * Checks whether nested editors are calling <code>firePropertyChange(PROP_DIRTY)</code>

	 * to signal an edit has taken place before passing property change along to

	 * <code>super.handlePropertyChange(int propertyId)</code>.

	 */

	/* (non-Javadoc)

	 * @see org.eclipse.ui.part.MultiPageEditorPart#handlePropertyChange(int)

	 */

	protected void handlePropertyChange(int propertyId) {

		if (propertyId == PROP_DIRTY) {

			setDirty(true);

		}

		super.handlePropertyChange(propertyId);

	}

	/** {@inheritDoc} */

	@Override

	public void doSaveAs() {}

	/** {@inheritDoc} */

	@Override

	public boolean isSaveAsAllowed() {

		return false;

	}

	/** {@inheritDoc} */

	@Override

	public void init(IEditorSite site, IEditorInput input) throws PartInitException {

		if (!(input instanceof TaxonEditorInput))

			throw new PartInitException(

					"Invalid Input: Must be TaxonEditorInput");

		this.input = (TaxonEditorInput) input;

//		try {

//			// Listen for name changes, 

//			//  change tab for this taxon editor accordingly

//			getTaxon().addPropertyChangeListener("name",

//					new PropertyChangeListener() {

//						public void propertyChange(PropertyChangeEvent e) {

//							setPartName();

//						}

//					});

//		} catch (NullPointerException e) {

//			EditorUtil.warn(getClass(), "Caught an NPE while initing an editor. This is most " +

//					"likely due to the unsuccesful attempt to restore the former " +

//					"state of the application. We ignore this because the workbench " +

//					"will simply be reset.");

//		}

		setPartName();

		super.init(site, input);

	}

    /**

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

    	TaxonNameBase<?, ?> name = getTaxon().getName();

    	if (name != null) {

    		partName = name.getTitleCache();

    	}

    	if (partName == null || partName.equals("")) {

    		partName = ("New taxon");

    	}

        setPartName(partName);

    }

    /**

     * {@inheritDoc}

     *

     * Editor pages call this in their postOperation to notify the MultiPageTaxonEditor

     * of unsaved changes

     */

    public void changed(Object element) {

//    	setDirty(true);

		dirty = true;

		super.editorDirtyStateChanged();

		if(element instanceof TaxonBase){

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

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

			if(container != null){

				container.refresh();

			}

		}

    }

    /**

     * The accepted taxon that is the input for this editor

     *

     * @return the accepted taxon

     */

    public Taxon getTaxon(){

    	return input.getTaxon();

    }

    /*

     * (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()

     */

	/**

	 * <p>getConversationHolder</p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.

	 */

	public ConversationHolder getConversationHolder() {

		return conversation;

	}

	/**

	 * <p>setConversationHolder</p>

	 *

	 * @param conversation a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.

	 */

	public void setConversationHolder(ConversationHolder conversation){

		this.conversation = conversation;

	}

	/**

	 * <p>Getter for the field <code>undoContext</code>.</p>

	 *

	 * @return a {@link org.eclipse.core.commands.operations.IUndoContext} object.

	 */

	public IUndoContext getUndoContext() {

		return undoContext;

	}

	/**

	 * <p>Setter for the field <code>undoContext</code>.</p>

	 *

	 * @param undoContext a {@link org.eclipse.core.commands.operations.IUndoContext} object.

	 */

	public void setUndoContext(IUndoContext undoContext) {

		this.undoContext = undoContext;

	}

	/** {@inheritDoc} */

	@Override

	public void setFocus(){

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

		// bind the conversation

		getConversationHolder().bind();

		// pass focus to the active editor page

		getActiveEditor().setFocus();

	}

	/*

	 * (non-Javadoc)

	 * @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostCrudObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmCrudEvent)

	 */

	/** {@inheritDoc} */

	public void update(CdmDataChangeMap events) {

		if(dataChangeBehavior == null){

			dataChangeBehavior = new MultiPageTaxonEditorDataChangeBehaviour(this);

		}

		DataChangeBridge.handleDataChange(events, dataChangeBehavior);

	}

	/*

	 * (non-Javadoc)

	 * @see eu.etaxonomy.taxeditor.store.operations.IPostOperationEnabled#postOperation()

	 */

	/** {@inheritDoc} */

	public boolean postOperation(CdmBase objectAffectedByOperation) {

		setDirty(true);

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

			if (editor instanceof IPostOperationEnabled) {

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

			} else {

				EditorUtil.warn(getClass(), "postOperation not enabled for editor " + editor);

			}

		}

		EditorUtil.warn(getClass(), "postOperation called on MultiPageTaxonEditor. Can you make it more specific?");

		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.

	 */

	public boolean onComplete() {

		return false;

	}

	/**

	 * Reloads the data for this 

	 */

	public void reload() {

		if(isDirty()){

			EditorUtil.warningDialog("Editor has unsaved data", getClass(), "This editor can not be " +

					"refreshed because it contains unsaved data. Refreshing " +

					"this editor would discard the changes. Please save this editor, " +

					"close and reopen it manually in order to get the latest content");

		}else{

			TaxonEditorInput input = (TaxonEditorInput) getEditorInput();

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

			conversation.clear();

			try {

				TaxonEditorInput newInput = TaxonEditorInput.NewInstance(uuid);

				setInput(newInput);

				for(IMultiPageTaxonEditorPage editorPart : getPages()){

					editorPart.redraw();

				}

			} catch (Exception e) {

				EditorUtil.errorDialog("Error refreshing editor", getClass(), "Could not refresh this editor", e);

			}

		}

	}

}