/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sebastian Davids <sdavids@gmx.de> bug 38692
 *******************************************************************************/

package org.eclipse.jdt.internal.ui.javadocexport;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.eclipse.jdt.launching.ExecutionArguments;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

import org.eclipse.jface.dialogs.DialogSettings;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.ui.JavaUI;

import org.eclipse.jdt.internal.corext.Assert;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.preferences.JavadocPreferencePage;

public class JavadocOptionsManager {

	private IWorkspaceRoot fRoot;
	//consider making a List
	private List fProjects;
	private IFile fXmlfile;

	private StatusInfo fWizardStatus;

	private List fSourceElements;

	private List fSelectedElements;

	private String fAccess;
	private String fDocletpath;
	private String fDocletname;
	private boolean fFromStandard;
	private String fStylesheet;
	private String fAdditionalParams;
	private String fOverview;
	private String fTitle;

	private IPath[] fSourcepath;
	private IPath[] fClasspath;

	private boolean fNotree;
	private boolean fNoindex;
	private boolean fSplitindex;
	private boolean fNonavbar;
	private boolean fNodeprecated;
	private boolean fNoDeprecatedlist;
	private boolean fAuthor;
	private boolean fVersion;
	private boolean fUse;
	
	private boolean fJDK14Mode;

	private boolean fOpenInBrowser;

	//list of hrefs in string format
	private Map fLinks;

	//add-on for multi-project version
	private String fDestination;
	private String fDependencies;
	private String fAntpath;

	public final String PRIVATE= "private"; //$NON-NLS-1$
	public final String PROTECTED= "protected"; //$NON-NLS-1$
	public final String PACKAGE= "package"; //$NON-NLS-1$
	public final String PUBLIC= "public"; //$NON-NLS-1$

	public final String USE= "use"; //$NON-NLS-1$
	public final String NOTREE= "notree"; //$NON-NLS-1$
	public final String NOINDEX= "noindex"; //$NON-NLS-1$
	public final String NONAVBAR= "nonavbar"; //$NON-NLS-1$
	public final String NODEPRECATED= "nodeprecated"; //$NON-NLS-1$
	public final String NODEPRECATEDLIST= "nodeprecatedlist"; //$NON-NLS-1$
	public final String VERSION= "version"; //$NON-NLS-1$
	public final String AUTHOR= "author"; //$NON-NLS-1$
	public final String SPLITINDEX= "splitindex"; //$NON-NLS-1$
	public final String STYLESHEETFILE= "stylesheetfile"; //$NON-NLS-1$
	public final String OVERVIEW= "overview"; //$NON-NLS-1$
	public final String DOCLETNAME= "docletname"; //$NON-NLS-1$
	public final String DOCLETPATH= "docletpath"; //$NON-NLS-1$
	public final String SOURCEPATH= "sourcepath"; //$NON-NLS-1$
	public final String CLASSPATH= "classpath"; //$NON-NLS-1$
	public final String DESTINATION= "destdir"; //$NON-NLS-1$
	public final String OPENINBROWSER= "openinbrowser"; //$NON-NLS-1$	

	public final String VISIBILITY= "access"; //$NON-NLS-1$
	public final String PACKAGENAMES= "packagenames"; //$NON-NLS-1$
	public final String SOURCEFILES= "sourcefiles"; //$NON-NLS-1$
	public final String EXTRAOPTIONS= "additionalparam"; //$NON-NLS-1$
	public final String JAVADOCCOMMAND= "javadoccommand"; //$NON-NLS-1$
	public final String TITLE= "doctitle"; //$NON-NLS-1$
	public final String HREF= "href"; //$NON-NLS-1$

	public final String NAME= "name"; //$NON-NLS-1$
	public final String PATH= "path"; //$NON-NLS-1$
	private final String FROMSTANDARD= "fromStandard"; //$NON-NLS-1$
	private final String ANTPATH= "antpath"; //$NON-NLS-1$
	public final String SOURCE= "source"; //$NON-NLS-1$
	
	
	/**
	 * @param xmlJavadocFile The ant file to take initl values from or null, if not started from an ant file.
	 * @param setting Dialog settings for the Javadoc exporter.
	 */
	public JavadocOptionsManager(IFile xmlJavadocFile, IDialogSettings settings, ISelection currSelection) {
		Element element;
		this.fRoot= ResourcesPlugin.getWorkspace().getRoot();
		this.fXmlfile= xmlJavadocFile;
		this.fWizardStatus= new StatusInfo();
		this.fLinks= new HashMap();
		fProjects= new ArrayList();

		if (xmlJavadocFile != null) {
			try {
				JavadocReader reader= new JavadocReader(xmlJavadocFile.getContents());
				element= reader.readXML();
				IJavaProject p= reader.getProject();

				if (element == null || p == null) {
					fWizardStatus.setWarning(JavadocExportMessages.getString("JavadocOptionsManager.antfileincorrectCE.warning")); //$NON-NLS-1$
					loadStore(settings, currSelection);
				} else {
					fProjects.add(p);
					loadStore(element, settings);
				}
			} catch (CoreException e) {
				JavaPlugin.log(e);
				fWizardStatus.setWarning(JavadocExportMessages.getString("JavadocOptionsManager.antfileincorrectCE.warning")); //$NON-NLS-1$
				loadStore(settings, currSelection);
			} catch (IOException e) {
				JavaPlugin.log(e);
				fWizardStatus.setWarning(JavadocExportMessages.getString("JavadocOptionsManager.antfileincorrectIOE.warning")); //$NON-NLS-1$
				loadStore(settings, currSelection);
			} catch (SAXException e) {
				fWizardStatus.setWarning(JavadocExportMessages.getString("JavadocOptionsManager.antfileincorrectSAXE.warning")); //$NON-NLS-1$
				loadStore(settings, currSelection);
			}
		} else
			loadStore(settings, currSelection);
	}

