/*******************************************************************************
 * Copyright (c) 2003, 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 API and implementation
 *******************************************************************************/
package org.eclipse.jst.j2ee.internal.common.operations;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jst.j2ee.application.internal.operations.ClassPathSelection;
import org.eclipse.jst.j2ee.application.internal.operations.ClasspathElement;
import org.eclipse.wst.common.frameworks.internal.DoNotUseMeThisWillBeDeletedPost15;
import org.eclipse.wst.common.frameworks.internal.enablement.nonui.WFTWrappedException;
import org.eclipse.wst.common.frameworks.internal.operations.IHeadlessRunnableWithProgress;

/**
 * {@link DoNotUseMeThisWillBeDeletedPost15}
 * 
 * @deprecated This should no longer be necessary because of the new EAR & Web Lib classpath
 *             containers
 */
public class UpdateJavaBuildPathOperation implements IHeadlessRunnableWithProgress {
	protected IJavaProject javaProject;
	protected ClassPathSelection classPathSelection;
	// All the Java build path entries created by the classpath selection
	protected Set allClasspathEntries;
	protected List allUnselectedClasspathEntries;

	/**
	 * UpdateJavaBuildPathOperation constructor comment.
	 */
	public UpdateJavaBuildPathOperation(IJavaProject aJavaProject, ClassPathSelection aClassPathSelection) {
		super();
		javaProject = aJavaProject;
		classPathSelection = aClassPathSelection;
		allClasspathEntries = new HashSet();
		IClasspathEntry[] classpathEntry = aClassPathSelection.getClasspathEntriesForSelected();
		if (classpathEntry != null)
			allClasspathEntries.addAll(Arrays.asList(classpathEntry));
	}

	/**
	 * UpdateJavaBuildPathOperation constructor comment.
	 */
	public UpdateJavaBuildPathOperation(IJavaProject aJavaProject, ClassPathSelection selected, ClassPathSelection unselected) {
		super();
		javaProject = aJavaProject;
		classPathSelection = selected;
		allClasspathEntries = new HashSet();
		if (selected != null && !selected.getClasspathElements().isEmpty())
			allClasspathEntries.addAll(Arrays.asList(selected.getClasspathEntriesForSelected()));

		allUnselectedClasspathEntries = new ArrayList();
		if (unselected != null && !unselected.getClasspathElements().isEmpty())
			allUnselectedClasspathEntries.addAll(unselected.getClasspathElements());
	}

	public UpdateJavaBuildPathOperation(IJavaProject aJavaProject, ClassPathSelection selected, List unselected) {
		super();
		javaProject = aJavaProject;
		classPathSelection = selected;
		allClasspathEntries = new HashSet();
		if (selected != null && !selected.getClasspathElements().isEmpty())
			allClasspathEntries.addAll(Arrays.asList(selected.getClasspathEntriesForSelected()));

		allUnselectedClasspathEntries = new ArrayList();
		if (unselected != null && !unselected.isEmpty())
			allUnselectedClasspathEntries.addAll(unselected);
	}

	protected void ensureClasspathEntryIsExported(List cp, IClasspathEntry entry) {
		if (entry.isExported())
			return;
		int index = getIndex(cp, entry);
		IClasspathEntry newEntry = null;
		switch (entry.getEntryKind()) {
			case IClasspathEntry.CPE_PROJECT :
				newEntry = JavaCore.newProjectEntry(entry.getPath(), true);
				break;
			case IClasspathEntry.CPE_LIBRARY :
				newEntry = JavaCore.newLibraryEntry(entry.getPath(), entry.getSourceAttachmentPath(), entry.getSourceAttachmentRootPath(), true);
				break;
			case IClasspathEntry.CPE_VARIABLE :
				newEntry = JavaCore.newVariableEntry(entry.getPath(), entry.getSourceAttachmentPath(), entry.getSourceAttachmentRootPath());
		}
		cp.set(index, newEntry);
	}

	protected IClasspathEntry ensureElementInList(List cp, ClasspathElement element, IClasspathEntry predecessor) {
		IClasspathEntry addedEntry = null;
		// The element might have multiple entries in the case of
		// the imported_classes.jar file
		IClasspathEntry[] cpEntries = element.newClasspathEntries();
		if (cpEntries == null || cpEntries.length == 0)
			// indicates an invalid entry
			return null;

		int predecessorPos = predecessor == null ? -1 : getIndex(cp, predecessor);
		addedEntry = cpEntries[0];
		// Ensure that the first item is in the list, and follows
		// the predecessor if specified; preserve existing items in
		// the case of source attachments
		int pos = getIndex(cp, addedEntry);
		if (pos == -1) {
			if (predecessorPos == -1)
				cp.add(addedEntry);
			else
				cp.add(predecessorPos + 1, addedEntry);
		} else {
			addedEntry = (IClasspathEntry) cp.get(pos);
			if (pos < predecessorPos) {
				cp.remove(addedEntry);
				cp.add(predecessorPos, addedEntry);
			}
		}
		ensureClasspathEntryIsExported(cp, addedEntry);

		// Remove and add so we can ensure the proper order; this
		// is the case of the imported_classes.jar; we always want it
		// directly after the project
		for (int i = 1; i < cpEntries.length; i++) {
			int index = getIndex(cp, cpEntries[i]);
			if (index != -1) {
				addedEntry = (IClasspathEntry) cp.get(index);
				cp.remove(index);
			} else
				addedEntry = cpEntries[i];
			pos = getIndex(cp, cpEntries[0]);
			cp.add(pos + 1, addedEntry);
		}
		return addedEntry;
	}

