/*

 * Copyright (c) 2007-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:

 *

 * A singleton access point to functionality of Trace Viewer

 *

 */

package com.nokia.traceviewer.engine;

import java.util.List;

import com.nokia.carbide.cpp.internal.featureTracker.FeatureUseTrackerConsts;

import com.nokia.carbide.cpp.internal.featureTracker.FeatureUseTrackerPlugin;

import com.nokia.carbide.remoteconnections.RemoteConnectionsActivator;

import com.nokia.carbide.remoteconnections.interfaces.IConnection;

import com.nokia.carbide.remoteconnections.internal.api.IConnection2;

import com.nokia.traceviewer.TraceViewerPlugin;

import com.nokia.traceviewer.action.OpenDecodeFileInStartupHandler;

import com.nokia.traceviewer.action.ReloadDecodeFilesAction;

import com.nokia.traceviewer.engine.dataprocessor.DataProcessor;

import com.nokia.traceviewer.engine.preferences.PreferenceConstants;

import com.nokia.traceviewer.engine.preferences.XMLGeneralConfigurationExporter;

import com.nokia.traceviewer.engine.preferences.XMLGeneralConfigurationImporter;

import com.nokia.traceviewer.internal.api.TraceViewerAPI2Impl;

/**

 * A singleton access point to functionality of Trace Viewer

 * 

 */

final class TraceViewer implements TraceViewerInterface, MediaCallback {

	/**

	 * Default file name

	 */

	private final String DEFAULT_FILE_NAME = Messages

			.getString("TraceViewer.DefaultFileName"); //$NON-NLS-1$

	/**

	 * Default file path

	 */

	private final String DEFAULT_FILE_PATH = TraceViewerPlugin.getDefault()

			.getStateLocation().append(DEFAULT_FILE_NAME).toOSString();

	/**

	 * Data Processor Access

	 */

	private DataProcessorAccess dataProcessorAccess;

	/**

	 * Data Reader Access

	 */

	private DataReaderAccess dataReaderAccess;

	/**

	 * Interface to the view

	 */

	private TraceViewerTraceViewInterface view;

	/**

	 * Interface to the dialogs. Initialize with dummy class.

	 */

	private TraceViewerDialogInterface dialogs = new DummyDialogs();

	/**

	 * Interface to trace file handler. Initialize with internal file handler.

	 */

	private TraceFileHandler fileHandler = new InternalFileHandler(

			DEFAULT_FILE_PATH);

	/**

	 * Interface to the propertyview

	 */

	private TraceViewerPropertyViewInterface propertyView;

	/**

	 * Event listener that listens events from EventRouter

	 */

	private TraceViewerEventListener eventListener;

	/**

	 * Interface to the connection

	 */

	private Connection connection;

	/**

	 * TraceViewer stateHolder

	 */

	private StateHolder stateHolder;

	/**

	 * Trace Provider in use

	 */

	private TraceProvider provider;

	/**

	 * Decode Provider

	 */

	private DecodeProvider decodeProvider;

	/**

	 * Indicates that filter progressbar can be closed when currentDataReader

	 * says EOF next time

	 */

	private boolean closeFilterProgressBar;

	/**

	 * Trace fetcher

	 */

	private TraceFetcher traceFetcher;

	/**

	 * Currently open connection

	 */

	private IConnection currentlyOpenConnection;

	/**

	 * Current connection status listener

	 */

	private ConnectionStatusListener currentConnectionStatusListener;

	/**

	 * Gets the trace viewer interface

	 * 

	 * @return this object

	 */

	TraceViewerInterface getTraceViewer() {

		return this;

	}

	/**

	 * Sets trace provider

	 * 

	 * @param newProvider

	 *            new trace provider

	 * @param clearDataBefore

	 *            if true, clear data file before changing the new provider

	 */

	public void setTraceProvider(TraceProvider newProvider,

			boolean clearDataBefore) {

		// First provider, set as default

		if (this.provider == null) {

			this.provider = newProvider;

			// Create main file

			createMainFile();

			initializeAfterProvider();

			// Check if new provider is selected and not in use already. If yes,

			// set as default.

		} else if (newProvider.getName().equals(

				TraceViewerPlugin.getDefault().getPreferenceStore().getString(

						PreferenceConstants.DATA_FORMAT))

				&& this.provider != newProvider) {

			this.provider = newProvider;

			// Clear old data file

			if (clearDataBefore) {

				clearAllData();

			}

			initializeAfterProvider();

		}

	}

	/**

	 * Initialize TraceViewer when Trace Provider has changed

	 */