	private void loadStore(IDialogSettings settings, ISelection sel) {

		if (settings != null) {
			//getValidSelection will also find the project
			fSelectedElements= getValidSelection(sel);

			fAccess= settings.get(VISIBILITY);
			if (fAccess == null)
				fAccess= PROTECTED;

			//this is defaulted to false.
			fFromStandard= settings.getBoolean(FROMSTANDARD);

			//doclet is loaded even if the standard doclet is being used
			fDocletpath= settings.get(DOCLETPATH);
			fDocletname= settings.get(DOCLETNAME);
			if (fDocletpath == null || fDocletname == null) {
				fFromStandard= true;
				fDocletpath= ""; //$NON-NLS-1$
				fDocletname= ""; //$NON-NLS-1$
			}

			//load a default antpath
			fAntpath= settings.get(ANTPATH);
			if (fAntpath == null)
				fAntpath= ""; //$NON-NLS-1$
			//$NON-NLS-1$

			//load a default antpath
			fDestination= settings.get(DESTINATION);
			if (fDestination == null)
				fDestination= ""; //$NON-NLS-1$
			//$NON-NLS-1$

			fTitle= settings.get(TITLE);
			if (fTitle == null)
				fTitle= ""; //$NON-NLS-1$

			fStylesheet= settings.get(STYLESHEETFILE);
			if (fStylesheet == null)
				fStylesheet= ""; //$NON-NLS-1$

			fAdditionalParams= settings.get(EXTRAOPTIONS);
			if (fAdditionalParams == null)
				fAdditionalParams= ""; //$NON-NLS-1$

			fOverview= settings.get(OVERVIEW);
			if (fOverview == null)
				fOverview= ""; //$NON-NLS-1$

			fUse= loadbutton(settings.get(USE));
			fAuthor= loadbutton(settings.get(AUTHOR));
			fVersion= loadbutton(settings.get(VERSION));
			fNodeprecated= loadbutton(settings.get(NODEPRECATED));
			fNoDeprecatedlist= loadbutton(settings.get(NODEPRECATEDLIST));
			fNonavbar= loadbutton(settings.get(NONAVBAR));
			fNoindex= loadbutton(settings.get(NOINDEX));
			fNotree= loadbutton(settings.get(NOTREE));
			fSplitindex= loadbutton(settings.get(SPLITINDEX));
			fOpenInBrowser= loadbutton(settings.get(OPENINBROWSER));
			
			fJDK14Mode= loadbutton(settings.get(SOURCE));

			//get the set of project specific data
			loadLinksFromDialogSettings(settings);

		} else
			loadDefaults(sel);
	}

	private String getDefaultAntPath(IJavaProject project) {
		if (project != null) {
			IPath path= project.getProject().getLocation();
			if (path != null)
				return path.append("javadoc.xml").toOSString(); //$NON-NLS-1$
		}

		return ""; //$NON-NLS-1$
	}

