/*

* 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:

*

* Trace project file manager

*

*/

package com.nokia.tracecompiler.engine.project;

import java.io.File;

import java.io.IOException;

import java.io.OutputStream;

import java.util.Enumeration;

import com.nokia.tracecompiler.engine.TraceCompilerEngineBase;

import com.nokia.tracecompiler.engine.TraceCompilerEngineErrorCodes.TraceCompilerErrorCode;

import com.nokia.tracecompiler.engine.plugin.TraceAPIPluginManager;

import com.nokia.tracecompiler.file.FileUtils;

import com.nokia.tracecompiler.model.TraceCompilerException;

import com.nokia.tracecompiler.model.TraceModel;

import com.nokia.tracecompiler.project.GroupNames;

import com.nokia.tracecompiler.project.ProjectUtils;

/**

 * Trace project engine

 * 

 */

public final class ProjectEngine extends TraceCompilerEngineBase {

	/**

	 * Parameters for create project

	 */

	private class CreateProjectParameters {

		/**

		 * Trace project path

		 */

		String traceProjectPath;

		/**

		 * Trace project name

		 */

		String traceProjectName;

		/**

		 * Trace project ID

		 */

		int traceProjectID;

	}

	/**

	 * Default project ID

	 */

	private static final int DEFAULT_PROJECT_ID = 0x0; // CodForChk_Dis_Magic

	/**

	 * Trace model

	 */

	private TraceModel model;

	/**

	 * Trace directory name

	 */

	public static String traceFolderName;

	/**

	 * Constructor

	 * 

	 * @param model

	 *            the trace model

	 */

	public ProjectEngine(TraceModel model) {

		this.model = model;

	}

	/**

	 * Opens trace project

	 * 

	 * @param projectPath

	 *            the path to the project to be opened

	 * @param modelName

	 *            the name for the model or null to use directory name

	 * @throws TraceCompilerException

	 *             if opening fails

	 */

	public void openTraceProject(String projectPath, String modelName)

