/*******************************************************************************

 * Copyright (c) 2000, 2008 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

 *     Martin Oberhuber (Wind River) - [210664] descriptionChanged(): ignore LF style

 *******************************************************************************/

package org.eclipse.core.internal.localstore;

import java.io.*;

import java.net.URI;

import java.util.*;

import org.eclipse.core.filesystem.*;

import org.eclipse.core.filesystem.URIUtil;

import org.eclipse.core.internal.resources.*;

import org.eclipse.core.internal.resources.File;

import org.eclipse.core.internal.utils.*;

import org.eclipse.core.resources.*;

import org.eclipse.core.runtime.*;

import org.eclipse.osgi.util.NLS;

import org.xml.sax.InputSource;

/**

 * Manages the synchronization between the workspace's view and the file system.  

 */

public class FileSystemResourceManager implements ICoreConstants, IManager {

	/**

	 * The history store is initialized lazily - always use the accessor method

	 */

	protected IHistoryStore _historyStore;

	protected Workspace workspace;

	public FileSystemResourceManager(Workspace workspace) {

		this.workspace = workspace;

	}

	/**

	 * Returns the workspace paths of all resources that may correspond to

	 * the given file system location.  Returns an empty ArrayList if there are no 

	 * such paths.  This method does not consider whether resources actually 

	 * exist at the given locations.

	 * <p>

	 * The workspace paths of {@link IResource#HIDDEN} project and resources

	 * located in {@link IResource#HIDDEN} projects won't be added to the result.

	 * </p>

	 */

	protected ArrayList allPathsForLocation(URI inputLocation) {

		URI location = FileUtil.canonicalURI(inputLocation);

		final boolean isFileLocation = EFS.SCHEME_FILE.equals(inputLocation.getScheme());

		final IWorkspaceRoot root = getWorkspace().getRoot();

		final ArrayList results = new ArrayList();

		if (URIUtil.equals(location, root.getLocationURI())) {

			//there can only be one resource at the workspace root's location

			results.add(Path.ROOT);

			return results;

		}

		IPathVariableManager varMan = workspace.getPathVariableManager();

		IProject[] projects = root.getProjects(IContainer.INCLUDE_HIDDEN);

		for (int i = 0; i < projects.length; i++) {

			IProject project = projects[i];

			//check the project location

			URI testLocation = project.getLocationURI();

			if (testLocation == null)

				continue;

			// if we are looking for file: locations try to get a file: location for this project

			if (isFileLocation && !EFS.SCHEME_FILE.equals(testLocation.getScheme()))

				testLocation = getFileURI(testLocation);

			if (testLocation == null)

				continue;

			URI relative = testLocation.relativize(location);

			if (!relative.isAbsolute() && !relative.equals(testLocation)) {

				IPath suffix = new Path(relative.getPath());

				results.add(project.getFullPath().append(suffix));

			}

			ProjectDescription description = ((Project) project).internalGetDescription();

			if (description == null)

				continue;

			HashMap links = description.getLinks();

			if (links == null)

				continue;

			for (Iterator it = links.values().iterator(); it.hasNext();) {

				LinkDescription link = (LinkDescription) it.next();

				testLocation = varMan.resolveURI(link.getLocationURI());

				// if we are looking for file: locations try to get a file: location for this link

				if (isFileLocation && !EFS.SCHEME_FILE.equals(testLocation.getScheme()))

					testLocation = getFileURI(testLocation);

				if (testLocation == null)

					continue;

				relative = testLocation.relativize(location);

				if (!relative.isAbsolute() && !relative.equals(testLocation)) {

					IPath suffix = new Path(relative.getPath());

					results.add(project.getFullPath().append(link.getProjectRelativePath()).append(suffix));

				}

			}

		}

		return results;

	}

	/** 

	 * Tries to obtain a file URI for the given URI. Returns <code>null</code> if the file system associated

	 * to the URI scheme does not map to the local file system. 

	 * @param locationURI the URI to convert

	 * @return a file URI or <code>null</code>

	 */

