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

import java.util.Iterator;

import java.util.List;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.operation.IRunnableContext;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.Document;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.Position;

import org.eclipse.jface.text.source.Annotation;

import org.eclipse.jface.text.source.IAnnotationModel;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.texteditor.AbstractDocumentProvider;

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

import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

/**

 * Using an <code>IEditorPart</code>, creates a document where each line is associated

 * with an entity. Mapping between document positions and entities is stored in

 * <code>LineAnnotation</code>s in a <code>LineAnnotationModel</code>.

 * <p>

 * Requires:

 * <ul>

 * <li>an <code>IEntityCreator</code> to create entities for new lines;

 * <li>an <code>IEntityPersistenceService</code> for interacting with the persistence layer; and

 * <li>an <code>ILineDisplayStrategy</code> for various visual manifestations of the domain object.

 * </ul>

 *

 * @author p.ciardelli

 * @author n.hoffmann

 * @created 25.06.2009

 * @version 1.0

 */

public class AnnotatedLineDocumentProvider extends AbstractDocumentProvider {

	private IDocument document;

	private LineAnnotationModel annotationModel;

	private IEntityCreator<?> entityCreator;

	private ILineDisplayStrategy lineDisplayStrategy;

	private final IEditorInput input;

	private ConversationHolder conversation;

	/**

	 * @return the conversation

	 */

	public ConversationHolder getConversation() {

		return conversation;

	}

	/**

	 * @param conversation the conversation to set

	 */

	public void setConversation(ConversationHolder conversation) {

		this.conversation = conversation;

	}

	/**

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

	 *

	 * @param input a {@link org.eclipse.ui.IEditorInput} object.

	 */

	public AnnotatedLineDocumentProvider(IEditorInput input){

		this.input = input;

		this.conversation = ((AbstractBulkEditorInput)input).getConversation();

	}

	/** {@inheritDoc} */

	@Override