	private String getDefaultDestination(IJavaProject project) {
		if (project != null) {
			URL url= JavaUI.getProjectJavadocLocation(project);
			//uses default if source is has http protocol
			if (url == null || !url.getProtocol().equals("file")) { //$NON-NLS-1$
				IPath path= project.getProject().getLocation();
				if (path != null)
					return path.append("doc").toOSString(); //$NON-NLS-1$
			} else {
				//must do this to remove leading "/"
				return (new File(url.getFile())).getPath();
			}
		}

		return ""; //$NON-NLS-1$

	}
	/**
	* Method creates a list of data structes that contain
	* The destination, antfile location and the list of library/project references for every
	* project in the workspace.Defaults are created for new project.
	*/
	private void loadLinksFromDialogSettings(IDialogSettings settings) {

		//sets data for projects if stored in the dialog settings
		if (settings != null) {
			IDialogSettings links= settings.getSection("projects"); //$NON-NLS-1$
			if (links != null) {
				IDialogSettings[] projs= links.getSections();
				for (int i= 0; i < projs.length; i++) {
					IDialogSettings iDialogSettings= projs[i];
					String projectName= iDialogSettings.getName();
					IProject project= fRoot.getProject(projectName);
					//make sure project has not been removed
					if (project.exists()) {
						IJavaProject javaProject= JavaCore.create(project);
						if (!fLinks.containsKey(javaProject)) {
							String hrefs= iDialogSettings.get(HREF);
							if (hrefs == null) {
								hrefs= ""; //$NON-NLS-1$
							}
							String destdir= iDialogSettings.get(DESTINATION);
							if (destdir == null || destdir.length() == 0) {
								destdir= getDefaultDestination(javaProject);
							}
							String antpath= iDialogSettings.get(ANTPATH);
							if (antpath == null || antpath.length() == 0) {
								antpath= getDefaultAntPath(javaProject);
							}
							ProjectData data= new ProjectData();
							data.setDestination(destdir);
							data.setAntpath(antpath);
							data.setLinks(hrefs);
							if (!fLinks.containsValue(javaProject))
								fLinks.put(javaProject, data);
						}
					}
				}
			}
		}
		//finds projects in the workspace that have been added since the
		//last time the wizard was run
		IProject[] projects= fRoot.getProjects();
		for (int i= 0; i < projects.length; i++) {
			IProject iProject= projects[i];
			IJavaProject javaProject= JavaCore.create(iProject);
			if (!fLinks.containsKey(javaProject)) {
				ProjectData data= new ProjectData();
				data.setDestination(getDefaultDestination(javaProject));
				data.setAntpath(getDefaultAntPath(javaProject));
				data.setLinks(""); //$NON-NLS-1$
				fLinks.put(javaProject, data);
			}
		}
	}
	//loads defaults for wizard (nothing is stored)
	private void loadDefaults(ISelection sel) {
		fSelectedElements= getValidSelection(sel);

		fAccess= PUBLIC;

		fDocletname= ""; //$NON-NLS-1$
		fDocletpath= ""; //$NON-NLS-1$
		fTitle= ""; //$NON-NLS-1$
		fStylesheet= ""; //$NON-NLS-1$
		fAdditionalParams= ""; //$NON-NLS-1$
		fOverview= ""; //$NON-NLS-1$
		fAntpath= ""; //$NON-NLS-1$
		fDestination= ""; //$NON-NLS-1$

		fUse= true;
		fAuthor= true;
		fVersion= true;
		fNodeprecated= false;
		fNoDeprecatedlist= false;
		fNonavbar= false;
		fNoindex= false;
		fNotree= false;
		fSplitindex= true;
		fOpenInBrowser= false;
		fJDK14Mode= false;

		//by default it is empty all project map to the empty string
		fFromStandard= true;
		loadLinksFromDialogSettings(null);
	}

