/**
 * <copyright>
 * 
 * Copyright (c) 2008-2010 See4sys and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 * 
 * Contributors: 
 *     See4sys - Initial API and implementation
 * 
 * </copyright>
 */
package org.eclipse.sphinx.platform.stats;

import java.io.File;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.framework.log.FrameworkLog;
import org.eclipse.osgi.util.NLS;
import org.eclipse.sphinx.platform.internal.Activator;
import org.eclipse.sphinx.platform.internal.messages.Messages;
import org.eclipse.sphinx.platform.messages.PlatformMessages;
import org.eclipse.sphinx.platform.util.PlatformLogUtil;

// TODO Add JavaDoc comments
public abstract class AbstractPerformanceStats<T extends IEventTypeEnumerator> implements IPerformanceStats<T> {

	private Map<Integer, String> contextNames;
	private Map<Integer, long[]> contextUserTimes;
	private Map<Integer, String> eventNames;
	private Map<Integer, ArrayList<Integer>> contextArborescence;
	private Map<Integer, Map<Integer, Map<Integer, StatsEvent>>> eventStatsMap;
	private LinkedList<String> contextStackCall;
	private LinkedList<String> contextPrinted;

	private PlatformLogWriter outLog;
	private static final String PERF = "/perf"; //$NON-NLS-1$
	private static final String JUNIT_OPTIONS = "/jUnitOptions";//$NON-NLS-1$
	private static final String LOG_OPTIONS = "/logOptions";//$NON-NLS-1$
	private static final String EVENT_OPTIONS = "/eventOptions";//$NON-NLS-1$
	private static final String TIMEOUT_VALUE = "/timeOutValue";//$NON-NLS-1$
	private static final String PERF_ID = Activator.PLUGIN_ID + PERF;
	private static final String RESET_EVENT_BASE_ID = Activator.PLUGIN_ID + PERF + JUNIT_OPTIONS + "/keepEventInfoAfterLogging"; //$NON-NLS-1$
	private static final String LOG_IN_SEPARATE_LOG_FILE_ID = Activator.PLUGIN_ID + PERF + LOG_OPTIONS + "/logInSeparateLogFile"; //$NON-NLS-1$
	private static final String LOG_ERROR_ON_TIMEOUT_ID = Activator.PLUGIN_ID + PERF + LOG_OPTIONS + "/logErrorOnTimeout"; //$NON-NLS-1$
	private static final String LOG_WARNING_ON_NO_TIME_ID = Activator.PLUGIN_ID + PERF + LOG_OPTIONS + "/logWarningOnNoTime"; //$NON-NLS-1$
	private static final String CLEAR_LOG_FILES_ON_STARTUP_ID = Activator.PLUGIN_ID + PERF + LOG_OPTIONS + "/clearLogFilesOnStartup";//$NON-NLS-1$
	private static final String LOG_EVENTS_DETAILS = Activator.PLUGIN_ID + PERF + LOG_OPTIONS + "/logEventsDetails"; //$NON-NLS-1$
	private static boolean logEventDetails;
	private static boolean enabled;
	private static boolean resetEventBase;
	private static boolean logInSeparateLogFile;
	private static boolean logErrorOnTimeOut;
	private static boolean logWarningOnNoTime;
	private static boolean clearLogFilesOnStartup;
	public static String DEFAULT_CONTEXT = "Global"; //$NON-NLS-1$

	public AbstractPerformanceStats() {
		contextNames = new HashMap<Integer, String>();
		eventNames = new HashMap<Integer, String>();
		contextArborescence = new HashMap<Integer, ArrayList<Integer>>();
		eventStatsMap = new HashMap<Integer, Map<Integer, Map<Integer, StatsEvent>>>();
		contextStackCall = new LinkedList<String>();
		contextPrinted = new LinkedList<String>();
		contextUserTimes = new HashMap<Integer, long[]>();
		outLog = createLog(getClass().getSimpleName() + ".log"); //$NON-NLS-1$
	}