	private void initializeAfterProvider() {

		// Empty views

		TraceViewerGlobals.getTraceViewer().emptyViews();

		// Provider is alive, data reader can now be created

		dataReaderAccess.createMainDataReader();

		// If filtering is on and TraceProvider changes, create a new Filter

		// Data Reader to be able to decode the new data

		if (dataProcessorAccess.getFilterProcessor().isFiltering()) {

			dataReaderAccess.createFilterDataReader();

		}

	}

	/**

	 * Gets trace provider

	 * 

	 * @return trace provider

	 */

	public TraceProvider getTraceProvider() {

		return provider;

	}

	/**

	 * Sets decode provider

	 * 

	 * @param decodeProvider

	 */

	public void setDecodeProvider(DecodeProvider decodeProvider) {

		this.decodeProvider = decodeProvider;

		// Set decode provider to show or not show class and function names

		// before the trace text

		boolean showClassFunctionName = TraceViewerPlugin.getDefault()

				.getPreferenceStore().getBoolean(

						PreferenceConstants.SHOW_CLASS_FUNCTION_NAME_CHECKBOX);

		boolean showComponentGroupName = TraceViewerPlugin.getDefault()

				.getPreferenceStore().getBoolean(

						PreferenceConstants.SHOW_COMPONENT_GROUP_NAME_CHECKBOX);

		decodeProvider.setAddPrefixesToTrace(showClassFunctionName,

				showComponentGroupName);

	}

	/**

	 * Gets decode provider

	 * 

	 * @return decode provider

	 */

