import java.io.File;

import java.io.StringReader;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.preferences.IEclipsePreferences;

import org.eclipse.core.runtime.preferences.InstanceScope;

import org.eclipse.mylyn.internal.context.core.InteractionContext;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.WorkbenchException;

import org.eclipse.ui.XMLMemento;

import org.eclipse.ui.preferences.ScopedPreferenceStore;

import org.osgi.service.prefs.BackingStoreException;

	private static final String EDITOR_MEMENTO_PREFS_PREFIX = "editors.task."; //$NON-NLS-1$

	private ContextMementoManager mementoManager;

			mementoManager = new ContextMementoManager(ContextCore.getContextManager(), getContextMementoPath());

			mementoManager.start();

	// XXX verify this works...delete preferences?

	private void migrateContextMementos(ContextMementoManager mementoManager) {

		ScopedPreferenceStore preferenceStore = new ScopedPreferenceStore(new InstanceScope(),

				"org.eclipse.mylyn.resources.ui"); //$NON-NLS-1$

		IEclipsePreferences[] nodes = preferenceStore.getPreferenceNodes(false);

		if (nodes.length > 0) {

			String[] keys;

			try {

				keys = nodes[0].keys();

				for (String key : keys) {

					if (key.startsWith(EDITOR_MEMENTO_PREFS_PREFIX)) {

						String contextHandle = key.substring(EDITOR_MEMENTO_PREFS_PREFIX.length());

						String mementoString = preferenceStore.getString(key);

						if (mementoString != null && !mementoString.trim().equals("")) { //$NON-NLS-1$

							try {

								IMemento oldMemento = XMLMemento.createReadRoot(new StringReader(mementoString));

								InteractionContext context = new InteractionContext(contextHandle,

										ContextCore.getCommonContextScaling());

								ContextMemento state = mementoManager.createMemento(context, contextHandle);

								IMemento newMemnto = state.createMemento("editors");

								newMemnto.putMemento(oldMemento);

								mementoManager.write(state);

							} catch (WorkbenchException e) {

								StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,

										"Migration of editor memento failed", e)); //$NON-NLS-1$

							}

						}

					}

				}

			} catch (BackingStoreException e) {

				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,

						"Migration of editor mementos failed", e)); //$NON-NLS-1$

			}

		}

	}

	private File getContextMementoPath() {

		IPath stateLocation = Platform.getStateLocation(getBundle());

		IPath cacheFile = stateLocation.append("workbench"); //$NON-NLS-1$

		return cacheFile.toFile();

	}

	public ContextMementoManager getMementoManager() {

		return mementoManager;

	}

			IMemento rootMemento = state.createMemento("editors");

/*******************************************************************************

 * Copyright (c) 2004, 2008 Tasktop Technologies and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Tasktop Technologies - initial API and implementation

 *******************************************************************************/

package org.eclipse.mylyn.internal.context.ui;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.CopyOnWriteArrayList;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.MultiStatus;

import org.eclipse.core.runtime.SafeRunner;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.util.SafeRunnable;

import org.eclipse.mylyn.commons.core.StatusHandler;

import org.eclipse.mylyn.context.core.AbstractContextListener;

import org.eclipse.mylyn.context.core.ContextChangeEvent;

import org.eclipse.mylyn.context.core.IInteractionContext;

import org.eclipse.mylyn.context.core.IInteractionContextManager;

import org.eclipse.mylyn.internal.provisional.tasks.core.TasksUtil;

import org.eclipse.osgi.util.NLS;

import org.eclipse.ui.WorkbenchException;

import org.eclipse.ui.XMLMemento;

/**

 * @author Steffen Pingel

 */

public class ContextMementoManager {

	private class ContextListener extends AbstractContextListener {

		@Override

		public void contextChanged(ContextChangeEvent event) {

			switch (event.getEventKind()) {

			case ACTIVATED:

				restoreState(event.getContext());

				break;

			case DEACTIVATED:

				saveState(event.getContext());

				break;

			case CLEARED:

				// use the handle since the context is null when it is cleared

				// bug 255588

				clearState(event.getContextHandle(), event.isActiveContext());

				break;

			}

		}

	}

