/*

 * 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 the License "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: 

 *

 */

package com.nokia.carbide.cpp.internal.pi.analyser;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.lang.reflect.InvocationTargetException;

import java.net.URI;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.WorkspaceJob;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.IJobChangeEvent;

import org.eclipse.core.runtime.jobs.IJobChangeListener;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.ide.IDE;

import org.eclipse.ui.progress.IProgressService;

import com.nokia.carbide.cpp.internal.pi.manager.PluginInitialiser;

import com.nokia.carbide.cpp.internal.pi.model.FunctionResolver;

import com.nokia.carbide.cpp.internal.pi.model.ParsedTraceData;

import com.nokia.carbide.cpp.internal.pi.model.RefinableTrace;

import com.nokia.carbide.cpp.internal.pi.model.TraceDataRepository;

import com.nokia.carbide.cpp.internal.pi.plugin.model.AbstractPiPlugin;

import com.nokia.carbide.cpp.internal.pi.plugin.model.ITrace;

import com.nokia.carbide.cpp.internal.pi.plugin.model.IVisualizable;

import com.nokia.carbide.cpp.internal.pi.test.AnalysisInfoHandler;

import com.nokia.carbide.cpp.internal.pi.test.IProvideTraceAdditionalInfo;

import com.nokia.carbide.cpp.internal.pi.visual.GraphDrawRequest;

import com.nokia.carbide.cpp.internal.pi.visual.PICompositePanel;

import com.nokia.carbide.cpp.pi.editors.PIPageEditor;

import com.nokia.carbide.cpp.pi.importer.SampleImporter;

import com.nokia.carbide.cpp.pi.util.GeneralMessages;

import com.nokia.carbide.cpp.pi.util.PIExceptionRuntime;

/*

 * Class for abstracting data processing core routine for open and import

 */

public class AnalyserDataProcessor {

	// whether the profile file was read correctly

	public static int STATE_OK				= 0;

	public static int STATE_IMPORTING		= 1;

	public static int STATE_OPENING			= 2;

	public static int STATE_TIMESTAMP		= 3;

	public static int STATE_CANCELED		= 4;

	public static int STATE_INVALID			= 5;

	public static int TOTAL_PROGRESS_COUNT	= 10000;

	static AnalyserDataProcessor instance = null;

	// following states should be cleanup for every run

	// There should be only one progress monitor used by data processor

	// regardless the task, and we don't want to expose public interface

	// that juggle around progress monitor, to avoid messy situation of

	// multiple progress indicator

	static IProgressMonitor mp = null;

	static Exception lastException = null;

	private static int analyserDataProcessorState = STATE_INVALID;

	private AnalyserDataProcessor() {

		// singleton

	}

	public static AnalyserDataProcessor getInstance() {

		if (instance == null) {

			instance = new AnalyserDataProcessor();

		}

		return instance;

	}

	// return whether the processed data file was successfully read

	public int getState() {

		return analyserDataProcessorState;

	}

	public void setImportFailed() {

		analyserDataProcessorState = STATE_INVALID;

	}

	private void setProgressMonitor (IProgressMonitor progressMonitor) {

		mp = progressMonitor;

	}

	private IProgressMonitor getProgressMonitor() {

		return mp;

	}

	public Exception getLastException() {

		return lastException;

	}

		analyserDataProcessorState = STATE_IMPORTING;

		final int workUnitsForImport = TOTAL_PROGRESS_COUNT * 60 / 100;

		int workUnitsLeft = workUnitsForImport * 99 / 100;

		checkCancelledThrowIE();

		// loop through all the plugins associated with traces

    		int traceId = plugin.getTraceId();

    		AbstractPiPlugin p = (AbstractPiPlugin)plugin;

    		// map trace plugins to this analysis data

    		NpiInstanceRepository.getInstance().addPlugin(uid, p);

    		if (traceId != -1)

