package acl2s.plugin.editors;
	
	import java.util.MissingResourceException;
	import java.util.ResourceBundle;
	
	import org.eclipse.core.resources.IEncodedStorage;
	import org.eclipse.core.resources.IStorage;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.OperationCanceledException;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.jobs.IJobManager;
	import org.eclipse.core.runtime.jobs.ISchedulingRule;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.ui.IEditorInput;
	import org.eclipse.ui.IStorageEditorInput;
	import org.eclipse.ui.IWorkbenchPartSite;
	import org.eclipse.ui.IWorkbenchWindow;
	import org.eclipse.ui.texteditor.IDocumentProvider;
	import org.eclipse.ui.texteditor.IElementStateListener;
	import org.eclipse.ui.texteditor.ITextEditor;
	import org.eclipse.ui.texteditor.quickdiff.IQuickDiffReferenceProvider;
	
	/**
	 * Copied from org.eclipse.ui.internal.editors.quickdiff.LastSaveReferenceProvider
	 */
	public class MyQuickDiffRefProvider implements IQuickDiffReferenceProvider, IElementStateListener {
		public static String id = "acl2s.plugin.editors.MyQuickDiffRefProvider";
		
		/** <code>true</code> if the document has been read. */
		private boolean fDocumentRead= false;
		/**
		 * The reference document - might be <code>null</code> even if <code>fDocumentRead</code>
		 * is <code>true</code>.
		 */
		private IDocument fReference= null;
		/**
		 * Our unique id that makes us comparable to another instance of the same
		 * provider. See extension point reference.
		 */
		private String fId;
		/** The current document provider. */
		private IDocumentProvider fDocumentProvider;
		/** The current editor input. */
		private IEditorInput fEditorInput;
		/** Private lock no one else will synchronize on. */
		private final Object fLock= new Object();
		/** The document lock for non-IResources. */
		private final Object fDocumentAccessorLock= new Object();
		/** Document lock state, protected by <code>fDocumentAccessorLock</code>. */
		private boolean fDocumentLocked;
		/**
		 * The progress monitor for a currently running <code>getReference</code>
		 * operation, or <code>null</code>.
		 */
		private IProgressMonitor fProgressMonitor;
		/** The text editor we run upon. */
		private ITextEditor fEditor;
	
		/**
		 * A job to put the reading of file contents into a background.
		 */
		private final class ReadJob extends Job {
	
			/**
			 * Creates a new instance.
			 */
			public ReadJob() {
				super(getString("LastSaveReferenceProvider.LastSaveReferenceProvider.readJob.label")); //$NON-NLS-1$
				setSystem(true);
				setPriority(SHORT);
			}
	
			/**
			 * Calls
			 * {@link MyQuickDiffRefProvider#readDocument(IProgressMonitor, boolean)}
			 * and returns {@link Status#OK_STATUS}.
			 *
			 * {@inheritDoc}
			 *
			 * @param monitor {@inheritDoc}
			 * @return {@link Status#OK_STATUS}
			 */
			protected IStatus run(IProgressMonitor monitor) {
				readDocument(monitor, false);
				return Status.OK_STATUS;
			}
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.quickdiff.IQuickDiffReferenceProvider#getReference(org.eclipse.core.runtime.IProgressMonitor)
		 */
		public IDocument getReference(IProgressMonitor monitor) {
			if (!fDocumentRead)
				readDocument(monitor, true); // force reading it

			return fReference;
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.quickdiff.IQuickDiffReferenceProvider#dispose()
		 */
		public void dispose() {
			IProgressMonitor monitor= fProgressMonitor;
			if (monitor != null) {
				monitor.setCanceled(true);
			}
	
			IDocumentProvider provider= fDocumentProvider;
	

			synchronized (fLock) {
				if (provider != null)
					provider.removeElementStateListener(this);
				fEditorInput= null;
				fDocumentProvider= null;

				fReference= null;
				fDocumentRead= false;
				fProgressMonitor= null;
				fEditor= null;
			}
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.quickdiff.IQuickDiffReferenceProvider#getId()
		 */
		public String getId() {
			return fId;
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.quickdiff.IQuickDiffProviderImplementation#setActiveEditor(org.eclipse.ui.texteditor.ITextEditor)
		 */
		public void setActiveEditor(ITextEditor targetEditor) {
			IDocumentProvider provider= null;
			IEditorInput input= null;
			if (targetEditor != null) {
				provider= targetEditor.getDocumentProvider();
				input= targetEditor.getEditorInput();
			}
	
	
			// dispose if the editor input or document provider have changed
			// note that they may serve multiple editors
			if (provider != fDocumentProvider || input != fEditorInput) {
				dispose();
				synchronized (fLock) {
					fEditor= targetEditor;
					fDocumentProvider= provider;
					fEditorInput= input;
				}
			}
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.quickdiff.IQuickDiffProviderImplementation#isEnabled()
		 */
		public boolean isEnabled() {
			return fEditorInput != null && fDocumentProvider != null;
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.quickdiff.IQuickDiffProviderImplementation#setId(java.lang.String)
		 */
		public void setId(String id) {
			fId= id;
		}
	
		/**
		 * Reads in the saved document into <code>fReference</code>.
		 *
		 * @param monitor a progress monitor, or <code>null</code>
		 * @param force <code>true</code> if the reference document should also
		 *        be read if the current document is <code>null</code>,<code>false</code>
		 *        if it should only be updated if it already existed.
		 */
		private void readDocument(IProgressMonitor monitor, boolean force) {
	
			// protect against concurrent disposal
			IDocumentProvider prov= fDocumentProvider;
			IEditorInput inp= fEditorInput;
			IDocument doc= fReference;
			ITextEditor editor= fEditor;
	
			if (prov instanceof MyDocumentProvider && inp instanceof IStorageEditorInput) {
	
				IStorageEditorInput input= (IStorageEditorInput) inp;
				MyDocumentProvider provider= (MyDocumentProvider) prov;
	
				if (doc == null)
					if (force || fDocumentRead)
						doc = provider.createEmptyDocument();
					else
						return;
	
				IJobManager jobMgr= Job.getJobManager();
	
				try {
					IStorage storage= input.getStorage();
					// check for null for backward compatibility (we used to check before...)
					if (storage == null)
						return;
					fProgressMonitor= monitor;
					ISchedulingRule rule= getSchedulingRule(storage);
	
					// this protects others from not being able to delete the file,
					// and protects ourselves from concurrent access to fReference
					// (in the case there already is a valid fReference)
	
					// one might argue that this rule should already be in the Job
					// description we're running in, however:
					// 1) we don't mind waiting for someone else here
					// 2) we do not take long, or require other locks etc. -> short
					// delay for any other job requiring the lock on file
					try {
						lockDocument(monitor, jobMgr, rule);
	
						String encoding;
						if (storage instanceof IEncodedStorage)
							encoding= ((IEncodedStorage) storage).getCharset();
						else
							encoding= null;
	
						provider.setDocumentContent(doc, input, encoding);
					} finally {
						unlockDocument(jobMgr, rule);
						fProgressMonitor= null;
					}
	
				} catch (CoreException e) {
					return;
				}
	
				if (monitor != null && monitor.isCanceled())
					return;
	
				// update state

				synchronized (fLock) {
					if (fDocumentProvider == provider && fEditorInput == input) {
						// only update state if our provider / input pair has not
						// been updated in between (dispose or setActiveEditor)

						fReference= doc;
						fDocumentRead= true;
						addElementStateListener(editor, prov);
					}
				}
			}
		}
	
		private ISchedulingRule getSchedulingRule(IStorage storage) {
			if (storage instanceof ISchedulingRule)
				return (ISchedulingRule) storage;
			else if (storage != null)
				return (ISchedulingRule) storage.getAdapter(ISchedulingRule.class);
			return null;
		}
	
		/* utility methods */
	
		private void lockDocument(IProgressMonitor monitor, IJobManager jobMgr, ISchedulingRule rule) {
			if (rule != null) {
				jobMgr.beginRule(rule, monitor);
			} else synchronized (fDocumentAccessorLock) {
				while (fDocumentLocked) {
					try {
						fDocumentAccessorLock.wait();
					} catch (InterruptedException e) {
						// nobody interrupts us!
						throw new OperationCanceledException();
					}
				}
				fDocumentLocked= true;
			}
		}
	
		private void unlockDocument(IJobManager jobMgr, ISchedulingRule rule) {
			if (rule != null) {
				jobMgr.endRule(rule);
			} else synchronized (fDocumentAccessorLock) {
				fDocumentLocked= false;
				fDocumentAccessorLock.notifyAll();
			}
		}
	
		/**
		 * Adds this as element state listener in the UI thread as it can otherwise
		 * conflict with other listener additions, since DocumentProvider is not
		 * thread-safe.
		 *
		 * @param editor the editor to get the display from
		 * @param provider the document provider to register as element state listener
		 */
		private void addElementStateListener(ITextEditor editor, final IDocumentProvider provider) {
			// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=66686 and
			// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=56871
	
			Runnable runnable= new Runnable() {
				public void run() {
					synchronized (fLock) {
						if (fDocumentProvider == provider)
							// addElementStateListener adds at most once - no problem to call repeatedly
							provider.addElementStateListener(MyQuickDiffRefProvider.this);
					}
				}
			};
	
			Display display= null;
			if (editor != null) {
				IWorkbenchPartSite site= editor.getSite();
				if (site != null) {
					IWorkbenchWindow window= site.getWorkbenchWindow();
					if (window != null) {
						Shell shell= window.getShell();
						if (shell != null)
							display= shell.getDisplay();
					}
				}
			}
	
			if (display != null && !display.isDisposed())
				display.asyncExec(runnable);
			else
				runnable.run();
		}
		
	
		/* IElementStateListener implementation */
	
		/*
		 * @see org.eclipse.ui.texteditor.IElementStateListener#elementDirtyStateChanged(java.lang.Object, boolean)
		 */
		public void elementDirtyStateChanged(Object element, boolean isDirty) {
			if (!isDirty && element == fEditorInput) {
				// document has been saved or reverted - recreate reference
				new ReadJob().schedule();
			}
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.IElementStateListener#elementContentAboutToBeReplaced(java.lang.Object)
		 */
		public void elementContentAboutToBeReplaced(Object element) {
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.IElementStateListener#elementContentReplaced(java.lang.Object)
		 */
		public void elementContentReplaced(Object element) {
			if (element == fEditorInput) {
				// document has been reverted or replaced
				new ReadJob().schedule();
			}
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.IElementStateListener#elementDeleted(java.lang.Object)
		 */
		public void elementDeleted(Object element) {
		}
	
		/*
		 * @see org.eclipse.ui.texteditor.IElementStateListener#elementMoved(java.lang.Object, java.lang.Object)
		 */
		public void elementMoved(Object originalElement, Object movedElement) {
		}
		
		
		
		
		// MESSAGES
		
		private static final String BUNDLE_NAME= "org.eclipse.ui.internal.editors.quickdiff.QuickDiffMessages";//$NON-NLS-1$
		private static final ResourceBundle RESOURCE_BUNDLE= ResourceBundle.getBundle(BUNDLE_NAME);
	
		private static String getString(String key) {
			try {
				return RESOURCE_BUNDLE.getString(key);
			} catch (MissingResourceException e) {
				return '!' + key + '!';
			}
		}
		/*
		private static ResourceBundle getResourceBundle() {
			return RESOURCE_BUNDLE;
		}
	
		private static String getFormattedString(String key, Object arg) {
			return getFormattedString(key, new Object[] { arg });
		}
	
		private static String getFormattedString(String key, Object[] args) {
			return MessageFormat.format(getString(key), args);
		}
		//*/
	}