/*******************************************************************************
 * 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
 *******************************************************************************/
package org.eclipse.team.examples.filesystem;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.sync.IRemoteResource;
import org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations;

/**
 * SimpleAccessOperations is not part of the Team API. We use it here because it provides
 * a reasonable set of operation commonly implemented by repository providers.
 * Note: This class is not to be interpreted as an example of how a repository
 * provider is to do its work. It is only here because we needed to have some operations
 * to perform. In the future, we may update this class to illustrate the use of the workspace 
 * synchronizer (<code>ISynchronizer</code>).
 */
public class FileSystemSimpleAccessOperations implements SimpleAccessOperations {

	// A reference to the provider
	private FileSystemProvider provider;

	/**
	 * Constructor
	 * @param provider
	 */
	FileSystemSimpleAccessOperations(FileSystemProvider provider) {
		this.provider = provider;
	}

	/**
	 * Given a local resource, finds the remote counterpart.
	 * @param resource The local resource to lookup
	 * @return FileSystemRemoteResource The remote counterpart to the given local resource
	 */
	public FileSystemRemoteResource getRemoteResourceFor(IResource resource) {
		return new FileSystemRemoteResource(provider.getRoot().append(resource.getProjectRelativePath()));
	}

	/**
	 * @see SimpleAccessOperations#get(IResource[], int, IProgressMonitor)
	 */
	public void get(IResource[] resources, int depth, IProgressMonitor progress) throws TeamException {
		// ensure the progress monitor is not null
		progress = Policy.monitorFor(progress);
		progress.beginTask(Policy.bind("GetAction.working"), resources.length);
		for (int i = 0; i < resources.length; i++) {
			Policy.checkCanceled(progress);
			IPath rootdir = provider.getRoot();
			FileSystemRemoteResource remote = getRemoteResourceFor(resources[i]);
			if (resources[i].getType() == IResource.FILE) {
				//Copy the resource over to the other side:
				IFile localFile = (IFile) resources[i]; //since we know the local resource is a file.
				if (localFile.getModificationStamp() != remote.getLastModified()) {
					//Only do this if the timestamps are different
					try {
						//Copy from the local file to the remote file:
						InputStream source = null;
						try {
							// Get the remote file content.
							source = remote.getContents(progress);
							// Set the local file content to be the same as the remote file.
							if (localFile.exists())
								localFile.setContents(source, false, false, progress);
							else
								localFile.create(source, false, progress);
						} finally {
							if (source != null)
								source.close();
						}
					} catch (IOException e) {
						throw FileSystemPlugin.wrapException(e);
					} catch (CoreException e) {
						throw FileSystemPlugin.wrapException(e);
					}
				}
			} else if (depth > 0) { //Assume that resources are either files or containers.
				//If the resource is a container, copy its children over.
				IRemoteResource[] estranged = remote.members(progress);
				IResource[] children = new IResource[estranged.length];

				if (resources[i].getType() == IResource.PROJECT) {
					for (int j = 0; j < estranged.length; j++) {
						if (estranged[j].isContainer())
							children[j] = provider.getProject().getFolder(estranged[j].getName());
						else
							children[j] = provider.getProject().getFile(estranged[j].getName());
					}
				} else if (resources[i].getType() == IResource.FOLDER) {
					//Make sure that the folder exists before trying to put anything into it:
					IFolder localFolder = (IFolder) resources[i];
					if (!localFolder.exists()) {
						try {
							localFolder.create(false, true, progress);
						} catch (CoreException e) {
							throw FileSystemPlugin.wrapException(e);
						}
					}

					//Create placeholder local resources to place data into:
					for (int j = 0; j < estranged.length; j++) {
						if (estranged[j].isContainer())
							children[j] = provider.getProject().getFolder(resources[i].getProjectRelativePath().append(estranged[j].getName()));
						else
							children[j] = provider.getProject().getFile(resources[i].getProjectRelativePath().append(estranged[j].getName()));
					}
				}

				//Recurse into children:
				if (children.length > 0)
					get(children, depth - 1, null);
			}
			progress.worked(1);
		}
		progress.done();
	}

	/**
	 * Simply make sure that the local resource is not read only.
	 * 
	 * @see SimpleAccessOperations#checkout(IResource[], int, IProgressMonitor)
	 */
	public void checkout(IResource[] resources, int depth, IProgressMonitor progress) throws TeamException {
		progress = Policy.monitorFor(progress);
		progress.beginTask("Checking resources out...", resources.length);
		IPath rootdir = provider.getRoot();
		for (int i = 0; i < resources.length; i++) {
			Policy.checkCanceled(progress);

			//Do the actual file locking:
			FileSystemRemoteResource remote = getRemoteResourceFor(resources[i]);
			File diskFile = new File(rootdir.append(resources[i].getProjectRelativePath()).toOSString());
			if (resources[i].getType() == IResource.FILE) {
				//TODO: lock the file on the 'server'.
				resources[i].setReadOnly(false);
			} else if (depth > 0) {
				diskFile.mkdirs();
				//Recursively checkout children too:
				try {
					IResource[] children;
					if (resources[i].getType() == IResource.PROJECT)
						children = provider.getProject().members();
					else
						children = provider.getProject().getFolder(resources[i].getName()).members();
					if (children.length > 0)
						checkout(children, depth - 1, null);
				} catch (CoreException e) {
					throw FileSystemPlugin.wrapException(e);
				}
			}
			progress.worked(1);
		}
		progress.done();
	}

