/*
 * Copyright (c) 2009 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:
 *
 * A singleton access point to functionality of Trace Compiler
 *
 */
package com.nokia.tracecompiler.engine;

import java.util.ArrayList;

import com.nokia.tracecompiler.engine.TraceCompilerEngineErrorCodes.TraceCompilerErrorCode;
import com.nokia.tracecompiler.engine.event.EventEngine;
import com.nokia.tracecompiler.engine.header.HeaderEngine;
import com.nokia.tracecompiler.engine.plugin.PluginEngine;
import com.nokia.tracecompiler.engine.project.ProjectEngine;
import com.nokia.tracecompiler.engine.propertyfile.PropertyFileEngine;
import com.nokia.tracecompiler.engine.rules.RulesEngine;
import com.nokia.tracecompiler.engine.source.SourceEngine;
import com.nokia.tracecompiler.engine.source.SourceListener;
import com.nokia.tracecompiler.engine.source.SourceProperties;
import com.nokia.tracecompiler.model.TraceCompilerException;
import com.nokia.tracecompiler.model.TraceModel;
import com.nokia.tracecompiler.plugin.TraceCompilerPlugin;

/**
 * A singleton access point to functionality of Trace Compiler
 * 
 */
final class TraceCompilerEngine implements SourceListener, TraceCompilerEngineInterface {

	/**
	 * TraceCompiler plug-in engine
	 */
	private PluginEngine pluginEngine;

	/**
	 * Event handler interface implementation
	 */
	private TraceCompilerEngineEvents eventEngine;

	/**
	 * Source editor engine
	 */
	private SourceEngine sourceEngine;

	/**
	 * Trace header engine
	 */
	private HeaderEngine headerEngine;

	/**
	 * Trace project engine
	 */
	private ProjectEngine projectEngine;

	/**
	 * Rule engine
	 */
	private RulesEngine rulesEngine;

	/**
	 * Trace property file engine
	 */
	private PropertyFileEngine propertyFileEngine;

	/**
	 * Source context manager
	 */
	private SourceContextManager contextManager;

	/**
	 * Location map
	 */
	private TraceLocationMap locationMap;

	/**
	 * Location converter
	 */
	private TraceLocationConverter locationConverter;

	/**
	 * Trace model
	 */
	private TraceModel model;

	/**
	 * Interface to the view
	 */
	private TraceCompilerEngineView view = new ViewAdapter();

	/**
	 * Configuration
	 */
	private ConfigurationDelegate configurationDelegate;

	/**
	 * List of engines that need project open / export / close notifications
	 */
	private ArrayList<TraceCompilerEngineBase> engines = new ArrayList<TraceCompilerEngineBase>();

	/**
	 * View has been registered flag
	 */
	private boolean isViewRegistered = false;

	/**
	 * Project path is stored in case the view unregisters and re-registers
	 */
	private String currentProjectPath;

	/**
	 * Gets the configuration of TraceCompiler
	 * 
	 * @return the configuration
	 */
	TraceCompilerEngineConfiguration getConfiguration() {
		return configurationDelegate;
	}

	/**
	 * Gets the trace compiler interface
	 * 
	 * @return this object
	 */
	TraceCompilerEngineInterface getTraceCompiler() {
		return this;
	}

	/**
	 * Gets the trace model
	 * 
	 * @return the trace model
	 */
	TraceModel getModel() {
		return model;
	}

	/**
	 * Gets the source engine
	 * 
	 * @return the source engine
	 */
	SourceEngine getSourceEngine() {
		return sourceEngine;
	}

	/**
	 * Gets the events interface
	 * 
	 * @return the events interface
	 */
	TraceCompilerEngineEvents getEvents() {
		return eventEngine;
	}

	/**
	 * Adds a plug-in
	 * 
	 * @param plugin
	 *            the plugin
	 */
	void registerPlugin(TraceCompilerPlugin plugin) {
		pluginEngine.add(plugin);
	}

	/**
	 * Removes an existing plug-in
	 * 
	 * @param plugin
	 *            the plugin
	 */
	void unregisterPlugin(TraceCompilerPlugin plugin) {
		pluginEngine.remove(plugin);
	}

	/**
	 * Gets the source context manager
	 * 
	 * @return the context manager
	 */
	public SourceContextManager getSourceContextManager() {
		return contextManager;
	}

