/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.sdt.sourcegen;

import com.nokia.sdt.datamodel.IDesignerDataModel;

import com.nokia.sdt.editor.EditorServices;

import com.nokia.sdt.editor.IDesignerDataModelEditor;

import com.nokia.sdt.editor.EditorServices.EditorListener;

import com.nokia.sdt.editor.IDesignerDataModelEditor.SaveListener;

import com.nokia.sdt.sourcegen.core.Messages;

import com.nokia.cpp.internal.api.utils.core.Logging;

import com.nokia.cpp.internal.api.utils.core.TextUtils;

import com.nokia.cpp.internal.api.utils.ui.UITaskUtils;

import org.eclipse.core.resources.*;

import org.eclipse.core.runtime.*;

import org.eclipse.jface.dialogs.IDialogConstants;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.jface.util.SafeRunnable;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.*;

import org.eclipse.ui.dialogs.ListSelectionDialog;

import org.eclipse.ui.model.*;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

import java.lang.reflect.InvocationTargetException;

import java.text.MessageFormat;

import java.util.*;

import java.util.regex.Pattern;

/**

 * The main plugin class to be used in the desktop (auto-generated)

 */

public class SourceGenPlugin extends AbstractUIPlugin implements SaveListener, EditorListener {

	//The shared instance.

	private static SourceGenPlugin plugin;

	//Resource bundle.

	private ResourceBundle resourceBundle;

	// Pattern matcher for files which might be written by sourcegen

	static final Pattern sourcePattern = Pattern.compile(

		".*\\.(c|cpp|h|hpp|ra|rss|rssi|loc|l[0-9]{2}|rls)$"); //$NON-NLS-1$

	/**

	 * The constructor.

	 */

	public SourceGenPlugin() {

		super();

		plugin = this;

		// attach to any open editors

		IEditorPart[] editors = EditorServices.getEditors();

		for (int i = 0; i < editors.length; i++) {

			editorAdded(editors[i]);

		}

		EditorServices.addListener(this);

	}

	/**

	 * This method is called upon plug-in activation

	 */

	public void start(BundleContext context) throws Exception {

		super.start(context);

		EditorServices.addListener(this);

	}

	/**

	 * This method is called when the plug-in is stopped

	 */

	public void stop(BundleContext context) throws Exception {

		super.stop(context);

		EditorServices.removeListener(this);

		plugin = null;

		resourceBundle = null;

	}

	/**

	 * Returns the shared instance.

	 */

	public static SourceGenPlugin getDefault() {

		return plugin;

	}

	/**

	 * Returns the string from the plugin's resource bundle,

	 * or 'key' if not found.

	 */

	public static String getResourceString(String key) {

		ResourceBundle bundle = SourceGenPlugin.getDefault().getResourceBundle();

		try {

			return (bundle != null) ? bundle.getString(key) : key;

		} catch (MissingResourceException e) {

			return key;

		}

	}

	/**

	 * Returns the plugin's resource bundle,

	 */

	public ResourceBundle getResourceBundle() {

		try {

			if (resourceBundle == null)

				resourceBundle = ResourceBundle.getBundle("com.nokia.sdt.sourcegen.SourceGenPluginResources"); //$NON-NLS-1$

		} catch (MissingResourceException x) {

			resourceBundle = null;

		}

		return resourceBundle;

	}

	/**

	 * Returns an image descriptor for the image file at the given

	 * plug-in relative path.

	 *

	 * @param path the path

	 * @return the image descriptor

	 */

	public static ImageDescriptor getImageDescriptor(String path) {

		return AbstractUIPlugin.imageDescriptorFromPlugin("com.nokia.sdt.sourcegen", path); //$NON-NLS-1$

	}

	/**

	 */

	public void log(Throwable t) {

		IStatus status = Logging.newSimpleStatus(0, t);

		Logging.log(this, status);

	}

    public IStatus createStatus(int severity, String message, Throwable t) {

        return Logging.newStatus(this, severity, message, t);

    }

	static interface IEditorPartFilter {

		public boolean accept(IEditorPart part);

	}

	/** 

	 * Save editors that appear to be source-related.

	 */