	private URI getFileURI(URI locationURI) {

		try {

			IFileStore testLocationStore = EFS.getStore(locationURI);

			java.io.File storeAsFile = testLocationStore.toLocalFile(EFS.NONE, null);

			if (storeAsFile != null)

				return URIUtil.toURI(storeAsFile.getAbsolutePath());

		} catch (CoreException e) {

			// we don't know such file system or some other failure, just return null

		}

		return null;

	}

	/**

	 * Returns all resources that correspond to the given file system location,

	 * including resources under linked resources. Returns an empty array if

	 * there are no corresponding resources.

	 * <p>

	 * If the {@link IContainer#INCLUDE_TEAM_PRIVATE_MEMBERS} flag is specified

	 * in the member flags, team private members will be included along with the

	 * others. If the {@link IContainer#INCLUDE_TEAM_PRIVATE_MEMBERS} flag is

	 * not specified (recommended), the result will omit any team private member

	 * resources.

	 * </p>

	 * <p>

	 * If the {@link IContainer#INCLUDE_HIDDEN} flag is specified in the member

	 * flags, hidden members will be included along with the others. If the

	 * {@link IContainer#INCLUDE_HIDDEN} flag is not specified (recommended),

	 * the result will omit any hidden member resources.

	 * </p>

	 * 

	 * @param location

	 *        the file system location

	 * @param files

	 *        resources that may exist below the project level can be either

	 *        files or folders. If this parameter is true, files will be

	 *        returned, otherwise containers will be returned.

	 * @param memberFlags

	 *        bit-wise or of member flag constants (

	 *        {@link IContainer#INCLUDE_TEAM_PRIVATE_MEMBERS} and

	 *        {@link IContainer#INCLUDE_HIDDEN}) indicating which members are of

	 *        interest

	 */

	public IResource[] allResourcesFor(URI location, boolean files, int memberFlags) {

		ArrayList result = allPathsForLocation(location);

		int count = 0;

		for (int i = 0, imax = result.size(); i < imax; i++) {

			//replace the path in the list with the appropriate resource type

			IResource resource = resourceFor((IPath) result.get(i), files);

			if (resource == null || (((memberFlags & IContainer.INCLUDE_HIDDEN) == 0) && resource.isHidden(IResource.CHECK_ANCESTORS)) 

					|| (((memberFlags & IContainer.INCLUDE_TEAM_PRIVATE_MEMBERS) == 0) && resource.isTeamPrivateMember(IResource.CHECK_ANCESTORS)))

				resource = null;

			result.set(i, resource);

			//count actual resources - some paths won't have a corresponding resource

			if (resource != null)

				count++;

		}

		//convert to array and remove null elements

		IResource[] toReturn = files ? (IResource[]) new IFile[count] : (IResource[]) new IContainer[count];

		count = 0;

		for (Iterator it = result.iterator(); it.hasNext();) {

			IResource resource = (IResource) it.next();

			if (resource != null)

				toReturn[count++] = resource;

		}

		return toReturn;

	}

	/* (non-javadoc)

	 * @see IResource.getResourceAttributes

	 */

	public ResourceAttributes attributes(IResource resource) {

		IFileStore store = getStore(resource);

		IFileInfo fileInfo = store.fetchInfo();

		if (!fileInfo.exists())

			return null;

		return FileUtil.fileInfoToAttributes(fileInfo);

	}

	/**

	 * Returns a container for the given file system location or null if there

	 * is no mapping for this path. If the path has only one segment, then an 

	 * <code>IProject</code> is returned.  Otherwise, the returned object

	 * is a <code>IFolder</code>.  This method does NOT check the existence

	 * of a folder in the given location. Location cannot be null.

	 */

	public IContainer containerForLocation(IPath location) {

		IPath path = pathForLocation(location);

		return path == null ? null : (IContainer) resourceFor(path, false);

	}

