/*

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

*

* Header engine manages the trace header file that is included into source code

*

*/

package com.nokia.tracecompiler.engine.header;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import com.nokia.tracecompiler.engine.LocationListBase;

import com.nokia.tracecompiler.engine.LocationProperties;

import com.nokia.tracecompiler.engine.TraceCompilerEngineBase;

import com.nokia.tracecompiler.engine.TraceCompilerEngineEvents;

import com.nokia.tracecompiler.engine.TraceCompilerEngineGlobals;

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

import com.nokia.tracecompiler.engine.project.ProjectEngine;

import com.nokia.tracecompiler.file.FileCompareOutputStream;

import com.nokia.tracecompiler.model.Trace;

import com.nokia.tracecompiler.model.TraceCompilerException;

import com.nokia.tracecompiler.model.TraceGroup;

import com.nokia.tracecompiler.model.TraceModel;

import com.nokia.tracecompiler.plugin.TraceHeaderContribution;

import com.nokia.tracecompiler.plugin.TraceHeaderContribution.TraceHeaderContributionType;

import com.nokia.tracecompiler.project.ProjectUtils;

import com.nokia.tracecompiler.project.TraceProjectAPI;

import com.nokia.tracecompiler.source.SourceUtils;

/**

 * Header engine manages the trace header file that is included into source

 * code. This implements the plug-in interface to get notifications about

 * project file opening and closing

 * 

 */

public final class HeaderEngine extends TraceCompilerEngineBase {

	/**

	 * Trace model

	 */

	private TraceModel model;

	/**

	 * Constructor

	 * 

	 * @param model

	 *            trace model

	 */

	public HeaderEngine(TraceModel model) {

		this.model = model;

	}

	/*

	 * (non-Javadoc)

	 * 

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

	 */

	@Override