	public IAnnotationModel getAnnotationModel(Object element) {

		if (element == input) {

			// Create model as necessary

			if (annotationModel == null) {

				annotationModel = new LineAnnotationModel(getLineDisplayStrategy(element));

				annotationModel.setEntityCreator(getEntityCreator(input));

			}

			return annotationModel;

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	protected IAnnotationModel createAnnotationModel(Object element)

			throws CoreException {

		return getAnnotationModel(element);

	}

	/** {@inheritDoc} */

	@Override

	public IDocument getDocument(Object element) {

		return document;

	}

	/** {@inheritDoc} */

	@Override

	protected IDocument createDocument(Object element) throws CoreException {

		if (element instanceof IEditorInput) {

			IEditorInput input = (IEditorInput) element;

			document = new Document("");

//			IAnnotationModel model = getAnnotationModel(element);

			List<?> entityList = getEntityList(element);

			if(entityList != null){

				for (Object entity : entityList) {

					try {

						createAnnotatedLine(input, entity);

					} catch (BadLocationException e) {

						MessagingUtils.error(getClass(), "Problems creating annotated line: ", e);

					}

				}

			}

			return document;

		}

		return null;

	}

	/**

	 * Creates an annotated line at the end of the document associated with the element

	 *

	 * @throws org.eclipse.jface.text.BadLocationException if any.

	 * @param element a {@link java.lang.Object} object.

	 * @param entity a {@link java.lang.Object} object.

	 * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.

	 */

	public LineAnnotation createAnnotatedLine(Object element, Object entity) throws BadLocationException {

		Document document = (Document) getDocument(element);

		ILineDisplayStrategy lineDisplayStrategy = getLineDisplayStrategy(element);

		LineAnnotation annotation = new LineAnnotation(entity, lineDisplayStrategy);

		// Is document zero length, or is last char in document line delimiter?

		int docLength = document.getLength();

		boolean useDelimiter = false;

		if (docLength > 0) {

			if (docLength > 1 && !document.get(docLength - 2, 2).equals(document.getDefaultLineDelimiter())) {

				useDelimiter = true;

			}

		}

		if (useDelimiter) {

			document.replace(docLength, 0, document.getDefaultLineDelimiter());

		}

		String text;

		if (lineDisplayStrategy.isEntityCacheEmpty(entity)) {

			text = lineDisplayStrategy.getEmptyCacheMessage(entity);

		} else {

			text = lineDisplayStrategy.getText(entity);

		}

		text += lineDisplayStrategy.getSupplementalText(entity);

		docLength = document.getLength();

		document.replace(docLength, 0, text);

		Position position = new Position(docLength, text.length());

		IAnnotationModel model = getAnnotationModel(element);

		if(model != null){

			model.addAnnotation(annotation, position);

		}

//		lineDisplayStrategy.addDisplayListener(entity,

//						new EntityListenerImpl((LineAnnotation) annotation, element));

//

		return annotation;

	}

	/**

	 * <p>updateLineFromAnnotation</p>

	 *

	 * @param annotation a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.

	 */

	public void updateLineFromAnnotation(LineAnnotation annotation) {

		IAnnotationModel model = getAnnotationModel(input);

		IDocument document = getDocument(input);

		ILineDisplayStrategy lineDisplay = getLineDisplayStrategy(input);

		Object entity = annotation.getEntity();

		String text = "";

		if (getLineDisplayStrategy(input).isEntityCacheEmpty(entity)) {

			text = lineDisplay.getEmptyCacheMessage(entity);

		} else {

			text = lineDisplay.getText(entity);

		}

		text += lineDisplay.getSupplementalText(entity);

		try {

			if (model.getPosition(annotation) == null) {

				return;

			}

			int offset = model.getPosition(annotation).getOffset();

			int line = document.getLineOfOffset(offset);

			int lineLength = document.getLineLength(document.getLineOfOffset(offset));

			if (document.getLineDelimiter(line) != null) {

				lineLength -= document.getLineDelimiter(line).length();

			}

			document.replace(offset, lineLength, text);

		} catch (BadLocationException e) {

			MessagingUtils.error(getClass(), "Problem updating annotated line: " ,e);

		}

	}

	/**

	 * @param element

	 * @return

	 */

	private List<?> getEntityList(Object element) {

		if (element instanceof AbstractBulkEditorInput) {

			return ((AbstractBulkEditorInput)element).getModel();

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	protected void doSaveDocument(IProgressMonitor monitor, Object element,

			IDocument document, boolean overwrite) throws CoreException {

		if (element instanceof AbstractBulkEditorInput) {

			IEntityPersistenceService persistenceService = (AbstractBulkEditorInput) element;

			// Get new containers from annotation model

			LineAnnotationModel model = (LineAnnotationModel) getAnnotationModel(element);

			Iterator iterator = model.getAnnotationIterator();

			if (!this.conversation.isBound()){

				this.conversation.bind();

			}

			while (iterator.hasNext()) {

				Annotation annotation = (Annotation) iterator.next();

				if (annotation instanceof IEntityContainer<?>) {

					IEntityContainer<?> container = (IEntityContainer<?>) annotation;

					if (container.isMarkedAsNew() || container.isDirty()) {

						Object entity = persistenceService.save(container.getEntity()); // save

						container.setEntity(entity);

						container.setDirty(false);

						container.markAsNew(false);

					}

				}

			}

			this.conversation.commit(true);

			for (LineAnnotation annotation : model.getDeletedAnnotations()) {

				if (annotation.isMarkedAsNew()) {

					continue;

				}

				if (annotation.isMarkedAsMerged()) {

					persistenceService.merge(annotation.getEntity(), annotation.getMergeTarget()); //  merge

				}

				if (annotation.isMarkedAsDeleted()) {

					try {

						persistenceService.delete(annotation.getEntity(), annotation.getDeleteConfigurator());

					} catch (ReferencedObjectUndeletableException e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

					} //  merge

				}

				else {

					// TODO clarify w AM whether this needs to be executed on merged objects

					//persistenceService.delete(annotation.getEntity()); // delete

				}

			}

			model.clearDeletedAnnotations();

		}

	}

	/** {@inheritDoc} */

	@Override

	protected IRunnableContext getOperationRunner(IProgressMonitor monitor) {

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public boolean isModifiable(Object element) {

		return true;

	}

	/** {@inheritDoc} */

	@Override

	public boolean isReadOnly(Object element) {

		// enables copy & paste

		return false;

	}

	/**

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

	 *

	 * @param element a {@link java.lang.Object} object.

	 * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.IEntityCreator} object.

	 */

	public IEntityCreator<?> getEntityCreator(IEditorInput input) {

		if (input instanceof AbstractBulkEditorInput) {

			entityCreator = ((AbstractBulkEditorInput) input).getEntityCreator();

		}

		return entityCreator;

	}

	/**

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

	 *

	 * @param lineDisplayStrategy a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.ILineDisplayStrategy} object.

	 * @param element a {@link java.lang.Object} object.

	 */

	public void setLineDisplayStrategy(

			ILineDisplayStrategy lineDisplayStrategy, Object element) {

		if (element instanceof IEditorInput) {

			this.lineDisplayStrategy = lineDisplayStrategy;

		}

	}

	/**

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

	 *

	 * @param element a {@link java.lang.Object} object.

	 * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.ILineDisplayStrategy} object.

	 */

	protected ILineDisplayStrategy getLineDisplayStrategy(Object element) {

		if (element instanceof IEditorInput) {

			Assert.isNotNull(lineDisplayStrategy, "No ILineDisplayStrategy set for this element.");

			return lineDisplayStrategy;

		}

		return null;

	}

	/**

	 * <p>removeAnnotatedLine</p>

	 *

	 * @param entity a {@link java.lang.Object} object.

	 */

	public void removeAnnotatedLine(Object entity){

		LineAnnotation annotation = (LineAnnotation) annotationModel.getAnnotation(entity);

		removeAnnotatedLine(annotation);

	}

	/**

	 * <p>removeAnnotatedLine</p>

	 *

	 * @param lineno a int.

	 * @param element a {@link java.lang.Object} object.

	 */

	public void removeAnnotatedLine(Object element, int lineno) {

		LineAnnotation annotation = (LineAnnotation) annotationModel.getAnnotationAtLine(lineno, document);

		removeAnnotatedLine(annotation);

	}

	/**

	 * <p>removeAnnotatedLine</p>

	 *

	 * @param annotation a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.

	 */

	public void removeAnnotatedLine(LineAnnotation annotation) {

		if (annotation != null) {

			Document document = (Document) getDocument(input);

			LineAnnotationModel model = (LineAnnotationModel) getAnnotationModel(input);

			Position position = model.getPosition(annotation);

			int offset = position.getOffset();

			int length = position.getLength();

			Object entity = annotation.getEntity();

			//annotation.markAsDeleted(configurator);

			model.removeAnnotation(annotation);

			// Immediately followed by a delimiter?

			int annotationEnd = offset + length;

			try {

				if (document.getLength() > annotationEnd + 1 && document.get(annotationEnd, 2).equals(document.getDefaultLineDelimiter())) {

					length += 2;

				}

			} catch (BadLocationException e1) {

				MessagingUtils.error(getClass(), "Problems removing annotated line", e1);

			}

			try {

				document.replace(offset, length, "");

			} catch (BadLocationException e) {

				MessagingUtils.error(getClass(), "Problems removing annotated line", e);

			}

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.texteditor.AbstractDocumentProvider#changed(java.lang.Object)

	 */

	/** {@inheritDoc} */

	@Override

	public void changed(Object entity) {

		LineAnnotation annotation = (LineAnnotation) annotationModel.getAnnotation(entity);

		if(annotation != null){

			annotation.setDirty(true);

			updateLineFromAnnotation(annotation);

		}

	}

}