//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation 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:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.project;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.epf.library.LibraryPlugin;
import org.eclipse.epf.uma.MethodLibrary;


/**
 * Helper class for managing the Method Library Projects in a workspace.
 * 
 * @author Kelvin Low
 * @author Jinhua Xi
 * 
 * @since 1.0
 */
public class MethodLibraryProject {

	/**
	 * Creates a new method library project in the current workspace.
	 * 
	 * @param path
	 *            An absolute path to a method library.
	 * @param projectName
	 *            A name for the new method library project.
	 * @param monitor
	 *            A progress monitor.
	 * @return A method library project.
	 * @throws CoreException
	 *             if an error occurs while performing the operation.
	 */
	public static IProject createProject(String path, String projectName,
			IProgressMonitor monitor) throws CoreException {
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		
		// find the project by path
		IProject project = findProject(path);		
		if (project != null ) {
			project.delete(IProject.FORCE
					| IProject.NEVER_DELETE_PROJECT_CONTENT, monitor);
		}
		
		if ( projectName == null ) {
			File libraryPath = new File(path);
			projectName = libraryPath.getName();
			if(!Workspace.caseSensitive) {
				// this is a non-case-sensitive file system
				// find existing method library project with different case variant
				//
				IProject[] projects = workspace.getRoot().getProjects();
				for (IProject prj : projects) {
					if(isMethodLibraryProject(prj) && prj.getName().equalsIgnoreCase(projectName)) {
						project = prj;
						break;
					}
				}
			}
		}
		if(project == null) {
			project = workspace.getRoot().getProject(projectName);
		}
		
		// if a project of the same name also exists, delete it
		// this is needed to take care of the following scenario:
		// a project is opened but not closed for some reason
		// now create a new library with the same name (same library folder)
		// we need to delete the previous one
		if (project.exists()) {
			project.delete(IProject.FORCE
					| IProject.NEVER_DELETE_PROJECT_CONTENT, monitor);
		}		

		IProjectDescription description = workspace
				.newProjectDescription(projectName);
		description.setNatureIds(MethodLibraryProjectNature.NATURE_IDS);
		IPath projectPath = new Path(path);
		if (!Platform.getLocation().isPrefixOf(projectPath)) {
			description.setLocation(projectPath);
		}
		project.create(description, monitor);
		return project;
	}

	/**
	 * Creates a new method library project in the current workspace.
	 * 
	 * @param path
	 *            An absolute path to a method library.
	 * @param monitor
	 *            A progress monitor.
	 * @return A <code>IProject</code> or <ocde>null</code> if the method
	 *         library project cannot be created.
	 * @throws CoreException
	 *             if an error occurs while performing the operation.
	 */
	public static IProject createProject(String path, IProgressMonitor monitor)
			throws CoreException {
//		IProject project = findProject(path);
//		if (project != null) {
//			project.delete(IProject.FORCE
//					| IProject.NEVER_DELETE_PROJECT_CONTENT, monitor);
//		}
//		File libraryPath = new File(path);
//		String projectPath = libraryPath.getAbsolutePath();
//		String projectName = libraryPath.getName();
//		return createProject(projectPath, projectName, monitor);
		
		return createProject(path, null, monitor);
	}

	/**
	 * Verifies that a workspace project is a method library project.
	 * 
	 * @param project
	 *            A workspace project.
	 * @return <code>true</code> if the given workspace project is a method
	 *         library project, <code>false</clode> otherwise.
	 */
	public static boolean isMethodLibraryProject(IProject project) {
		if (project != null) {
			boolean closeProjectOnExit = false;
			try {
				if (!project.isOpen()) {
					project.open(IResource.BACKGROUND_REFRESH,
							new NullProgressMonitor());
					closeProjectOnExit = true;
				}
				IProjectDescription description = project.getDescription();
				if (description != null) {
					String[] natureIds = description.getNatureIds();
					if (Arrays.asList(natureIds).contains(
							MethodLibraryProjectNature.NATURE_ID)) {
						return true;
					}
				}
			} catch (CoreException e) {
			} finally {
				if (closeProjectOnExit) {
					try {
						project.close(new NullProgressMonitor());
					} catch (CoreException e) {
					}
				}
			}

		}
		return false;
	}

	/**
	 * Locates a method library project in the current workspace.
	 * 
	 * @param path
	 *            An absolute path to a method library.
	 * @return A <code>IProject</code> or <ocde>null</code> if the method
	 *         library project cannot be found.
	 */
	public static IProject findProject(String path) {
		if (path == null) {
			return null;
		}
		final IWorkspace workspace = ResourcesPlugin.getWorkspace();
		IProject[] projects = workspace.getRoot().getProjects();
		try {
			for (int i = 0; i < projects.length; i++) {
				IProject project = projects[i];
				if (new File(path).compareTo(project.getLocation().toFile()) == 0
						&& isMethodLibraryProject(project)) {
					return project;
				}
				if (new File(path).compareTo(project.getLocation().toFile()) == 0) {
					return project;
				}
			}
		} catch (Exception e) {
			LibraryPlugin.getDefault().getLogger().logError(e);
		}
		return null;
	}

	/**
	 * Locates a method library project in the current workspace.
	 * 
	 * @param library
	 *            A method library.
	 * @return A <code>IProject</code> or <ocde>null</code> if the method
	 *         library project cannot be found.
	 */
	public static IProject findProject(MethodLibrary library) {
		return findProject(getLibraryPath(library));
	}

