taverna-workbench-file-impl/src/main/java/net/sf/taverna/t2/workbench/file/impl/FileManagerImpl.java - incubator-taverna-workbench - Git at Google

 /*******************************************************************************
  * Copyright (C) 2007-2010 The University of Manchester
  *
  *  Modifications to the initial code base are copyright of their
  *  respective authors, or their employers as appropriate.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public License
  *  as published by the Free Software Foundation; either version 2.1 of
  *  the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful, but
  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  ******************************************************************************/
 package net.sf.taverna.t2.workbench.file.impl;

 import static java.awt.GraphicsEnvironment.isHeadless;
 import static java.util.Collections.singleton;
 import static javax.swing.SwingUtilities.invokeAndWait;
 import static javax.swing.SwingUtilities.isEventDispatchThread;

 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Set;

 import javax.swing.filechooser.FileFilter;

 import net.sf.taverna.t2.lang.observer.MultiCaster;
 import net.sf.taverna.t2.lang.observer.Observable;
 import net.sf.taverna.t2.lang.observer.Observer;
 import net.sf.taverna.t2.workbench.edits.EditManager;
 import net.sf.taverna.t2.workbench.edits.EditManager.AbstractDataflowEditEvent;
 import net.sf.taverna.t2.workbench.edits.EditManager.EditManagerEvent;
 import net.sf.taverna.t2.workbench.file.DataflowInfo;
 import net.sf.taverna.t2.workbench.file.DataflowPersistenceHandler;
 import net.sf.taverna.t2.workbench.file.FileManager;
 import net.sf.taverna.t2.workbench.file.FileType;
 import net.sf.taverna.t2.workbench.file.events.ClosedDataflowEvent;
 import net.sf.taverna.t2.workbench.file.events.ClosingDataflowEvent;
 import net.sf.taverna.t2.workbench.file.events.FileManagerEvent;
 import net.sf.taverna.t2.workbench.file.events.OpenedDataflowEvent;
 import net.sf.taverna.t2.workbench.file.events.SavedDataflowEvent;
 import net.sf.taverna.t2.workbench.file.events.SetCurrentDataflowEvent;
 import net.sf.taverna.t2.workbench.file.exceptions.OpenException;
 import net.sf.taverna.t2.workbench.file.exceptions.OverwriteException;
 import net.sf.taverna.t2.workbench.file.exceptions.SaveException;
 import net.sf.taverna.t2.workbench.file.exceptions.UnsavedException;

 import org.apache.log4j.Logger;

 import uk.org.taverna.scufl2.api.common.Scufl2Tools;
 import uk.org.taverna.scufl2.api.container.WorkflowBundle;
 import uk.org.taverna.scufl2.api.core.Workflow;
 import uk.org.taverna.scufl2.api.profiles.Profile;

 /**
  * Implementation of {@link FileManager}
  *
  * @author Stian Soiland-Reyes
  */
 public class FileManagerImpl implements FileManager {
 	private static Logger logger = Logger.getLogger(FileManagerImpl.class);
 	private static int nameIndex = 1;

 	/**
 	 * The last blank workflowBundle created using #newDataflow() until it has
 	 * been changed - when this variable will be set to null again. Used to
 	 * automatically close unmodified blank workflowBundles on open.
 	 */
 	private WorkflowBundle blankWorkflowBundle = null;
 	@SuppressWarnings("unused")
 	private EditManager editManager;
 	private EditManagerObserver editManagerObserver = new EditManagerObserver();
 	protected MultiCaster<FileManagerEvent> observers = new MultiCaster<>(this);
 	/**
 	 * Ordered list of open WorkflowBundle
 	 */
 	private LinkedHashMap<WorkflowBundle, OpenDataflowInfo> openDataflowInfos = new LinkedHashMap<>();
 	private DataflowPersistenceHandlerRegistry dataflowPersistenceHandlerRegistry;
 	private Scufl2Tools scufl2Tools = new Scufl2Tools();
 	private WorkflowBundle currentWorkflowBundle;

 	public DataflowPersistenceHandlerRegistry getPersistanceHandlerRegistry() {
 		return dataflowPersistenceHandlerRegistry;
 	}

 	public FileManagerImpl(EditManager editManager) {
 		this.editManager = editManager;
 		editManager.addObserver(editManagerObserver);
 	}

 	/**
 	 * Add an observer to be notified of {@link FileManagerEvent}s, such as
 	 * {@link OpenedDataflowEvent} and {@link SavedDataflowEvent}.
 	 *
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void addObserver(Observer<FileManagerEvent> observer) {
 		observers.addObserver(observer);
 	}

 	@Override
 	public boolean canSaveWithoutDestination(WorkflowBundle workflowBundle) {
 		OpenDataflowInfo dataflowInfo = getOpenDataflowInfo(workflowBundle);
 		if (dataflowInfo.getSource() == null)
 			return false;
 		Set<?> handlers = getPersistanceHandlerRegistry()
 				.getSaveHandlersForType(
 						dataflowInfo.getFileType(),
 						dataflowInfo.getDataflowInfo().getCanonicalSource()
 								.getClass());
 		return !handlers.isEmpty();
 	}

 	@Override
 	public boolean closeDataflow(WorkflowBundle workflowBundle,
 			boolean failOnUnsaved) throws UnsavedException {
 		if (workflowBundle == null)
 			throw new NullPointerException("Dataflow can't be null");
 		ClosingDataflowEvent message = new ClosingDataflowEvent(workflowBundle);
 		observers.notify(message);
 		if (message.isAbortClose())
 			return false;
 		if ((failOnUnsaved && getOpenDataflowInfo(workflowBundle).isChanged()))
 			throw new UnsavedException(workflowBundle);
 		if (workflowBundle.equals(getCurrentDataflow())) {
 			// We'll need to change current workflowBundle
 			// Find best candidate to the left or right
 			List<WorkflowBundle> workflowBundles = getOpenDataflows();
 			int openIndex = workflowBundles.indexOf(workflowBundle);
 			if (openIndex == -1)
 				throw new IllegalArgumentException("Workflow was not opened "
 						+ workflowBundle);

 			if (openIndex > 0)
 				setCurrentDataflow(workflowBundles.get(openIndex - 1));
 			else if (openIndex == 0 && workflowBundles.size() > 1)
 				setCurrentDataflow(workflowBundles.get(1));
 			else
 				// If it was the last one, start a new, empty workflowBundle
 				newDataflow();
 		}
 		if (workflowBundle == blankWorkflowBundle)
 			blankWorkflowBundle = null;
 		openDataflowInfos.remove(workflowBundle);
 		observers.notify(new ClosedDataflowEvent(workflowBundle));
 		return true;
 	}

 	@Override
 	public WorkflowBundle getCurrentDataflow() {
 		return currentWorkflowBundle;
 	}

 	@Override
 	public WorkflowBundle getDataflowBySource(Object source) {
 		for (Entry<WorkflowBundle, OpenDataflowInfo> infoEntry : openDataflowInfos
 				.entrySet()) {
 			OpenDataflowInfo info = infoEntry.getValue();
 			if (source.equals(info.getSource()))
 				return infoEntry.getKey();
 		}
 		// Not found
 		return null;
 	}

 	@Override
 	public String getDataflowName(WorkflowBundle workflowBundle) {
 		Object source = null;
 		if (isDataflowOpen(workflowBundle))
 			source = getDataflowSource(workflowBundle);
 		// Fallback
 		String name;
 		Workflow workflow = workflowBundle.getMainWorkflow();
 		if (workflow != null)
 			name = workflow.getName();
 		else
 			name = workflowBundle.getName();
 		if (source == null)
 			return name;
 		if (source instanceof File)
 			return ((File) source).getAbsolutePath();
 		else if (source instanceof URL)
 			return source.toString();

 		// Check if it has implemented a toString() method
 		Method toStringMethod = null;
 		Method toStringMethodFromObject = null;
 		try {
 			toStringMethod = source.getClass().getMethod("toString");
 			toStringMethodFromObject = Object.class.getMethod("toString");
 		} catch (Exception e) {
 			throw new IllegalStateException(
 					"Source did not implement Object.toString() " + source);
 		}
 		if (!toStringMethod.equals(toStringMethodFromObject))
 			return source.toString();
 		return name;
 	}

 	@Override
 	public String getDefaultWorkflowName() {
 		return "Workflow" + (nameIndex++);
 	}

 	@Override
 	public Object getDataflowSource(WorkflowBundle workflowBundle) {
 		return getOpenDataflowInfo(workflowBundle).getSource();
 	}

 	@Override
 	public FileType getDataflowType(WorkflowBundle workflowBundle) {
 		return getOpenDataflowInfo(workflowBundle).getFileType();
 	}

 	@Override
 	public List<Observer<FileManagerEvent>> getObservers() {
 		return observers.getObservers();
 	}

 	/**
 	 * Get the {@link OpenDataflowInfo} for the given WorkflowBundle
 	 *
 	 * @throws NullPointerException
 	 *             if the WorkflowBundle was <code>null</code>
 	 * @throws IllegalArgumentException
 	 *             if the WorkflowBundle was not open.
 	 * @param workflowBundle
 	 *            WorkflowBundle which information is to be found
 	 * @return The {@link OpenDataflowInfo} describing the WorkflowBundle
 	 */
 	protected synchronized OpenDataflowInfo getOpenDataflowInfo(
 			WorkflowBundle workflowBundle) {
 		if (workflowBundle == null)
 			throw new NullPointerException("Dataflow can't be null");
 		OpenDataflowInfo info = openDataflowInfos.get(workflowBundle);
 		if (info == null)
 			throw new IllegalArgumentException("Workflow was not opened "
 					+ workflowBundle);
 		return info;
 	}

 	@Override
 	public List<WorkflowBundle> getOpenDataflows() {
 		return new ArrayList<>(openDataflowInfos.keySet());
 	}

 	@Override
 	public List<FileFilter> getOpenFileFilters() {
 		List<FileFilter> fileFilters = new ArrayList<>();

 		Set<FileType> fileTypes = getPersistanceHandlerRegistry()
 				.getOpenFileTypes();
 		if (!fileTypes.isEmpty())
 			fileFilters.add(new MultipleFileTypes(fileTypes,
 					"All supported workflows"));
 		for (FileType fileType : fileTypes)
 			fileFilters.add(new FileTypeFileFilter(fileType));
 		return fileFilters;
 	}

 	@Override
 	public List<FileFilter> getOpenFileFilters(Class<?> sourceClass) {
 		List<FileFilter> fileFilters = new ArrayList<>();
 		for (FileType fileType : getPersistanceHandlerRegistry()
 				.getOpenFileTypesFor(sourceClass))
 			fileFilters.add(new FileTypeFileFilter(fileType));
 		return fileFilters;
 	}

 	@Override
 	public List<FileFilter> getSaveFileFilters() {
 		List<FileFilter> fileFilters = new ArrayList<>();
 		for (FileType fileType : getPersistanceHandlerRegistry()
 				.getSaveFileTypes())
 			fileFilters.add(new FileTypeFileFilter(fileType));
 		return fileFilters;
 	}

 	@Override
 	public List<FileFilter> getSaveFileFilters(Class<?> destinationClass) {
 		List<FileFilter> fileFilters = new ArrayList<>();
 		for (FileType fileType : getPersistanceHandlerRegistry()
 				.getSaveFileTypesFor(destinationClass))
 			fileFilters.add(new FileTypeFileFilter(fileType));
 		return fileFilters;
 	}

 	@Override
 	public boolean isDataflowChanged(WorkflowBundle workflowBundle) {
 		return getOpenDataflowInfo(workflowBundle).isChanged();
 	}

 	@Override
 	public boolean isDataflowOpen(WorkflowBundle workflowBundle) {
 		return openDataflowInfos.containsKey(workflowBundle);
 	}

 	@Override
 	public WorkflowBundle newDataflow() {
 		WorkflowBundle workflowBundle = new WorkflowBundle();
 		workflowBundle.setMainWorkflow(new Workflow());
 		workflowBundle.getMainWorkflow().setName(getDefaultWorkflowName());
 		workflowBundle.setMainProfile(new Profile());
 		scufl2Tools.setParents(workflowBundle);
 		blankWorkflowBundle = null;
 		openDataflowInternal(workflowBundle);
 		blankWorkflowBundle = workflowBundle;
 		observers.notify(new OpenedDataflowEvent(workflowBundle));
 		return workflowBundle;
 	}

 	@Override
 	public void openDataflow(WorkflowBundle workflowBundle) {
 		openDataflowInternal(workflowBundle);
 		observers.notify(new OpenedDataflowEvent(workflowBundle));
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public WorkflowBundle openDataflow(FileType fileType, Object source)
 			throws OpenException {
 		if (isHeadless())
 			return performOpenDataflow(fileType, source);

 		OpenDataflowRunnable r = new OpenDataflowRunnable(this, fileType,
 				source);
 		if (isEventDispatchThread()) {
 			r.run();
 		} else
 			try {
 				invokeAndWait(r);
 			} catch (InterruptedException | InvocationTargetException e) {
 				throw new OpenException("Opening was interrupted", e);
 			}
 		OpenException thrownException = r.getException();
 		if (thrownException != null)
 			throw thrownException;
 		return r.getDataflow();
 	}

 	public WorkflowBundle performOpenDataflow(FileType fileType, Object source)
 			throws OpenException {
 		DataflowInfo dataflowInfo;
 		WorkflowBundle workflowBundle;
 		dataflowInfo = openDataflowSilently(fileType, source);
 		workflowBundle = dataflowInfo.getDataflow();
 		openDataflowInternal(workflowBundle);
 		getOpenDataflowInfo(workflowBundle).setOpenedFrom(dataflowInfo);
 		observers.notify(new OpenedDataflowEvent(workflowBundle));
 		return workflowBundle;
 	}

 	@Override
 	public DataflowInfo openDataflowSilently(FileType fileType, Object source)
 			throws OpenException {
 		Set<DataflowPersistenceHandler> handlers;
 		Class<? extends Object> sourceClass = source.getClass();

 		boolean unknownFileType = (fileType == null);
 		if (unknownFileType)
 			handlers = getPersistanceHandlerRegistry().getOpenHandlersFor(
 					sourceClass);
 		else
 			handlers = getPersistanceHandlerRegistry().getOpenHandlersFor(
 					fileType, sourceClass);
 		if (handlers.isEmpty())
 			throw new OpenException("Unsupported file type or class "
 					+ fileType + " " + sourceClass);

 		Throwable lastException = null;
 		for (DataflowPersistenceHandler handler : handlers) {
 			Collection<FileType> fileTypes;
 			if (unknownFileType)
 				fileTypes = handler.getOpenFileTypes();
 			else
 				fileTypes = singleton(fileType);
 			for (FileType candidateFileType : fileTypes) {
 				if (unknownFileType && (source instanceof File))
 					/*
 					 * If source is file but fileType was not explicitly set
 					 * from the open workflow dialog - check the file extension
 					 * and decide which handler to use based on that (so that we
 					 * do not loop though all handlers)
 					 */
 					if (!((File) source).getPath().endsWith(
 							candidateFileType.getExtension()))
 						continue;

 				try {
 					DataflowInfo openDataflow = handler.openDataflow(
 							candidateFileType, source);
 					WorkflowBundle workflowBundle = openDataflow.getDataflow();
 					logger.info("Loaded workflow: " + workflowBundle.getName()
 							+ " " + workflowBundle.getGlobalBaseURI()
 							+ " from " + source + " using " + handler);
 					return openDataflow;
 				} catch (OpenException ex) {
 					logger.warn("Could not open workflow " + source + " using "
 							+ handler + " of type " + candidateFileType);
 					lastException = ex;
 				}
 			}
 		}
 		throw new OpenException("Could not open workflow " + source + "\n",
 				lastException);
 	}

 	/**
 	 * Mark the WorkflowBundle as opened, and close the blank WorkflowBundle if
 	 * needed.
 	 *
 	 * @param workflowBundle
 	 *            WorkflowBundle that has been opened
 	 */
 	protected void openDataflowInternal(WorkflowBundle workflowBundle) {
 		if (workflowBundle == null)
 			throw new NullPointerException("Dataflow can't be null");
 		if (isDataflowOpen(workflowBundle))
 			throw new IllegalArgumentException("Workflow is already open: "
 					+ workflowBundle);

 		openDataflowInfos.put(workflowBundle, new OpenDataflowInfo());
 		setCurrentDataflow(workflowBundle);
 		if (openDataflowInfos.size() == 2 && blankWorkflowBundle != null)
 			/*
 			 * Behave like a word processor and close the blank WorkflowBundle
 			 * when another workflow has been opened
 			 */
 			try {
 				closeDataflow(blankWorkflowBundle, true);
 			} catch (UnsavedException e) {
 				logger.error("Blank workflow was modified "
 						+ "and could not be closed");
 			}
 	}

 	@Override
 	public void removeObserver(Observer<FileManagerEvent> observer) {
 		observers.removeObserver(observer);
 	}

 	@Override
 	public void saveDataflow(WorkflowBundle workflowBundle,
 			boolean failOnOverwrite) throws SaveException {
 		if (workflowBundle == null)
 			throw new NullPointerException("Dataflow can't be null");
 		OpenDataflowInfo lastSave = getOpenDataflowInfo(workflowBundle);
 		if (lastSave.getSource() == null)
 			throw new SaveException("Can't save without source "
 					+ workflowBundle);
 		saveDataflow(workflowBundle, lastSave.getFileType(),
 				lastSave.getSource(), failOnOverwrite);
 	}

 	@Override
 	public void saveDataflow(WorkflowBundle workflowBundle, FileType fileType,
 			Object destination, boolean failOnOverwrite) throws SaveException {
 		DataflowInfo savedDataflow = saveDataflowSilently(workflowBundle,
 				fileType, destination, failOnOverwrite);
 		getOpenDataflowInfo(workflowBundle).setSavedTo(savedDataflow);
 		observers.notify(new SavedDataflowEvent(workflowBundle));
 	}

 	@Override
 	public DataflowInfo saveDataflowSilently(WorkflowBundle workflowBundle,
 			FileType fileType, Object destination, boolean failOnOverwrite)
 			throws SaveException, OverwriteException {
 		Set<DataflowPersistenceHandler> handlers;

 		Class<? extends Object> destinationClass = destination.getClass();
 		if (fileType != null)
 			handlers = getPersistanceHandlerRegistry().getSaveHandlersForType(
 					fileType, destinationClass);
 		else
 			handlers = getPersistanceHandlerRegistry().getSaveHandlersFor(
 					destinationClass);

 		SaveException lastException = null;
 		for (DataflowPersistenceHandler handler : handlers) {
 			if (failOnOverwrite) {
 				OpenDataflowInfo openDataflowInfo = getOpenDataflowInfo(workflowBundle);
 				if (handler.wouldOverwriteDataflow(workflowBundle, fileType,
 						destination, openDataflowInfo.getDataflowInfo()))
 					throw new OverwriteException(destination);
 			}
 			try {
 				DataflowInfo savedDataflow = handler.saveDataflow(
 						workflowBundle, fileType, destination);
 				savedDataflow.getDataflow();
 				logger.info("Saved workflow: " + workflowBundle.getName() + " "
 						+ workflowBundle.getGlobalBaseURI() + " to "
 						+ savedDataflow.getCanonicalSource() + " using "
 						+ handler);
 				return savedDataflow;
 			} catch (SaveException ex) {
 				logger.warn("Could not save to " + destination + " using "
 						+ handler);
 				lastException = ex;
 			}
 		}

 		if (lastException == null)
 			throw new SaveException("Unsupported file type or class "
 					+ fileType + " " + destinationClass);
 		throw new SaveException("Could not save to " + destination + ":\n"
 				+ lastException.getLocalizedMessage(), lastException);
 	}

 	@Override
 	public void setCurrentDataflow(WorkflowBundle workflowBundle) {
 		setCurrentDataflow(workflowBundle, false);
 	}

 	@Override
 	public void setCurrentDataflow(WorkflowBundle workflowBundle,
 			boolean openIfNeeded) {
 		currentWorkflowBundle = workflowBundle;
 		if (!isDataflowOpen(workflowBundle)) {
 			if (!openIfNeeded)
 				throw new IllegalArgumentException("Workflow is not open: "
 						+ workflowBundle);
 			openDataflow(workflowBundle);
 			return;
 		}
 		observers.notify(new SetCurrentDataflowEvent(workflowBundle));
 	}

 	@Override
 	public void setDataflowChanged(WorkflowBundle workflowBundle,
 			boolean isChanged) {
 		getOpenDataflowInfo(workflowBundle).setIsChanged(isChanged);
 		if (blankWorkflowBundle == workflowBundle)
 			blankWorkflowBundle = null;
 	}

 	@Override
 	public Object getCanonical(Object source) throws IllegalArgumentException,
 			URISyntaxException, IOException {
 		Object canonicalSource = source;

 		if (source instanceof URL) {
 			URL url = ((URL) source);
 			if (url.getProtocol().equalsIgnoreCase("file"))
 				canonicalSource = new File(url.toURI());
 		}

 		if (canonicalSource instanceof File)
 			canonicalSource = ((File) canonicalSource).getCanonicalFile();
 		return canonicalSource;
 	}

 	public void setDataflowPersistenceHandlerRegistry(
 			DataflowPersistenceHandlerRegistry dataflowPersistenceHandlerRegistry) {
 		this.dataflowPersistenceHandlerRegistry = dataflowPersistenceHandlerRegistry;
 	}

 	/**
 	 * Observe the {@link EditManager} for changes to open workflowBundles. A
 	 * change of an open workflow would set it as changed using
 	 * {@link FileManagerImpl#setDataflowChanged(Dataflow, boolean)}.
 	 *
 	 * @author Stian Soiland-Reyes
 	 *
 	 */
 	private final class EditManagerObserver implements
 			Observer<EditManagerEvent> {
 		@Override
 		public void notify(Observable<EditManagerEvent> sender,
 				EditManagerEvent message) throws Exception {
 			if (message instanceof AbstractDataflowEditEvent) {
 				AbstractDataflowEditEvent dataflowEdit = (AbstractDataflowEditEvent) message;
 				WorkflowBundle workflowBundle = dataflowEdit.getDataFlow();
 				/**
 				 * TODO: on undo/redo - keep last event or similar to determine
 				 * if workflow was saved before. See
 				 * FileManagerTest#isChangedWithUndo().
 				 */
 				setDataflowChanged(workflowBundle, true);
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (C) 2007-2010 The University of Manchester
	*
	* Modifications to the initial code base are copyright of their
	* respective authors, or their employers as appropriate.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public License
	* as published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	******************************************************************************/
	package net.sf.taverna.t2.workbench.file.impl;

	import static java.awt.GraphicsEnvironment.isHeadless;
	import static java.util.Collections.singleton;
	import static javax.swing.SwingUtilities.invokeAndWait;
	import static javax.swing.SwingUtilities.isEventDispatchThread;

	import java.io.File;
	import java.io.IOException;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.net.URISyntaxException;
	import java.net.URL;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.LinkedHashMap;
	import java.util.List;
	import java.util.Map.Entry;
	import java.util.Set;

	import javax.swing.filechooser.FileFilter;

	import net.sf.taverna.t2.lang.observer.MultiCaster;
	import net.sf.taverna.t2.lang.observer.Observable;
	import net.sf.taverna.t2.lang.observer.Observer;
	import net.sf.taverna.t2.workbench.edits.EditManager;
	import net.sf.taverna.t2.workbench.edits.EditManager.AbstractDataflowEditEvent;
	import net.sf.taverna.t2.workbench.edits.EditManager.EditManagerEvent;
	import net.sf.taverna.t2.workbench.file.DataflowInfo;
	import net.sf.taverna.t2.workbench.file.DataflowPersistenceHandler;
	import net.sf.taverna.t2.workbench.file.FileManager;
	import net.sf.taverna.t2.workbench.file.FileType;
	import net.sf.taverna.t2.workbench.file.events.ClosedDataflowEvent;
	import net.sf.taverna.t2.workbench.file.events.ClosingDataflowEvent;
	import net.sf.taverna.t2.workbench.file.events.FileManagerEvent;
	import net.sf.taverna.t2.workbench.file.events.OpenedDataflowEvent;
	import net.sf.taverna.t2.workbench.file.events.SavedDataflowEvent;
	import net.sf.taverna.t2.workbench.file.events.SetCurrentDataflowEvent;
	import net.sf.taverna.t2.workbench.file.exceptions.OpenException;
	import net.sf.taverna.t2.workbench.file.exceptions.OverwriteException;
	import net.sf.taverna.t2.workbench.file.exceptions.SaveException;
	import net.sf.taverna.t2.workbench.file.exceptions.UnsavedException;

	import org.apache.log4j.Logger;

	import uk.org.taverna.scufl2.api.common.Scufl2Tools;
	import uk.org.taverna.scufl2.api.container.WorkflowBundle;
	import uk.org.taverna.scufl2.api.core.Workflow;
	import uk.org.taverna.scufl2.api.profiles.Profile;

	/**
	* Implementation of {@link FileManager}
	*
	* @author Stian Soiland-Reyes
	*/
	public class FileManagerImpl implements FileManager {
	private static Logger logger = Logger.getLogger(FileManagerImpl.class);
	private static int nameIndex = 1;

	/**
	* The last blank workflowBundle created using #newDataflow() until it has
	* been changed - when this variable will be set to null again. Used to
	* automatically close unmodified blank workflowBundles on open.
	*/
	private WorkflowBundle blankWorkflowBundle = null;
	@SuppressWarnings("unused")
	private EditManager editManager;
	private EditManagerObserver editManagerObserver = new EditManagerObserver();
	protected MultiCaster<FileManagerEvent> observers = new MultiCaster<>(this);
	/**
	* Ordered list of open WorkflowBundle
	*/
	private LinkedHashMap<WorkflowBundle, OpenDataflowInfo> openDataflowInfos = new LinkedHashMap<>();
	private DataflowPersistenceHandlerRegistry dataflowPersistenceHandlerRegistry;
	private Scufl2Tools scufl2Tools = new Scufl2Tools();
	private WorkflowBundle currentWorkflowBundle;

	public DataflowPersistenceHandlerRegistry getPersistanceHandlerRegistry() {
	return dataflowPersistenceHandlerRegistry;
	}

	public FileManagerImpl(EditManager editManager) {
	this.editManager = editManager;
	editManager.addObserver(editManagerObserver);
	}

	/**
	* Add an observer to be notified of {@link FileManagerEvent}s, such as
	* {@link OpenedDataflowEvent} and {@link SavedDataflowEvent}.
	*
	* {@inheritDoc}
	*/
	@Override
	public void addObserver(Observer<FileManagerEvent> observer) {
	observers.addObserver(observer);
	}

	@Override
	public boolean canSaveWithoutDestination(WorkflowBundle workflowBundle) {
	OpenDataflowInfo dataflowInfo = getOpenDataflowInfo(workflowBundle);
	if (dataflowInfo.getSource() == null)
	return false;
	Set<?> handlers = getPersistanceHandlerRegistry()
	.getSaveHandlersForType(
	dataflowInfo.getFileType(),
	dataflowInfo.getDataflowInfo().getCanonicalSource()
	.getClass());
	return !handlers.isEmpty();
	}

	@Override
	public boolean closeDataflow(WorkflowBundle workflowBundle,
	boolean failOnUnsaved) throws UnsavedException {
	if (workflowBundle == null)
	throw new NullPointerException("Dataflow can't be null");
	ClosingDataflowEvent message = new ClosingDataflowEvent(workflowBundle);
	observers.notify(message);
	if (message.isAbortClose())
	return false;
	if ((failOnUnsaved && getOpenDataflowInfo(workflowBundle).isChanged()))
	throw new UnsavedException(workflowBundle);
	if (workflowBundle.equals(getCurrentDataflow())) {
	// We'll need to change current workflowBundle
	// Find best candidate to the left or right
	List<WorkflowBundle> workflowBundles = getOpenDataflows();
	int openIndex = workflowBundles.indexOf(workflowBundle);
	if (openIndex == -1)
	throw new IllegalArgumentException("Workflow was not opened "
	+ workflowBundle);

	if (openIndex > 0)
	setCurrentDataflow(workflowBundles.get(openIndex - 1));
	else if (openIndex == 0 && workflowBundles.size() > 1)
	setCurrentDataflow(workflowBundles.get(1));
	else
	// If it was the last one, start a new, empty workflowBundle
	newDataflow();
	}
	if (workflowBundle == blankWorkflowBundle)
	blankWorkflowBundle = null;
	openDataflowInfos.remove(workflowBundle);
	observers.notify(new ClosedDataflowEvent(workflowBundle));
	return true;
	}

	@Override
	public WorkflowBundle getCurrentDataflow() {
	return currentWorkflowBundle;
	}

	@Override
	public WorkflowBundle getDataflowBySource(Object source) {
	for (Entry<WorkflowBundle, OpenDataflowInfo> infoEntry : openDataflowInfos
	.entrySet()) {
	OpenDataflowInfo info = infoEntry.getValue();
	if (source.equals(info.getSource()))
	return infoEntry.getKey();
	}
	// Not found
	return null;
	}

	@Override
	public String getDataflowName(WorkflowBundle workflowBundle) {
	Object source = null;
	if (isDataflowOpen(workflowBundle))
	source = getDataflowSource(workflowBundle);
	// Fallback
	String name;
	Workflow workflow = workflowBundle.getMainWorkflow();
	if (workflow != null)
	name = workflow.getName();
	else
	name = workflowBundle.getName();
	if (source == null)
	return name;
	if (source instanceof File)
	return ((File) source).getAbsolutePath();
	else if (source instanceof URL)
	return source.toString();

	// Check if it has implemented a toString() method
	Method toStringMethod = null;
	Method toStringMethodFromObject = null;
	try {
	toStringMethod = source.getClass().getMethod("toString");
	toStringMethodFromObject = Object.class.getMethod("toString");
	} catch (Exception e) {
	throw new IllegalStateException(
	"Source did not implement Object.toString() " + source);
	}
	if (!toStringMethod.equals(toStringMethodFromObject))
	return source.toString();
	return name;
	}

	@Override
	public String getDefaultWorkflowName() {
	return "Workflow" + (nameIndex++);
	}

	@Override
	public Object getDataflowSource(WorkflowBundle workflowBundle) {
	return getOpenDataflowInfo(workflowBundle).getSource();
	}

	@Override
	public FileType getDataflowType(WorkflowBundle workflowBundle) {
	return getOpenDataflowInfo(workflowBundle).getFileType();
	}

	@Override
	public List<Observer<FileManagerEvent>> getObservers() {
	return observers.getObservers();
	}

	/**
	* Get the {@link OpenDataflowInfo} for the given WorkflowBundle
	*
	* @throws NullPointerException
	* if the WorkflowBundle was <code>null</code>
	* @throws IllegalArgumentException
	* if the WorkflowBundle was not open.
	* @param workflowBundle
	* WorkflowBundle which information is to be found
	* @return The {@link OpenDataflowInfo} describing the WorkflowBundle
	*/
	protected synchronized OpenDataflowInfo getOpenDataflowInfo(
	WorkflowBundle workflowBundle) {
	if (workflowBundle == null)
	throw new NullPointerException("Dataflow can't be null");
	OpenDataflowInfo info = openDataflowInfos.get(workflowBundle);
	if (info == null)
	throw new IllegalArgumentException("Workflow was not opened "
	+ workflowBundle);
	return info;
	}

	@Override
	public List<WorkflowBundle> getOpenDataflows() {
	return new ArrayList<>(openDataflowInfos.keySet());
	}

	@Override
	public List<FileFilter> getOpenFileFilters() {
	List<FileFilter> fileFilters = new ArrayList<>();

	Set<FileType> fileTypes = getPersistanceHandlerRegistry()
	.getOpenFileTypes();
	if (!fileTypes.isEmpty())
	fileFilters.add(new MultipleFileTypes(fileTypes,
	"All supported workflows"));
	for (FileType fileType : fileTypes)
	fileFilters.add(new FileTypeFileFilter(fileType));
	return fileFilters;
	}

	@Override
	public List<FileFilter> getOpenFileFilters(Class<?> sourceClass) {
	List<FileFilter> fileFilters = new ArrayList<>();
	for (FileType fileType : getPersistanceHandlerRegistry()
	.getOpenFileTypesFor(sourceClass))
	fileFilters.add(new FileTypeFileFilter(fileType));
	return fileFilters;
	}

	@Override
	public List<FileFilter> getSaveFileFilters() {
	List<FileFilter> fileFilters = new ArrayList<>();
	for (FileType fileType : getPersistanceHandlerRegistry()
	.getSaveFileTypes())
	fileFilters.add(new FileTypeFileFilter(fileType));
	return fileFilters;
	}

	@Override
	public List<FileFilter> getSaveFileFilters(Class<?> destinationClass) {
	List<FileFilter> fileFilters = new ArrayList<>();
	for (FileType fileType : getPersistanceHandlerRegistry()
	.getSaveFileTypesFor(destinationClass))
	fileFilters.add(new FileTypeFileFilter(fileType));
	return fileFilters;
	}

	@Override
	public boolean isDataflowChanged(WorkflowBundle workflowBundle) {
	return getOpenDataflowInfo(workflowBundle).isChanged();
	}

	@Override
	public boolean isDataflowOpen(WorkflowBundle workflowBundle) {
	return openDataflowInfos.containsKey(workflowBundle);
	}

	@Override
	public WorkflowBundle newDataflow() {
	WorkflowBundle workflowBundle = new WorkflowBundle();
	workflowBundle.setMainWorkflow(new Workflow());
	workflowBundle.getMainWorkflow().setName(getDefaultWorkflowName());
	workflowBundle.setMainProfile(new Profile());
	scufl2Tools.setParents(workflowBundle);
	blankWorkflowBundle = null;
	openDataflowInternal(workflowBundle);
	blankWorkflowBundle = workflowBundle;
	observers.notify(new OpenedDataflowEvent(workflowBundle));
	return workflowBundle;
	}

	@Override
	public void openDataflow(WorkflowBundle workflowBundle) {
	openDataflowInternal(workflowBundle);
	observers.notify(new OpenedDataflowEvent(workflowBundle));
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public WorkflowBundle openDataflow(FileType fileType, Object source)
	throws OpenException {
	if (isHeadless())
	return performOpenDataflow(fileType, source);

	OpenDataflowRunnable r = new OpenDataflowRunnable(this, fileType,
	source);
	if (isEventDispatchThread()) {
	r.run();
	} else
	try {
	invokeAndWait(r);
	} catch (InterruptedException \| InvocationTargetException e) {
	throw new OpenException("Opening was interrupted", e);
	}
	OpenException thrownException = r.getException();
	if (thrownException != null)
	throw thrownException;
	return r.getDataflow();
	}

	public WorkflowBundle performOpenDataflow(FileType fileType, Object source)
	throws OpenException {
	DataflowInfo dataflowInfo;
	WorkflowBundle workflowBundle;
	dataflowInfo = openDataflowSilently(fileType, source);
	workflowBundle = dataflowInfo.getDataflow();
	openDataflowInternal(workflowBundle);
	getOpenDataflowInfo(workflowBundle).setOpenedFrom(dataflowInfo);
	observers.notify(new OpenedDataflowEvent(workflowBundle));
	return workflowBundle;
	}

	@Override
	public DataflowInfo openDataflowSilently(FileType fileType, Object source)
	throws OpenException {
	Set<DataflowPersistenceHandler> handlers;
	Class<? extends Object> sourceClass = source.getClass();

	boolean unknownFileType = (fileType == null);
	if (unknownFileType)
	handlers = getPersistanceHandlerRegistry().getOpenHandlersFor(
	sourceClass);
	else
	handlers = getPersistanceHandlerRegistry().getOpenHandlersFor(
	fileType, sourceClass);
	if (handlers.isEmpty())
	throw new OpenException("Unsupported file type or class "
	+ fileType + " " + sourceClass);

	Throwable lastException = null;
	for (DataflowPersistenceHandler handler : handlers) {
	Collection<FileType> fileTypes;
	if (unknownFileType)
	fileTypes = handler.getOpenFileTypes();
	else
	fileTypes = singleton(fileType);
	for (FileType candidateFileType : fileTypes) {
	if (unknownFileType && (source instanceof File))
	/*
	* If source is file but fileType was not explicitly set
	* from the open workflow dialog - check the file extension
	* and decide which handler to use based on that (so that we
	* do not loop though all handlers)
	*/
	if (!((File) source).getPath().endsWith(
	candidateFileType.getExtension()))
	continue;

	try {
	DataflowInfo openDataflow = handler.openDataflow(
	candidateFileType, source);
	WorkflowBundle workflowBundle = openDataflow.getDataflow();
	logger.info("Loaded workflow: " + workflowBundle.getName()
	+ " " + workflowBundle.getGlobalBaseURI()
	+ " from " + source + " using " + handler);
	return openDataflow;
	} catch (OpenException ex) {
	logger.warn("Could not open workflow " + source + " using "
	+ handler + " of type " + candidateFileType);
	lastException = ex;
	}
	}
	}
	throw new OpenException("Could not open workflow " + source + "\n",
	lastException);
	}

	/**
	* Mark the WorkflowBundle as opened, and close the blank WorkflowBundle if
	* needed.
	*
	* @param workflowBundle
	* WorkflowBundle that has been opened
	*/
	protected void openDataflowInternal(WorkflowBundle workflowBundle) {
	if (workflowBundle == null)
	throw new NullPointerException("Dataflow can't be null");
	if (isDataflowOpen(workflowBundle))
	throw new IllegalArgumentException("Workflow is already open: "
	+ workflowBundle);

	openDataflowInfos.put(workflowBundle, new OpenDataflowInfo());
	setCurrentDataflow(workflowBundle);
	if (openDataflowInfos.size() == 2 && blankWorkflowBundle != null)
	/*
	* Behave like a word processor and close the blank WorkflowBundle
	* when another workflow has been opened
	*/
	try {
	closeDataflow(blankWorkflowBundle, true);
	} catch (UnsavedException e) {
	logger.error("Blank workflow was modified "
	+ "and could not be closed");
	}
	}

	@Override
	public void removeObserver(Observer<FileManagerEvent> observer) {
	observers.removeObserver(observer);
	}

	@Override
	public void saveDataflow(WorkflowBundle workflowBundle,
	boolean failOnOverwrite) throws SaveException {
	if (workflowBundle == null)
	throw new NullPointerException("Dataflow can't be null");
	OpenDataflowInfo lastSave = getOpenDataflowInfo(workflowBundle);
	if (lastSave.getSource() == null)
	throw new SaveException("Can't save without source "
	+ workflowBundle);
	saveDataflow(workflowBundle, lastSave.getFileType(),
	lastSave.getSource(), failOnOverwrite);
	}

	@Override
	public void saveDataflow(WorkflowBundle workflowBundle, FileType fileType,
	Object destination, boolean failOnOverwrite) throws SaveException {
	DataflowInfo savedDataflow = saveDataflowSilently(workflowBundle,
	fileType, destination, failOnOverwrite);
	getOpenDataflowInfo(workflowBundle).setSavedTo(savedDataflow);
	observers.notify(new SavedDataflowEvent(workflowBundle));
	}

	@Override
	public DataflowInfo saveDataflowSilently(WorkflowBundle workflowBundle,
	FileType fileType, Object destination, boolean failOnOverwrite)
	throws SaveException, OverwriteException {
	Set<DataflowPersistenceHandler> handlers;

	Class<? extends Object> destinationClass = destination.getClass();
	if (fileType != null)
	handlers = getPersistanceHandlerRegistry().getSaveHandlersForType(
	fileType, destinationClass);
	else
	handlers = getPersistanceHandlerRegistry().getSaveHandlersFor(
	destinationClass);

	SaveException lastException = null;
	for (DataflowPersistenceHandler handler : handlers) {
	if (failOnOverwrite) {
	OpenDataflowInfo openDataflowInfo = getOpenDataflowInfo(workflowBundle);
	if (handler.wouldOverwriteDataflow(workflowBundle, fileType,
	destination, openDataflowInfo.getDataflowInfo()))
	throw new OverwriteException(destination);
	}
	try {
	DataflowInfo savedDataflow = handler.saveDataflow(
	workflowBundle, fileType, destination);
	savedDataflow.getDataflow();
	logger.info("Saved workflow: " + workflowBundle.getName() + " "
	+ workflowBundle.getGlobalBaseURI() + " to "
	+ savedDataflow.getCanonicalSource() + " using "
	+ handler);
	return savedDataflow;
	} catch (SaveException ex) {
	logger.warn("Could not save to " + destination + " using "
	+ handler);
	lastException = ex;
	}
	}

	if (lastException == null)
	throw new SaveException("Unsupported file type or class "
	+ fileType + " " + destinationClass);
	throw new SaveException("Could not save to " + destination + ":\n"
	+ lastException.getLocalizedMessage(), lastException);
	}

	@Override
	public void setCurrentDataflow(WorkflowBundle workflowBundle) {
	setCurrentDataflow(workflowBundle, false);
	}

	@Override
	public void setCurrentDataflow(WorkflowBundle workflowBundle,
	boolean openIfNeeded) {
	currentWorkflowBundle = workflowBundle;
	if (!isDataflowOpen(workflowBundle)) {
	if (!openIfNeeded)
	throw new IllegalArgumentException("Workflow is not open: "
	+ workflowBundle);
	openDataflow(workflowBundle);
	return;
	}
	observers.notify(new SetCurrentDataflowEvent(workflowBundle));
	}

	@Override
	public void setDataflowChanged(WorkflowBundle workflowBundle,
	boolean isChanged) {
	getOpenDataflowInfo(workflowBundle).setIsChanged(isChanged);
	if (blankWorkflowBundle == workflowBundle)
	blankWorkflowBundle = null;
	}

	@Override
	public Object getCanonical(Object source) throws IllegalArgumentException,
	URISyntaxException, IOException {
	Object canonicalSource = source;

	if (source instanceof URL) {
	URL url = ((URL) source);
	if (url.getProtocol().equalsIgnoreCase("file"))
	canonicalSource = new File(url.toURI());
	}

	if (canonicalSource instanceof File)
	canonicalSource = ((File) canonicalSource).getCanonicalFile();
	return canonicalSource;
	}

	public void setDataflowPersistenceHandlerRegistry(
	DataflowPersistenceHandlerRegistry dataflowPersistenceHandlerRegistry) {
	this.dataflowPersistenceHandlerRegistry = dataflowPersistenceHandlerRegistry;
	}

	/**
	* Observe the {@link EditManager} for changes to open workflowBundles. A
	* change of an open workflow would set it as changed using
	* {@link FileManagerImpl#setDataflowChanged(Dataflow, boolean)}.
	*
	* @author Stian Soiland-Reyes
	*
	*/
	private final class EditManagerObserver implements
	Observer<EditManagerEvent> {
	@Override
	public void notify(Observable<EditManagerEvent> sender,
	EditManagerEvent message) throws Exception {
	if (message instanceof AbstractDataflowEditEvent) {
	AbstractDataflowEditEvent dataflowEdit = (AbstractDataflowEditEvent) message;
	WorkflowBundle workflowBundle = dataflowEdit.getDataFlow();
	/**
	* TODO: on undo/redo - keep last event or similar to determine
	* if workflow was saved before. See
	* FileManagerTest#isChangedWithUndo().
	*/
	setDataflowChanged(workflowBundle, true);
	}
	}
	}
	}