	private void loadStore(Element element, IDialogSettings settings) {

		fAccess= element.getAttribute(VISIBILITY);
		if (!(fAccess.length() > 0))
			fAccess= PROTECTED;

		//Since the selected packages are stored we must locate the project
		String destination= element.getAttribute(DESTINATION);
		fDestination= destination;
		fFromStandard= true;
		fDocletname= ""; //$NON-NLS-1$
		fDocletpath= ""; //$NON-NLS-1$

		if (destination.equals("")) { //$NON-NLS-1$
			NodeList list= element.getChildNodes();
			for (int i= 0; i < list.getLength(); i++) {
				Node child= list.item(i);
				if (child.getNodeName().equals("doclet")) { //$NON-NLS-1$
					fDocletpath= ((Element) child).getAttribute(PATH);
					fDocletname= ((Element) child).getAttribute(NAME);
					if (!(fDocletpath.equals("") && !fDocletname.equals(""))) { //$NON-NLS-1$ //$NON-NLS-2$
						fFromStandard= false;
					} else {
						fDocletname= ""; //$NON-NLS-1$
						fDocletpath= ""; //$NON-NLS-1$
					}
					break;
				}
			}
		}

		//find all the links stored in the ant script
		boolean firstTime= true;
		StringBuffer buf= new StringBuffer();
		NodeList children= element.getChildNodes();
		for (int i= 0; i < children.getLength(); i++) {
			Node child= children.item(i);
			if (child.getNodeName().equals("link")) { //$NON-NLS-1$
				String href= ((Element) child).getAttribute(HREF);
				if (firstTime)
					firstTime= false;
				else
					buf.append(';');
				buf.append(href);
			}
		}

		//associate all those links with each project selected	
		for (Iterator iter= fProjects.iterator(); iter.hasNext();) {
			IJavaProject iJavaProject= (IJavaProject) iter.next();

			ProjectData data= new ProjectData();
			IPath path= fXmlfile.getLocation();
			if (path != null)
				data.setAntpath(path.toOSString());
			else
				data.setAntpath(""); //$NON-NLS-1$
			data.setLinks(buf.toString());
			data.setDestination(destination);
			fLinks.put(iJavaProject, data);
		}

		//get tree elements
		setSelectedElementsFromAnt(element, (IJavaProject) fProjects.get(0));
		IPath p= fXmlfile.getLocation();
		if (p != null)
			fAntpath= p.toOSString();
		else
			fAntpath= ""; //$NON-NLS-1$

		fStylesheet= element.getAttribute(STYLESHEETFILE);
		fTitle= element.getAttribute(TITLE);
		fAdditionalParams= element.getAttribute(EXTRAOPTIONS);
		fOverview= element.getAttribute(OVERVIEW);

		fUse= loadbutton(element.getAttribute(USE));
		fAuthor= loadbutton(element.getAttribute(AUTHOR));
		fVersion= loadbutton(element.getAttribute(VERSION));
		fNodeprecated= loadbutton(element.getAttribute(NODEPRECATED));
		fNoDeprecatedlist= loadbutton(element.getAttribute(NODEPRECATEDLIST));
		fNonavbar= loadbutton(element.getAttribute(NONAVBAR));
		fNoindex= loadbutton(element.getAttribute(NOINDEX));
		fNotree= loadbutton(element.getAttribute(NOTREE));
		fSplitindex= loadbutton(element.getAttribute(SPLITINDEX));
	}

	/*
	 * Method creates an absolute path to the project. If the path is already
	 * absolute it returns the path. If it encounters any difficulties in
	 * creating the absolute path, the method returns null.
	 * 
	 * @param pathStr
	 * @return IPath
	 */
	private IPath makeAbsolutePathFromRelative(String pathStr) {
		IPath path= new Path(pathStr);
		if (!path.isAbsolute()) {
			if (fXmlfile == null) {
				return null;
			}
			IPath basePath= fXmlfile.getParent().getLocation(); // relative to the ant file location
			if (basePath == null) {
				return null;
			}
			return basePath.append(pathStr);
		}
		return path;
	}

	private void setSelectedElementsFromAnt(Element element, IJavaProject iJavaProject) {
		fSelectedElements= new ArrayList();

		//get all the packages in side the project
		String name;
		String packagenames= element.getAttribute(PACKAGENAMES);
		if (packagenames != null) {
			StringTokenizer tokenizer= new StringTokenizer(packagenames, ","); //$NON-NLS-1$
			while (tokenizer.hasMoreTokens()) {
				name= tokenizer.nextToken().trim();
				IJavaElement el;
				try {
					el= JavaModelUtil.findTypeContainer(iJavaProject, name);
				} catch (JavaModelException e) {
					JavaPlugin.log(e);
					continue;
				}
				if ((el != null) && (el instanceof IPackageFragment)) {
					fSelectedElements.add(el);
				}
			}
		}

		//get all CompilationUnites in side the project
		String sourcefiles= element.getAttribute(SOURCEFILES);
		if (sourcefiles != null) {
			StringTokenizer tokenizer= new StringTokenizer(sourcefiles, ","); //$NON-NLS-1$
			while (tokenizer.hasMoreTokens()) {
				name= tokenizer.nextToken().trim();
				if (name.endsWith(".java")) { //$NON-NLS-1$
					IPath path= makeAbsolutePathFromRelative(name);

					//if unable to create an absolute path the the resource skip it
					if (path == null)
						continue;

					IFile[] files= fRoot.findFilesForLocation(path);
					for (int i= 0; i < files.length; i++) {
						IFile curr= files[i];
						if (curr.getProject().equals(iJavaProject.getProject())) {
							IJavaElement el= JavaCore.createCompilationUnitFrom(curr);
							if (el != null) {
								fSelectedElements.add(el);
							}
						}
					}
				}
			}
		}
	}

	//it is possible that the package list is empty
	public StatusInfo getWizardStatus() {
		return fWizardStatus;
	}

	public IJavaElement[] getSelectedElements() {
		return (IJavaElement[]) fSelectedElements.toArray(new IJavaElement[fSelectedElements.size()]);
	}

	public IJavaElement[] getSourceElements() {
		return (IJavaElement[]) fSourceElements.toArray(new IJavaElement[fSourceElements.size()]);
	}

	public String getAccess() {
		return fAccess;
	}

	public String getGeneralAntpath() {
		return fAntpath;
	}