	public void copy(IResource target, IResource destination, int updateFlags, IProgressMonitor monitor) throws CoreException {

		monitor = Policy.monitorFor(monitor);

		try {

			int totalWork = ((Resource) target).countResources(IResource.DEPTH_INFINITE, false);

			String title = NLS.bind(Messages.localstore_copying, target.getFullPath());

			monitor.beginTask(title, totalWork);

			IFileStore destinationStore = getStore(destination);

			if (destinationStore.fetchInfo().exists()) {

				String message = NLS.bind(Messages.localstore_resourceExists, destination.getFullPath());

				throw new ResourceException(IResourceStatus.FAILED_WRITE_LOCAL, destination.getFullPath(), message, null);

			}

			getHistoryStore().copyHistory(target, destination, false);

			CopyVisitor visitor = new CopyVisitor(target, destination, updateFlags, monitor);

			UnifiedTree tree = new UnifiedTree(target);

			tree.accept(visitor, IResource.DEPTH_INFINITE);

			IStatus status = visitor.getStatus();

			if (!status.isOK())

				throw new ResourceException(status);

		} finally {

			monitor.done();

		}

	}

	public void delete(IResource target, int flags, IProgressMonitor monitor) throws CoreException {

		monitor = Policy.monitorFor(monitor);

		try {

			Resource resource = (Resource) target;

			final int deleteWork = resource.countResources(IResource.DEPTH_INFINITE, false) * 2;

			boolean force = (flags & IResource.FORCE) != 0;

			int refreshWork = 0;

			if (!force)

				refreshWork = Math.min(deleteWork, 100);

			String title = NLS.bind(Messages.localstore_deleting, resource.getFullPath());

			monitor.beginTask(title, deleteWork + refreshWork);

			monitor.subTask(""); //$NON-NLS-1$

			MultiStatus status = new MultiStatus(ResourcesPlugin.PI_RESOURCES, IResourceStatus.FAILED_DELETE_LOCAL, Messages.localstore_deleteProblem, null);

			List skipList = null;

			UnifiedTree tree = new UnifiedTree(target);

			if (!force) {

				IProgressMonitor sub = Policy.subMonitorFor(monitor, refreshWork);

				sub.beginTask("", 1000); //$NON-NLS-1$

				try {

					CollectSyncStatusVisitor refreshVisitor = new CollectSyncStatusVisitor(Messages.localstore_deleteProblem, sub);

					refreshVisitor.setIgnoreLocalDeletions(true);

					tree.accept(refreshVisitor, IResource.DEPTH_INFINITE);

					status.merge(refreshVisitor.getSyncStatus());

					skipList = refreshVisitor.getAffectedResources();

				} finally {

					sub.done();

				}

			}

			DeleteVisitor deleteVisitor = new DeleteVisitor(skipList, flags, monitor, deleteWork);

			tree.accept(deleteVisitor, IResource.DEPTH_INFINITE);

			status.merge(deleteVisitor.getStatus());

			if (!status.isOK())

				throw new ResourceException(status);

		} finally {

			monitor.done();

		}

	}

	/**

	 * Returns true if the description on disk is different from the given byte array,

	 * and false otherwise.

	 * Since org.eclipse.core.resources 3.4.1 differences in line endings (CR, LF, CRLF) 

	 * are not considered.

	 */

	private boolean descriptionChanged(IFile descriptionFile, byte[] newContents) {

		InputStream oldStream = null;

		try {

			//buffer size: twice the description length, but maximum 8KB

			int bufsize = newContents.length > 4096 ? 8192 : newContents.length * 2;

			oldStream = new BufferedInputStream(descriptionFile.getContents(true), bufsize);

			InputStream newStream = new ByteArrayInputStream(newContents);

			//compare streams char by char, ignoring line endings

			int newChar = newStream.read();

			int oldChar = oldStream.read();

			while (newChar >= 0 && oldChar >= 0) {

				if (newChar == oldChar) {

					//streams are the same

					newChar = newStream.read();

					oldChar = oldStream.read();

				} else if ((newChar == '\r' || newChar == '\n') && (oldChar == '\r' || oldChar == '\n')) {

					//got a difference, but both sides are newlines: read over newlines

					while (newChar == '\r' || newChar == '\n')

						newChar = newStream.read();

					while (oldChar == '\r' || oldChar == '\n')

						oldChar = oldStream.read();

				} else {

					//streams are different

					return true;

				}

			}

			//test for excess data in one stream

			if (newChar >= 0 || oldChar >= 0)

				return true;

			return false;

		} catch (Exception e) {

			Policy.log(e);

			//if we failed to compare, just write the new contents

		} finally {

			FileUtil.safeClose(oldStream);

		}

		return true;

	}