			throws TraceCompilerException {

		if (projectPath != null) {

			CreateProjectParameters parameters = createParameters(projectPath,

					modelName);

			// Create empty project

			if (model.getExtension(TraceCompilerProject.class) == null) {

				createEmptyProjectFile(parameters);

			}

		} else {

			// If fileName is null, there's no open source files. In

			// that the project cannot be created

			throw new TraceCompilerException(

					TraceCompilerErrorCode.SOURCE_NOT_OPEN);

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.tracecompiler.engine.TraceCompilerEngine#projectOpened()

	 */

	@Override

	public void projectOpened() {

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.tracecompiler.engine.TraceCompilerEngine#projectClosed()

	 */

	@Override

	public void projectClosed() {

		model.removeExtensions(TraceCompilerProject.class);

		model.removeExtensions(TraceIDCache.class);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.tracecompiler.engine.TraceCompilerEngine#exportProject()

	 */

	@Override

	public void exportProject() {

		try {

			// The fixed id definitions file is updated even there are no traces

			// in case that old fixed id definitions file exist

			syncFixedIdDefinitionsFile();

		} catch (TraceCompilerException e) {

		}

	}

	/**

	 * Updated fixed id definitions file

	 * 

	 * @throws TraceCompilerException

	 *             if update fails

	 */

	private void syncFixedIdDefinitionsFile() throws TraceCompilerException {

		TraceIDCache cache = model.getExtension(TraceIDCache.class);

		// Create trace Id cache if it does not exist

		if (cache == null) {

			String path = ProjectUtils.getLocationForFile(model,

					ProjectEngine.traceFolderName,

					ProjectConstants.FIXED_ID_DEFINITIONS_FILE_NAME, false);

			if (path != null) {

				cache = new TraceIDCache(new File(path).getParent());

				model.addExtension(cache);

			}

		}

		if (cache != null) {

			File cacheFile = new File(cache.getAbsolutePath());

			// The fixed id definitions file is updated in case that there are

			// traces in model

			if (model.hasTraces()) {

				// Try to save Ids to fixed Id definition file

				try {

					SortedProperties ids = new SortedProperties();

					// Save Ids from model to fixed Id properties

					model.saveIDs(ids);

					// If there are some fixed Ids in that are not used anymore,

					// keep also those Ids in defininiton file, but mark those

					// ids as obsolete

					ids = handleObsoleteIds(ids);

					// Rewrites the trace Id cache file

					OutputStream fos = FileUtils.createOutputStream(cacheFile);

					ids.store(fos,

							ProjectConstants.FIXED_ID_DEFINITION_FILE_TITLE);

					fos.close();

					cache.postFileWrittenEvent(cache.getAbsolutePath());

				} catch (IOException e) {

					cacheFile.delete();

				}

			}

		}

	}

	/**

	 * Handle obsolete Ids

	 * 

	 * @param ids

	 *            Ids

	 */

	private SortedProperties handleObsoleteIds(SortedProperties ids) {

		SortedProperties fixedIds = model.getFixedIds();

		if (fixedIds != null) {

			Enumeration<Object> fixedIdKeys = fixedIds.keys();

			while (fixedIdKeys.hasMoreElements()) {

				String fixedIdKey = (String) fixedIdKeys.nextElement();

				if (!ids.containsKey(fixedIdKey)) {

					String value = fixedIds.getProperty(fixedIdKey);

					boolean markAsObsolete = true;

					// In case of groups we only mark user defined

					// groups as obsolete

					if (fixedIdKey.startsWith(model.GROUP_PROPERTY_PREFIX)) {

						int valueAsInt = 0;

						try {

							valueAsInt = Integer.decode(value).intValue();

						} catch (NumberFormatException e) {

							// Corrupted.

							valueAsInt = 0;

						}

						if (valueAsInt < GroupNames.USER_GROUP_ID_FIRST) {

							markAsObsolete = false;

						}

					}

					if (markAsObsolete) {

						// If OBSOLETE tag text already exit, do not

						// add that again

						if (fixedIdKey

								.startsWith(model.OBSOLETE_PROPERTY_PREFIX)) {

							ids.setProperty(fixedIdKey, value);

						} else {

							ids.setProperty(model.OBSOLETE_PROPERTY_PREFIX

									+ fixedIdKey, value);

						}

					}

				}

			}

		}

		return ids;

	}

	/**

	 * Creates the parameters for new project

	 * 

	 * @param projectPath

	 *            the project path

	 * @param projectName

	 *            the name for the project

	 * @return the parameters

	 */

	private CreateProjectParameters createParameters(String projectPath,

			String projectName) {

		CreateProjectParameters queryData = new CreateProjectParameters();

		queryData.traceProjectPath = projectPath + File.separator

				+ ProjectEngine.traceFolderName;

		queryData.traceProjectName = projectName;

		queryData.traceProjectID = DEFAULT_PROJECT_ID;

		return queryData;

	}

	/**

	 * Creates the project file from query results

	 * 

	 * @param queryData

	 *            the query result

	 * @throws TraceCompilerException 

	 */

	private void createEmptyProjectFile(CreateProjectParameters queryData) throws TraceCompilerException {

		model.setName(queryData.traceProjectName);

		model.setID(queryData.traceProjectID);

		String componentName = model.getName();

		TraceCompilerProject file = new TraceCompilerProject(

				queryData.traceProjectPath, componentName);

		createAPI(file);

	}

	/**

	 * Creates the project API

	 * 

	 * @param file

	 *            the project file

	 */

	private void createAPI(TraceCompilerProject file) {

		model.addExtension(file);

		TraceAPIPluginManager plugin = model

				.getExtension(TraceAPIPluginManager.class);

		plugin.createDefaultAPI();

	}

}