	public DecodeProvider getDecodeProvider() {

		return decodeProvider;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.traceviewer.engine.TraceViewerInterface#getConnection()

	 */

	public Connection getConnection() {

		return connection;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * com.nokia.traceviewer.engine.TraceViewerInterface#getDataProcessorAccess

	 * ()

	 */

	public DataProcessorAccess getDataProcessorAccess() {

		return dataProcessorAccess;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * com.nokia.traceviewer.engine.TraceViewerInterface#getDataReaderAccess()

	 */

	public DataReaderAccess getDataReaderAccess() {

		return dataReaderAccess;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.traceviewer.engine.TraceViewerInterface#getStateHolder()

	 */

	public StateHolder getStateHolder() {

		return stateHolder;

	}

	/**

	 * Starts TraceViewer.

	 */

	void start() {

		// Create DataProcessors

		dataProcessorAccess = new DataProcessorAccess();

		dataProcessorAccess.createDataProcessors();

		stateHolder = new StateHolder();

		// Create Data Reader Access class

		dataReaderAccess = new DataReaderAccess(this, DEFAULT_FILE_PATH);

		// Start listening events from the event router

		eventListener = new TraceViewerEventListener();

		eventListener.register();

		// Create "current connection" listener

		ConnectionChangedListener connectionListener = new ConnectionChangedListener();

		RemoteConnectionsActivator.getConnectionsManager()

				.addConnectionListener(connectionListener);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @seecom.nokia.traceviewer.engine.TraceViewerInterface#setTraceView(

	 * TraceViewerTraceViewInterface)

	 */

	public void setTraceView(TraceViewerTraceViewInterface newView) {

		if (view == null || view.isDisposed()) {

			// If old view is disposed but not null, remove it from the list

			if (view != null) {

				dataProcessorAccess.getDataProcessorList().remove(view);

			}

			view = newView;

			// Add view to DataProcessor list

			dataProcessorAccess.addTraceViewToList((DataProcessor) newView);

			if (view != null) {

				// View has notified about himself, we can import old

				// configurations which require view

				dataProcessorAccess.importConfiguration();

				// Import general settings

				XMLGeneralConfigurationImporter importer = new XMLGeneralConfigurationImporter(

						TraceViewerPlugin.getDefault().getPreferenceStore()

								.getString(

										PreferenceConstants.CONFIGURATION_FILE),

						true);

				importer.importData();

				// Clear data when view comes visible. This is to ensure that

				// view is in sync with the data file.

				clearAllData();

				// Open possible previous decode files

				new OpenDecodeFileInStartupHandler().start();

			}

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @seecom.nokia.traceviewer.engine.TraceViewerInterface#setPropertyView(

	 * TraceViewerPropertyViewInterface)

	 */

	public void setPropertyView(TraceViewerPropertyViewInterface newView) {

		if (propertyView == null || propertyView.isDisposed()) {

			// If old one is disposed but not null, remove it from the list

			if (propertyView != null) {

				dataProcessorAccess.getDataProcessorList().remove(propertyView);

			}

			this.propertyView = newView;

			// Add view to DataProcessor list

			dataProcessorAccess.addTraceViewToList((DataProcessor) newView);

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @seecom.nokia.traceviewer.engine.TraceViewerInterface#setDialogs(

	 * TraceViewerDialogInterface)

	 */

	public void setDialogs(TraceViewerDialogInterface dialogs) {

		this.dialogs = dialogs;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * com.nokia.traceviewer.engine.MediaCallback#processTrace(com.nokia.traceviewer

	 * .engine.TraceProperties)

	 */

	public void processTrace(TraceProperties properties) {

		// Loop through DataProcessors

		List<DataProcessor> dataProcessors = dataProcessorAccess

				.getDataProcessorList();

		for (int i = 0; i < dataProcessors.size(); i++) {

			dataProcessors.get(i).processData(properties);

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.traceviewer.engine.MediaCallback#endOfFile()

	 */

	public void endOfFile(DataReader reader) {

		// If everything is not shown, show it

		if (((view != null && view.hasUnshownData()) || (propertyView != null && propertyView

				.hasUnshownData()))) {

			if (reader == dataReaderAccess.getCurrentDataReader()) {

				if (view != null) {

					view.update();

				}

				if (propertyView != null) {

					propertyView.updatePropertyTables();

				}

			} else {

				// Nothing

			}

		}

		// Plain text filter file must be flushed

		if (reader instanceof PlainTextReader

				&& (reader == dataReaderAccess.getMainDataReader())) {

			dataProcessorAccess.getFilterProcessor().flush();

		}

		// If processing something with the progressbar, close it

		if ((reader == dataReaderAccess.getMainDataReader())

				&& (dataProcessorAccess.processingWithProgressBar())) {

			if (!dataProcessorAccess.getFilterProcessor().isFiltering()) {

				dataProcessorAccess.closeProgressBar();

				// Filtering and main data reader is in the end. Next time

				// current data reader is in the end, progressbar can be closed

			} else {

				closeFilterProgressBar = true;

			}

		}

		// Close filter progressBar when current data reader is in the end after

		// first the main data reader is in the end

		if (closeFilterProgressBar

				&& reader == dataReaderAccess.getCurrentDataReader()) {

			dataProcessorAccess.closeProgressBar();

			closeFilterProgressBar = false;

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.traceviewer.engine.MediaCallback#dataHandleChanged()

	 */

	public void dataHandleChanged() {

		// No need to do anything because main and current reader are handled

		// already in DataReaderAccess

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.traceviewer.engine.TraceViewerInterface#connect()

	 */

	public boolean connect() {

		boolean success = false;

		ConnectionCreator creator = new ConnectionCreator(DEFAULT_FILE_PATH);

		connection = creator.getConnection();

		if (connection != null) {

			// Open file

			fileHandler.openFile();

			// Try to connect

			success = connection.connect();

		}

		// Check if connection succeeded

		if (success) {

			currentlyOpenConnection = ConnectionHelper.currentEnsuredConnection;

			// If Ensured connection was not found, try with current ID

			if (currentlyOpenConnection == null) {

				currentlyOpenConnection = ConnectionHelper

						.getConnectionWithCurrentID();

			}

			// Set connection to use mode

			if (currentlyOpenConnection != null) {

				currentlyOpenConnection.useConnection(true);

				// Add status listener to the connection

				if (currentlyOpenConnection instanceof IConnection2) {

					currentConnectionStatusListener = new ConnectionStatusListener();

					((IConnection2) currentlyOpenConnection)

							.addStatusChangedListener(currentConnectionStatusListener);

				}

				// Notifying possible clients interested in connect event

				TraceViewerAPI2Impl.notifyConnection(currentlyOpenConnection);

			}

			// Start using feature

			FeatureUseTrackerPlugin.getFeatureUseProxy().startUsingFeature(

					FeatureUseTrackerConsts.CARBIDE_OST_TRACE);

			// Connection failed, set internal file handler back

		} else {

			fileHandler = new InternalFileHandler(DEFAULT_FILE_PATH);

		}

		return success;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.traceviewer.engine.TraceViewerInterface#disconnect()

	 */

	public boolean disconnect() {

		boolean success = false;

		// Disconnect and set internal file handler

		success = disconnectAndSetFileHandler();

		// Notifying possible clients interested in disconnect event

		if (success) {

			TraceViewerAPI2Impl.notifyDisconnection();

		}

		return success;

	}

	/**

	 * Create the main trace file

	 */

	private void createMainFile() {

		// Open the file and clear it

		fileHandler.openFile();

		fileHandler.clearFile();

	}

	/*

	 * (non-Javadoc)