	/**

	 * @deprecated

	 */

	public int doGetEncoding(IFileStore store) throws CoreException {

		InputStream input = null;

		try {

			input = store.openInputStream(EFS.NONE, null);

			int first = input.read();

			int second = input.read();

			if (first == -1 || second == -1)

				return IFile.ENCODING_UNKNOWN;

			first &= 0xFF;//converts unsigned byte to int

			second &= 0xFF;

			//look for the UTF-16 Byte Order Mark (BOM)

			if (first == 0xFE && second == 0xFF)

				return IFile.ENCODING_UTF_16BE;

			if (first == 0xFF && second == 0xFE)

				return IFile.ENCODING_UTF_16LE;

			int third = (input.read() & 0xFF);

			if (third == -1)

				return IFile.ENCODING_UNKNOWN;

			//look for the UTF-8 BOM

			if (first == 0xEF && second == 0xBB && third == 0xBF)

				return IFile.ENCODING_UTF_8;

			return IFile.ENCODING_UNKNOWN;

		} catch (IOException e) {

			String message = NLS.bind(Messages.localstore_couldNotRead, store.toString());

			throw new ResourceException(IResourceStatus.FAILED_READ_LOCAL, null, message, e);

		} finally {

			FileUtil.safeClose(input);

		}

	}

	/**

	 * Optimized sync check for files.  Returns true if the file exists and is in sync, and false

	 * otherwise.  The intent is to let the default implementation handle the complex

	 * cases like gender change, case variants, etc.

	 */

	public boolean fastIsSynchronized(File target) {

		ResourceInfo info = target.getResourceInfo(false, false);

		if (target.exists(target.getFlags(info), true)) {

			IFileInfo fileInfo = getStore(target).fetchInfo();

			if (!fileInfo.isDirectory() && info.getLocalSyncInfo() == fileInfo.getLastModified())

				return true;

		}

		return false;

	}

	/**

	 * Returns an IFile for the given file system location or null if there

	 * is no mapping for this path. This method does NOT check the existence

	 * of a file in the given location. Location cannot be null.

	 */

	public IFile fileForLocation(IPath location) {

		IPath path = pathForLocation(location);

		return path == null ? null : (IFile) resourceFor(path, true);

	}

	/**

	 * @deprecated

	 */

	public int getEncoding(File target) throws CoreException {

		// thread safety: (the location can be null if the project for this file does not exist)

		IFileStore store = getStore(target);

		if (!store.fetchInfo().exists()) {

			String message = NLS.bind(Messages.localstore_fileNotFound, store.toString());

			throw new ResourceException(IResourceStatus.FAILED_READ_LOCAL, target.getFullPath(), message, null);

		}

		return doGetEncoding(store);

	}

	public IHistoryStore getHistoryStore() {

		if (_historyStore == null) {

			IPath location = getWorkspace().getMetaArea().getHistoryStoreLocation();

			location.toFile().mkdirs();

			_historyStore = ResourcesCompatibilityHelper.createHistoryStore(location, 256);

		}

		return _historyStore;

	}

	/** 

	 * Returns the real name of the resource on disk. Returns null if no local

	 * file exists by that name.  This is useful when dealing with

	 * case insensitive file systems.

	 */

	public String getLocalName(IFileStore target) {

		return target.fetchInfo().getName();

	}

	protected IPath getProjectDefaultLocation(IProject project) {

		return workspace.getRoot().getLocation().append(project.getFullPath());

	}

	/**

	 * Never returns null

	 * @param target

	 * @return The file store for this resource

	 */

	public IFileStore getStore(IResource target) {

		try {

			return getStoreRoot(target).createStore(target.getFullPath());

		} catch (CoreException e) {

			//callers aren't expecting failure here, so return null file system

			return EFS.getNullFileSystem().getStore(target.getFullPath());

		}

	}

	/**

	 * Returns the file store root for the provided resource. Never returns null.

	 */