    		{

    			}

    		}

            // assume this load takes 39%

    		getProgressMonitor().worked((workUnitsForImport * 39 / 100) / numberOfPlugins);

    		checkCancelledThrowIE();

            workUnitsLeft -= (workUnitsForImport * 39 / 100) / numberOfPlugins;

    	}

		getProgressMonitor().worked((workUnitsForImport * 60 / 100) - workUnitsLeft);

		checkCancelledThrowIE();

		workUnitsLeft = (workUnitsForImport * 60 / 100);

		// refine any traces whose addresses can be refined

		Iterator<ParsedTraceData> traces = TraceDataRepository.getInstance().getTraceCollectionIter(uid);

    	if (traces == null) {

    		throw new InvocationTargetException(new PIExceptionRuntime(Messages.getString("AnalyserDataProcessor.0") + uid + Messages.getString("AnalyserDataProcessor.1")));     //$NON-NLS-1$ //$NON-NLS-2$

    	}

    	while (traces.hasNext())

    	{

    		ParsedTraceData trace = (ParsedTraceData)traces.next();

    		// for those trace data items that can be refined

    		if (trace.traceData instanceof RefinableTrace)

    		{

    			Iterator<ParsedTraceData> traces2 = TraceDataRepository.getInstance().getTraceCollectionIter(uid);

    			while (traces2.hasNext())

    			{

    				ParsedTraceData trace2 = traces2.next();

    				// refine with other resolvers but not with own (which has been used already)

    				if (!trace2.equals(trace) && trace2.functionResolvers != null)

    				{

    					for (int i = 0; i < trace2.functionResolvers.length; i++)

    					{

    						FunctionResolver fr = trace2.functionResolvers[i];

    						System.out.println(Messages.getString("AnalyserDataProcessor.2") + trace.traceData.getClass().getName() + Messages.getString("AnalyserDataProcessor.3") + fr.getResolverString());     //$NON-NLS-1$ //$NON-NLS-2$

    						((RefinableTrace)trace.traceData).refineTrace(fr);

    					}

    				}

    				checkCancelledThrowIE();

    			}

    			// after all refinement is done, do any final touches to the samples

    			((RefinableTrace)trace.traceData).finalizeTrace();

    		}

    		getProgressMonitor().worked(workUnitsLeft / 2);

    		checkCancelledThrowIE();

    		workUnitsLeft -= workUnitsLeft / 2;

    	}

    	// Should move resolver out of trace, PI only need resolver in import phase, trace is more of a

    	// core data in NPI file; before that, we would just strip all resolvers here

    	Iterator<ParsedTraceData> tracesItr = TraceDataRepository.getInstance().getTraceCollectionIter(uid);

    	while (tracesItr.hasNext()) {

    		ParsedTraceData ptd = tracesItr.next();

    		ptd.functionResolvers = null;

    	}

    	System.gc();

	}

	private void loadExistingAnalysis(final Composite parent, final String analysisFilename, final String displayName, final int uid) throws InvocationTargetException, InterruptedException {

		assertThrowITE(NpiInstanceRepository.getInstance().activeUid() == uid, Messages.getString("AnalyserDataProcessor.4"));   //$NON-NLS-1$

		// do the loading part with indicator in non-UI thread

		final IProgressMonitor pm = getProgressMonitor();

		pm.worked(1);

		class LoadRunnable implements Runnable {

			IOException myIOE = null;

			InterruptedException myIE  =null;

			public void handleException () throws InvocationTargetException, InterruptedException {

				if (myIOE != null) {

					String reason = Messages.getString("AnalyserDataProcessor.12") + analysisFilename; //$NON-NLS-1$

					if (myIOE.getMessage() != null) {

						reason += " " + myIOE.getMessage(); //$NON-NLS-1$

					}

					assertThrowITE(myIOE, reason);

				}

				if (myIE != null) {

					throw myIE;

				}

			}

			public void run() {

				try {

					ProfileReader.getInstance().loadAnalysisFile(analysisFilename, displayName, pm, uid);

				} catch (IOException e) {

					myIOE = e;

				} catch (InterruptedException e) {

					myIE = e;

				}	

			}

		}

		LoadRunnable loadRunnable = new LoadRunnable();

		new Thread(loadRunnable).run();

		loadRunnable.handleException();

		checkCancelledThrowIE();

		processTraceDrawAndResize(parent, false);

	}

	// called by createPage() of PIPageEditor

	public void openNpiForPIPageEditor(final URI analysisFileURI, final Composite parent, final int uid) {

		boolean isImport = analyserDataProcessorState == STATE_IMPORTING;

		final String displayName = new java.io.File(analysisFileURI).getName();

		if (isImport && getProgressMonitor() != null) {

			//import is already wrapped in runnable, and we should have progressmonitor

			getProgressMonitor().setTaskName(Messages.getString("AnalyserDataProcessor.5") + displayName);   //$NON-NLS-1$

			try {

				analyserDataProcessorState = STATE_OPENING;

				// by saying isImport true, we assume trace is set up proper in repository

				processTraceDrawAndResize(parent, true);

				analyserDataProcessorState = STATE_OK;

				if (false)

				internalOpenNPI (analysisFileURI, parent, uid);

			} catch (InvocationTargetException e) {

				analyserDataProcessorState = STATE_INVALID;

				String error = Messages.getString("AnalyserDataProcessor.6") + e.getTargetException().getMessage() + Messages.getString("AnalyserDataProcessor.7");   //$NON-NLS-1$ //$NON-NLS-2$

				if (e.getTargetException().getStackTrace() != null) {

					StringWriter sw = new StringWriter ();

					PrintWriter pw = new PrintWriter(sw);

					e.getTargetException().printStackTrace(pw);

					error += sw.toString() + "\n"; //$NON-NLS-1$

				}

				GeneralMessages.showErrorMessage(error);

			} catch (InterruptedException e) {

				String error = Messages.getString("AnalyserDataProcessor.8") + e.getMessage() + Messages.getString("AnalyserDataProcessor.9");   //$NON-NLS-1$ //$NON-NLS-2$

				analyserDataProcessorState = STATE_CANCELED;

			} catch (Exception e) {

				analyserDataProcessorState = STATE_INVALID;

				String error = Messages.getString("AnalyserDataProcessor.6") + e.getMessage() + Messages.getString("AnalyserDataProcessor.7");   //$NON-NLS-1$ //$NON-NLS-2$

				if (e.getStackTrace() != null) {

					StringWriter sw = new StringWriter ();

					PrintWriter pw = new PrintWriter(sw);

					e.printStackTrace(pw);

					error += sw.toString() + "\n"; //$NON-NLS-1$

				}

				GeneralMessages.showErrorMessage(error);

			}

		} else {

			setUp();

			//open need to be wrapped in runnable, and we should set progressmonitor

			IProgressService progressService = PlatformUI.getWorkbench().getProgressService();

			IRunnableWithProgress runnable= new IRunnableWithProgress() {

				public void run(IProgressMonitor progressMonitor)

				throws InvocationTargetException, InterruptedException {

					setProgressMonitor(progressMonitor);

					progressMonitor.beginTask(Messages.getString("AnalyserDataProcessor.10") + displayName, AnalyserDataProcessor.TOTAL_PROGRESS_COUNT * 20 / 100); //$NON-NLS-1$

					internalOpenNPI (analysisFileURI, parent, uid);

				}

			};

			try {

				progressService.busyCursorWhile(runnable);

			} catch (InvocationTargetException e) {

				analyserDataProcessorState = STATE_INVALID;

			} catch (InterruptedException e) {

				analyserDataProcessorState = STATE_CANCELED;

			}

		}

		getProgressMonitor().done();

	}

	private void internalOpenNPI(final URI analysisFileURI, final Composite parent, final int uid) throws InvocationTargetException, InterruptedException {

		analyserDataProcessorState = STATE_OPENING;

		if (analysisFileURI == null) {

			assertThrowITE(false, Messages.getString("AnalyserDataProcessor.11")); //$NON-NLS-1$

			return;

		}

		String filePath = null;

		String displayName = null;

		filePath = analysisFileURI.getPath();

		displayName = new java.io.File(analysisFileURI).getName();

		loadExistingAnalysis(parent, filePath, displayName, uid);

		analyserDataProcessorState = STATE_OK;

	}

		analyserDataProcessorState = STATE_IMPORTING;

		setProgressMonitor(null);

		final int uid = NpiInstanceRepository.getInstance().register(null);

		setUp();

		IProgressService progressService = PlatformUI.getWorkbench().getProgressService();

		IRunnableWithProgress runnableImportAndSave = new IRunnableWithProgress() {

			public void run(IProgressMonitor progressMonitor)

					throws InvocationTargetException, InterruptedException {

			}

		};

		IRunnableWithProgress runnableOpen = new IRunnableWithProgress() {

			public void run(IProgressMonitor arg0)

					throws InvocationTargetException, InterruptedException {

				// open the saved file

			}

		};

		try {

			progressService.busyCursorWhile(runnableImportAndSave);

			final WorkspaceJob saveNpi = new WorkspaceJob (Messages.getString("AnalyserDataProcessor.savingImportedFile")) { //$NON-NLS-1$

				public IStatus runInWorkspace(IProgressMonitor monitor)

						throws CoreException {

					try {

					} catch (InvocationTargetException e) {

					} catch (InterruptedException e) {

					}

				}

			};

			progressService.busyCursorWhile(runnableOpen);

			saveNpi.setPriority(Job.DECORATE);

			saveNpi.addJobChangeListener(new IJobChangeListener () {

				public void aboutToRun(IJobChangeEvent event) {

				}

				public void awake(IJobChangeEvent event) {

				}

				public void done(IJobChangeEvent event) {

					if (saveNpi.getResult().getSeverity()  != IStatus.OK) {

					}

				}

				public void running(IJobChangeEvent event) {

				}

				public void scheduled(IJobChangeEvent event) {

				}

				public void sleeping(IJobChangeEvent event) {

				}

			});

			saveNpi.schedule();

			if (pollTillNpiSaved) {

				while (saveNpi.getState() != Job.NONE) {

					// until it's done

				}

			}

		} catch (InvocationTargetException e) {

		} catch (InterruptedException e) {

		}							

	}