	private class FlushJob extends Job {

		public FlushJob() {

			super("Flush context mementos"); //$NON-NLS-1$

		}

		@Override

		protected IStatus run(IProgressMonitor monitor) {

			ContextMementoManager.this.flushPending();

			return Status.OK_STATUS;

		}

	}

	private static final String TAG_CONTEXT_STATE = "ContextState"; //$NON-NLS-1$

	private static final long FLUSH_DELAY = 500;

	private static final String CHARSET = "UTF-8"; //$NON-NLS-1$

	private final Map<String, ContextMemento> pending;

	private final File location;

	private FlushJob flushJob;

	private boolean scheduled;

	private final IInteractionContextManager contextManager;

	private final ContextListener contextListener;

	private final List<ContextMementoListener> listeners;

	public ContextMementoManager(IInteractionContextManager contextManager, File location) {

		Assert.isNotNull(contextManager);

		Assert.isNotNull(location);

		this.contextManager = contextManager;

		this.location = location;

		this.contextListener = new ContextListener();

		this.pending = new HashMap<String, ContextMemento>();

		this.listeners = new CopyOnWriteArrayList<ContextMementoListener>();

	}

	public void addMementoListener(ContextMementoListener listener) {

		if (listeners.contains(listener)) {

			throw new IllegalStateException("listener already added"); //$NON-NLS-1$

		}

		listeners.add(listener);

	}

	public void removeMementoListener(ContextMementoListener listener) {

		listeners.remove(listener);

	}

