import java.io.File;

import org.eclipse.core.runtime.IPath;

	private ContextMementoManager mementoManager;

	private File getContextMementoPath() {

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

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

		return cacheFile.toFile();

	}

	public ContextMementoManager getMementoManager() {

		return mementoManager;

	}

					} finally {

						mementoManager.unlock(context);

//			// TODO: avoid storing with preferences due to bloat?

//			StringWriter writer = new StringWriter();

//			try {

//				rootMemento.save(writer);

//				writeEditorMemento(context, writer.getBuffer().toString());

//			} catch (IOException e) {

//				StatusHandler.log(new Status(IStatus.ERROR, ContextUiPlugin.ID_PLUGIN, "Could not store editor state", //$NON-NLS-1$

//						e));

//			}

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

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

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

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

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

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

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

	private final Map<String, ContextMemento> pending;

	private final File location;

	private FlushJob flushJob;

	private boolean scheduled;

	public ContextMementoManager(File location) {

		Assert.isNotNull(location);

		this.location = location;

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

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

	}

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

		}

	}

	public synchronized ContextMemento lock(IInteractionContext context) {

		if (locked.containsKey(context.getHandleIdentifier())) {

			throw new IllegalStateException(NLS.bind("Memento for \"{0}\" is already locked", //$NON-NLS-1$

					context.getHandleIdentifier()));

		}

		ContextMemento result = pending.remove(context.getHandleIdentifier());

		if (result == null) {

			result = read(context);

		}

		// if reading failed or memento did not exist, start with an empty one

		if (result == null) {

			result = new ContextMemento(context, XMLMemento.createWriteRoot(TAG_CONTEXT_STATE));

		}

		locked.put(context.getHandleIdentifier(), result);

		return result;

	}

	private ContextMemento read(IInteractionContext context) {

		File file = getFile(context);

		if (file.exists()) {

			try {

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

				XMLMemento memento = XMLMemento.createReadRoot(reader);

				return new ContextMemento(context, 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 null;

	}

	private IStatus write(ContextMemento memento) {

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

		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(IInteractionContext context) {

		return new File(location, TasksUtil.encode(context.getHandleIdentifier()));

	}

	public synchronized void unlock(IInteractionContext context) {

		ContextMemento result = locked.remove(context.getHandleIdentifier());

		if (result == null) {

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

					"Failed attempt to unlock memento \"{0}\"", context.getHandleIdentifier()))); //$NON-NLS-1$

			return;

		}

		pending.put(context.getHandleIdentifier(), result);

		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 XMLMemento memento;

	public ContextMemento(IInteractionContext context, XMLMemento memento) {

		Assert.isNotNull(context);

		Assert.isNotNull(memento);

		this.context = context;

		this.memento = memento;

	}

	@Override

	public boolean equals(Object obj) {

		if (!(obj instanceof ContextMemento)) {

			return false;

		}

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

	}

	public IInteractionContext getContext() {

		return context;

	}

	XMLMemento getMemento() {

		return memento;

	}

	public IMemento getMemento(String type) {

		return memento.getChild(type);

	}

	public IMemento createMemento(String type) {

		return memento.createChild(type);

	}

	@Override

	public int hashCode() {

		return context.hashCode();

	}

	public boolean isChanged() {

		return changed;

	}

	public void setChanged(boolean changed) {

		this.changed = changed;

	}

	public void removeMemento(String type) {

		memento.createChild(type);

	}

}