/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

* File utility functions

*

*/

package com.nokia.tracebuilder.file;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.net.URI;

import org.eclipse.core.runtime.IPath;

import com.nokia.tracebuilder.source.SourceConstants;

/**

 * File utility functions

 * 

 */

public final class FileUtils {

	/**

	 * File copy buffer size

	 */

	private static final int COPY_BUFFER_SIZE = 4096; // CodForChk_Dis_Magic

	/**

	 * cpp extension

	 */

	public final static String CPP_EXTENSION = "cpp"; //$NON-NLS-1$	

	/**

	 * c extension

	 */

	public final static String C_EXTENSION = "c"; //$NON-NLS-1$	

	/**

	 * Allowed files

	 */

	private final static String[] FILE_FILTERS = { ".cpp", //$NON-NLS-1$

			".c", //$NON-NLS-1$

			".inl", //$NON-NLS-1$

			".h" //$NON-NLS-1$

	};

	/**

	 * MMP file extension

	 */

	public static final String MMP = ".mmp"; //$NON-NLS-1$

	/**

	 * Creates a file output stream. This creates directories and overwriting

	 * possible read-only flag

	 * 

	 * @param file

	 *            the file

	 * @return the file output stream

	 * @throws FileNotFoundException

	 *             if file cannot be created

	 */

	public static OutputStream createOutputStream(File file)

			throws FileNotFoundException {

		File parent = file.getParentFile();

		if (!parent.exists()) {

			parent.mkdirs();

		}

		FileOutputStream fos;

		try {

			fos = new FileOutputStream(file);

		} catch (IOException e) {

			if (file.exists()) {

				file.delete();

			}

			fos = new FileOutputStream(file);

		}

		return new BufferedOutputStream(fos);

	}

	/**

	 * Creates a copy of a file

	 * 

	 * @param source

	 *            the source file

	 * @param target

	 *            the target file

	 * @return true if written successfully

	 */

	public static boolean copyFile(File source, File target) {

		boolean backup = true;

		try {

			byte[] buf = new byte[COPY_BUFFER_SIZE];

			FileInputStream fis = new FileInputStream(source);

			OutputStream fos = createOutputStream(target);

			int len;

			do {

				len = fis.read(buf);

				if (len > 0) {

					fos.write(buf, 0, len);

				}

			} while (len > 0);

			fis.close();

			fos.close();

		} catch (Exception e) {

			backup = false;

		}

		return backup;

	}

	/**

	 * Converts file separator characters

	 * 

	 * @param separator

	 *            separator to be used

	 * @param path

	 *            string to be converted

	 * @param addLast

	 *            true if the converted string should end with a separator

	 * @return the converted string

	 */

	public static String convertSeparators(char separator, String path,

			boolean addLast) {

		path = path.replace(SourceConstants.FORWARD_SLASH_CHAR, separator);

		path = path.replace(SourceConstants.BACKSLASH_CHAR, separator);

		String sepStr = String.valueOf(separator);

		if (addLast && !path.endsWith(sepStr)) {

			path += separator;

		} else if (!addLast && path.endsWith(sepStr)) {

			path = path.substring(0, path.length() - 1);

		}

		return path;

	}

	/**

	 * Gets the relative path from source to target

	 * 

	 * @param source

	 *            the source file

	 * @param target

	 *            the target file

	 * @return the relative path without file name

	 */

	public static String getRelativePath(String source, String target) {

		try {

			source = new File(source).getCanonicalPath();

			target = new File(target).getCanonicalPath();

		} catch (IOException e) {

		}

		source = convertSeparators(SourceConstants.FORWARD_SLASH_CHAR, source,

				false);

		target = convertSeparators(SourceConstants.FORWARD_SLASH_CHAR, target,

				false);

		int len = Math.min(source.length(), target.length());

		int start = -1;

		for (int i = 0; i < len && start == -1; i++) {

			if (source.charAt(i) != target.charAt(i)) {

				start = i;

			}

		}

		String retval;

		if (start == -1) {

			retval = getRelativePathSub(source, target);

		} else {

			retval = getRelativePathUnrelated(source, target, start);

		}

		return retval;

	}

	/**

	 * Gets the relative path from source to target when either one is a

	 * sub-directory of another

	 * 

	 * @param source

	 *            the source

	 * @param target

	 *            the target

	 * @return the relative path

	 */

	private static String getRelativePathSub(String source, String target) {

		StringBuffer sb = new StringBuffer();

		if (source.length() > target.length()) {

			// Source is in sub-directory of target

			for (int i = target.length(); i < source.length(); i++) {

				if (source.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {

					sb.append(SourceConstants.PATH_UP);

				}

			}

		} else if (target.length() > source.length()) {

			// Target is in sub-directory of source

			int lastIndex;

			if (source.endsWith(String

					.valueOf(SourceConstants.FORWARD_SLASH_CHAR))) {

				lastIndex = source.length();

			} else {

				lastIndex = source.length() + 1;

			}

			for (int i = source.length(); i < target.length(); i++) {

				if (target.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {

					sb.append(target.substring(lastIndex, i + 1));

					lastIndex = i + 1;

				}

			}

			if (new File(target).isDirectory() && lastIndex < target.length()) {

				sb.append(target.substring(lastIndex));

			}

		} else {

			// Paths were equal

			sb.append(SourceConstants.THIS_PATH);

		}

		return sb.toString();

	}

	/**

	 * Gets the relative path between two unrelated directories

	 * 

	 * @param source

	 *            the source

	 * @param target

	 *            the target

	 * @param start

	 *            the start index where the paths differ

	 * @return the relative path

	 */

	private static String getRelativePathUnrelated(String source,

			String target, int start) {

		String retval;

		StringBuffer sb = new StringBuffer();

		File f = new File(target);

		// If target is absolute path and there is nothing in common between the

		// paths, the target absolute path is returned as such

		if (f.isAbsolute() && start == 0) {

			int lastIndex = target

					.lastIndexOf(SourceConstants.FORWARD_SLASH_CHAR) + 1;

			sb.append(target.substring(0, lastIndex));

		} else {

			for (int i = start; i < source.length(); i++) {

				if (source.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {

					sb.append(SourceConstants.PATH_UP);

				}

			}

			int lastIndex;

			// The previous directory separator is used as the root between the

			// two paths.

			lastIndex = target.lastIndexOf(SourceConstants.FORWARD_SLASH_CHAR,

					start - 1) + 1;

			for (int i = start; i < target.length(); i++) {

				if (target.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {

					sb.append(target.substring(lastIndex, i + 1));

					lastIndex = i + 1;

				}

			}

		}

		retval = sb.toString();

		return retval;

	}

	/**

	 * Checks if given file is allowed to be opened into TraceBuilder

	 * 

	 * @param fileName

	 *            the file to be checked

	 * @return true if filtered, false if not

	 */

	public static boolean isFileAllowed(String fileName) {

		boolean allowed = false;

		fileName = fileName.toLowerCase();

		for (String filter : FILE_FILTERS) {

			if (fileName.endsWith(filter)) {

				allowed = true;

				break;

			}

		}

		return allowed;

	}

	/**

	 * Creates URI from given IPath instance.

	 * @param path

	 * @return URI from given IPath instance

	 */

	public static URI makeURI(IPath path) {

		File file = path.toFile();

		return file.toURI();

	}	

}