	public void clearState(final String contextHandle, final boolean isActiveContext) {

		final ContextMemento memento = createMemento(null, contextHandle);

		for (final ContextMementoListener listener : listeners) {

			SafeRunner.run(new SafeRunnable() {

				public void run() throws Exception {

					listener.clearState(contextHandle, isActiveContext);

				}

				@Override

				public void handleException(Throwable e) {

					StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,

							"Unexpected error processing context event", e)); //$NON-NLS-1$

					removeMementoListener(listener);

				}

			});

		}

		delete(memento);

	}

	public void saveState(IInteractionContext context) {

		final ContextMemento memento = createMemento(context, context.getHandleIdentifier());

		for (final ContextMementoListener listener : listeners) {

			SafeRunner.run(new SafeRunnable() {

				public void run() throws Exception {

					listener.saveState(memento);

				}

				@Override

				public void handleException(Throwable e) {

					StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,

							"Unexpected error processing context event", e)); //$NON-NLS-1$

					removeMementoListener(listener);

				}

			});

		}

		if (memento.isChanged()) {

			writeLater(memento);

		}

	}

	ContextMemento createMemento(IInteractionContext context, String contextHandle) {

		return new ContextMemento(context, contextHandle, XMLMemento.createWriteRoot(TAG_CONTEXT_STATE));

	}

	public void restoreState(IInteractionContext context) {

		final ContextMemento memento = read(context);

		for (final ContextMementoListener listener : listeners) {

			SafeRunner.run(new SafeRunnable() {

				public void run() throws Exception {

					listener.restoreState(memento);

				}

				@Override

				public void handleException(Throwable e) {

					StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN,

							"Unexpected error processing context event", e)); //$NON-NLS-1$

					removeMementoListener(listener);

				}

			});

		}

	}

	public synchronized void start() {

		contextManager.addListener(contextListener);

	}

	public synchronized void stop() {

		contextManager.removeListener(contextListener);

	}

	public synchronized void flushPending() {

		MultiStatus status = new MultiStatus(ContextUiPlugin.ID_PLUGIN, 0,

				"Failed to save context workbench state", null); //$NON-NLS-1$

		for (ContextMemento memento : pending.values()) {

			if (memento.isChanged()) {

				IStatus result = write(memento);

				status.add(result);

			}

		}

		pending.clear();

		if (!status.isOK()) {

			StatusHandler.log(status);

		}

	}

	private ContextMemento read(IInteractionContext context) {

		File file = getFile(context.getHandleIdentifier());

		if (file.exists()) {

			try {

				BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), CHARSET));

				XMLMemento memento = XMLMemento.createReadRoot(reader);

				return new ContextMemento(context, context.getHandleIdentifier(), memento);

			} catch (IOException e) {

				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(

						"Failed to read context memento from \"{0}\"", file.getAbsolutePath()), e)); //$NON-NLS-1$

			} catch (WorkbenchException e) {

				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(

						"Failed to read context memento from \"{0}\"", file.getAbsolutePath()), e)); //$NON-NLS-1$

			}

		}

		return createMemento(context, context.getHandleIdentifier());

	}

	IStatus write(ContextMemento memento) {

		File file = getFile(memento.getContextHandle());

		if (!file.getParentFile().exists()) {

			file.getParentFile().mkdirs();

		}

		try {

			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), CHARSET));

			try {

				(memento.getMemento()).save(writer);

			} finally {

				writer.close();

			}

		} catch (IOException e) {

			return new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(

					"Failed to write context memento to \"{0}\"", file.getAbsolutePath()), e); //$NON-NLS-1$

		}

		return Status.OK_STATUS;

	}

	private File getFile(String contextHandle) {

		return new File(location, TasksUtil.encode(contextHandle));

	}

	public synchronized void delete(ContextMemento memento) {

		String contextHandle = memento.getContextHandle();

		pending.remove(contextHandle);

		File file = getFile(contextHandle);

		if (file != null && file.exists()) {

			boolean succeeded = file.delete();

			if (!succeeded) {

				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, NLS.bind(

						"Unable to remove the editor memento \"{0}\"", file.getAbsolutePath()))); //$NON-NLS-1$

			}

		}

	}

	public synchronized void writeLater(ContextMemento memento) {

		pending.put(memento.getContextHandle(), memento);

		schedule();

	}

	private synchronized void schedule() {

		if (!scheduled) {

			if (flushJob == null) {

				flushJob = new FlushJob();

			}

			flushJob.schedule(FLUSH_DELAY);

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2004, 2008 Tasktop Technologies and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Tasktop Technologies - initial API and implementation

 *******************************************************************************/

package org.eclipse.mylyn.internal.context.ui;

import org.eclipse.core.runtime.Assert;

import org.eclipse.mylyn.context.core.IInteractionContext;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.XMLMemento;

/**

 * Stores workspace specific settings for a context.

 * 

 * @author Steffen Pingel

 */

public class ContextMemento {

	private boolean changed;

	private final IInteractionContext context;

	private final String contextHandle;

	private final XMLMemento memento;

	public ContextMemento(IInteractionContext context, String contextHandle, XMLMemento memento) {

		Assert.isNotNull(memento);

		this.context = context;

		this.memento = memento;

		this.contextHandle = contextHandle;

	}

	// XXX equals and hashcode should probably use the handle to determine equality

	@Override

	public boolean equals(Object obj) {

		if (!(obj instanceof ContextMemento)) {

			return false;

		}

		return context.equals(((ContextMemento) obj).context);

	}

	@Override

	public int hashCode() {

		return context.hashCode();

	}

	public String getContextHandle() {

		return contextHandle;

	}

	public IInteractionContext getContext() {

		return context;

	}

	XMLMemento getMemento() {

		return memento;

	}

	public IMemento getMemento(String type) {

		return memento.getChild(type);

	}

	public IMemento createMemento(String type) {

		changed = true;

		return memento.createChild(type);

	}

	public boolean isChanged() {

		return changed;

	}

	public void removeMemento(String type) {

		memento.createChild(type);

	}

}

/*******************************************************************************

 * Copyright (c) 2004, 2008 Tasktop Technologies and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Tasktop Technologies - initial API and implementation

 *******************************************************************************/

package org.eclipse.mylyn.internal.context.ui;

/**

 * @author Steffen Pingel

 */

public abstract class ContextMementoListener {

	public abstract void clearState(String contextHandle, boolean isActiveContext);

	public abstract void restoreState(ContextMemento memento);

	public abstract void saveState(ContextMemento memento);

}