/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.cpp.internal.api.utils.core;

import org.eclipse.core.resources.*;

import org.eclipse.core.runtime.*;

import org.eclipse.swt.widgets.Shell;

import org.osgi.framework.Bundle;

import com.nokia.cpp.utils.core.noexport.UtilsCorePlugin;

import java.io.*;

import java.net.*;

import java.util.*;

public class FileUtils {

	// special IStatus code for file modified during validateEdit

	public static final int MODIFIED_FILES_STATUS = 1000;

    /** Copy files or directories from 'from' to 'to'.  

     * 

     * Recursively descends if 'from' is a directory.  

     * Creates 'from' tail directory in 'to', e.g.:

     * from = c:/foo/bar

     * to = c:/temp

     * 

     * -->

     * 

     * c:/temp/bar

     * 

     * @param from

     * @param to

     * @param filter the filename filter, or null

     */

    public static void copyTree(File from, File to, FileFilter filter) throws IOException {

        File[] children;

    	if (!from.exists()) {

    		throw new IOException ("Source of copy \'" + from.getName() + "\' doesn't exist");

    	}

    	if (to.getCanonicalPath().equals(from.getCanonicalPath())) {

    		throw new IOException ("\'" + from.getName() + "\' cannot copy to itself");

    	}

        if (from.isDirectory()) {

            children = from.listFiles(filter);

            // just like cp command, if target exist, make a new folder into

            // the target, copy content into the target folder

            if (to.exists()) {

            	if (to.isFile()) {

            		throw new IOException("Cannot overwrite non-directory \'" + to.getName() + "\' with directory " + from.getName());

            	}

            	// copy into new directory name grafted after the existing one

            	to = new File(to, from.getName());

            	copyTree(from, to, filter);

            	return;

            } else {

            	// copy into new directory name

            	to.mkdir();            	

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

                    File curto = new File(to, children[i].getName());

                    copyTree(children[i], curto, filter);

                }

                return;

            }

        }

