// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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.symbian.smt.gui;

import java.io.File;

import java.util.HashMap;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IFolder;

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IResourceDelta;

import org.eclipse.core.resources.ProjectScope;

import org.eclipse.core.resources.WorkspaceJob;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Status;

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

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.part.FileEditorInput;

import com.symbian.smt.gui.editors.svgeditor.SVGEditor;

public class ChangeManager {

	static HashMap<String, Boolean> dirtyProjects = new HashMap<String, Boolean>();

	private String checkModelNameExtension(final IProject project,

			final IResource addedFile, String newOutputName) {

		if (!newOutputName.endsWith(".svg")) {

			final StringBuilder fullName = new StringBuilder();

			fullName.append(newOutputName);

			fullName.append(".svg");

			newOutputName = fullName.toString();

			final String outputName = fullName.toString();

			// The file has the extension added and is moved to the new filename

			WorkspaceJob wj = new WorkspaceJob("auto-rename") {

				@Override

				public IStatus runInWorkspace(IProgressMonitor monitor)

						throws CoreException {

					IPath newLocation = addedFile.getFullPath()

							.addFileExtension("svg");

					addedFile

							.move(newLocation, true, new NullProgressMonitor());

					project.getFile(outputName).setDerived(true);

					return new Status(IStatus.OK, Activator.PLUGIN_ID,

							IStatus.OK, "auto-rename succeeded", null);

				}

			};

			wj.schedule();

		}

		return newOutputName;

	}

	private void checkPropertyChangeMarkers(final IProject project) {

		try {

			IMarker[] mMarkers = project.findMarkers(IMarker.MESSAGE, false, 0);

			for (final IMarker aMarker : mMarkers) {

				if (aMarker.getAttribute(IMarker.MESSAGE) != null) {

					if (aMarker.getAttribute(IMarker.MESSAGE).equals(

							"properties changed")) {

						dirtyProjects.put(project.getName(), true);

						try {

							aMarker.delete();

						} catch (CoreException e) {

							// Do nothing, the markers are a bit unstable, an

							// exception will only occur if the marker has

							// already been deleted.

						}

					}

				}

			}

		} catch (CoreException e) {

			Logger.log(e.getMessage(), e);

		}

	}

	public void closeEditor(final IFile oldProjectFile) {

		Display.getDefault().asyncExec(new Runnable() {

			public void run() {

				IWorkbenchPage page = PlatformUI.getWorkbench()

						.getActiveWorkbenchWindow().getActivePage();

				IEditorPart oldEditor = page.findEditor(new FileEditorInput(

						oldProjectFile));

				page.closeEditor(oldEditor, false);

			}

		});

	}

	private IResourceDelta[] getAddedItems(IResourceDelta delta,

			IProject project) {

		IResourceDelta[] added = null;

		if (delta.getFullPath().equals(Path.ROOT)) {

			IResourceDelta[] children = delta

					.getAffectedChildren(IResourceDelta.CHANGED);

			for (IResourceDelta child : children) {

				added = child.getAffectedChildren(IResourceDelta.ADDED);

				break;

			}

		} else if (project.getFullPath().equals(delta.getFullPath())) {

			added = delta.getAffectedChildren(IResourceDelta.ADDED);

		}

		return added;

	}

	private IResourceDelta[] getDeletedItems(IResourceDelta delta,

			IProject project) {

		IResourceDelta[] deleted = null;

		if (delta.getFullPath().equals(Path.ROOT)) {

			IResourceDelta[] children = delta

					.getAffectedChildren(IResourceDelta.CHANGED);

			for (IResourceDelta child : children) {

				deleted = child.getAffectedChildren(IResourceDelta.REMOVED);

				break;

			}

		} else if (project.getFullPath().equals(delta.getFullPath())) {

			deleted = delta.getAffectedChildren(IResourceDelta.REMOVED);

		}

		return deleted;

	}

	private IPath getDeltaPath(IResourceDelta delta, IProject project) {

		IPath deltaPath = null;

		if (delta.getFullPath().equals(Path.ROOT)) {

			IResourceDelta[] children = delta

					.getAffectedChildren(IResourceDelta.CHANGED);

			for (IResourceDelta child : children) {

				deltaPath = child.getFullPath();

				break;

			}

		} else if (project.getFullPath().equals(delta.getFullPath())) {

			deltaPath = delta.getFullPath();

		}

		return deltaPath;

	}