	/**
	 * Opens an existing method library project in the current workspace.
	 * <p>
	 * If the method library project cannot be located, create a new one.
	 * 
	 * @param path
	 *            An absolute path to a method library.
	 * @param monitor
	 *            A progress monitor.
	 * @throws IOException
	 *             if an I/O error occurs while performing the operation.
	 * @return A <code>IProject</code>.
	 * @throws CoreException
	 *             if an error occurs while performing the operation.
	 * @throws IOException 
	 */
	public static IProject openProject(String path, IProgressMonitor monitor) 
			throws CoreException, IOException {
		return openProject(path, null,  monitor);
	}

	/**
	 * Opens an existing method library project in the current workspace.
	 * <p>
	 * If the method library project cannot be located, create a new one.
	 * 
	 * @param path
	 *            An absolute path to a method library.
	 * @param monitor
	 *            A progress monitor.
	 * @throws IOException
	 *             if an I/O error occurs while performing the operation.
	 * @return A <code>IProject</code>.
	 * @throws CoreException
	 *             if an error occurs while performing the operation.
	 * @throws IOException 
	 */
	public static IProject openProject(String path, String projectName, IProgressMonitor monitor)
			throws CoreException, IOException {
		IPath projectPath = new Path(path + File.separator
				+ IProjectDescription.DESCRIPTION_FILE_NAME);

		IProjectDescription description;
		try {
			description = ResourcesPlugin.getWorkspace()
					.loadProjectDescription(projectPath);
		} catch (CoreException exception) {
			description = null;
		}

		IProject project = null;

		if (description == null) {
			// .project file is missing, create a new method library
			// project.
			project = MethodLibraryProject.createProject(path, projectName, monitor);
		} else {
			// .project file exists, retrieve the project from the
			// workspace.
			if ( projectName != null ) {
				description.setName(projectName);
			}
			
			project = ResourcesPlugin.getWorkspace().getRoot().getProject(
					description.getName());
			if (!project.exists()) {
				// The project does not exist in the workspace. Create a new
				// method library project using the project name from the
				// .project file.
				project = MethodLibraryProject.createProject(path, project
						.getName(), monitor);
			} else {
				// The project does exist in the workspace.
				// Verify that the location matches. If not, create a new method
				// library project.
				File prjLoc = project.getLocation().toFile();
				File libLoc = new File(path);
				if (libLoc.compareTo(prjLoc) != 0) {
					project = MethodLibraryProject.createProject(path, monitor);
				} else if(!libLoc.getCanonicalPath().equals(prjLoc.getAbsolutePath())) {
					// letter case change in library path from the last time it was opened
					// the project need to be recreate to clear cache of path names
					//
					project.delete(IProject.FORCE
							| IProject.NEVER_DELETE_PROJECT_CONTENT, monitor);
					project = MethodLibraryProject.createProject(path, monitor);
				}
			}
		}

		if (!project.isOpen()) {
			project.open(IResource.BACKGROUND_REFRESH, monitor);
		}

		if (description == null) {
			description = project.getDescription();
		}

		// Make sure the project has the MethodLibraryProjectNature.
		String[] natureIds = description.getNatureIds();
		if (!Arrays.asList(natureIds).contains(
				MethodLibraryProjectNature.NATURE_ID)) {
			description.setNatureIds(MethodLibraryProjectNature.NATURE_IDS);
			project.setDescription(description, IProject.FORCE
					| IProject.KEEP_HISTORY, monitor);
		}

		return project;
	}

	/**
	 * Closes a method library project in the workspace.
	 * 
	 * @param path
	 *            An absolute path to a method library.
	 * @param monitor
	 *            A progress monitor.
	 * @throws CoreException
	 *             if an error occurs while performing the operation.
	 */
	public static void closeProject(String path, IProgressMonitor monitor)
			throws CoreException {
		IProject project = findProject(path);
		// check if workspace is modifiable
		if (project != null && !project.getWorkspace().isTreeLocked() && project.isOpen()) {
			project.close(monitor);
		}
	}

	/**
	 * Closes a method library project in the workspace.
	 * 
	 * @param library
	 *            A method library.
	 * @param monitor
	 *            A progress monitor.
	 * @throws CoreException
	 *             if an error occurs while performing the operation.
	 */
	public static void closeProject(MethodLibrary library,
			IProgressMonitor monitor) throws CoreException {
		closeProject(getLibraryPath(library), monitor);
	}

	/**
	 * Deletes a method library project from the current workspace.
	 * 
	 * @param path
	 *            An absolute path to a method library.
	 * @param monitor
	 *            A progress monitor.
	 * @return <code>true</code> if the method library project is successfully
	 *         deleted, <code>false</code> otherwise.
	 * @throws CoreException
	 *             if an error occurs while performing the operation.
	 */
	public static boolean deleteProject(String path, IProgressMonitor monitor) {
		IProject project = findProject(path);
		if (project != null) {
			try {
				if (monitor == null) {
					monitor = new NullProgressMonitor();
				}
				project.delete(IProject.FORCE
						| IProject.NEVER_DELETE_PROJECT_CONTENT, monitor);
			} catch (CoreException e) {
				LibraryPlugin.getDefault().getLogger().logError(e);
				return false;
			}
		}
		return true;
	}

	/**
	 * Deletes a method library project from the current workspace.
	 * 
	 * @param library
	 *            A method library.
	 * @param monitor
	 *            A progress monitor.
	 * @return <code>true</code> if the method library project is successfully
	 *         deleted, <code>false</code> otherwise.
	 */
	public static boolean deleteProject(MethodLibrary library,
			IProgressMonitor monitor) {
		return deleteProject(getLibraryPath(library), monitor);
	}

	/**
	 * Returns the absolute path to a method library.
	 * 
	 * @param library
	 * @return An absolute path to a method library.
	 */
	private static String getLibraryPath(MethodLibrary library) {
		return new File(library.eResource().getURI().toFileString())
				.getParent();
	}

}