	public String getSpecificAntpath(IJavaProject project) {
		ProjectData data= (ProjectData) fLinks.get(project);
		if (data != null)
			return data.getAntPath();
		else
			return ""; //$NON-NLS-1$
	}

	public boolean fromStandard() {
		return fFromStandard;
	}

	//for now if multiple projects are selected the destination
	//feild will be empty, 
	public String getDestination(IJavaProject project) {

		ProjectData data= (ProjectData) fLinks.get(project);
		if (data != null)
			return data.getDestination();
		else
			return ""; //$NON-NLS-1$
	}

	public String getDestination() {
		return fDestination;
	}

	public String getDocletPath() {
		return fDocletpath;
	}

	public String getDocletName() {
		return fDocletname;
	}

	public String getStyleSheet() {
		return fStylesheet;
	}

	public String getOverview() {
		return fOverview;
	}

	public String getAdditionalParams() {
		return fAdditionalParams;
	}

	public IPath[] getClasspath() {
		return fClasspath;
	}

	public IPath[] getSourcepath() {
		return fSourcepath;
	}

	public IWorkspaceRoot getRoot() {
		return fRoot;
	}

	//	public IJavaProject[] getJavaProjects() {
	//		return (IJavaProject[]) fProjects.toArray(new IJavaProject[fProjects.size()]);
	//	}

	//Use only this one later
	public List getJavaProjects() {
		return fProjects;
	}

	public String getTitle() {
		return fTitle;
	}

	public String getLinks(IJavaProject project) {
		ProjectData data= (ProjectData) fLinks.get(project);
		if (data != null)
			return data.getLinks();
		else
			return ""; //$NON-NLS-1$
	}

	public String getDependencies() {
		return fDependencies;
	}

	public Map getLinkMap() {
		return fLinks;
	}

	public boolean doOpenInBrowser() {
		return fOpenInBrowser;
	}

	public boolean getBoolean(String flag) {

		if (flag.equals(AUTHOR))
			return fAuthor;
		else if (flag.equals(VERSION))
			return fVersion;
		else if (flag.equals(USE))
			return fUse;
		else if (flag.equals(NODEPRECATED))
			return fNodeprecated;
		else if (flag.equals(NODEPRECATEDLIST))
			return fNoDeprecatedlist;
		else if (flag.equals(NOINDEX))
			return fNoindex;
		else if (flag.equals(NOTREE))
			return fNotree;
		else if (flag.equals(SPLITINDEX))
			return fSplitindex;
		else if (flag.equals(NONAVBAR))
			return fNonavbar;
		else
			return false;
	}

	private boolean loadbutton(String value) {

		if (value == null || value.equals("")) //$NON-NLS-1$
			return false;
		else {
			if (value.equals("true")) //$NON-NLS-1$
				return true;
			else
				return false;
		}
	}
	
	private String flatPathList(IPath[] paths) {
		StringBuffer buf= new StringBuffer();
		for (int i= 0; i < paths.length; i++) {
			if (i > 0) {
				buf.append(File.pathSeparatorChar);
			}
			buf.append(paths[i].toOSString());
		}
		return buf.toString();
	}
	