	public void handleDelta(IResourceDelta delta, final IProject project) {

		checkPropertyChangeMarkers(project);

		if (delta != null) {

			IScopeContext projectScope = new ProjectScope(project);

			PersistentDataStore store = new PersistentDataStore(projectScope

					.getNode(Activator.PLUGIN_ID));

			// Check to see if the System Model diagram name has changed

			checkPropertyChangeMarkers(project); // True means that name has

													// changed

			// Get the added and deleted items, we use these to work out what

			// has happened

			IResourceDelta[] deletedItems = getDeletedItems(delta, project);

			IResourceDelta[] addedItems = getAddedItems(delta, project);

			// If the diagram has been deleted but a new one hasn't been added

			// then close the editor

			if (addedItems != null & deletedItems != null

					&& deletedItems.length == 1 && addedItems.length == 0) {

				final String deletedfile = deletedItems[0].getFullPath()

						.toString();

				String outputName = store.getOutputFilename();

				String resourceName = getDeltaPath(delta, project).append(

						outputName).toString();

				// Check that it was the system model diagram what was deleted,

				// we are not interested in any other files

				if (deletedfile.equals(resourceName)) {

					IFile oldProjectFile = project.getFile(store

							.getOutputFilename());

					closeEditor(oldProjectFile);

					dirtyProjects.put(project.getName(), true);

				}

			}

			// Otherwise if the diagram has been deleted and a new one added

			// then the diagram has been renamed

			else if (addedItems != null & deletedItems != null

					&& deletedItems.length == 1 && addedItems.length == 1) {

				String outputName = store.getOutputFilename();

				if (outputName == null) {

					return;

				}

				final String deletedfile = deletedItems[0].getFullPath()

						.toString();

				final String addedfile = addedItems[0].getFullPath().toString();

				String resourceName = getDeltaPath(delta, project).append(

						outputName).toString();

				if (addedfile.equals(resourceName)

						|| deletedfile.equals(resourceName)) {

					final String oldOutputName = new File(deletedfile)

							.getName();

					// Will add the .svg extension if required and also rename

					// the file

					final String newOutputName = checkModelNameExtension(

							project, addedItems[0].getResource(), new File(

									addedfile).getName());

					// Update the project properties with the new model name

					updatePropertiesWithModelName(store, resourceName,

							deletedfile, newOutputName);

					final IFile newProjectFile = project.getFile(newOutputName);

					Boolean isDirty = false;

					if (dirtyProjects.containsKey(project.getName())) {

						isDirty = dirtyProjects.get(project.getName());

					}

					if (delta.getAffectedChildren(IResourceDelta.CHANGED).length <= 1

							&& !isDirty) {

						Display.getDefault().asyncExec(new Runnable() {

							public void run() {

								if (newProjectFile.exists()

										&& !newProjectFile.isPhantom()) {

									try {

										IWorkbenchPage page = PlatformUI

												.getWorkbench()

												.getActiveWorkbenchWindow()

												.getActivePage();

										FileEditorInput editorInput = new FileEditorInput(

												newProjectFile);

										IEditorPart oldEditor = page

												.findEditor(new FileEditorInput(

														project

																.getFile(oldOutputName)));

										page.closeEditor(oldEditor, false);

										page.openEditor(editorInput,

												SVGEditor.ID);

									} catch (PartInitException e) {

										Logger.log(e.getMessage(), e);

									}

								}

							}

						});

					}

				}

			} else { // Nothing has been deleted and nothing has been added - A

						// file has been amended.

				IResourceDelta[] children = delta

						.getAffectedChildren(IResourceDelta.CHANGED);

				for (IResourceDelta child : children) {

					if (child.getResource() instanceof IFile) {

						if (child.getResource().getFileExtension()

								.equalsIgnoreCase("xml")) {

							dirtyProjects.put(project.getName(), true);

						}

					} else if (child.getResource() instanceof IProject) {

						if (child.getFlags() == IResourceDelta.OPEN) {

							dirtyProjects.put(child.getResource().getName(),

									true);

						}

					} else if (child.getResource() instanceof IFolder) {

						IResourceDelta[] moreChildren = child

								.getAffectedChildren(IResourceDelta.CHANGED);

						for (IResourceDelta littlerChild : moreChildren) {

							if (littlerChild.getResource().getFileExtension()

									.equalsIgnoreCase("xml")) {

								dirtyProjects.put(project.getName(), true);

							}

						}

					}

				}

			}

		}

	}

	public void remove(IProject project) {

		if (dirtyProjects.containsKey(project.getName())) {

			dirtyProjects.remove(project.getName());

		}

	}

	public boolean needsBuilding(IProject project) {

		if (dirtyProjects.containsKey(project.getName())) {

			return dirtyProjects.get(project.getName());

		}

		IScopeContext projectScope = new ProjectScope(project);

		PersistentDataStore store = new PersistentDataStore(projectScope

				.getNode(Activator.PLUGIN_ID));

		if (!project.getFile(store.getOutputFilename()).exists()) {

			return true;

		}

		return false;

	}

	public void reset(IProject project) {

		dirtyProjects.put(project.getName(), false);

	}

	private void updatePropertiesWithModelName(final PersistentDataStore store,

			final String resourceName, final String deletedfile,

			final String outName) {

		WorkspaceJob wj = new WorkspaceJob("updating properties") {

			@Override

			public IStatus runInWorkspace(IProgressMonitor monitor)

					throws CoreException {

				if (deletedfile.equals(resourceName)) {

					store.setOutputFilename(outName);

				}

				return new Status(IStatus.OK, Activator.PLUGIN_ID, IStatus.OK,

						"updating properties succeeded", null);

			}

		};

		wj.schedule();

	}

}