	public boolean saveAllSourceEditors(final IEditorPartFilter filter, boolean confirm) {

		final IWorkbench workbench = PlatformUI.getWorkbench();

		final boolean finalConfirm = confirm;

		final boolean[] result = new boolean[1];

		result[0] = true;

		SafeRunner.run(new SafeRunnable() {

			public void run() {

				// Collect unsaved parts

				ArrayList dirtyParts = new ArrayList();

				ArrayList dirtyEditorsInput = new ArrayList();

				IWorkbenchWindow windows[] = workbench.getWorkbenchWindows();

				for (int i = 0; i < windows.length; i++) {

					IWorkbenchPage pages[] = windows[i].getPages();

					for (int j = 0; j < pages.length; j++) {

						IWorkbenchPage page = (IWorkbenchPage) pages[j];

                        ISaveablePart[] parts = page.getDirtyEditors();

                        for (int k = 0; k < parts.length; k++) {

                            ISaveablePart part = parts[k];

                            if (part instanceof IEditorPart) {

                            	IEditorPart editor = (IEditorPart)part;

                            	if (editor.isSaveOnCloseNeeded() && filter.accept(editor)) {

                                    if (!dirtyEditorsInput.contains(editor

                                            .getEditorInput())) {

                                        dirtyParts.add(editor);

                                        dirtyEditorsInput.add(editor

                                                .getEditorInput());

                                    }

                                }

                            }

                        }

   					}

				}

				if (dirtyParts.size() > 0) {

					IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();

					if (window == null)

						window = windows[0];

					result[0] = confirmAndSaveAll(dirtyParts, finalConfirm, window);

				}

			}

		});

		return result[0];

	}

	/**

	 * Put up a dialog showing possible sources that will be

	 * modified and allow the user to select items to save,

	 * and save the selected items.

	 * <p>

	 * This is a ripoff of the Eclipse EditorManager#saveAll()

	 * method, which is internal.

	 * @param dirtyParts

	 * @return true: saving confirmed, false: save canceled

	 */

	private boolean confirmAndSaveAll(List dirtyParts, boolean confirm, IWorkbenchWindow window) {

    	// If the editor list is empty return.

        if (dirtyParts.isEmpty())

        	return true;

        // Convert the list into an element collection.

        AdaptableList input = new AdaptableList(dirtyParts);

        ListSelectionDialog dlg = new ListSelectionDialog(

                window.getShell(), input,

                new BaseWorkbenchContentProvider(),

                new WorkbenchPartLabelProvider(), 

                Messages.getString("SourceGenPlugin.SelectResources")); //$NON-NLS-1$

        dlg.setInitialSelections(dirtyParts

                .toArray(new Object[dirtyParts.size()]));

        dlg.setTitle(Messages.getString("SourceGenPlugin.SaveSourcesTitle")); //$NON-NLS-1$

        int result = dlg.open();

        if (result == IDialogConstants.CANCEL_ID)

            return false;

        final List savingDirtyParts = Arrays.asList(dlg.getResult());

        final boolean[] saveSucceeded = new boolean[1];

		saveSucceeded[0] = true;

        UITaskUtils.runImmediately(new IRunnableWithProgress() {

			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {

				monitor.beginTask(Messages.getString("SourceGenPlugin.SavingEditors"), savingDirtyParts.size()); //$NON-NLS-1$

		        for (Iterator iter = savingDirtyParts.iterator(); iter.hasNext();) {

		        	if (monitor.isCanceled())

		        		saveSucceeded[0] = false;

		        	IEditorPart editor = (IEditorPart) iter.next();

		        	editor.doSave(monitor);

		        	monitor.worked(1);

				}

				monitor.done();

			}

        });

        return saveSucceeded[0];

	}

	/**

	 * Check that the workspace is synchronized and in a 

	 * sane state to save sources.

	 * @return true: everything is up-to-date, false: cancel the save

	 */

