/*******************************************************************************
 * Copyright (c) 2009 by SAP AG, Walldorf. 
 * 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:
 *     SAP AG - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.ws.jaxws.utils.resources;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.ws.jaxws.utils.ContractChecker;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

/**
 * Implementation for file utilities interface
 * 
 * @author Danail Branekov
 * 
 */
public class FileUtils implements IFileUtils {
	private static IFileUtils utils = null;
	private static int index = 0;

	public FileUtils() {
	}

	/**
	 * The factory method
	 * 
	 * @return a FileUtils instance
	 */
	public static IFileUtils getInstance() {
		if (utils == null) {
			utils = new FileUtils();
		}

		return utils;
	}

	public final List<IEditorPart> getEditorsByFileLocation(
			final String fileLocation) throws FileNotFoundException {
		List<ICompilationUnit> units = getCompilationUnits(fileLocation);
		Set<IEditorPart> editors = new HashSet<IEditorPart>();
		for (ICompilationUnit cu : units) {
			final IEditorDescriptor editorDescr = getEditorDescriptor(cu
					.getElementName());
			editors.addAll(getEditorsByCompilationUnit(editorDescr,
					getActiveWorkbenchPage(), cu));

		}

		return Arrays.asList(editors.toArray(new IEditorPart[editors.size()]));
	}

	public final List<ICompilationUnit> getCompilationUnits(
			final String fileLocation) throws FileNotFoundException {
		if (fileLocation == null) {
			throw new NullPointerException("fileLocation"); //$NON-NLS-1$
		}

		IFile[] filesFound = ResourcesPlugin.getWorkspace().getRoot()
				.findFilesForLocationURI(new File(fileLocation).toURI());
		if (filesFound == null || filesFound.length == 0) {
			throw new FileNotFoundException("File: " + fileLocation + " does not exist"); //$NON-NLS-1$ //$NON-NLS-2$
		}

		List<ICompilationUnit> units = new ArrayList<ICompilationUnit>();

		for (IFile file : filesFound) {
			IJavaElement javaElement = JavaCore.create(file);
			if (!(javaElement instanceof ICompilationUnit)) {
				throw new IllegalStateException("File: " + fileLocation + " is not a compilation unit"); //$NON-NLS-1$ //$NON-NLS-2$
			}

			units.add((ICompilationUnit) javaElement);
		}

		return units;
	}
			
	public IProject getProjectUnit(String fileLocation)
			throws FileNotFoundException {
		
		if (fileLocation == null)
		{
			throw new NullPointerException("fileLocation"); //$NON-NLS-1$
		}

		IFile file = getFileForLocation(new Path(fileLocation));
		if (file == null)
		{
			throw new FileNotFoundException("File: " + fileLocation + " does not exist"); //$NON-NLS-1$ //$NON-NLS-2$
		}

		return file.getProject();
	}

	public final boolean isFileDisplayedInDirtyEditor(final String fileLocation)
			throws FileNotFoundException {
		return isFileDisplayedInDirtyEditor(getEditorsByFileLocation(fileLocation));
	}

	public boolean isCompilationUnitDisplayedInDirtyEditor(
			final ICompilationUnit unit) {
		return isFileDisplayedInDirtyEditor(getEditorsByCompilationUnit(unit));
	}

	public final void saveEditor(String fileLocation)
			throws FileNotFoundException {
		saveEditor(fileLocation, new NullProgressMonitor());
	}

	public void saveEditor(final String fileLocation,
			final IProgressMonitor monitor) throws FileNotFoundException {
		List<IEditorPart> editors = getEditorsByFileLocation(fileLocation);
		if (editors.size() == 0) {
			throw new IllegalStateException("The file is not displayed by an editor"); //$NON-NLS-1$
		}

		saveEditors(editors, monitor);
	}

	public void saveEditor(final ICompilationUnit cu,
			final IProgressMonitor monitor) {
		List<IEditorPart> editors = getEditorsByCompilationUnit(cu);
		if (editors.size() == 0) {
			throw new IllegalStateException("The file is not displayed by an editor"); //$NON-NLS-1$
		}

		saveEditors(editors, monitor);
	}

	public void saveEditor(final ICompilationUnit cu) {
		List<IEditorPart> editors = getEditorsByCompilationUnit(cu);
		if (editors.size() == 0) {
			throw new IllegalStateException("The file is not displayed by an editor"); //$NON-NLS-1$
		}

		saveEditors(editors, new NullProgressMonitor());
	}