	public String[] createArgumentArray() throws CoreException {
		if (fProjects.isEmpty()) {
			return new String[0];
		}

		List args= new ArrayList();
		//bug 38692
		args.add(JavadocPreferencePage.getJavaDocCommand());
		if (fFromStandard) {
			args.add("-d"); //$NON-NLS-1$
			args.add(fDestination);
		} else {
			if (!fAdditionalParams.equals("")) { //$NON-NLS-1$
				ExecutionArguments tokens= new ExecutionArguments("", fAdditionalParams); //$NON-NLS-1$
				String[] argsArray= tokens.getProgramArgumentsArray();
				for (int i= 0; i < argsArray.length; i++) {
					args.add(argsArray[i]);
				}
			}
			args.add("-doclet"); //$NON-NLS-1$
			args.add(fDocletname);
			args.add("-docletpath"); //$NON-NLS-1$
			args.add(fDocletpath);
		}
		args.add("-sourcepath"); //$NON-NLS-1$
		args.add(flatPathList(fSourcepath));
		args.add("-classpath"); //$NON-NLS-1$
		args.add(flatPathList(fClasspath));
		args.add("-" + fAccess); //$NON-NLS-1$

		if (fFromStandard) {
			if (fJDK14Mode) {
				args.add("-source"); //$NON-NLS-1$
				args.add("1.4"); //$NON-NLS-1$
			}			
			
			if (fUse)
				args.add("-use"); //$NON-NLS-1$
			if (fVersion)
				args.add("-version"); //$NON-NLS-1$
			if (fAuthor)
				args.add("-author"); //$NON-NLS-1$
			if (fNonavbar)
				args.add("-nonavbar"); //$NON-NLS-1$
			if (fNoindex)
				args.add("-noindex"); //$NON-NLS-1$
			if (fNotree)
				args.add("-notree"); //$NON-NLS-1$
			if (fNodeprecated)
				args.add("-nodeprecated"); //$NON-NLS-1$
			if (fNoDeprecatedlist)
				args.add("-nodeprecatedlist"); //$NON-NLS-1$
			if (fSplitindex)
				args.add("-splitindex"); //$NON-NLS-1$

			if (!fTitle.equals("")) { //$NON-NLS-1$
				args.add("-doctitle"); //$NON-NLS-1$
				args.add(fTitle);
			}


			if (!fStylesheet.equals("")) { //$NON-NLS-1$
				args.add("-stylesheetfile"); //$NON-NLS-1$
				args.add(fStylesheet);
			}

			if (!fAdditionalParams.equals("")) { //$NON-NLS-1$
				ExecutionArguments tokens= new ExecutionArguments("", fAdditionalParams); //$NON-NLS-1$
				String[] argsArray= tokens.getProgramArgumentsArray();
				for (int i= 0; i < argsArray.length; i++) {
					args.add(argsArray[i]);
				}
			}

			String hrefs= (String) fDependencies;
			StringTokenizer tokenizer= new StringTokenizer(hrefs, ";"); //$NON-NLS-1$
			while (tokenizer.hasMoreElements()) {
				String href= (String) tokenizer.nextElement();
				args.add("-link"); //$NON-NLS-1$
				args.add(href);
			}
		} //end standard options

		if (!fOverview.equals("")) { //$NON-NLS-1$
			args.add("-overview"); //$NON-NLS-1$
			args.add(fOverview);
		}

		for (int i= 0; i < fSourceElements.size(); i++) {
			IJavaElement curr= (IJavaElement) fSourceElements.get(i);
			if (curr instanceof IPackageFragment) {
				args.add(curr.getElementName());
			} else if (curr instanceof ICompilationUnit) {
				IPath p= curr.getResource().getLocation();
				if (p != null)
					args.add(p.toOSString());
			}
		}

		String[] res= (String[]) args.toArray(new String[args.size()]);
		return res;

	}

	public void createXML() {
		FileOutputStream objectStreamOutput= null;
		//@change
		//for now only writting ant files for single project selection
		String antpath= fAntpath;
		try {
			if (!antpath.equals("")) { //$NON-NLS-1$
				File file= new File(antpath);

				IPath antPath= new Path(antpath);
				IPath antDir= antPath.removeLastSegments(1);
				
				IPath basePath= null;
				
				Assert.isTrue(fProjects.size() == 1);
				IJavaProject jproject= (IJavaProject) fProjects.get(0);
				IWorkspaceRoot root= jproject.getProject().getWorkspace().getRoot();
				if (root.findFilesForLocation(antPath).length > 0) {
					basePath= antDir; // only do relative path if ant file is stored in the workspace
				}
				
				antDir.toFile().mkdirs();

				objectStreamOutput= new FileOutputStream(file);
				JavadocWriter writer= new JavadocWriter(objectStreamOutput, basePath, jproject);
				writer.writeXML(this);

			}
		} catch (IOException e) {
			JavaPlugin.log(e);
		} catch (CoreException e) {
			JavaPlugin.log(e);
		} finally {
			if (objectStreamOutput != null) {
				try {
					objectStreamOutput.close();
				} catch (IOException e) {
				}
			}
		}
	}

	public IDialogSettings createDialogSettings() {

		IDialogSettings settings= new DialogSettings("javadoc"); //$NON-NLS-1$

		settings.put(FROMSTANDARD, fFromStandard);

		settings.put(DOCLETNAME, fDocletname);
		settings.put(DOCLETPATH, fDocletpath);

		settings.put(VISIBILITY, fAccess);

		settings.put(USE, fUse);
		settings.put(AUTHOR, fAuthor);
		settings.put(VERSION, fVersion);
		settings.put(NODEPRECATED, fNodeprecated);
		settings.put(NODEPRECATEDLIST, fNoDeprecatedlist);
		settings.put(SPLITINDEX, fSplitindex);
		settings.put(NOINDEX, fNoindex);
		settings.put(NOTREE, fNotree);
		settings.put(NONAVBAR, fNonavbar);
		settings.put(OPENINBROWSER, fOpenInBrowser);
		settings.put(SOURCE, fJDK14Mode);

		if (!fAntpath.equals("")) //$NON-NLS-1$
			settings.put(ANTPATH, fAntpath);
		if (!fDestination.equals("")) //$NON-NLS-1$
			settings.put(DESTINATION, fDestination);
		if (!fAdditionalParams.equals("")) //$NON-NLS-1$
			settings.put(EXTRAOPTIONS, fAdditionalParams);
		if (!fOverview.equals("")) //$NON-NLS-1$
			settings.put(OVERVIEW, fOverview);
		if (!fStylesheet.equals("")) //$NON-NLS-1$
			settings.put(STYLESHEETFILE, fStylesheet);
		if (!fTitle.equals("")) //$NON-NLS-1$
			settings.put(TITLE, fTitle);

		IDialogSettings links= new DialogSettings("projects"); //$NON-NLS-1$

		//Write all project information to DialogSettings.
		Set keys= fLinks.keySet();
		for (Iterator iter= keys.iterator(); iter.hasNext();) {

			IJavaProject iJavaProject= (IJavaProject) iter.next();

			IDialogSettings proj= new DialogSettings(iJavaProject.getElementName());
			if (!keys.contains(iJavaProject)) {
				proj.put(HREF, ""); //$NON-NLS-1$
				proj.put(DESTINATION, ""); //$NON-NLS-1$
				proj.put(ANTPATH, ""); //$NON-NLS-1$
			} else {
				ProjectData data= (ProjectData) fLinks.get(iJavaProject);
				proj.put(HREF, data.getLinks());
				proj.put(DESTINATION, data.getDestination());
				proj.put(ANTPATH, data.getAntPath());
			}
			links.addSection(proj);
		}
		settings.addSection(links);

		return settings;
	}