        else {

        	if (to.isDirectory()) {

        		to = new File (to, from.getName());

        	}

            copyFile(from, to);

            return;

        }

    }

    /** Copy files or directories from 'from' to 'to'.  

     * 

     * Recursively descends if 'from' is a directory.  

     * Does not create 'from' tail directory in 'to', e.g.:

     * from = c:/foo/bar contains a,b,c

     * to = c:/temp

     * 

     * -->

     * 

     * c:/temp/a

     * c:/temp/b

     * c:/temp/c

     * 

     * @param from

     * @param to

     * @param filter the filename filter, or null

     */

    public static void copyTreeNoParent(File from, File to, FileFilter filter) throws IOException {

        File[] files;

        Check.checkArg(from.isDirectory());

        files = from.listFiles(filter);

        to.mkdirs();

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

            if (files[i].isDirectory()) {

                //File curto = new File(to, files[i].getName());

                //curto.mkdirs();

                copyTree(files[i], to, filter);

            }

            else {

                File curto = new File(to, files[i].getName());

                copyFile(files[i], curto);

            }

        }

    }

    /**

     * Copy from an input stream to a file

     * 

     * @param in

     * @param to

     * @throws IOException

     */

    public static void copyFile(InputStream in, File to) throws IOException {

        FileOutputStream out = new FileOutputStream(to);

        int len;

        byte[] buffer = new byte[4096];

        while ((len = in.read(buffer)) != -1) {

            out.write(buffer, 0, len);

        }

        out.close();

        in.close();

    }

    /** Copy a single file from 'from' to 'to'

     * 

     * @param from

     * @param to

     * @throws IOException

     */

    public static void copyFile(File from, File to) throws IOException {

        FileInputStream in = new FileInputStream(from);

        copyFile(in, to);

    }

    /** Delete a directory tree recursively.

     * <p> 

     * Does not delete file.

     * @param file start point for deletion -- not itself deleted

     */

    public static void delTree(File file) {

        File[] files = file.listFiles();

        if (files != null) { 

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

                if (files[i].isDirectory()) {

                    delTree(files[i]);

                }

            }

        }

        files = file.listFiles();

        if (files != null) {

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

                files[i].delete();

            }

        }

    }

    /**

     * 

     * Try our best to find the base directory of plugin among an Eclipse project,

     * this enable us to use run JUnit without the slow JUnit Plugin test

     * 

     * This would still fail for EMMA as the run in alternative locations that

     * doesn't mirror our plugin.

     * 

     * @param plugin plugin object

     * @return URL or base of project

     */

    private static URL findPluginBaseWithoutLoadingPlugin(Plugin plugin) {

    	try {

    		URL url = plugin.getClass().getResource(".");

    		try {

    			// Plugin test with OSGi plugin need to resolve bundle resource

				url = FileLocator.resolve(url);

			} catch (NullPointerException e) {

				// junit non plugin test, OSGi plugin is not loaded

			} catch (IOException e) {

				// junit non plugin test

			}

			java.io.File currentFile = new java.io.File(url.toURI());	//$NON-NLS-1$

			do {

				currentFile = currentFile.getParentFile();

				if (currentFile.getName().equals("bin") || currentFile.getName().equals("src")) {	//$NON-NLS-1$ //$NON-NLS-2$

					if (new File(currentFile.getParentFile(), "plugin.xml").exists()) {		//$NON-NLS-1$

						// Eclipse project should have plugin.xml at root

						try {

							return currentFile.getParentFile().toURI().toURL();

						} catch (MalformedURLException e) {

							// give up and just bail out to null like before

							return null;

						}

					}

				}

			} while (currentFile.getParentFile() != null);

		} catch (URISyntaxException e) {

			// give up and just bail out to null like before

			return null;

		}

    	return null;

    }

	public static File pluginRelativeFile(Plugin plugin, String file) throws IOException {

        Check.checkArg(plugin);

        Bundle bundle = plugin.getBundle();

        if (bundle == null) {

        	// If we are a JUnit test, not a JUnit Plugin test

        	// the plugin will not be loaded(hence bundle is not there)

        	// instead the test will fake the plugin by declaring

        	// the plugin

        	URL url = findPluginBaseWithoutLoadingPlugin(plugin);

            if (url == null)

            	return null;

            return new File(url.getPath(), file);

        } else {

        	URL url = FileLocator.find(bundle, new Path("."), null); //$NON-NLS-1$

            if (url == null)

                return null;

            url = FileLocator.resolve(url);

            return new File(url.getPath(), file);

        }

    }

    /** 

     * Convert the path to a path relative to the base, if possible.

     * @param rootPath full path to base

     * @param cpath full path to resource

     * @return new path (base-relative) or null if not resolvable to base

     */

    static public IPath removePrefixFromPath(IPath rootPath, IPath cpath) {

        if (matchingFirstSegments(rootPath, cpath) == rootPath.segmentCount()) {

        	IPath suffix = cpath.removeFirstSegments(rootPath.segmentCount());

        	return suffix.setDevice(null);

        }

        return null;

    }

    /** 

     * Convert the path to a path in the workspace, if possible.

     * Either the path comes in as a path pointing inside the

     * workspace, or we can find a linked resource which aliases

     * to the same location.

     * @param cpath full filesystem path to resource

     * @return new path (workspace-relative) or null if not resolvable to workspace

     */

    static public IPath convertToWorkspacePath(IPath cpath) {

    	return convertToWorkspacePath(cpath, false);

    }

    /** 

     * Convert the path to a path in the workspace, if possible.

     * Either the path comes in as a path pointing inside the

     * workspace, or we can find a linked resource which aliases

     * to the same location.

     * @param cpath full filesystem path to resource

     * @param makeCanonical if true, work from the canonical path if possible

     * (recommended)

     * @return new path (workspace-relative) or null if not resolvable to workspace

     */

    static public IPath convertToWorkspacePath(IPath cpath, boolean makeCanonical) {

    	return convertToWorkspacePath(cpath, makeCanonical, true);

    }

    /** 

     * Convert the path to a path in the workspace, if possible.

     * Either the path comes in as a path pointing inside the

     * workspace, or we can find a linked resource which aliases

     * to the same location.

     * @param cpath full filesystem path to resource

     * @param makeCanonical if true, work from the canonical path if possible

     * (recommended)

     * @param resolveLinks if true, look for project paths which reference files outside

     * the workspace via links (very slow)

     * @return new path (workspace-relative) or null if not resolvable to workspace

     */

    @SuppressWarnings("deprecation")

	static public IPath convertToWorkspacePath(IPath cpath, boolean makeCanonical, boolean resolveLinks) {

        if (!Platform.isRunning() || cpath == null)

            return null;

        if (makeCanonical) {

			try {

				// Since we have a filesystem path, try using the filesystem

				// and Java's smarter APIs to fix the caps early. 

				// Watch out for the device being set incorrectly, though.

				String device = cpath.getDevice();

				cpath = new Path(cpath.toFile().getCanonicalPath()).setDevice(device);

			} catch (IOException e) {

				// Something's wrong with the path; just use it as-is

			}

        }

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

        IFile file = root.getFileForLocation(cpath);

        if (file != null) {

        	return file.getFullPath().setDevice(null);

        }

        if (resolveLinks) {

	        // try to see if a linked resource points to this

	        IFile[] files = root.findFilesForLocation(cpath);

	        IPath newPath = null;

	        if (files.length > 0)

	            newPath = files[0].getFullPath().setDevice(null);

	        else {

	            IContainer[] folders = root.findContainersForLocation(cpath);

	            if (folders.length > 0)

	                newPath = folders[0].getFullPath().setDevice(null);

	        }

	        return newPath;

        }

        return null;

    }

    /** 

     * Convert the full path to a full path inside the workspace, if possible.

     * (E.g. change a linked resource to the real full path.)

     * <p>

     * Either the path comes in as a path pointing inside the

     * workspace, or we can find a linked resource which aliases

     * to the same location.

     * @param cpath full filesystem path

     * @return same cpath, new path, or null if not resolvable to workspace

     */

    static public IPath convertToWorkspaceLocation(IPath cpath) {

        if (!Platform.isRunning())

            return null;

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

        IPath rootPath = root.getLocation();

        IPath newPath = convertToWorkspacePath(cpath);

        if (newPath == null)

            return null;

        // convert to full path

        return rootPath.append(newPath);

    }

    /** 

     * Variant of routine that works with case-insensitive matching.

     * @see IPath#matchingFirstSegments(IPath) 

     */

    public static int matchingFirstSegments(IPath my, IPath anotherPath) {

    	if (my == null || anotherPath == null)

    		return 0;

        int anotherPathLen = anotherPath.segmentCount();

        int max = Math.min(my.segmentCount(), anotherPathLen);

        int count = 0;

        for (int i = 0; i < max; i++) {

            if (!my.segment(i).equalsIgnoreCase(anotherPath.segment(i))) {

                return count;

            }

            count++;

        }

        return count;

    }

    /**

     * Map the given file to a path in the current workspace.

     * @param file

     * @return the IFile for the file

     * @deprecated this function is broken since it doesn't resolve linked resources.

     */

    public static IFile convertFileToIFile(IContainer container, File file) {

        IPath path = new Path(file.getAbsolutePath());

        IPath rootPath = container.getLocation();

        int match = matchingFirstSegments(path, rootPath);

        Check.checkState(match >= rootPath.segmentCount()); 

        path = path.removeFirstSegments(match);

        IFile wsFile = container.getFile(path);

        return wsFile;

    }

    /**

     * Map the given file to a path in the current workspace.

     * @param file

     * @return the IFile for the file, or null if the file is not in the workspace

     */

    public static IFile convertFileToIFile(File file) {

       IPath path = new Path(file.getAbsolutePath());

        IPath wsPath = convertToWorkspacePath(path, true);

        if (wsPath != null)

        	return ResourcesPlugin.getWorkspace().getRoot().getFile(wsPath);

        return null;

    }

    /**

     * Map the given file to a resource in the current workspace.  This only handles

     * files that map to known workspace resources.

     * @param file

     * @return the IResource for the file, or null if the file is not in the workspace or doesn't

     * exist.

     */

    public static IResource convertFileToExistingResource(File file) {

       IPath path = new Path(file.getAbsolutePath());

       IPath wsPath = convertToWorkspacePath(path, true);

       if (wsPath != null)

    	   return ResourcesPlugin.getWorkspace().getRoot().findMember(wsPath);

       return null;

    }

    /**

     * Return the project for the given workspace-relative path.

     */

    public static IProject projectForPath(IPath path) {

    	IProject result = null;

    	if (path != null) {

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

    		result = root.getProject(path.segment(0));

    	}

    	return result;

    }

	/**

	 * Read contents of a file into an array

	 * @param file

	 * @param encoding (null = system default)

	 * @return array of text

	 * @throws CoreException wrapping java.io.FileException

	 */

	public static char[] readFileContents(File file, String encoding) throws CoreException {

		Check.checkArg(file);

		FileInputStream fis;

        try {

        	fis = new FileInputStream(file);

        	return readInputStreamContents(fis, encoding);

        } catch (IOException e) {

            throw new CoreException(createErrorStatus(e));

        }

	}

	/**

	 * Read contents of a file into an array

	 * @param is input stream

	 * @param encoding (null is system default)

	 * @return array of text

	 * @throws CoreException wrapping java.io.FileException

	 */

	public static char[] readInputStreamContents(InputStream is, String encoding) throws CoreException {

		Check.checkArg(is);

		Reader reader;

		try {

	    	if (encoding != null)

	    		reader = new InputStreamReader(is, encoding);

	    	else

	    		reader = new InputStreamReader(is);

	        return readReaderContents(reader);

		} catch (UnsupportedEncodingException e) {

            throw new CoreException(createErrorStatus(e));

        }

	}

	/**

	 * Read contents of a file into an array

	 * @param file

	 * @param encoding (null = system default)

	 * @return array of text

	 * @throws CoreException wrapping java.io.FileException

	 */

	public static char[] readReaderContents(Reader reader) throws CoreException {

		Check.checkArg(reader);

        try {

            char[] buf = new char[1024];

            StringBuffer sb = new StringBuffer();

            int len;

            while ((len = reader.read(buf)) > 0) {

                sb.append(buf, 0, len);

            }

            reader.close();

            return sb.toString().toCharArray();

        } catch (UnsupportedEncodingException e) {

            throw new CoreException(createErrorStatus(e));

        } catch (IOException e) {

            throw new CoreException(createErrorStatus(e));

        }

	}

	/**

	 * Write contents of a file from an array

	 * @param file

	 * @param encoding (null = system default)

	 * @throws CoreException wrapping java.io.FileException

	 */

	public static void writeFileContents(File file, char[] text, String encoding) throws CoreException {

		Check.checkArg(file);

		FileOutputStream fos;

        try {

        	fos = new FileOutputStream(file);

        	writeOutputStreamContents(fos, text, encoding);

        } catch (IOException e) {

            throw new CoreException(createErrorStatus(e));

        }

	}

	/**