	private void saveEditors(final List<IEditorPart> editors,
			final IProgressMonitor monitor) {
		for (IEditorPart e : editors) {
			if (e.isDirty()) {
				e.doSave(monitor);
			}
		}
	}

	public Collection<IEditorPart> getDirtyEditors() {
		final Set<IEditorInput> inputs = new HashSet<IEditorInput>();
		final Collection<IEditorPart> result = new ArrayList<IEditorPart>();
		final IWorkbench workbench = PlatformUI.getWorkbench();
		final IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
		for (int i = 0; i < windows.length; i++) {
			final IWorkbenchPage[] pages = windows[i].getPages();
			for (int x = 0; x < pages.length; x++) {
				final IEditorPart[] editors = pages[x].getDirtyEditors();
				for (int z = 0; z < editors.length; z++) {
					final IEditorPart ep = editors[z];
					final IEditorInput input = ep.getEditorInput();
					if (!inputs.contains(input)) {
						inputs.add(input);
						result.add(ep);
					}
				}
			}
		}
		return result;
	}

	private IEditorDescriptor getEditorDescriptor(String fileName) {
		IEditorRegistry editorRegistry = PlatformUI.getWorkbench()
				.getEditorRegistry();
		return editorRegistry.getDefaultEditor(fileName);
	}

	/**
	 * Converts a String to a URL, assuming 'file:' as a default scheme.
	 * 
	 * @param base
	 * @param path
	 * 
	 * @return
	 * 
	 * @throws NullPointerException,
	 *             if the String is neither a valid URL, nor a valid filename.
	 * 
	 */
	public final URL fileOrURLToURL(final URL base, final String path)
			throws IOException {
		if (path == null) {
			throw new NullPointerException("path"); //$NON-NLS-1$
		}

		String localPath = path;
		URL localBase = base;

		if (localBase == null) {
			localBase = new URL("file:");//$NON-NLS-1$
		}

		localPath = localPath.replace('\\', '/');
		try {
			String protocol = localBase.getProtocol();
			if (!"http".equals(protocol) //$NON-NLS-1$
					&& !"https".equals(protocol) //$NON-NLS-1$
					&& (localPath.charAt(1) == ':'
							|| localPath.charAt(0) == '/' || localPath
							.charAt(0) == '\\')) {
				localPath = (new File(localPath)).toURI().toURL().toExternalForm();
			}
		} catch (IndexOutOfBoundsException e) {
			// $JL-EXC$
		}

		if (localPath.startsWith("file:") && localPath.length() > 5 //$NON-NLS-1$
				&& localPath.charAt(5) != '/') {
			localPath = "file:/".concat(localPath.substring(5)); //$NON-NLS-1$
		} else {
			if (localPath.startsWith("file://") //$NON-NLS-1$
					&& !localPath.startsWith("file:////") //$NON-NLS-1$
					&& !localPath.startsWith("file://localhost/")) { //$NON-NLS-1$
				localPath = "file:////".concat(localPath.substring("file://" //$NON-NLS-1$ //$NON-NLS-2$
						.length()));
			}
		}
		URL url = new URL(localBase, localPath);
		return url;
	}

	public File createTempDirectory() {
		String tempDir = System.getProperty("java.io.tmpdir"); //$NON-NLS-1$
		index++;
		File temp1 = new File(tempDir, Integer.toString(this.hashCode()) + "_" //$NON-NLS-1$
				+ index);
		temp1.mkdir();
		return temp1;
	}

	public void deleteDirectory(final File directory) {
		if (directory == null) {
			return;
		}
		if (!directory.exists()) {
			return;
		}
		for (File f : directory.listFiles()) {
			f.delete();
		}
		directory.delete();
	}

	public IFile[] getFilesByExtension(IProject project, String extension)
			throws CoreException {
		ContractChecker.nullCheckParam(extension, "extension"); //$NON-NLS-1$
		ArrayList<IFile> foundFiles = new ArrayList<IFile>();

		getFilesByExtension(foundFiles, project.members(), extension);

		return foundFiles.toArray(new IFile[foundFiles.size()]);
	}