	public void setAccess(String access) {
		this.fAccess= access;
	}

	public void setDestination(IJavaProject project, String destination) {
		ProjectData data= (ProjectData) fLinks.get(project);
		if (data != null)
			data.setDestination(destination);
	}

	public void setDestination(String destination) {
		fDestination= destination;
	}

	public void setDocletPath(String docletpath) {
		this.fDocletpath= docletpath;
	}

	public void setDocletName(String docletname) {
		this.fDocletname= docletname;
	}

	public void setStyleSheet(String stylesheet) {
		this.fStylesheet= stylesheet;
	}

	public void setOverview(String overview) {
		this.fOverview= overview;
	}

	public void setAdditionalParams(String params) {
		fAdditionalParams= params;
	}

	public void setSpecificAntpath(IJavaProject project, String antpath) {
		ProjectData data= (ProjectData) fLinks.get(project);
		if (data != null)
			data.setAntpath(antpath);
	}

	public void setGeneralAntpath(String antpath) {
		this.fAntpath= antpath;
	}
	public void setClasspath(IPath[] classpath) {
		this.fClasspath= classpath;
	}

	public void setSourcepath(IPath[] sourcepath) {
		this.fSourcepath= sourcepath;
	}

	public void setSourceElements(IJavaElement[] elements) {
		this.fSourceElements= new ArrayList(Arrays.asList(elements));
	}

	public void setRoot(IWorkspaceRoot root) {
		this.fRoot= root;
	}

	public void setProjects(IJavaProject[] projects, boolean clear) {
		if (clear)
			fProjects.clear();

		for (int i= 0; i < projects.length; i++) {
			IJavaProject iJavaProject= projects[i];
			if (!fProjects.contains(iJavaProject))
				this.fProjects.add(iJavaProject);
		}
	}

	public void setFromStandard(boolean fromStandard) {
		this.fFromStandard= fromStandard;
	}

	public void setTitle(String title) {
		this.fTitle= title;
	}

	public void setDependencies(String dependencies) {
		fDependencies= dependencies;
	}

	public void setLinks(IJavaProject project, String hrefs) {
		ProjectData data= (ProjectData) fLinks.get(project);
		if (data != null)
			data.setLinks(hrefs);
	}

	public void setOpenInBrowser(boolean openInBrowser) {
		this.fOpenInBrowser= openInBrowser;
	}

	public void setBoolean(String flag, boolean value) {

		if (flag.equals(AUTHOR))
			this.fAuthor= value;
		else if (flag.equals(USE))
			this.fUse= value;
		else if (flag.equals(VERSION))
			this.fVersion= value;
		else if (flag.equals(NODEPRECATED))
			this.fNodeprecated= value;
		else if (flag.equals(NODEPRECATEDLIST))
			this.fNoDeprecatedlist= value;
		else if (flag.equals(NOINDEX))
			this.fNoindex= value;
		else if (flag.equals(NOTREE))
			this.fNotree= value;
		else if (flag.equals(SPLITINDEX))
			this.fSplitindex= value;
		else if (flag.equals(NONAVBAR))
			this.fNonavbar= value;
	}
	
	public boolean isJDK14Mode() {
		return fJDK14Mode;
	}

	public void setJDK14Mode(boolean jdk14Mode) {
		fJDK14Mode= jdk14Mode;
	}	

