/*
* 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:
*
* Project file utilities
*
*/
package com.nokia.tracebuilder.project;

import java.io.File;
import java.util.ArrayList;

import com.nokia.tracebuilder.engine.TraceBuilderConfiguration;
import com.nokia.tracebuilder.engine.TraceBuilderDialogs;
import com.nokia.tracebuilder.engine.TraceBuilderGlobals;
import com.nokia.tracebuilder.engine.TraceBuilderDialogs.DirectoryDialogQueryParameters;
import com.nokia.tracebuilder.engine.TraceBuilderDialogs.QueryDialogType;
import com.nokia.tracebuilder.engine.TraceBuilderErrorCodes.TraceBuilderErrorCode;
import com.nokia.tracebuilder.engine.project.ProjectEngine;
import com.nokia.tracebuilder.model.TraceBuilderException;
import com.nokia.tracebuilder.model.TraceModel;
import com.nokia.tracebuilder.source.SymbianConstants;

/**
 * Project file utilities
 * 
 */
public final class ProjectUtils {


	/**
	 * Tries to locate existing file with given extension and if not found,
	 * proposes a new location for that file. The new location will be
	 * <i>createPath</i> or if that is null, the directory where the trace
	 * project file (.tbprj) resides. Trace project must be open before this can
	 * be called
	 * 
	 * @param model
	 *            the trace model
	 * @param createPath
	 *            the path to create if existing file is not found
	 * @param fileName
	 *            the name for the new file
	 * @param appendProjectName
	 *            true if the name is appended to end of model name
	 * @return the project file path for the new file
	 * @throws TraceBuilderException
	 *             if the model does not have any project files
	 */
	public static String getLocationForFile(TraceModel model,
			String createPath, String fileName, boolean appendProjectName)
			throws TraceBuilderException {
		TraceProjectFile projectFile = model
				.getExtension(TraceProjectFile.class);
		if (projectFile == null) {
			throw new TraceBuilderException(
					TraceBuilderErrorCode.MODEL_NOT_READY);
		}
		String projectName = ""; //$NON-NLS-1$
		if (appendProjectName) {
			projectName = projectFile.getProjectName();
		}
		return getLocationForFile(projectFile.getPath(), projectName,
				createPath, fileName);
	}

	/**
	 * Tries to locate existing file with given extension and if not found,
	 * proposes a new location for that file. The new location will be
	 * <i>createPath</i> or if that is null, the directory where the trace
	 * project file resides. Trace project must be open before this can
	 * be called
	 * 
	 * @param projectPath
	 *            path to the project
	 * @param projectName
	 *            name of the project
	 * @param createPath
	 *            the path to create if existing file is not found
	 * @param extension
	 *            the file extension for the new file
	 * @return the project file path for the new file
	 */
	public static String getLocationForFile(String projectPath,
			String projectName, String createPath, String extension) {
		ArrayList<String> searchPaths = new ArrayList<String>();
		if (createPath != null && createPath.length() > 0) {
			// If create path is explicitly specified, it is added to the search
			// path list
			searchPaths.add(createPath);
		}
		// Default directories are always included into search
		searchPaths.add(ProjectEngine.traceFolderName);
		searchPaths.add(SymbianConstants.GROUP_DIRECTORY);
		searchPaths.add(SymbianConstants.INCLUDE_DIRECTORY);
		String[] pathArr = new String[searchPaths.size()];
		searchPaths.toArray(pathArr);
		return getLocationForFile(projectPath, projectName, pathArr,
				createPath, extension);
	}

	/**
	 * Tries to locate existing file and if not found, proposes a new location
	 * for that file. The search starts from <i>projectPath</i>. If
	 * <i>checkParents</i> is true, the parent directories are also checked if
	 * the file is not found
	 * 
	 * @param projectPath
	 *            path where to start the search
	 * @param projectName
	 *            the name of the project
	 * @param searchPaths
	 *            the sub-paths to be searched
	 * @param createPath
	 *            the sub-path to create if file is not found
	 * @param fileName
	 *            extension of the file to be located
	 * @return the project file path for the new file
	 */
	private static String getLocationForFile(String projectPath,
			String projectName, String[] searchPaths, String createPath,
			String fileName) {
		
		// If the project file is in one of the search paths, the path is
		// changed to its parent
		for (int i = 0; i < searchPaths.length; i++) {
			String projectPathInLowerCase = projectPath.toLowerCase();
			String searchPathInLowerCase = searchPaths[i].toLowerCase();
			if (projectPathInLowerCase.endsWith(searchPathInLowerCase)) {
				int endIndex = projectPathInLowerCase.indexOf(searchPathInLowerCase);
				projectPath = projectPath.substring(0, endIndex);
				i = searchPaths.length;
			}
		}
		// Tries to find an existing file based on project path and project name
		String filePath = findProjectFile(projectPath, projectName,
				searchPaths, fileName, false);
		if (filePath == null) {
			// If file is not found, this returns a new path
			filePath = projectPath + File.separator + createPath
					+ File.separator + projectName + fileName;
		}
		return filePath;
	}