	protected int getIndex(List cp, IClasspathEntry entry) {
		for (int i = 0; i < cp.size(); i++) {
			IClasspathEntry elmt = (IClasspathEntry) cp.get(i);
			if (elmt.getPath().equals(entry.getPath()))
				return i;
		}
		return -1;
	}

	protected void ensureElementNotInList(List cp, ClasspathElement element) {
		IClasspathEntry[] cpEntries = element.newClasspathEntries();
		if (cpEntries == null || cpEntries.length == 0)
			return;
		for (int i = 0; i < cpEntries.length; i++) {
			if (allClasspathEntries.contains(cpEntries[i]))
				// This may be included indirectly by a transitive dependency
				continue;
			int index = getIndex(cp, cpEntries[i]);
			if (index != -1)
				cp.remove(index);
		}
	}

	protected void ensureRemoveElementInList(List cp, ClasspathElement element) {
		IClasspathEntry[] cpEntries = element.newClasspathEntries();
		if (cpEntries == null || cpEntries.length == 0)
			return;
		for (int i = 0; i < cpEntries.length; i++) {
			if (cp.contains(cpEntries[i])) {
				int index = getIndex(cp, cpEntries[i]);
				if (index != -1)
					cp.remove(index);
			}
		}
	}

	/**
	 * Runs this operation. Progress should be reported to the given progress monitor. This method
	 * is usually invoked by an <code>IRunnableContext</code>'s<code>run</code> method, which
	 * supplies the progress monitor. A request to cancel the operation should be honored and
	 * acknowledged by throwing <code>InterruptedException</code>.
	 * 
	 * @param monitor
	 *            the progress monitor to use to display progress and receive requests for
	 *            cancelation
	 * @exception InvocationTargetException
	 *                if the run method must propagate a checked exception, it should wrap it inside
	 *                an <code>InvocationTargetException</code>; runtime exceptions are
	 *                automatically wrapped in an <code>InvocationTargetException</code> by the
	 *                calling context
	 * @exception InterruptedException
	 *                if the operation detects a request to cancel, using
	 *                <code>IProgressMonitor.isCanceled()</code>, it should exit by throwing
	 *                <code>InterruptedException</code>
	 * 
	 * @see IRunnableContext#run
	 */
	public void run(org.eclipse.core.runtime.IProgressMonitor monitor) throws java.lang.reflect.InvocationTargetException, InterruptedException {
		try {
			String[] prevRequiredProjects = javaProject.getRequiredProjectNames();
			List cp = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
			List classpathElements = classPathSelection.getClasspathElements();
			IClasspathEntry predecessor = null;
			IClasspathEntry result = null;
			for (int i = 0; i < classpathElements.size(); i++) {
				ClasspathElement element = (ClasspathElement) classpathElements.get(i);
				if (element.isSelected()) {
					result = ensureElementInList(cp, element, predecessor);
					if (result != null)
						predecessor = result;
				} else
					ensureElementNotInList(cp, element);
			}
			filterUnselectedEntries(cp);
			IClasspathEntry[] newCp = ((IClasspathEntry[]) cp.toArray(new IClasspathEntry[cp.size()]));
			javaProject.setRawClasspath(newCp, monitor);
			updateRequiredProjects(javaProject, prevRequiredProjects, new SubProgressMonitor(monitor, 1));
		} catch (Exception ex) {
			throw new WFTWrappedException(ex);
		}
	}

	private void filterUnselectedEntries(List cp) {
		if (allUnselectedClasspathEntries != null) {
			for (int i = 0; i < allUnselectedClasspathEntries.size(); i++) {
				ClasspathElement element = (ClasspathElement) allUnselectedClasspathEntries.get(i);
				ensureRemoveElementInList(cp, element);
			}
		}
	}

	protected void updateRequiredProjects(IJavaProject jproject, String[] prevRequiredProjects, IProgressMonitor monitor) throws CoreException {
		String[] newRequiredProjects = jproject.getRequiredProjectNames();

		ArrayList prevEntries = new ArrayList(Arrays.asList(prevRequiredProjects));
		ArrayList newEntries = new ArrayList(Arrays.asList(newRequiredProjects));

		IProject proj = jproject.getProject();
		IProjectDescription projDesc = proj.getDescription();

		ArrayList newRefs = new ArrayList();
		IProject[] referencedProjects = projDesc.getReferencedProjects();
		for (int i = 0; i < referencedProjects.length; i++) {
			String curr = referencedProjects[i].getName();
			if (newEntries.remove(curr) || !prevEntries.contains(curr)) {
				newRefs.add(referencedProjects[i]);
			}
		}
		IWorkspaceRoot root = proj.getWorkspace().getRoot();
		for (int i = 0; i < newEntries.size(); i++) {
			String curr = (String) newEntries.get(i);
			newRefs.add(root.getProject(curr));
		}
		projDesc.setReferencedProjects((IProject[]) newRefs.toArray(new IProject[newRefs.size()]));
		proj.setDescription(projDesc, monitor);
	}
}