	public void projectOpened() {

		TraceHeader header = model.getExtension(TraceHeader.class);

		if (header == null) {

			String fileName = null;

			try {

				fileName = ProjectUtils.getLocationForFile(model,

						ProjectEngine.traceFolderName,

						HeaderConstants.TRACE_HEADER_NAME, false);

			} catch (TraceCompilerException e) {

				// Model should always be open when traceProjectOpened is called

			}

			if (fileName != null) {

				header = new TraceHeader(fileName, false);

				model.addExtension(header);

			} else {

				String msg = Messages

						.getString("HeaderEngine.FailedToAttachHeader"); //$NON-NLS-1$

				TraceCompilerEngineGlobals.getEvents().postErrorMessage(msg, null, true);

			}

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.tracecompiler.engin.TraceCompilererEngine#projectClosing()

	 */

	@Override

	public void projectClosed() {

		model.removeExtensions(TraceHeader.class);

	}

	/**

	 * Gets the name for the trace header file based on given source

	 * 

	 * @param sourceFile

	 *            the source file name

	 * @return the header file name

	 */

	public String getHeaderFileName(String sourceFile) {

		String retval = null;

		if (model != null) {

			// The header file name is the source file name with extension

			// replaced by Traces.h

			File f = new File(sourceFile);

			retval = removeFileExtension(f.getName())

					+ HeaderConstants.TRACE_HEADER_EXTENSION;

		}

		return retval;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.tracecompiler.engi.TraceCompilerlerEngine#projectExporting()

	 */

	@Override

	public void exportProject() throws TraceCompilerException {

		if (model.isValid() && model.hasTraces()) {

			TraceHeader header = model.getExtension(TraceHeader.class);

			if (header != null) {

				// Headers for each source are written first

				String path = header.getPath();

				ArrayList<String> fileNames = new ArrayList<String>();

				collectSourceFilesFromTraces(fileNames);

				for (String fileName : fileNames) {

					String target = path + File.separator + fileName;

					writeHeaderFile(target);

				}

				// The main header is written after everything else succeeds

				writeMainHeaderFile(header);

			}

		}

	}

	/**

	 * Collects the source file names from traces

	 * 

	 * @param fileNames

	 *            the file names

	 */

	private void collectSourceFilesFromTraces(ArrayList<String> fileNames) {

		for (TraceGroup group : model) {

			for (Trace trace : group) {

				Iterator<LocationListBase> itr = trace

						.getExtensions(LocationListBase.class);

				while (itr.hasNext()) {

					LocationListBase base = itr.next();

					for (LocationProperties loc : base) {

						String locFileName = loc.getFileName();

						if (locFileName != null) {

							addFileToList(fileNames, locFileName);

						}

					}

				}

			}

		}

	}

	/**

	 * Adds a file to list if it does not exist

	 * 

	 * @param fileNames

	 *            the list

	 * @param locFileName

	 *            the file

	 */

	private void addFileToList(ArrayList<String> fileNames, String locFileName) {

		locFileName = removeFileExtension(locFileName);

		if (!fileNames.contains(locFileName)) {

			fileNames.add(locFileName);

		}

	}

	/**

	 * Removes the file extension from file name

	 * 

	 * @param fileName

	 *            the file name

	 * @return name without extension

	 */

	private String removeFileExtension(String fileName) {

		int index = fileName.lastIndexOf('.');

		int sep1 = fileName.lastIndexOf('/');

		int sep2 = fileName.lastIndexOf('\\');

		if (index > sep1 && index > sep2) {

			fileName = fileName.substring(0, index);

		}

		return fileName;

	}

	/**

	 * Writes the header to given target

	 * 

	 * @param target

	 *            the target file

	 * @throws TraceCompilerException

	 *             if writing fails

	 */

	private void writeHeaderFile(String target) throws TraceCompilerException {

		// The TraceHeader stored into the model is not used when writing

		// headers, since a separate header is written for each source file

		TraceHeader header = new TraceHeader(target, true);

		try {

			header.setOwner(model);

			TraceHeaderWriter writer = new TraceHeaderWriter(header);

			TraceCompilerEngineEvents events = TraceCompilerEngineGlobals.getEvents();

			if (writer.write()) {

				header.postFileWrittenEvent(header.getAbsolutePath());

			} else {

				String msg = Messages

						.getString("HeaderEngine.TraceHeaderNotChangedPrefix"); //$NON-NLS-1$

				events.postInfoMessage(msg + header.getAbsolutePath(), null);

			}

		} finally {

			// The header owner must be reset to null, since that makes

			// unregisters it from the model

			header.setOwner(null);

		}

	}

	/**

	 * Writes the main header file to given target

	 * 

	 * @param header

	 *            the header

	 * @throws TraceCompilerException

	 *             if writing fails

	 */

	private void writeMainHeaderFile(TraceHeader header)

			throws TraceCompilerException {

		// The TraceHeader stored into the model is not used when writing

		// headers, since a separate header is written for each source file

		TraceCompilerEngineEvents events = TraceCompilerEngineGlobals.getEvents();

		String path = header.getAbsolutePath();

		try {

			if (writeMainHeader(path)) {

				header.postFileWrittenEvent(path);

			} else {

				String msg = Messages

						.getString("HeaderEngine.TraceHeaderNotChangedPrefix"); //$NON-NLS-1$

				events.postInfoMessage(msg + path, null);

			}

		} catch (IOException e) {

			throw new TraceCompilerException(

					TraceCompilerErrorCode.CANNOT_WRITE_PROJECT_FILE, e);

		}

	}

	/**

	 * Writes the main header to given target

	 * 

	 * @param target

	 *            the target

	 * @return true if written, false if the file already had the same content

	 * @throws IOException

	 *             if writing fails

	 */

	private boolean writeMainHeader(String target) throws IOException {

		File f = new File(target);

		FileCompareOutputStream stream = new FileCompareOutputStream(f);

		String licence = TraceCompilerEngineGlobals.getDefaultLicence(true);

		if (licence != null) {

			stream.write(licence.getBytes());

		}

		stream.write(SourceUtils.createHeaderGuard(f.getName()).getBytes());

		TraceProjectAPI api = model.getExtension(TraceProjectAPI.class);

		if (api instanceof TraceHeaderContribution) {

			String[] content = ((TraceHeaderContribution) api)

					.getContribution(TraceHeaderContributionType.MAIN_HEADER_CONTENT);

			if (content != null && content.length == 1) {

				stream.write(content[0].getBytes());

			}

		}

		return stream.writeFile();

	}

}