	private boolean checkSynchronizedWorkspace(IDesignerDataModel dataModel) {

		// ask to save any source editors

		if (dataModel.getProjectContext() == null)

			return true;

		final IProject theProject = dataModel.getProjectContext().getProject();

		if (theProject == null)

			return true;

		IEditorPartFilter filter = new IEditorPartFilter() {

			public boolean accept(IEditorPart part) {

				// only look at stuff in this project

				IResource rsrc = (IResource) part.getEditorInput().getAdapter(IResource.class);

				if (rsrc != null) {

					IProject project = rsrc.getProject();

					if (project == null || !project.equals(theProject))

						return false;

				}

				String name = part.getEditorInput().getName();

				return sourcePattern.matcher(name).matches();

			}

		};

		if (!saveAllSourceEditors(filter, true))

			return false;

		// check for changes made outside workspace

		IProject project = null;

		if (dataModel.getProjectContext() != null

				&& (project = dataModel.getProjectContext().getProject()) != null) {

			final List<IPath> unsynchronizedResources = new ArrayList<IPath>();

			IResourceProxyVisitor visitor = new IResourceProxyVisitor() {

				public boolean visit(IResourceProxy resourceProxy) throws CoreException {

					String name = resourceProxy.getName();

					boolean looksLikeSource = sourcePattern.matcher(name).matches();

					if (looksLikeSource || resourceProxy.getType() == IResource.FOLDER) {

						IResource resource = resourceProxy.requestResource();

						if (resource != null && !resource.isSynchronized(IResource.DEPTH_ZERO))

							unsynchronizedResources.add(resource.getProjectRelativePath());

					}

					return resourceProxy.getType() == IResource.FOLDER ||

						resourceProxy.getType() == IResource.PROJECT;

				}

			};

			try {

				project.accept(visitor, 0);

				if (unsynchronizedResources.size() == 0)

					return true;

			} catch (CoreException e1) {

				SourceGenPlugin.getDefault().log(e1);

				// fall through, something bad happened

			}

			Shell shell = null;

			boolean doSync = MessageDialog.openConfirm(shell, 

					Messages.getString("SourceGenProvider.ProjectOutOfSync"), //$NON-NLS-1$

					MessageFormat.format(

							Messages.getString("SourceGenProvider.ProjectOutOfSyncMessage"), //$NON-NLS-1$

							new Object[] { project.getName(), 

								TextUtils.formatTabbedList(unsynchronizedResources) }));

			if (doSync) {

				try {

					project.refreshLocal(IResource.DEPTH_INFINITE, null);

					return true;

				} catch (CoreException e) {

					SourceGenPlugin.getDefault().log(e);

					Logging.showErrorDialog(Messages.getString("SourceGenProvider.Error"),  //$NON-NLS-1$

							null, e.getStatus());

					return false;

				}

			} else {

				return false;

			}

		}

		return true;

	}

	/* (non-Javadoc)

	 * @see com.nokia.sdt.ui.IDesignerEditorBase.SaveListener#queryAboutToSave(com.nokia.sdt.ui.IDesignerEditorBase)

	 */

	public boolean queryAboutToSave(IDesignerDataModelEditor editor) {

		return checkSynchronizedWorkspace(editor.getDataModel());

	}

	/* (non-Javadoc)

	 * @see com.nokia.sdt.ui.IDesignerEditorBase.SaveListener#preSaveNotify(com.nokia.sdt.ui.IDesignerEditorBase)

	 */

	public void preSaveNotify(IDesignerDataModelEditor editor, IProgressMonitor monitor) {

	}

	/* (non-Javadoc)

	 * @see com.nokia.sdt.ui.IDesignerEditorBase.SaveListener#postSaveNotify(com.nokia.sdt.ui.IDesignerEditorBase)

	 */

	public void postSaveNotify(IDesignerDataModelEditor editor, IProgressMonitor monitor) {

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.IPartListener2#partOpened(org.eclipse.ui.IWorkbenchPartReference)

	 */

	public void editorAdded(IEditorPart part) {

		IDesignerDataModelEditor editor = (IDesignerDataModelEditor) part.getAdapter(IDesignerDataModelEditor.class);

		if (editor != null)

			editor.addSaveListener(SourceGenPlugin.this);

	}

	public void editorRemoved(IEditorPart part) {

		IDesignerDataModelEditor editor = (IDesignerDataModelEditor) part.getAdapter(IDesignerDataModelEditor.class);

		if (editor != null)

			editor.removeSaveListener(SourceGenPlugin.this);

	}

}