/*
* Copyright (c) 2008-2010 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.tracecompiler.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 com.nokia.tracecompiler.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$

	/**
	 * number of times trying to create a directy(ies)
	 */
	private static final int MAX_DIRECTORY_CREATION_TRIES = 5;
	
	/**
	 * Time to sleep between tries to create a directory(ies)
	 */
	private static final int SLEEP_TIME_BETWEEN_DIRECTORY_CREATION_TRIES = 100;

	
	/**
	 * 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()) {
			createDirectories(parent);
		}
		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;
	}

	/**
	 * Checks if given file is allowed to be opened into TraceCompiler
	 * 
	 * @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;
	}

	/**
	 * Create directories safely in a multiple instances case
	 * @param path
	 * @param access
	 * @return boolean pass/fail
	 */
	public static boolean createDirectories(File path) {

		boolean retVal = true;

		int tries = 0;

		if (path.exists()) {
			return retVal;
		}

		// try few times
		while (tries < MAX_DIRECTORY_CREATION_TRIES) {

			retVal = path.mkdirs();
			// mkdirs can fail for a number of reasons including the case where
			// the directory is open by another process. The API does not make
			// any difference so we assume the latter case (worst case)
			if (!retVal) { // sleep for moment and try again.

				tries++;

				try {
					Thread.sleep(SLEEP_TIME_BETWEEN_DIRECTORY_CREATION_TRIES);
				} catch (InterruptedException e) {
					// Do nothing
				}
			} else { // pass
				break;
			}
		}

		return retVal;

	}
}