	private FileStoreRoot getStoreRoot(IResource target) {

		ResourceInfo info = workspace.getResourceInfo(target.getFullPath(), true, false);

		FileStoreRoot root;

		if (info != null) {

			root = info.getFileStoreRoot();

			if (root != null && root.isValid())

				return root;

			if (info.isSet(ICoreConstants.M_LINK)) {

				ProjectDescription description = ((Project) target.getProject()).internalGetDescription();

				if (description != null) {

					final URI linkLocation = description.getLinkLocationURI(target.getProjectRelativePath());

					//if we can't determine the link location, fall through to parent resource

					if (linkLocation != null) {

						setLocation(target, info, linkLocation);

						return info.getFileStoreRoot();

					}

				}

			}

		}

		final IContainer parent = target.getParent();

		if (parent == null) {

			//this is the root, so we know where this must be located

			//initialize root location

			info = workspace.getResourceInfo(Path.ROOT, false, true);

			final IWorkspaceRoot rootResource = workspace.getRoot();

			setLocation(rootResource, info, URIUtil.toURI(rootResource.getLocation()));

			return info.getFileStoreRoot();

		}

		root = getStoreRoot(parent);

		if (info != null)

			info.setFileStoreRoot(root);

		return root;

	}

	protected Workspace getWorkspace() {

		return workspace;

	}

	/**

	 * Returns whether the project has any local content on disk.

	 */

	public boolean hasSavedContent(IProject project) {

		return getStore(project).fetchInfo().exists();

	}

	/**

	 * Returns whether the project has a project description file on disk.

	 */

	public boolean hasSavedDescription(IProject project) {

		return getStore(project).getChild(IProjectDescription.DESCRIPTION_FILE_NAME).fetchInfo().exists();

	}

	/**

	 * Initializes the file store for a resource.

	 * 

	 * @param target The resource to initialize the file store for.

	 * @param location the File system location of this resource on disk

	 * @return The file store for the provided resource

	 */

	private IFileStore initializeStore(IResource target, URI location) throws CoreException {

		ResourceInfo info = ((Resource) target).getResourceInfo(false, true);

		setLocation(target, info, location);

		FileStoreRoot root = getStoreRoot(target);

		return root.createStore(target.getFullPath());

	}

	/**

	 * The target must exist in the workspace.  This method must only ever

	 * be called from Project.writeDescription(), because that method ensures

	 * that the description isn't then immediately discovered as a new change.

	 * @return true if a new description was written, and false if it wasn't written

	 * because it was unchanged

	 */

	public boolean internalWrite(IProject target, IProjectDescription description, int updateFlags, boolean hasPublicChanges, boolean hasPrivateChanges) throws CoreException {

		//write the project's private description to the metadata area

		if (hasPrivateChanges)

			getWorkspace().getMetaArea().writePrivateDescription(target);

		if (!hasPublicChanges)

			return false;

		//can't do anything if there's no description

		if (description == null)

			return false;

		//write the model to a byte array

		ByteArrayOutputStream out = new ByteArrayOutputStream();

		try {

			new ModelObjectWriter().write(description, out);

		} catch (IOException e) {

			String msg = NLS.bind(Messages.resources_writeMeta, target.getFullPath());

			throw new ResourceException(IResourceStatus.FAILED_WRITE_METADATA, target.getFullPath(), msg, e);

		}

		byte[] newContents = out.toByteArray();

		//write the contents to the IFile that represents the description

		IFile descriptionFile = target.getFile(IProjectDescription.DESCRIPTION_FILE_NAME);

		if (!descriptionFile.exists())

			workspace.createResource(descriptionFile, false);

		else {

			//if the description has not changed, don't write anything

			if (!descriptionChanged(descriptionFile, newContents))

				return false;

		}

		ByteArrayInputStream in = new ByteArrayInputStream(newContents);

		IFileStore descriptionFileStore = ((Resource) descriptionFile).getStore();

		IFileInfo fileInfo = descriptionFileStore.fetchInfo();

		if (fileInfo.getAttribute(EFS.ATTRIBUTE_READ_ONLY)) {

			IStatus result = getWorkspace().validateEdit(new IFile[] {descriptionFile}, null);

			if (!result.isOK())

				throw new ResourceException(result);

			// re-read the file info in case the file attributes were modified	

			fileInfo = descriptionFileStore.fetchInfo();