	/**
	 * Checkin the resources to the given depth. Mark all checked in resources as read only.
	 * 
	 * @see org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations#checkin(IResource[], int, IProgressMonitor)
	 */
	public void checkin(IResource[] resources, int depth, IProgressMonitor progress) throws TeamException {
		// ensure the progress monitor is not null
		progress = Policy.monitorFor(progress);
		progress.beginTask(Policy.bind("PutAction.working"), resources.length);
		for (int i = 0; i < resources.length; i++) {
			Policy.checkCanceled(progress);
			IPath rootdir = provider.getRoot();
			// Verify that the resources are checked out:
			if (!isCheckedOut(resources[i]))
				return;

			File diskFile = new File(rootdir.append(resources[i].getProjectRelativePath()).toOSString());
			if (resources[i].getType() == IResource.FILE) {
				//Copy the resource over to the other side:
				IFile localFile = (IFile) resources[i]; //since we know the local resource is a file.
				if (localFile.getModificationStamp() != diskFile.lastModified()) {
					//Only do this if the timestamps are different
					try {
						diskFile.getParentFile().mkdirs();
						//Copy from the local file to the remote file:
						InputStream in = null;
						FileOutputStream out = null;
						try {
							in = localFile.getContents();
							out = new FileOutputStream(diskFile);
							//Copy the contents of the local file to the remote file:
							StreamUtil.pipe(in, out, diskFile.length(), progress, diskFile.getName());
						} finally {
							if (in != null)
								in.close();
							if (out != null)
								out.close();
						}
					} catch (IOException e) {
						throw FileSystemPlugin.wrapException(e);
					} catch (CoreException e) {
						throw FileSystemPlugin.wrapException(e);
					}
				}
			} else if (depth > 0) { //Assume that resources are either files or containers.
				diskFile.mkdirs();
				//Recursively copy children, if any, over as well:
				try {
					IResource[] children;
					if (resources[i].getType() == IResource.PROJECT)
						children = provider.getProject().members();
					else
						children = provider.getProject().getFolder(resources[i].getName()).members();
					if (children.length > 0)
						checkin(children, depth - 1, null);
				} catch (CoreException e) {
					throw FileSystemPlugin.wrapException(e);
				}
			}
			progress.worked(1);
		}
		uncheckout(resources, depth, progress);
		progress.done();
	}

	/**
	 * Mark all checked in resources as read only.
	 * 
	 * @see org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations#uncheckout(IResource[], int, IProgressMonitor)
	 */
	public void uncheckout(IResource[] resources, int depth, IProgressMonitor progress) throws TeamException {
		progress = Policy.monitorFor(progress);
		progress.beginTask("Re-locking resources...", resources.length);
		IPath rootdir = provider.getRoot();
		for (int i = 0; i < resources.length; i++) {
			Policy.checkCanceled(progress);

			//Do the actual file unlocking:
			FileSystemRemoteResource remote = getRemoteResourceFor(resources[i]);
			File diskFile = new File(rootdir.append(resources[i].getProjectRelativePath()).toOSString());
			if (resources[i].getType() == IResource.FILE) {
				//TODO: unlock the file on the 'server'.
				resources[i].setReadOnly(true);
			} else if (depth > 0) {
				diskFile.mkdirs();
				//Recursively uncheckout children too:
				try {
					IResource[] children;
					if (resources[i].getType() == IResource.PROJECT)
						children = provider.getProject().members();
					else
						children = provider.getProject().getFolder(resources[i].getName()).members();
					if (children.length > 0)
						uncheckout(children, depth - 1, null);
				} catch (CoreException e) {
					throw FileSystemPlugin.wrapException(e);
				}
			}
			progress.worked(1);
		}
		progress.done();
	}

	/**
	 * @see org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations#delete(IResource[], IProgressMonitor)
	 */
	public void delete(IResource[] resources, IProgressMonitor progress) throws TeamException {}

	/**
	 * @see org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations#moved(IPath, IResource, IProgressMonitor)
	 */
	public void moved(IPath source, IResource target, IProgressMonitor progress) throws TeamException {}

	/**
	 * A resource is checked out if it is not read only.
	 * 
	 * @see org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations#isCheckedOut(IResource)
	 */
	public boolean isCheckedOut(IResource resource) {
		return !resource.isReadOnly();
	}

	/**
	 * @see org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations#hasRemote(IResource)
	 */
	public boolean hasRemote(IResource resource) {
		return false;
	}

	/**
	 * @see org.eclipse.team.internal.core.simpleAccess.SimpleAccessOperations#isDirty(IResource)
	 */
	public boolean isDirty(IResource resource) {
		return false;
	}

}