	static {
		/**  */
		enabled = getBooleanOption(PERF_ID, false);

		/**  */
		resetEventBase = getBooleanOption(RESET_EVENT_BASE_ID, false);

		/**  */
		logInSeparateLogFile = !getBooleanOption(LOG_IN_SEPARATE_LOG_FILE_ID, true);

		/**  */
		logErrorOnTimeOut = getBooleanOption(LOG_ERROR_ON_TIMEOUT_ID, true);

		/**  */
		logWarningOnNoTime = getBooleanOption(LOG_WARNING_ON_NO_TIME_ID, true);

		clearLogFilesOnStartup = getBooleanOption(CLEAR_LOG_FILES_ON_STARTUP_ID, true);

		logEventDetails = getBooleanOption(LOG_EVENTS_DETAILS, false);
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#isEnabled()
	 */
	@Override
	public boolean isEnabled() {
		return enabled;
	}

	private PlatformLogWriter createLog(String logOutFileName) {
		FrameworkLog perfLog = new PerformanceStatsLog(new File(logOutFileName));
		IPath logLocation = Platform.getLogFileLocation();
		logLocation = logLocation.removeLastSegments(1).append(logOutFileName);
		try {
			perfLog.setFile(logLocation.toFile(), false);
			if (perfLog.getFile() != null) {
				if (perfLog.getFile().exists() && clearLogFilesOnStartup) {
					perfLog.getFile().delete();
				}
			}
			perfLog.setFile(logLocation.toFile(), false);
		} catch (Exception ex) {
			PlatformLogUtil.logAsError(Activator.getDefault(), ex);
		}
		return new PlatformLogWriter(perfLog);
	}

	private void addEventName(String eventName) {
		if (!eventNames.containsKey(eventName.hashCode())) {
			eventNames.put(eventName.hashCode(), eventName);
		}
	}

	private String getEventName(Integer eventId) {
		if (eventNames.containsKey(eventId)) {
			return eventNames.get(eventId);
		} else {
			return "Not referenced Event"; //$NON-NLS-1$
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#isEventTriggered()
	 */
	@Override
	public boolean isEventTriggered() {
		return true;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#openContextIfFirstOne(java.lang.String)
	 */
	@Override
	public boolean openContextIfFirstOne(String context) {
		if (contextStackCall.isEmpty()) {
			openContext(context);
			return true;
		}
		return false;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#openContext(java.lang.String, java.lang.Object)
	 */
	@Override
	public void openContext(String context, Object blame) {
		if (blame != null) {
			openContext(context + blame.toString());
		} else {
			openContext(context);
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#openContext(java.lang.String)
	 */
	@Override
	public void openContext(String context) {
		if (context != null) {
			if (isEnabled()) {
				if (contextStackCall != null) {
					if (contextStackCall.size() == 0) {
						addContextName(context);
						contextStackCall.addLast(context);
					} else {
						addChildContext(contextStackCall.getLast(), context);
						contextStackCall.addLast(context);
					}
					long[] userTimeForContext = contextUserTimes.get(context.hashCode());
					if (userTimeForContext != null) {
						if (userTimeForContext[0] <= 0) {
							userTimeForContext[0] = System.currentTimeMillis();
						}
					} else {
						if (userTimeForContext[0] <= 0) {
							userTimeForContext[0] = System.currentTimeMillis();
						}
					}
				}
			}
		} else {
			String arg = "context";//$NON-NLS-1$
			String msg = NLS.bind(PlatformMessages.error_mustNotBeNull, arg);
			PlatformLogUtil.logAsWarning(Activator.getDefault(), new IllegalArgumentException(msg));
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#closeAndLogContext(java.lang.String, java.lang.Object)
	 */
	@Override
	public void closeAndLogContext(String context, Object blame) {
		closeAndLogContext(context + blame.toString());
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#closeAndLogContext(java.lang.String)
	 */
	@Override
	public void closeAndLogContext(String context) {
		if (isEnabled()) {
			if (contextStackCall != null && !contextStackCall.isEmpty()) {
				if (context.equals(contextStackCall.getLast())) {
					if (context.equals(contextStackCall.getFirst())) {
						long[] userTimeForContext = contextUserTimes.get(context.hashCode());
						if (userTimeForContext != null) {
							userTimeForContext[0] = System.currentTimeMillis() - userTimeForContext[0];
						}
						if (getLongContextRunningTime(context.hashCode()) != 0) {
							logContext(context);
						}
						if (!resetEventBase) {
							removeContext(context);
						}
						contextStackCall.remove(context);
					} else {
						long[] userTimeForContext = contextUserTimes.get(context.hashCode());
						if (userTimeForContext != null) {
							userTimeForContext[0] = System.currentTimeMillis() - userTimeForContext[0];
						}
						contextStackCall.remove(context);
					}
				}
			}
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#closeAndLogCurrentContext()
	 */
	@Override
	public void closeAndLogCurrentContext() {
		if (isEnabled()) {
			if (contextStackCall != null && !contextStackCall.isEmpty()) {
				String context = contextStackCall.getLast();
				if (context != null) {
					closeAndLogContext(context);
				} else {
					closeAndLogContext(DEFAULT_CONTEXT);
				}
			}
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#closeAllParentContext()
	 */
	@Override
	public void closeAllParentContext() {
		if (isEnabled()) {
			while (!contextStackCall.isEmpty()) {
				closeAndLogCurrentContext();
			}
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#closeContext(java.lang.String)
	 */
	@Override
	public void closeContext(String context) {
		if (contextStackCall != null && !contextStackCall.isEmpty()) {
			if (context.equals(contextStackCall.getLast())) {
				contextStackCall.remove(context);
			}
		}
	}

	private boolean isParentContext(String contextTested, String SupposedParentContext) {
		if (contextTested != null && SupposedParentContext != null) {
			ArrayList<Integer> childs = getContextChilds(SupposedParentContext);
			if (childs != null) {
				if (childs.contains(contextTested.hashCode())) {
					return true;
				}
				for (Integer childId : childs) {
					if (isParentContext(contextTested, getContextName(childId))) {
						return true;
					}
				}
			}
		}
		return false;
	}

	private synchronized ArrayList<Integer> getContextChilds(String context) {
		return context != null ? getContextChilds(context.hashCode()) : null;
	}

	private synchronized ArrayList<Integer> getContextChilds(Integer context) {
		return contextArborescence != null ? contextArborescence.get(context) : null;
	}

	private boolean addContextName(String context) {
		if (context != null) {
			if (!contextNames.containsKey(context.hashCode())) {
				long[] temp = { 0 };
				contextUserTimes.put(context.hashCode(), temp);
				contextNames.put(context.hashCode(), context);
				return true;
			}
		}
		return false;
	}

	private String getContextName(Integer contextId) {
		return contextNames.get(contextId);
	}

	private boolean addChildContext(String parentContextName, String childContext) {
		if (parentContextName != null && childContext != null) {
			addContextName(parentContextName);
			addContextName(childContext);
			if (!parentContextName.equals(childContext) && contextArborescence != null) {
				ArrayList<Integer> contextChilds = contextArborescence.get(parentContextName.hashCode());
				if (contextChilds == null) {
					contextChilds = new ArrayList<Integer>();
					contextArborescence.put(parentContextName.hashCode(), contextChilds);
				}
				if (!isParentContext(parentContextName, childContext)) {
					if (!contextChilds.contains(childContext.hashCode())) {
						contextChilds.add(childContext.hashCode());
						return true;
					}
				}
			}
		}
		return false;
	}

	protected static boolean getBooleanOption(String optionName, boolean defaultValue) {
		String optionValue = Platform.getDebugOption(optionName);
		if (optionValue != null) {
			Boolean value = Boolean.parseBoolean(optionValue);
			return value.booleanValue();
		} else {
			return defaultValue;
		}
	}

	protected int getIntOption(String optionName, int defaultValue) {
		String optionValue = Platform.getDebugOption(optionName);
		if (optionValue != null) {
			int value = Integer.parseInt(optionValue);
			return value;
		} else {
			return defaultValue;
		}
	}

	private int getTimeOutForEvent(StatsEvent event) {
		return event == null ? -1 : getIntOption(getPerformanceStatsId() + "/" + event.getEvent() + TIMEOUT_VALUE, -1); //$NON-NLS-1$
	}

	protected abstract String getPluginId();

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#removeStat(T, java.lang.Object, java.lang.String)
	 */
	@Override
	public void removeStat(T enumerator, Object blameObject, String context) {
		if (enumerator != null && blameObject != null && context != null) {
			Map<Integer, StatsEvent> eventMap = getEventStats(enumerator, context);
			if (eventMap != null) {
				eventMap.remove(blameObject.hashCode());
			}
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#removeContext(java.lang.String)
	 */
	@Override
	public void removeContext(String context) {
		if (context != null && contextNames != null) {
			contextNames.remove(context.hashCode());
			removeStatsForContext(context);
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#removeStatsForContext(java.lang.String)
	 */
	@Override
	public void removeStatsForContext(String context) {
		if (context != null && eventStatsMap != null) {
			Map<Integer, Map<Integer, StatsEvent>> mapEventStats = eventStatsMap.get(context.hashCode());
			if (mapEventStats != null) {
				mapEventStats.clear();
				if (!contextArborescence.isEmpty() && contextArborescence.containsKey(context.hashCode())) {
					ArrayList<Integer> childList = contextArborescence.get(context.hashCode());
					if (childList != null) {
						for (Integer contextChildsToEraseID : childList) {
							removeStatsForContext(contextNames.get(contextChildsToEraseID));
							contextNames.remove(contextChildsToEraseID);
						}
						childList.clear();
					}
				}
			}
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#removeStatsForEvent(T, java.lang.String)
	 */
	@Override
	public void removeStatsForEvent(T enumerator, String context) {
		if (enumerator != null && eventStatsMap != null) {
			Map<Integer, Map<Integer, StatsEvent>> mapEventStats = eventStatsMap.get(context.hashCode());
			if (mapEventStats != null) {
				mapEventStats.remove(enumerator.getName().hashCode());
			}
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#removeAllStats()
	 */
	@Override
	public void removeAllStats() {
		if (eventStatsMap != null && eventStatsMap != null && contextArborescence != null) {
			eventStatsMap.clear();
			contextNames.clear();
			contextArborescence.clear();
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#isEventTimeFail(T, java.lang.Object)
	 */
	@Override
	public boolean isEventTimeFail(T enumerator, Object blameObject) {
		return isEventTimeFail(enumerator, blameObject, DEFAULT_CONTEXT);
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#isEventTimeFail(T, java.lang.Object, java.lang.String)
	 */
	@Override
	public boolean isEventTimeFail(T enumerator, Object blameObject, String context) {
		if (blameObject != null && enumerator != null) {
			return isEventTimeFailure(getEventStat(enumerator, blameObject, context));
		} else {
			String arg = "";//$NON-NLS-1$
			if (blameObject == null) {
				arg = "blameObject"; //$NON-NLS-1$
			} else if (enumerator == null) {
				arg = "eventId"; //$NON-NLS-1$
			} else if (context == null) {
				arg = "context"; //$NON-NLS-1$
			}
			String msg = NLS.bind(PlatformMessages.error_mustNotBeNull, arg);
			PlatformLogUtil.logAsWarning(Activator.getDefault(), new IllegalArgumentException(msg));
			return false;
		}
	}

	private boolean isEventTimeFailure(StatsEvent event) {
		if (event != null) {
			int timeOut = getTimeOutForEvent(event);
			if (timeOut != -1) {
				return event.getRunningTime() >= timeOut;
			}
		}
		return false;
	}

	private String getPerformanceStatsId() {
		return getPluginId() + PERF + EVENT_OPTIONS + "/" + getClass().getSimpleName(); //$NON-NLS-1$
	}

	private boolean isEventTracingActive(String eventName) {
		return eventName != null ? getBooleanOption(getPerformanceStatsId() + "/" + eventName, false) : false; //$NON-NLS-1$
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#startNewEvent(T, java.lang.Object)
	 */
	@Override
	public void startNewEvent(T enumerator, Object blameObject) {
		if (blameObject != null && enumerator != null) {
			if (contextStackCall != null) {
				if (contextStackCall.isEmpty()) {
					addContextName(DEFAULT_CONTEXT);
					startEvent(enumerator, blameObject, DEFAULT_CONTEXT, true);
				} else {
					startEvent(enumerator, blameObject, contextStackCall.getLast(), true);
				}
			} else {
				addContextName(DEFAULT_CONTEXT);
				startEvent(enumerator, blameObject, DEFAULT_CONTEXT, true);
			}
		} else {
			String arg = "";//$NON-NLS-1$
			if (blameObject == null) {
				arg = "blameObject"; //$NON-NLS-1$
			} else if (enumerator == null) {
				arg = "eventId"; //$NON-NLS-1$
			}
			String msg = NLS.bind(PlatformMessages.error_mustNotBeNull, arg);
			PlatformLogUtil.logAsWarning(Activator.getDefault(), new IllegalArgumentException(msg));
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#startEvent(T, java.lang.Object)
	 */
	@Override
	public void startEvent(T enumerator, Object blameObject) {
		if (blameObject != null && enumerator != null) {
			if (contextStackCall != null) {
				if (contextStackCall.isEmpty()) {
					addContextName(DEFAULT_CONTEXT);
					startEvent(enumerator, blameObject, DEFAULT_CONTEXT, false);
				} else {
					startEvent(enumerator, blameObject, contextStackCall.getLast(), false);
				}
			} else {
				addContextName(DEFAULT_CONTEXT);
				startEvent(enumerator, blameObject, DEFAULT_CONTEXT, false);
			}
		} else {
			String arg = "";//$NON-NLS-1$
			if (blameObject == null) {
				arg = "blameObject"; //$NON-NLS-1$
			} else if (enumerator == null) {
				arg = "eventId"; //$NON-NLS-1$
			}
			String msg = NLS.bind(PlatformMessages.error_mustNotBeNull, arg);
			PlatformLogUtil.logAsWarning(Activator.getDefault(), new IllegalArgumentException(msg));
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#startNewEvent(T, java.lang.Object, java.lang.String)
	 */
	@Override
	public void startNewEvent(T enumerator, Object blameObject, String context) {
		startEvent(enumerator, blameObject, context, true);
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#startEvent(T, java.lang.Object, java.lang.String)
	 */
	@Override
	public void startEvent(T enumerator, Object blameObject, String context) {
		startEvent(enumerator, blameObject, context, false);
	}

	private void startEvent(T enumerator, Object blameObject, String context, boolean reset) {
		long time = 0;
		if (isEnabled() && isEventTracingActive(enumerator.getName())) {
			StatsEvent eventStat = null;
			if (context != null) {
				eventStat = getEventStat(enumerator, blameObject, context);
			} else {
				eventStat = getEventStat(enumerator, blameObject, DEFAULT_CONTEXT);
			}
			if (eventStat == null) {
				eventStat = addEventStat(enumerator, blameObject, context);
			}
			time = getTime();
			eventStat.startRun(time, reset, context);
		}
	}

	/**
	 * Return the name of the current opened context.
	 * 
	 * @return
	 */
	private String getLastContext() {
		if (contextStackCall != null && !contextStackCall.isEmpty()) {
			return contextStackCall.getLast();
		}
		return DEFAULT_CONTEXT;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#endEvent(T, java.lang.Object)
	 */
	@Override
	public void endEvent(T enumerator, Object blameObject) {
		endEvent(enumerator, blameObject, getLastContext());
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#endEvent(T, java.lang.Object, java.lang.String)
	 */
	@Override
	public void endEvent(T enumerator, Object blameObject, String context) {
		long time = getTime();
		if (blameObject != null && enumerator != null && context != null) {
			if (isEnabled() && isEventTracingActive(enumerator.getName())) {
				// String context = returnCurrentContext(contextPath);
				StatsEvent eventStat = getEventStat(enumerator, blameObject, context);
				if (eventStat != null) {
					eventStat.endRun(time);
					logEvent(eventStat);
				}
			}
		} else {
			String arg = "";//$NON-NLS-1$
			if (blameObject == null) {
				arg = "blameObject"; //$NON-NLS-1$

			} else if (enumerator == null) {
				arg = "eventId"; //$NON-NLS-1$
			} else if (context == null) {
				arg = "contextId"; //$NON-NLS-1$
			}
			String msg = NLS.bind(PlatformMessages.error_mustNotBeNull, arg);
			PlatformLogUtil.logAsWarning(Activator.getDefault(), new IllegalArgumentException(msg));
		}
	}

	private StatsEvent addEventStat(T enumerator, Object blameObject, String context) {
		Map<Integer, Map<Integer, StatsEvent>> statsForContext = eventStatsMap.get(context.hashCode());
		if (statsForContext == null) {
			eventStatsMap.put(context.hashCode(), new HashMap<Integer, Map<Integer, StatsEvent>>());
			statsForContext = eventStatsMap.get(context.hashCode());
		}
		Map<Integer, StatsEvent> statsForEvent = statsForContext.get(enumerator.getName().hashCode());
		if (statsForEvent == null) {
			statsForContext.put(enumerator.getName().hashCode(), new HashMap<Integer, StatsEvent>());
			statsForEvent = statsForContext.get(enumerator.getName().hashCode());
			addEventName(enumerator.getName());
		}
		StatsEvent eventStat = statsForEvent.get(blameObject.hashCode());
		if (eventStat == null) {
			eventStat = new StatsEvent(enumerator.getName(), blameObject);
			statsForEvent.put(blameObject.hashCode(), eventStat);
		}
		return eventStat;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#getEventStat(T, java.lang.Object, java.lang.String)
	 */
	@Override
	public StatsEvent getEventStat(T enumerator, Object blameObject, String context) {
		if (blameObject != null && enumerator != null && context != null) {
			Map<Integer, StatsEvent> statsForEvent = getEventStats(enumerator, context);
			if (statsForEvent != null) {
				StatsEvent stats = statsForEvent.get(blameObject.hashCode());
				return stats;
			} else {
				return null;
			}
		} else {
			String arg = "";//$NON-NLS-1$
			if (blameObject == null) {
				arg = "blameObject"; //$NON-NLS-1$

			} else if (enumerator == null) {
				arg = "eventId"; //$NON-NLS-1$
			}
			String msg = NLS.bind(PlatformMessages.error_mustNotBeNull, arg);
			PlatformLogUtil.logAsWarning(Activator.getDefault(), new IllegalArgumentException(msg));
			return null;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#getEventStats(T, java.lang.String)
	 */
	@Override
	public Map<Integer, StatsEvent> getEventStats(T enumerator, String context) {
		if (enumerator != null && context != null) {
			return getEventStats(enumerator.getName().hashCode(), context.hashCode());
		} else {
			String arg = "";//$NON-NLS-1$
			if (enumerator == null) {
				arg = "eventId"; //$NON-NLS-1$
			} else if (context == null) {
				arg = "context"; //$NON-NLS-1$
			}
			String msg = NLS.bind(PlatformMessages.error_mustNotBeNull, arg);
			PlatformLogUtil.logAsWarning(Activator.getDefault(), new IllegalArgumentException(msg));
			return null;
		}
	}

	private Map<Integer, StatsEvent> getEventStats(Integer EventTypeId, Integer context) {
		Map<Integer, Map<Integer, StatsEvent>> statsForContext = getContextStats(context);
		if (statsForContext != null) {
			return statsForContext.get(EventTypeId);
		} else {
			return null;
		}
	}

	private Map<Integer, Map<Integer, StatsEvent>> getContextStats(Integer context) {
		return eventStatsMap.get(context);
	}

	// TODO Create and use NLS messages.
	private String getStringContextRunningTime(Integer contextId) {
		long[] userTimeForContext = contextUserTimes.get(contextId);
		String message = ""; //$NON-NLS-1$
		if (userTimeForContext != null) {
			message = NLS.bind(Messages.perfLog_$0$1runningTimeAndUserRunningTime, getConvertedRunningTime(getLongContextRunningTime(contextId)),
					getConvertedRunningTime(userTimeForContext[0]));
			userTimeForContext[0] = 0;
		} else {
			message = NLS.bind(Messages.perfLog_$0runningTime, getConvertedRunningTime(getLongContextRunningTime(contextId)));
		}
		return message;
	}

	private long getLongContextEventsRunningTime(Integer context, Integer eventId) {
		long result = 0;
		Map<Integer, Map<Integer, StatsEvent>> statsForContext = getContextStats(context);
		if (statsForContext != null) {
			Map<Integer, StatsEvent> statsforEvent = statsForContext.get(eventId);
			if (statsforEvent != null) {
				for (Integer statId : statsforEvent.keySet()) {
					result += statsforEvent.get(statId).getRunningTime();
				}
			}
		}
		return result;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#getContextNames()
	 */
	@Override
	public Collection<String> getContextNames() {
		if (contextNames != null) {
			return contextNames.values();
		} else {
			return null;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#contextRunningTimeExceedTimeOut(java.lang.String, long)
	 */
	@Override
	public boolean contextRunningTimeExceedTimeOut(String context, long timeOut) {
		if (context != null) {
			return getContextRunningTime(context) >= timeOut;
		} else {
			return false;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#isRegisteredContext(java.lang.String)
	 */
	@Override
	public boolean isRegisteredContext(String context) {
		if (contextNames != null) {
			return contextNames.containsKey(context.hashCode());
		} else {
			return false;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#getContextRunningTime(java.lang.String)
	 */
	@Override
	public long getContextRunningTime(String context) {
		long result = 0;
		if (contextNames.containsKey(context.hashCode())) {
			result = getLongContextRunningTime(context.hashCode());
		} else {
			result = -1;
		}
		return result;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#getTimeFailureEventsInContext(java.lang.String)
	 */
	@Override
	public List<StatsEvent> getTimeFailureEventsInContext(String context) {
		if (isRegisteredContext(context) && context != null) {
			return getTimeFailureEventsInContext(context.hashCode());
		} else {
			return null;
		}
	}

	private LinkedList<StatsEvent> getTimeFailureEventsInContext(Integer context) {
		LinkedList<StatsEvent> result = new LinkedList<StatsEvent>();
		Map<Integer, Map<Integer, StatsEvent>> statsForContext = getContextStats(context);
		if (statsForContext != null) {
			for (Integer eventId : statsForContext.keySet()) {
				Map<Integer, StatsEvent> statsforEvent = statsForContext.get(eventId);
				if (statsforEvent != null) {
					for (Integer statId : statsforEvent.keySet()) {
						if (isEventTimeFailure(statsforEvent.get(statId))) {
							result.addLast(statsforEvent.get(statId));
						}
					}
				}
			}
		}
		ArrayList<Integer> contextChilds = getContextChilds(getContextName(context));
		if (contextChilds != null) {
			for (Integer childiD : contextChilds) {
				result.addAll(getTimeFailureEventsInContext(childiD));
			}
		}
		return result;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#isEventsTimeFailure()
	 */
	@Override
	public boolean isEventsTimeFailure() {
		boolean result = false;
		for (Integer contextId : contextNames.keySet()) {
			result = result || isContextEventsTimeFailure(contextId) > 0;
		}
		return result;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#numberOfEventsTimeFailure(java.lang.String)
	 */
	@Override
	public int numberOfEventsTimeFailure(String context) {
		if (context != null) {
			return getTimeFailureEventsInContext(context).size();
		} else {
			return 0;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#getEventsTimeFailure()
	 */
	@Override
	public List<StatsEvent> getEventsTimeFailure() {
		LinkedList<StatsEvent> result = null;
		if (isEnabled() && eventStatsMap != null) {
			result = new LinkedList<StatsEvent>();
			for (Integer contextid : eventStatsMap.keySet()) {
				if (eventStatsMap.get(contextid) != null) {
					for (Integer eventTypeid : eventStatsMap.get(contextid).keySet()) {
						if (eventStatsMap.get(contextid).get(eventTypeid) != null) {
							for (Integer blameId : eventStatsMap.get(contextid).get(eventTypeid).keySet()) {
								if (isEventTimeFailure(eventStatsMap.get(contextid).get(eventTypeid).get(blameId))) {
									result.addLast(eventStatsMap.get(contextid).get(eventTypeid).get(blameId));
								}
							}
						}
					}
				}
			}
		}
		return result;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#isContextEventsTimeFailure(java.lang.String)
	 */
	@Override
	public boolean isContextEventsTimeFailure(String context) {
		if (isRegisteredContext(context)) {
			return isContextEventsTimeFailure(context.hashCode()) > 0;
		} else {
			return false;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#numberOfContextEventsTimeFailure(java.lang.String)
	 */
	@Override
	public int numberOfContextEventsTimeFailure(String context) {
		if (isRegisteredContext(context)) {
			return isContextEventsTimeFailure(context.hashCode());
		} else {
			return 0;
		}
	}

	private int isContextEventsTimeFailure(Integer context) {
		int result = 0;
		Map<Integer, Map<Integer, StatsEvent>> statsForContext = getContextStats(context);
		if (statsForContext != null) {
			for (Integer eventId : statsForContext.keySet()) {
				Map<Integer, StatsEvent> statsforEvent = statsForContext.get(eventId);
				if (statsforEvent != null) {
					for (Integer statId : statsforEvent.keySet()) {
						if (isEventTimeFailure(statsforEvent.get(statId))) {
							result++;
						}
					}
				}
			}
		}
		ArrayList<Integer> contextChilds = getContextChilds(getContextName(context));
		if (contextChilds != null) {
			for (Integer childiD : contextChilds) {
				result += isContextEventsTimeFailure(childiD);
			}
		}
		return result;
	}

	private long getLongContextRunningTime(Integer context) {
		long result = 0;
		Map<Integer, Map<Integer, StatsEvent>> statsForContext = getContextStats(context);
		if (statsForContext != null) {
			for (Integer eventId : statsForContext.keySet()) {
				Map<Integer, StatsEvent> statsforEvent = statsForContext.get(eventId);
				if (statsforEvent != null) {
					for (Integer statId : statsforEvent.keySet()) {
						result += statsforEvent.get(statId).getRunningTime();
					}
				}
			}
		}
		ArrayList<Integer> contextChilds = getContextChilds(getContextName(context));
		if (contextChilds != null) {
			for (Integer childiD : contextChilds) {
				result += getLongContextRunningTime(childiD);
			}
		}
		return result;
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#printContextTree(java.lang.String)
	 */
	@Override
	public String printContextTree(String context) {
		return printContextTree(context.hashCode());
	}

	private String printContextTree(Integer contextId) {
		if (isEnabled()) {
			StringBuffer result = new StringBuffer();
			ArrayList<Integer> Childlist = contextArborescence.get(contextId);
			if (Childlist != null) {
				for (Integer childId : Childlist) {
					result.append("\n Child: " + getContextName(childId));//$NON-NLS-1$
					result.append("\n -> " + printContextTree(childId)); //$NON-NLS-1$
				}
			}
			return result.toString();
		}
		return ""; //$NON-NLS-1$
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#printContextsTree()
	 */
	@Override
	public String printContextsTree() {
		if (isEnabled() && contextArborescence != null) {
			StringBuffer result = new StringBuffer();
			for (Integer contextId : contextArborescence.keySet()) {
				result.append("\n\nContext: " + getContextName(contextId) + " Running time: " //$NON-NLS-1$ //$NON-NLS-2$
						+ getConvertedRunningTime(getLongContextRunningTime(contextId)));
				result.append("\n -> " + printContextTree(contextId)); //$NON-NLS-1$
			}
			return result.toString();
		}
		return ""; //$NON-NLS-1$
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#printAllStats()
	 */
	@Override
	public String printAllStats() {
		contextPrinted.clear();
		if (isEnabled() && contextNames != null) {
			StringBuffer result = new StringBuffer();
			String offset = "|";//$NON-NLS-1$
			for (Integer contextId : contextNames.keySet()) {
				if (!contextPrinted.contains(getContextName(contextId))) {
					result.append("\n-------------------------------------------------------" + printContextStats(getContextName(contextId), offset)//$NON-NLS-1$
							+ "\n-------------------------------------------------------"); //$NON-NLS-1$
				}
			}
			return result.toString();
		} else {
			return Messages.perfLog_performanceStatsNotActivated;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#printContextStats(java.lang.String)
	 */
	@Override
	public String printContextStats(String context) {
		return printContextStats(context, ""); //$NON-NLS-1$
	}

	private String printContextStats(String context, String offset) {
		if (isEnabled() && context != null && eventStatsMap != null) {
			StringBuffer result = new StringBuffer("");//$NON-NLS-1$
			if (eventStatsMap.containsKey(context.hashCode())) {
				Map<Integer, Map<Integer, StatsEvent>> Statsmap = eventStatsMap.get(context.hashCode());
				if (Statsmap != null) {
					result.append("\n\n" + offset + " + " + "Context: " + getContextName(context.hashCode()) + " Running time: " //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
							+ getConvertedRunningTime(getLongContextRunningTime(context.hashCode())));
					for (Integer eventId : Statsmap.keySet()) {
						result.append(printEventStats(eventId, context.hashCode(), offset));
					}
				}
				ArrayList<Integer> contextChilds = getContextChilds(context);
				if (contextChilds != null) {
					for (int i = 0; i < contextChilds.size(); i++) {
						result.append(printContextStats(getContextName(contextChilds.get(i)), offset + "  " + "|")); //$NON-NLS-1$ //$NON-NLS-2$
					}
				}
				contextPrinted.add(context);
			}
			return result.toString();
		} else {
			return Messages.perfLog_performanceStatsNotActivated;
		}
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#printEventStat(T, java.lang.Object, java.lang.String)
	 */
	@Override
	public String printEventStat(T enumerator, Object blameObject, String context) {
		if (isEnabled() && enumerator != null && blameObject != null && context != null) {
			StatsEvent event = getEventStat(enumerator, blameObject, context);
			if (event != null) {
				return printEventStat(event);
			}
			return ""; //$NON-NLS-1$
		} else {
			if (isEnabled()) {
				return PlatformMessages.arg_mustNotBeNull;
			} else {
				return Messages.perfLog_performanceStatsNotActivated;
			}
		}
	}

	private String printEventStats(Integer EventId, Integer contextId, String offset) {
		Map<Integer, StatsEvent> eventMap = getEventStats(EventId, contextId);
		if (eventMap != null) {
			StringBuffer result = new StringBuffer();
			for (Integer eventBlameId : eventMap.keySet()) {
				result.append("\n" + printEventStat(eventMap.get(eventBlameId), offset)); //$NON-NLS-1$
			}
			return result.toString();
		}
		return ""; //$NON-NLS-1$
	}

	/*
	 * @see org.eclipse.sphinx.platform.stats.IPerformanceStats#printEventStats(T, java.lang.String)
	 */
	@Override
	public String printEventStats(T enumerator, String context) {
		if (isEnabled() && enumerator != null && context != null) {
			Map<Integer, StatsEvent> eventMap = getEventStats(enumerator, context);
			if (eventMap != null) {
				StringBuffer result = new StringBuffer("\n-Event Type: " + enumerator.getName());//$NON-NLS-1$ 
				for (Integer eventBlameId : eventMap.keySet()) {
					result.append("\n" + eventMap.get(eventBlameId).printEventStatProperties()); //$NON-NLS-1$
				}
				return result.toString();
			}
			return ""; //$NON-NLS-1$
		} else {
			return Messages.perfLog_performanceStatsNotActivated;
		}
	}

	private String printEventStat(StatsEvent event) {
		return event.printEventStat();
	}

	private String printEventStat(StatsEvent event, String offset) {
		return event.printEventStat(offset);
	}

	private long getTime() {
		long time = ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime();
		time = time / 1000000;
		return time;
	}

	private void logEvent(StatsEvent event) {
		if (event != null) {
			if (event.getContextName().equals(DEFAULT_CONTEXT)) {
				Status eventStatus = getEventStatus(event);
				if (eventStatus != null) {
					if (!logInSeparateLogFile) {
						if (outLog != null) {
							outLog.logging(eventStatus, Activator.PLUGIN_ID);
						}
					} else {
						Activator.getDefault().getLog().log(eventStatus);
					}
				}
			}
		}
	}

	private void logContext(String context) {
		if (!logInSeparateLogFile) {
			if (outLog != null) {
				outLog.logging(getContextInfoStatus(context.hashCode()), Activator.PLUGIN_ID);
			}
		} else {
			Activator.getDefault().getLog().log(getContextInfoStatus(context.hashCode()));
		}
	}

	private MultiStatus getContextEventsInfoStatus(Integer contextId, Integer eventId) {
		int count = 0;
		Map<Integer, Map<Integer, StatsEvent>> contextStatstemp = getContextStats(contextId);
		if (contextStatstemp != null) {
			Map<Integer, StatsEvent> eventsMap = contextStatstemp.get(eventId);
			if (eventsMap != null) {
				count = eventsMap.size();
			}
		}
		int status = IStatus.INFO;
		MultiStatus result = new MultiStatus(Activator.PLUGIN_ID, status, NLS.bind(Messages.perfLog_$0$1$2contextInfos, new String[] { "" + count, //$NON-NLS-1$
				getEventName(eventId), getConvertedRunningTime(getLongContextEventsRunningTime(contextId, eventId)) }), new RuntimeException());
		if (contextId != null && logEventDetails) {
			Map<Integer, Map<Integer, StatsEvent>> contextStats = getContextStats(contextId);
			if (contextStats != null) {
				Map<Integer, StatsEvent> eventsMap = contextStats.get(eventId);
				if (eventsMap != null) {
					for (Integer statId : eventsMap.keySet()) {
						StatsEvent statsEvent = eventsMap.get(statId);
						if (statsEvent != null) {
							Status eventStatus = getEventStatus(statsEvent);
							if (eventStatus != null) {
								encloseStatus(result, eventStatus);
							}
						}
					}
				}
			}
		}
		return result;
	}

	private Status getEventStatus(StatsEvent event) {
		if (isEnabled()) {
			if (event != null) {
				if (logErrorOnTimeOut && isEventTimeFailure(event)) {
					return new Status(IStatus.ERROR, Activator.PLUGIN_ID, NLS.bind(Messages.perfLog_$0runningTimeExceedTimeout, event.toString()),
							new RuntimeException());
				} else if (logWarningOnNoTime && event.getRunningTime() == 0) {
					return new Status(IStatus.WARNING, Activator.PLUGIN_ID, NLS.bind(Messages.perfLog_$0runningTimeZero, event.toString()),
							new RuntimeException());
				} else {
					return null;
				}
			}
		}
		return null;
	}

	private MultiStatus getContextInfoStatus(Integer contextId) {
		String contextName = getContextName(contextId);
		if (contextId == DEFAULT_CONTEXT.hashCode()) {
			contextName = DEFAULT_CONTEXT;
		} else if (contextName == null) {
			contextName = "_" + contextId + "_"; //$NON-NLS-1$ //$NON-NLS-2$
		}
		String msg = contextName + " - " + getStringContextRunningTime(contextId); //$NON-NLS-1$
		MultiStatus result = new MultiStatus(Activator.PLUGIN_ID, IStatus.INFO, msg, new RuntimeException());
		if (contextId != null) {
			Map<Integer, Map<Integer, StatsEvent>> contextStats = getContextStats(contextId);
			if (contextStats != null) {
				for (Integer eventId : contextStats.keySet()) {
					encloseStatus(result, getContextEventsInfoStatus(contextId, eventId));
				}
			}
			ArrayList<Integer> contextChilds = this.getContextChilds(contextId);
			if (contextChilds != null) {
				for (Integer childId : contextChilds) {
					encloseStatus(result, getContextInfoStatus(childId));
				}
			}
		}
		return result;
	}

	private static void encloseStatus(MultiStatus parentIStatus, Status childIStatus) {
		parentIStatus.add(childIStatus);
	}

	private static void encloseStatus(MultiStatus parentIStatus, MultiStatus childIStatus) {
		parentIStatus.add(childIStatus);
	}

	private String getConvertedSecondes(long runningTime) {
		String result = ""; //$NON-NLS-1$
		double time = ((double) runningTime - (double) (runningTime % 1000)) / 1000;
		double reste = (double) runningTime % 1000;
		result = (long) time + " s"; //$NON-NLS-1$
		if (reste > 0) {
			result += ":" + (long) reste + " ms"; //$NON-NLS-1$//$NON-NLS-2$
		}
		return result;
	}

	private String getConvertedRunningTime(long runningTime) {
		String result = "";//$NON-NLS-1$
		if (runningTime >= 60000) {
			double time = ((double) runningTime - (double) (runningTime % 60000)) / 60000;
			double reste = runningTime % 60000;
			result = (long) time + " min"; //$NON-NLS-1$
			if (reste > 0) {
				result += ":" + getConvertedSecondes((long) reste); //$NON-NLS-1$

			}
		} else if (runningTime >= 1000) {

			result = getConvertedSecondes(runningTime);

		} else {
			result = runningTime + " ms"; //$NON-NLS-1$
		}
		return "[ " + result + " ]"; //$NON-NLS-1$//$NON-NLS-2$
	}
}