	private List getValidSelection(ISelection currentSelection) {

		ArrayList res= new ArrayList();
		if (currentSelection instanceof IStructuredSelection) {
			IStructuredSelection structuredSelection= (IStructuredSelection) currentSelection;

			if (structuredSelection.isEmpty()) {
				currentSelection= JavaPlugin.getActiveWorkbenchWindow().getSelectionService().getSelection();
				if (currentSelection instanceof IStructuredSelection)
					structuredSelection= (IStructuredSelection) currentSelection;
			}
			Iterator iter= structuredSelection.iterator();
			//this method will also find the project for default
			//destination and ant generation paths
			getProjects(res, iter);
		}
		return res;
	}

	private void getProjects(List selectedElements, Iterator iter) {

		while (iter.hasNext()) {
			Object selectedElement= iter.next();
			IJavaElement elem= getSelectableJavaElement(selectedElement);
			if (elem != null) {
				IJavaProject jproj= elem.getJavaProject();
				if (jproj != null) {
					//adding the project of the selected element in the list
					//now we can select and generate javadoc for two 
					//methods in different projects
					if (!fProjects.contains(jproj))
						fProjects.add(jproj);
					selectedElements.add(elem);
				}
			}
		}
		//if no projects selected add a default
		if (fProjects.isEmpty()) {
			try {
				IJavaProject[] jprojects= JavaCore.create(fRoot).getJavaProjects();

				for (int i= 0; i < jprojects.length; i++) {
					IJavaProject iJavaProject= jprojects[i];
					if (getValidProject(iJavaProject)) {
						fProjects.add(iJavaProject);
						break;
					}
				}				
			} catch (JavaModelException e) {
				JavaPlugin.log(e);
			}
		}
	}

	private IJavaElement getSelectableJavaElement(Object obj) {
		IJavaElement je= null;
		try {
			if (obj instanceof IAdaptable) {
				je= (IJavaElement) ((IAdaptable) obj).getAdapter(IJavaElement.class);
			}

			if (je == null) {
				return null;
			}

			switch (je.getElementType()) {
				case IJavaElement.JAVA_MODEL :
				case IJavaElement.JAVA_PROJECT :
				case IJavaElement.CLASS_FILE :
					break;
				case IJavaElement.PACKAGE_FRAGMENT_ROOT :
					if (containsCompilationUnits((IPackageFragmentRoot) je)) {
						return je;
					}
					break;
				case IJavaElement.PACKAGE_FRAGMENT :
					if (containsCompilationUnits((IPackageFragment) je)) {
						return je;
					}
					break;
				default :
					ICompilationUnit cu= (ICompilationUnit) je.getAncestor(IJavaElement.COMPILATION_UNIT);
					if (cu != null) {
						if (cu.isWorkingCopy()) {
							cu= (ICompilationUnit) cu.getOriginalElement();
						}
						return cu;
					}
			}
		} catch (JavaModelException e) {
			JavaPlugin.log(e);
		}
		IJavaProject project= je.getJavaProject();
		if (getValidProject(project))
			return project;
		else
			return null;
	}

	private boolean getValidProject(IJavaProject project) {
		if (project != null && project.exists()) {
			try {
				IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
				for (int i= 0; i < roots.length; i++) {
					if (containsCompilationUnits(roots[i])) {
						return true;
					}
				}

			} catch (JavaModelException e) {
				JavaPlugin.log(e);
			}
		}
		return false;
	}

	private boolean containsCompilationUnits(IPackageFragmentRoot root) throws JavaModelException {
		if (root.getKind() != IPackageFragmentRoot.K_SOURCE) {
			return false;
		}

		IJavaElement[] elements= root.getChildren();
		for (int i= 0; i < elements.length; i++) {
			if (elements[i] instanceof IPackageFragment) {
				IPackageFragment fragment= (IPackageFragment) elements[i];
				if (containsCompilationUnits(fragment)) {
					return true;
				}
			}
		}
		return false;
	}

	private boolean containsCompilationUnits(IPackageFragment pack) throws JavaModelException {
		return pack.getCompilationUnits().length > 0;
	}

	private class ProjectData {

		private String dataHrefs;
		private String dataDestdir;
		private String dataAntPath;

		public void setLinks(String hrefs) {
			if (hrefs == null)
				dataHrefs= ""; //$NON-NLS-1$
			else
				dataHrefs= hrefs;
		}

		public void setDestination(String destination) {
			if (destination == null)
				dataDestdir= ""; //$NON-NLS-1$
			else
				dataDestdir= destination;
		}

		public void setAntpath(String antpath) {
			if (antpath == null)
				dataAntPath= ""; //$NON-NLS-1$
			else
				dataAntPath= antpath;
		}

		public String getLinks() {
			return dataHrefs;
		}

		public String getDestination() {
			return dataDestdir;
		}

		public String getAntPath() {
			return dataAntPath;
		}

	}


}