/*

 * 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 java.util.List;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.NullProgressMonitor;

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;

import com.nokia.carbide.cpp.pi.visual.IGenericTraceGraph;

/*

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

 */

public class AnalyserDataProcessor {

	protected static final int MAX_CPU = 4;

	// whether the profile file was read correctly

	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;

	}

	private void importNewAnalysis(Hashtable<Integer,String> traceFileNames, int uid, List<ITrace> pluginsToUse) throws InterruptedException, InvocationTargetException {

		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 numberOfPlugins = pluginsToUse.size();

		for (ITrace plugin : pluginsToUse) {

    		int traceId = plugin.getTraceId();

    		AbstractPiPlugin p = (AbstractPiPlugin)plugin;

    		// map trace plugins to this analysis data

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

    		if (traceId != -1)

    		{

    			if (traceId == 1){ //support SMP by expecting one file per CPU

					List<File> files = new ArrayList<File>();

    				for (int i = 0; i < MAX_CPU; i++) {

    					int smpTraceId = traceId + i * 20;

    					{

    	        			String fileName = traceFileNames.get(smpTraceId);

    	        			if (fileName != null && fileName.endsWith(".dat")) //$NON-NLS-1$

    	        			{

    	        				File traceFile = new File(fileName);

    	        				if (traceFile.exists()){

    	        					files.add(traceFile);

    	        				}

    	        			}    						

    					}

    				}

					ProfileReader.getInstance().readTraceFile(plugin, files.toArray(new File[files.size()]), this,uid);

    			} else {

        			String fileName = traceFileNames.get(traceId);

        			if (fileName != null)

        			{

        				File traceFile = new File(fileName);

        				if (traceFile.exists()) 

    						if (traceFile.getName().endsWith(".dat"))  //$NON-NLS-1$

    							ProfileReader.getInstance().readTraceFile(plugin, traceFile, this,uid);

        			}    				

    			}

    		}

            // 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;

	}

	public void importSaveAndOpen(final IFile analysisFile, boolean pollTillNpiSaved, final List<ITrace> pluginsToUse) {

		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 {

				importAndSave(analysisFile, uid, pluginsToUse, null,progressMonitor);

			}

		};

		IRunnableWithProgress runnableOpen = new IRunnableWithProgress() {

			public void run(IProgressMonitor arg0)

					throws InvocationTargetException, InterruptedException {

				// open the saved file

				openFile(analysisFile);

			}

		};

		try {

			progressService.busyCursorWhile(runnableImportAndSave);

				}

		} catch (InvocationTargetException e) {

			handleRunnableException(e, uid, analysisFile);

		} catch (InterruptedException e) {

			handleRunnableException(e, uid, analysisFile);

	}

	public void importSave(final IFile analysisFile, final List<ITrace> pluginsToUse, String suffixTaskName, IProgressMonitor monitor) {

		analyserDataProcessorState = STATE_IMPORTING;

		setUp();

		setProgressMonitor(monitor);		

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

		try{

			importAndSave(analysisFile, uid, pluginsToUse, suffixTaskName, monitor);	

			ProfileReader.getInstance().writeAnalysisFile(analysisFile.getLocation().toString(), monitor, suffixTaskName, uid);				

			analyserDataProcessorState = STATE_OK;

		}catch (Exception e) {

			handleRunnableException(e, uid, analysisFile);

			monitor.setCanceled(true);

		}

	}

	private void importAndSave(final IFile analysisFile, final int uid, List<ITrace> pluginsToUse, String suffixTaskName,IProgressMonitor progressMonitor) throws InvocationTargetException, InterruptedException{

		if(progressMonitor == null){

			progressMonitor = new NullProgressMonitor();

		}

		setProgressMonitor(progressMonitor);

		String taskName = Messages.getString("AnalyserDataProcessor.17") + analysisFile.getName();; //$NON-NLS-1$

		if(suffixTaskName != null){

			taskName += " "+suffixTaskName; //$NON-NLS-1$

		}

	    progressMonitor.beginTask(taskName, TOTAL_PROGRESS_COUNT);   //$NON-NLS-1$

		progressMonitor.setTaskName(taskName);

		// open a profile data file that should contain at least thread/address information

		// import new .dat

		assertThrowITE(SampleImporter.getInstance().validate(), Messages.getString("AnalyserDataProcessor.18"));	  //$NON-NLS-1$

		// invoke analysis-specific plugin instances

		PluginInitialiser.invokePluginInstances(uid, "com.nokia.carbide.cpp.internal.pi.plugin.model.ITrace"); //$NON-NLS-1$

		StreamFileParser stp;

		try {

			stp = new StreamFileParser(new File(SampleImporter.getInstance().getDatFileName()));

			Hashtable<Integer,String> traceFileNames = new Hashtable<Integer,String>();

			ArrayList<File> tracesForCleanUp = new ArrayList<File>();

			// loop through all the plugins associated with traces and note their trace IDs names

			for (ITrace plugin : pluginsToUse) {

				File tempFile;

				int traceId = plugin.getTraceId();

				if (traceId != -1)

				{

					try {

						if (traceId == 1) {// the SMP change; separate temp data files for each CPU

							for (int i = 0; i < MAX_CPU; i++) {

								int smpTraceId = traceId + i * 20;

								tempFile = stp.getTempFileForTraceType(smpTraceId);

								if (tempFile != null) {

									tempFile.deleteOnExit();

									traceFileNames.put(smpTraceId, tempFile.getAbsolutePath());

									tracesForCleanUp.add(tempFile);

								}

							}

						} else {

							tempFile = stp.getTempFileForTraceType(traceId);

							if (tempFile != null)

							{

								tempFile.deleteOnExit();

								traceFileNames.put(traceId, tempFile.getAbsolutePath());

								tracesForCleanUp.add(tempFile);

							}									

						}

					} catch (IOException e) {

						throw new InvocationTargetException(e, Messages.getString("AnalyserDataProcessor.25")); //$NON-NLS-1$

					}

				}

			}

			// import a new analysis

			importNewAnalysis(traceFileNames, uid, pluginsToUse);

			// clean up temp file for each trace

			for (File traceFile : tracesForCleanUp) {

				traceFile.delete();

			}

		} catch (IOException e) {

			throw new InvocationTargetException(e, Messages.getString("AnalyserDataProcessor.26") + SampleImporter.getInstance().getDatFileName()); //$NON-NLS-1$

		}

		if (progressMonitor.isCanceled()) {

			throw new InterruptedException(Messages.getString("AnalyserDataProcessor.19"));   //$NON-NLS-1$

		}

		// give the .NPI file null contents

		byte[] b = new byte[0];

		try {

			analysisFile.create(new ByteArrayInputStream(b), true, null);

			// make sure we can open an input stream to the trace file

			analysisFile.getContents();

		} catch (CoreException e) {

			throw new InvocationTargetException(e, Messages.getString("AnalyserDataProcessor.14") + analysisFile.getName()); //$NON-NLS-1$

		}

		// extract additional info from importer

		int numberOfTraces = 0;

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

		AnalysisInfoHandler handler = NpiInstanceRepository.getInstance().activeUidGetAnalysisInfoHandler();

		// for all traces exist in .dat set up their additional info

	    while (enuTraces.hasNext()) {

	    	Object object = enuTraces.next();

	    	numberOfTraces++;