	/**
	 * Starts TraceCompiler.
	 * @throws TraceCompilerException 
	 */
	void start() throws TraceCompilerException {
		configurationDelegate = new ConfigurationDelegate();
		rulesEngine = new RulesEngine();
		pluginEngine = new PluginEngine();
		model = new TraceModel(rulesEngine, pluginEngine.getVerifier());
		pluginEngine.setModel(model);
		projectEngine = new ProjectEngine(model);
		propertyFileEngine = new PropertyFileEngine(model);
		eventEngine = new EventEngine(model);
		sourceEngine = new SourceEngine(model);
		locationMap = new TraceLocationMap(model);
		locationConverter = new TraceLocationConverter(model);
		sourceEngine.addSourceListener(this);
		contextManager = new SourceContextManagerImpl();
		headerEngine = new HeaderEngine(model);
		// Keep this order -> Exports need to be in correct order
		// Property file engine manages the ID cache so it needs to be run
		// before plug-in's and header
		engines.add(projectEngine);
		engines.add(propertyFileEngine);
		engines.add(headerEngine);
		engines.add(pluginEngine);
	}

	/**
	 * Shuts down TraceCompiler
	 * @throws TraceCompilerException 
	 */
	void shutdown() throws TraceCompilerException {
		closeProject();
	}

	/**
	 * Registers the view
	 * 
	 * @param view
	 *            the view
	 * @throws TraceCompilerException 
	 */
	void setView(TraceCompilerEngineView view) throws TraceCompilerException {
		if (view == null) {
			// Closes the project, but leaves the currentProjectName and
			// currentProjectPath variables. When view re-registers the project
			// is opened back
			internalCloseProject();
			this.view = new ViewAdapter();
			isViewRegistered = false;
		} else {
			this.view = view;
			isViewRegistered = true;
		}
		configurationDelegate.setConfiguration(this.view.getConfiguration());
	}

	/**
	 * Checks that model is valid
	 * 
	 * @throws TraceCompilerException
	 *             if model is not valid
	 */
	private void checkIsModelValid() throws TraceCompilerException {
		if (!model.isValid()) {
			throw new TraceCompilerException(
					TraceCompilerErrorCode.MODEL_NOT_READY);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracecompiler.engine.TraceCompilerEngineInterface#openProject(java.lang.String,
	 *      java.lang.String)
	 */
	public void openProject(String modelName) throws Exception {
		try {
			if (view != null && isViewRegistered && !model.isValid()) {
				projectEngine.openTraceProject(currentProjectPath, modelName);
				for (TraceCompilerEngineBase engine : engines) {
					engine.projectOpened();
				}
				model.setValid(true);
				sourceEngine.start();
			}
		} catch (TraceCompilerException e) {
			closeModel();
			throw e;
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracecompiler.engine.TraceCompilerEngineInterface#exportProject()
	 */
	public void exportProject() throws TraceCompilerException {
		checkIsModelValid();
		if (model.getID() != 0) {
			for (TraceCompilerEngineBase engine : engines) {
					engine.exportProject();
			}
		} else {
			throw new TraceCompilerException(
					TraceCompilerErrorCode.INVALID_MODEL_PROPERTIES_FOR_EXPORT);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracecompiler.engine.TraceCompilerEngineInterface#closeProject()
	 */
	public void closeProject() throws TraceCompilerException {
		internalCloseProject();
		currentProjectPath = null;
	}

	/**
	 * Closes the project
	 * @throws TraceCompilerException 
	 */
	private void internalCloseProject() throws TraceCompilerException {
		if (model.isValid()) {
			if (!TraceCompilerEngineGlobals.getConfiguration().getFlag(
					TraceCompilerEngineConfiguration.CONSOLE_UI_MODE)) {
				try {
					// Plug-in's are not exported when project is closed
					// They can do cleanup in traceProjectClosed call
					for (TraceCompilerEngineBase engine : engines) {
						if (engine != pluginEngine) {
							engine.exportProject();
						}
					}
				} catch (TraceCompilerException e) {
					getEvents().postError(e);
						throw e;
				}
			}
			// Engines are closed in reverse order
			for (int i = engines.size() - 1; i >= 0; i--) {
				engines.get(i).projectClosed();
			}
			sourceEngine.shutdown();
			closeModel();
		}
	}

	/**
	 * Closes the trace model
	 */
	private void closeModel() {
		try {
			if (model != null) {
				model.reset();
				model.setValid(false);
			}
		} catch (Exception e) {
			if (TraceCompilerEngineConfiguration.ASSERTIONS_ENABLED) {
				getEvents().postAssertionFailed("Failed to close model", e); //$NON-NLS-1$
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracecompiler.engine.SourceListener#
	 *      sourceOpened(com.nokia.tracecompiler.engine.SourceProperties)
	 */
	public void sourceOpened(SourceProperties properties) throws TraceCompilerException {
		locationMap.addSource(properties);
		locationConverter.sourceOpened(properties);
	}

	/**
	 * Get project path
	 * 
	 * @return project path
	 */
	public String getProjectPath() {
		return currentProjectPath;
	}

	/**
	 * Set project path
	 * 
	 * @param path
	 *            the path
	 */
	public void setProjectPath(String path) {
		currentProjectPath = path;
	}

}