	private void getFilesByExtension(ArrayList<IFile> foundFiles,
			IResource[] currentResources, String extension)
			throws CoreException {
		for (int ii = 0; ii < currentResources.length; ii++) {
			if (currentResources[ii].getType() == IResource.FOLDER) {
				getFilesByExtension(foundFiles,
						((IFolder) currentResources[ii]).members(), extension);
			} else if (currentResources[ii].getType() == IResource.FILE
					&& extension
							.equals(currentResources[ii].getFileExtension())) {
				foundFiles.add((IFile) currentResources[ii]);
			}
		}
	}

	public IFile getFileForLocation(IPath location) {
		return ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(
				location);
	}

	private IWorkbenchPage getActiveWorkbenchPage() {
		if (PlatformUI.getWorkbench().getActiveWorkbenchWindow() == null) {
			return null;
		}

		return PlatformUI.getWorkbench().getActiveWorkbenchWindow()
				.getActivePage();
	}

	public List<IEditorPart> getEditorsByCompilationUnit(
			final ICompilationUnit cu) {
		ContractChecker.nullCheckParam(cu, "cu"); //$NON-NLS-1$
		final IEditorDescriptor editorDescr = getEditorDescriptor(cu
				.getElementName());
		final IWorkbenchPage wbPage = getActiveWorkbenchPage();
		if (wbPage == null) {
			return new ArrayList<IEditorPart>(0);
		}

		return getEditorsByCompilationUnit(editorDescr, wbPage, cu);
	}

	private List<IEditorPart> getEditorsByCompilationUnit(
			final IEditorDescriptor editorDescriptor,
			final IWorkbenchPage page, final ICompilationUnit cu) {
		List<IEditorPart> editorPartReturned = new ArrayList<IEditorPart>();

		if (editorDescriptor != null && page != null) {
			for (IEditorReference editorReferece : page.getEditorReferences()) {
				IEditorPart editorPart = editorReferece.getEditor(true);
				if (isEditorApplicableForCu(editorPart, cu)) {
					editorPartReturned.add(editorPart);
				}
			}
		}

		return editorPartReturned;
	}

	private boolean isEditorApplicableForCu(final IEditorPart editor,
			final ICompilationUnit cu) {
		if (editor == null) {
			return false;
		}

		if (!(editor.getEditorInput() instanceof IFileEditorInput)
				|| !(cu.getResource() instanceof IFile)) {
			return false;
		}

		final IFile cuFile = (IFile) cu.getResource();
		final IFileEditorInput editorInput = (IFileEditorInput) editor
				.getEditorInput();

		return cuFile.equals(editorInput.getFile());
	}

	public final boolean isFileDisplayedInDirtyEditor(
			final List<IEditorPart> displayingEditors) {
		ContractChecker.nullCheckParam(displayingEditors, "displayingEditors"); //$NON-NLS-1$
		for (IEditorPart editor : displayingEditors) {
			if (editor.isDirty()) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Reads file content as text and returns {@link String}
	 * 
	 * @param sourceFile
	 * @return the content of file
	 * @throws IOException
	 */
	public String getFileContent(final File sourceFile) throws IOException {
		final FileReader fr = new FileReader(sourceFile);
		final StringBuilder builder = new StringBuilder();

		try {
			final char[] buff = new char[1024];
			for (int cnt = 0; (cnt = fr.read(buff)) > -1;) {
				builder.append(buff, 0, cnt);
			}
		} finally {
			fr.close();
		}

		return builder.toString();
	}

	public void setCompilationUnitContent(final ICompilationUnit unit,
			final String content, final boolean force,
			final IProgressMonitor monitor) throws JavaModelException {
		ContractChecker.nullCheckParam(unit, "unit"); //$NON-NLS-1$
		ContractChecker.nullCheckParam(content, "content"); //$NON-NLS-1$

		unit.becomeWorkingCopy(monitor);
		try {
			unit.getBuffer().setContents(content);
			unit.commitWorkingCopy(force, monitor);
		} finally {
			unit.discardWorkingCopy();
		}
	}

	public void setCompilationUnitContentAndSaveDirtyEditors(
			final ICompilationUnit unit, final String content,
			final boolean force, final IProgressMonitor monitor)
			throws JavaModelException {
		setCompilationUnitContent(unit, content, force, monitor);
		if (isCompilationUnitDisplayedInDirtyEditor(unit)) {
			saveEditor(unit);
		}
	}
}