/*

 * 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.BufferedInputStream;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.EOFException;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InvalidClassException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.ObjectStreamClass;

import java.io.Serializable;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Vector;

import java.util.zip.GZIPInputStream;

import java.util.zip.GZIPOutputStream;

import org.eclipse.core.resources.WorkspaceJob;

import org.eclipse.core.runtime.IProgressMonitor;

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

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.swt.widgets.Display;

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

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

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

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

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.IAnalysisItem;

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.nokia.carbide.cpp.internal.pi.utils.PluginClassLoader;

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

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

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

/*

 * Class for reading a processed profile data file and setting up the

 * editor pages, initial graphs, and initial tables

 */

{

	// objects (mainly traces) read, it's lifetime exist between loadAnalysisFile for last usage in loadAnalysisFile

	static private ArrayList<Object> readObjects = new ArrayList<Object>();

	static private ArrayList<Hashtable> recObjects = new ArrayList<Hashtable>();

	static private ProfileReader instance;

	private static ILock lock = WorkspaceJob.getJobManager().newLock();

	public static ProfileReader getInstance() {

		if (instance == null) {

			instance = new ProfileReader();

		}

		return instance;

	}

	private ProfileReader()

	{

		//singleton

	}

	public boolean readTraceFile(ITrace plugin, File[] traceFiles, AnalyserDataProcessor dataInstance, int instanceUID){

		// prepare the trace repository

		try 

		{

			ParsedTraceData parsedTraceData = null;

			if (traceFiles.length == 1){

				parsedTraceData = plugin.parseTraceFile(traceFiles[0]);

			} else {

				parsedTraceData = plugin.parseTraceFiles(traceFiles);

			}

			if (parsedTraceData != null) 

			{

				// each resolvable trace is primarily resolved first 

				// with its own functionresolver(s)

				if (parsedTraceData.traceData instanceof RefinableTrace)

				{

					if (parsedTraceData.functionResolvers != null && parsedTraceData.functionResolvers.length > 0)

					{

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

						{

							FunctionResolver fr = parsedTraceData.functionResolvers[i];

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

						}

					}

				}

				TraceDataRepository.getInstance().insertTraceCollection(plugin.getTraceClass(), parsedTraceData, instanceUID);	

				addToMenus(plugin);

			}

		} 

		catch (Exception e) 

		{

			e.printStackTrace();

			return false;

		}

		return true;

	}

	// read a plugin's information from a profile data file

	public boolean readTraceFile(ITrace plugin, File traceFile, AnalyserDataProcessor dataInstance, int instanceUID){

		return readTraceFile(plugin, new File[]{traceFile}, dataInstance, instanceUID);

	}

	public void loadAnalysisFile(String filePath, String displayName, IProgressMonitor progressMonitor, int instanceUID) throws IOException, InterruptedException

	{

		final int workUnitsForLoad = AnalyserDataProcessor.TOTAL_PROGRESS_COUNT * 20 / 100;

		int workUnitsLeft = workUnitsForLoad;

		progressMonitor.worked(1); // kick it start to please user

		AnalyserDataProcessor.getInstance().checkCancelledThrowIE();

	    System.out.println(Messages.getString("ProfileReader.0") + displayName);  //$NON-NLS-1$

	    // find and record all PI plugins that implement the specified interface

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

		// the file contains Java objects that have been gziped

	    FileInputStream fis = new FileInputStream(filePath);

		GZIPInputStream ziss = new GZIPInputStream(fis);

		BufferedInputStream bis = new BufferedInputStream(ziss);

		ObjectInputStream ois = new ObjectInputStream(bis)

	    {   	

	        @SuppressWarnings("unchecked") //$NON-NLS-1$

			protected Class resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException

	        {

	        	// each object read must have a class corresponding to a plugin class

	        	String name = desc.getName();

                Class c = PluginInitialiser.getPluginClass(name);

	    		if (c == null)

	    		{

	    			try {

						c = Class.forName(name);

					} catch (ClassNotFoundException e) {

						// see if we have a replacement

						PluginClassLoader pcl = (PluginClassLoader)PluginInitialiser.getPluginClassLoader();

						// don't catch for class not found exception, they did it on purpose 

						// to back out of this missing plugin that exist in data file

						c = pcl.findClass(name);

					}	

	    		}

	       		return c;

	        }

	    };

	    readObjects.clear();

	    String notFoundMessage = ""; //$NON-NLS-1$

		//loads all objects

	    try

	    {

	        while(true)

	        {

            	Object ou = null;

            	try

            	{

	                ou = ois.readObject();

            	}

	    	    catch (ClassNotFoundException cnfe)

	    	    {

	    		    //probably the plugin which has this class is not loaded

    	        	ou = null;

    	        	if (notFoundMessage.length() != 0)

    	        		notFoundMessage += "\n";  //$NON-NLS-1$

    	        	notFoundMessage += "Cannot find class " + cnfe.getMessage() //$NON-NLS-1$

					+ Messages.getString("ProfileReader.1");  //$NON-NLS-1$

	    	    }

    	        if (ou != null)

    	        	readObjects.add(ou);

	            // allocate what's left to roughly all plugins loaded, even some of them may not be in profiled sample

	            progressMonitor.worked(workUnitsLeft / PluginRegistry.getInstance().getRegistrySize());

	            workUnitsLeft -= workUnitsLeft / PluginRegistry.getInstance().getRegistrySize();

	            AnalyserDataProcessor.getInstance().checkCancelledThrowIE();

	        }

	    }

	    catch(EOFException eof)

	    {

	    	if (eof.getMessage() == null)

	        System.out.println(Messages.getString("ProfileReader.2"));  //$NON-NLS-1$

		    	else

		    	{

		    		System.out.println(Messages.getString("ProfileReader.3") + eof.getMessage());  //$NON-NLS-1$

		    		eof.printStackTrace();

		    	}

	    }

	    catch (InvalidClassException ie)

	    {

	    	// assume that the reason you got here was a UID mismatch

	        // close the readers

	        System.out.println(Messages.getString("ProfileReader.4"));  //$NON-NLS-1$

	        ois.close();

	        fis.close();

	        bis.close();

	        ziss.close();

	        notFoundMessage = ""; //$NON-NLS-1$

	        // fix the UID mismatch problem

	        fis = new FileInputStream(filePath);

	        ziss = new GZIPInputStream(fis);

	        InputStream fixedStream = fixUIDProblem(ziss);

	        bis = new BufferedInputStream(fixedStream);

	        ois = new ObjectInputStream(bis)

	        {       

	            @SuppressWarnings("unchecked") //$NON-NLS-1$

				protected Class resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException

	            {

		        	// each object read must have a class corresponding to a plugin class

		        	String className = desc.getName();

		        	Class c = PluginInitialiser.getPluginClass(className);

	                if (c == null)

	                {

	                    try {

	                        c = Class.forName(className);

	                    }

	                    catch (ClassNotFoundException e1) {

	                            throw e1;

	                    }

	                }

	                return c;

	            }

	        };

	        // try again to read the objects

            readObjects.clear();

	        try

	        {

	            while (true)

	            {

	            	Object ou = null;

	            	try

	            	{

		                ou = ois.readObject();

	            	}

	    	        catch (ClassNotFoundException cnfe)

	    	        {

	    			    //probably the plugin which has this class is not loaded

	    	        	ou = null;

	    	        	if (notFoundMessage.length() != 0)

	    	        		notFoundMessage += "\n";  //$NON-NLS-1$

	    	        	notFoundMessage += Messages.getString("ProfileReader.5") + cnfe.getMessage()  //$NON-NLS-1$

	    	        			+ Messages.getString("ProfileReader.6");  //$NON-NLS-1$

	    	        }

	    	        if (ou != null)

	    	        	readObjects.add(ou);

		            // allocate what's left to roughly all plugins loaded, even some of them may not be in profiled sample

		            progressMonitor.worked(workUnitsLeft / PluginRegistry.getInstance().getRegistrySize());

		            workUnitsLeft -= workUnitsLeft / PluginRegistry.getInstance().getRegistrySize();

		            AnalyserDataProcessor.getInstance().checkCancelledThrowIE();

	            }

	        }   

	        catch (EOFException eof)

	        {

	            System.out.println(Messages.getString("ProfileReader.7"));  //$NON-NLS-1$

	        }

	        catch (Exception eih)

	        {

	        	eih.printStackTrace();

	        }

	    }

	    catch(Exception e)

	    {

	        e.printStackTrace();

	    }

	    // close the readers

	    ois.close();

	    fis.close();

	    bis.close();

	    ziss.close();

	    progressMonitor.worked((workUnitsForLoad * 98 / 100) - workUnitsLeft);	// assume reading takes 98%

	    AnalyserDataProcessor.getInstance().checkCancelledThrowIE();

	    workUnitsLeft = workUnitsForLoad * 2 / 100;

	    // display routine wants to see Analysis info first,

	    // and the rest in the order of what you want it to

	    // be displayed, GPP first, and then MEM

		Iterator<Object> readObjectsItr = readObjects.iterator();

		Object analysisInfoObj = null;

		Object gppObj = null;

		Object memObj = null;

		while (readObjectsItr.hasNext())

		{

			Object objFromFile = readObjectsItr.next();

			if (objFromFile.getClass().getName().endsWith("PIAnalysisInfo")) //$NON-NLS-1$

			{

				readObjectsItr.remove();

				analysisInfoObj = objFromFile;

			}

			if (objFromFile.getClass().getName().endsWith("BappeaAnalysisInfo")) //$NON-NLS-1$

			{

				readObjectsItr.remove();

				if (analysisInfoObj == null)

					analysisInfoObj = objFromFile;

			}

			if (objFromFile.getClass().getName().endsWith("GppTrace")) //$NON-NLS-1$

			{

				readObjectsItr.remove();

				gppObj = objFromFile;

			}

			if (objFromFile.getClass().getName().endsWith("MemTrace")) //$NON-NLS-1$

			{

				readObjectsItr.remove();

				memObj = objFromFile;

			}

		}

		if (memObj != null)

		{

			readObjects.add(0, memObj);

		}

		if (gppObj != null)

		{

			readObjects.add(0, gppObj);

		}

		if (analysisInfoObj != null)

		{

			readObjects.add(0, analysisInfoObj);

		}

		progressMonitor.worked(workUnitsForLoad - workUnitsLeft);

		AnalyserDataProcessor.getInstance().checkCancelledThrowIE();

		// if any problems were found, print them

	    if (notFoundMessage.length() != 0) {

	    	GeneralMessages.showWarningMessage(notFoundMessage);

	    }

	}

	// setup data from all objects in NPI file, e.g. setup trace repository

	public void processDataReadFromNpiFile(AnalyserDataProcessor dataInstance)

	{

		int uid = NpiInstanceRepository.getInstance().activeUid();

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

		if (readObjects == null)

			return;

		recObjects.clear();

		Object o;

		int nextTrace = 1;

	    if (readObjects.size() > 0) 

	    	o = readObjects.get(0);

	    else

	    	o = new Object();

		// the first element must identify the analysis info type

	    String className = o.getClass().getCanonicalName();

	    if (o instanceof PIAnalysisInfo)

	    {

	        try

	        {

	            PIAnalysisInfo info = (PIAnalysisInfo) o;

	            infoHandler.analysisDataReader(info);

	            System.out.println(Messages.getString("ProfileReader.8") + infoHandler.getFileVersion());  //$NON-NLS-1$

	        }

	        catch (Exception eu)

	        {

	            System.out.println(Messages.getString("ProfileReader.9"));  //$NON-NLS-1$

	            return;

	        }

	    }

	    else if (className.indexOf("BappeaAnalysisInfo") != -1) //$NON-NLS-1$

	    {

	        try

	        {

	        	// Old-style analysis info

	            BappeaAnalysisInfo info = (BappeaAnalysisInfo) o;

	            infoHandler.analysisDataReader(info);

	            System.out.println(Messages.getString("ProfileReader.10") + infoHandler.getFileVersion());  //$NON-NLS-1$

	        }

	        catch (Exception eu)

	        {

	            System.out.println(Messages.getString("ProfileReader.11"));  //$NON-NLS-1$

	            return;

	        }

	    }

	    else

	    {

		    //analysis info was not stored in old files

	        System.out.println(Messages.getString("ProfileReader.12"));  //$NON-NLS-1$

            nextTrace = 0;

            PIAnalysisInfo info = null;

            infoHandler.analysisDataReader(info);	// try this and make updater attempts conversion

	    }

	    LinkedHashMap<Class, ParsedTraceData> traces = TraceDataRepository.getInstance().getTraceCollection(uid);

		// Note: The first trace encountered MUST be the address/thread (GPP) trace

	    while (nextTrace < readObjects.size() && o != null)

	    {

	    	o = readObjects.get(nextTrace++);

	    	if (o instanceof GenericTrace)

	    	{

	    		GenericTrace trace = (GenericTrace)o;

	    		// iterate through all PI plugins that implement the given interface

	    		Enumeration<AbstractPiPlugin> enumeration = PluginInitialiser.getPluginInstances(uid, "com.nokia.carbide.cpp.internal.pi.plugin.model.ITrace");  //$NON-NLS-1$

		    	while (enumeration.hasMoreElements())

		        {

		    		final ITrace plugin = (ITrace)enumeration.nextElement();

		    		AbstractPiPlugin p = (AbstractPiPlugin)plugin;

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

		        	if (plugin.getTraceClass() != null && plugin.getTraceClass().isInstance(o))

		        	{

		        		// add this trace to the trace repository

		        		ParsedTraceData ptd = new ParsedTraceData();

		        		ptd.traceData = trace;

		        		TraceDataRepository.getInstance().insertTraceCollection(plugin.getTraceClass(), ptd, uid);

		        	}

		        }

	    	}

	    	else if (o instanceof Hashtable)

	    	{

	    		recObjects.add((Hashtable)o);

	    	}

        } 

	    // We are done with this

	    readObjects.clear();

		// In general it's a good idea to keep memory footprint low

		// most plugin allocate locals with new in initialiseTrace(GenericTrace)

		// so there should be a bunch of memory to be collected here

		System.runFinalization();

		System.gc();

	}

	public void setAddtionalDataForRecordable() {

		final int uid = NpiInstanceRepository.getInstance().activeUid();

		// do the graphic painting with indicator, SWT require it to be in UI thread

		Display.getDefault().syncExec( new Runnable() {

			public void run() {

				Enumeration<AbstractPiPlugin> enumeration = PluginInitialiser.getPluginInstances(uid, "com.nokia.carbide.cpp.internal.pi.plugin.model.IRecordable"); //$NON-NLS-1$

				while (enumeration.hasMoreElements())

				{

					IRecordable recPlugin = (IRecordable)enumeration.nextElement();

					ITrace tracePlugin = (ITrace)recPlugin;

					for (Hashtable table : recObjects) {

						Object data = table.get(tracePlugin.getTraceClass());

						if (data != null && data instanceof Serializable)

						{

							for (int i = 0; i < recPlugin.getGraphCount(); i++)

								recPlugin.setAdditionalData(i, (Serializable)data);

						}

					}

				}	

			}

		});

		recObjects.clear();

	}

	private static final long UID1 = -6477250745688244253L;

	private static final long UID1Correct = -8144591614894549185L;

	private static final long UID2 = -7847355697200551872L;

	private static final long UID2Correct = -8082342532211331507L;

	private static final long UID3 = -7057416050237320718L;

	private static final long UID3Correct = 8411844143949264073L;

	private InputStream fixUIDProblem(InputStream inputStream) throws IOException

	{

		int[] UID1Array = {

				(int) ((UID1 >>> 56) & 0xff), (int) ((UID1 >>> 48) & 0xff),

				(int) ((UID1 >>> 40) & 0xff), (int) ((UID1 >>> 32) & 0xff),

				(int) ((UID1 >>> 24) & 0xff), (int) ((UID1 >>> 16) & 0xff),

				(int) ((UID1 >>>  8) & 0xff), (int)  (UID1 & 0xff)