	/**
	 * Finds a project file or directory based on a file or directory
	 * 
	 * @param startPath
	 *            the file name or path where to start search
	 * @param projectName
	 *            the name of the project file
	 * @param searchDirectories
	 *            the directories to search
	 * @param fileExtension
	 *            the file extension to be located or null if locating one of
	 *            the search directories
	 * @param checkParents
	 *            true if parent directories should be checked
	 * @return the file or directory path if found or null if not
	 */
	private static String findProjectFile(String startPath, String projectName,
			String[] searchDirectories, String fileExtension,
			boolean checkParents) {
		String foundFile = null;
		if (startPath != null) {
			File file = new File(startPath);
			if (!file.isDirectory()) {
				file = file.getParentFile();
			}
			if (file != null) {
				do {
					for (int i = 0; i < searchDirectories.length
							&& foundFile == null; i++) {
						foundFile = findProjectFile(searchDirectories[i],
								projectName, fileExtension, file);
					}
					file = file.getParentFile();
				} while (file != null && foundFile == null && checkParents);
			}
		}
		return foundFile;
	}

	/**
	 * Searches a single directory for a project file
	 * 
	 * @param searchDirectory
	 *            the directory to search
	 * @param fileExtension
	 *            the file extension to be located or null if locating one of
	 *            the search directories
	 * @param projectName
	 *            the name of the project file
	 * @param file
	 *            the current file
	 * @return the file or directory path if found or null if not
	 */
	private static String findProjectFile(String searchDirectory,
			String projectName, String fileExtension, File file) {
		String foundFile = null;
		File projectPath = new File(file.getAbsolutePath() + File.separator
				+ searchDirectory + File.separator);
		if (projectPath.exists()) {
			if (fileExtension == null) {
				foundFile = projectPath.getAbsolutePath();
			} else {
				foundFile = findProjectFileFromDirectory(projectPath,
						projectName, fileExtension);
			}
		}
		return foundFile;
	}

	/**
	 * Gets the first file with given extension from given directory
	 * 
	 * @param path
	 *            the path to search
	 * @param projectName
	 *            the name of the project file
	 * @param fileExtension
	 *            the file extension
	 * @return the file name if found or null if not
	 */
	private static String findProjectFileFromDirectory(File path,
			String projectName, String fileExtension) {
		String proposal = null;
		File[] files = path.listFiles();
		if (projectName != null) {
			// If project name is specified, only the file that matches the name
			// is returned
			String nameFromProjectFile = projectName + fileExtension;
			for (int i = 0; i < files.length && proposal == null; i++) {
				String fname = files[i].getName();
				if (fname.equals(nameFromProjectFile)) {
					proposal = files[i].getAbsolutePath();
				}
			}
		} else {
			// If project name is not specified, this proposes the first file
			// which ends with the file extension
			for (int i = 0; i < files.length && proposal == null; i++) {
				String fname = files[i].getName();
				if (fname.length() > fileExtension.length()) {
					int extstart = fname.length() - fileExtension.length();
					if (fname.substring(extstart).equals(fileExtension)) {
						proposal = files[i].getAbsolutePath();
					}
				}
			}
		}
		return proposal;
	}

	/**
	 * Shows the directory query for environment root
	 * 
	 * @param dialogType
	 *            the query dialog type
	 * @return the environment root
	 */
	public static String queryEnvironmentRoot(QueryDialogType dialogType) {
		String path = TraceBuilderGlobals.getConfiguration().getText(
				TraceBuilderConfiguration.ENVIRONMENT_ROOT);
		DirectoryDialogQueryParameters query = new DirectoryDialogQueryParameters();
		query.path = path;
		query.dialogType = dialogType;
		int res = TraceBuilderGlobals.getDialogs().showConfirmationQuery(query);
		if (res == TraceBuilderDialogs.OK) {
			// Environment root is stored to configuration
			TraceBuilderGlobals.getConfiguration().setText(
					TraceBuilderConfiguration.ENVIRONMENT_ROOT, query.path);
		} else {
			query.path = null;
		}
		return query.path;
	}

}