/*

 * Copyright (c) 2010 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.pi.graphicsmemory;

import java.io.ByteArrayInputStream;

import java.io.DataInputStream;

import java.io.EOFException;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.List;

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

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

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

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

public class GraphicsMemoryTraceParser extends Parser {

	private boolean debug = false;

	private String version;

	private GraphicsMemoryTrace memTrace;

	private int readCount = 0;

	// constants

	public final static int SAMPLE_TOTAL_MEMORY_PROCESS_ID = -1;

	public final static String SAMPLE_TOTAL_MEMORY_PROCESS_NAME = "TOTAL_MEMORY_USAGE"; //$NON-NLS-1$

	public ParsedTraceData parse(File file) throws IOException {

		if (!file.exists() || file.isDirectory()) {

			throw new IOException(Messages

					.getString("GraphicsMemoryTraceParser.cannotOpenTraceFile")); //$NON-NLS-1$

		}

		if (debug)

			System.out

					.println(Messages

							.getString("GraphicsMemoryTraceParser.traceFileLength") + file.length()); //$NON-NLS-1$

		parseMemTrace(file);

		int versionNumber = convertVersionStringToInt(version);

		memTrace.setVersion(versionNumber);

		ParsedTraceData ptd = new ParsedTraceData();

		ptd.traceData = this.getTrace();

		return ptd;

	}

	private void parseV100GPUFile(DataInputStream dis) throws IOException {

		// read the version again

		byte[] version = readElementWithLength(dis);

		if (debug)

			System.out

					.println(Messages

							.getString("GraphicsMemoryTraceParser.readVersionDebug") + new String(version)); //$NON-NLS-1$

		this.version = new String(version);

		this.readV100GPUSample(dis);

	}

	public String getProfilerVersion() {

		return version;

	}

	private void readV100GPUSample(DataInputStream dis) throws IOException {

		memTrace = new GraphicsMemoryTrace();

		GraphicsMemoryProcess process;

		// read sample header length

		dis.readUnsignedByte();

		readCount++;

		int length;

		int mode = -1;

		String processName = null;

		GraphicsMemorySample gpuSample = null;

		int usedMemory = -1;

		int totalMemory = -1;

		long sample = -1;

		List<GraphicsMemoryProcess> processList = new ArrayList<GraphicsMemoryProcess>();

		try {

			while (true) {

				length = dis.readUnsignedByte();

				readCount++;

				if (length == 1) {

					mode = dis.readUnsignedByte();

					readCount++;

				} else {

					throw new IOException(Messages

							.getString("GraphicsMemoryTraceParser.wrongLength")); //$NON-NLS-1$

				}

				if (mode == 0xac) { // time stamp

					// first there should be 4 bytes of sample time

					sample = this.readTUint(dis);

				}

				else if (mode == 0xaa) { // process name

					length = dis.readUnsignedByte();

					readCount++; // process sample length

					// reading process name

					processName = readProcessName(dis, length);

				} else if (mode == 0xab) { // process id

					// reading process id

					long processId = readTUint(dis);

					// create process and sample

					process = new GraphicsMemoryProcess(Integer

							.valueOf((int) processId), processName);

					gpuSample = new GraphicsMemorySample(process, (int) sample);

				} else if (mode == 0xdb) { // total GPU data

					// read the total GPU data

					long total = readTUint(dis);

					totalMemory = (int) total;

				} else if (mode == 0xdc) { // used GPU data

					// read the used GPU data

					long used = readTUint(dis);

					usedMemory = (int) used;

					if (debug)

						System.out

								.println(MessageFormat

										.format(

												Messages

														.getString("GraphicsMemoryTraceParser.readMemoryUsageDebug"), usedMemory, totalMemory, sample)); //$NON-NLS-1$

					GraphicsMemorySample memoryUsageSample = new GraphicsMemorySample(

							usedMemory, totalMemory, (int) sample);

					memTrace.addSample(memoryUsageSample);

					processList.add(memoryUsageSample.process);

					length = dis.readUnsignedByte(); // read process sample

														// length

					readCount++;

				} else if (mode == 0xde) { // private data

					// read the private data

					long privateSize = readTUint(dis);

					gpuSample.privateSize = (int) privateSize;

				} else if (mode == 0xdf) { // shared data

					// read the shared data

					long sharedSize = readTUint(dis);

					gpuSample.sharedSize = (int) sharedSize;

					if (debug)

						System.out

								.println(MessageFormat

										.format(

												Messages

														.getString("GraphicsMemoryTraceParser.readProcessDebug"), gpuSample.process.processName, gpuSample.sampleSynchTime, Long.toHexString(gpuSample.process.processId), gpuSample.privateSize, gpuSample.sharedSize)); //$NON-NLS-1$

					memTrace.addSample(gpuSample);

					processList.add(gpuSample.process);

					length = dis.readUnsignedByte(); // read process sample

														// length

					readCount++;

				} else {

					throw new IOException(

							Messages

									.getString("GraphicsMemoryTraceParser.wrongMode") + mode); //$NON-NLS-1$

				}

			}

		} catch (EOFException e) {

			memTrace.setProcesses(processList

					.toArray(new GraphicsMemoryProcess[processList.size()]));

			System.out.println(Messages

					.getString("GraphicsMemoryTraceParser.finishedReading")); //$NON-NLS-1$

		}

	}

	/*

	 * A method for calculating hash value for a string

	 */

	public static long sum(String arg) {

		int total = 0;

		for (int i = 0; i < arg.length(); i++) {

			total += (long) arg.charAt(i);

		}

		return total; // returns the sum of the chars after cast

	}

	private String readProcessName(DataInputStream dis, int length)

			throws IOException {

		if (length != 0) {

			byte[] element = new byte[length];

			dis.read(element, 0, length);

			readCount += length;

			return new String(element);

		} else

			return null;

	}

	private byte[] readElementWithLength(DataInputStream dis) throws IOException {

		byte length = dis.readByte();

		readCount++;

		if (length != 0) {

			byte[] element = new byte[length];

			dis.read(element, 0, length);

			readCount += length;

			return element;

		} else

			return null;

	}

	private long readTUint(DataInputStream dis) throws IOException {

		long result = dis.readUnsignedByte();

		readCount++;

		result += dis.readUnsignedByte() << 8;

		readCount++;

		result += dis.readUnsignedByte() << 16;

		readCount++;

		result += dis.readUnsignedByte() << 24;

		readCount++;

		return result;

	}

	private void parseMemTrace(File file) throws IOException {

		DataInputStream dis = new DataInputStream(new FileInputStream(file));

		byte[] traceArray = new byte[(int) file.length()];

		dis.readFully(traceArray);

		// test the graph mem trace version

		String s = new String(traceArray, 1, traceArray[0]);

		if (traceArray.length > 257) {

			if (s.startsWith("Bappea_GPU_V1.00")) { //$NON-NLS-1$

				ByteArrayInputStream bais = new ByteArrayInputStream(traceArray);

				dis = new DataInputStream(bais);

				this.parseV100GPUFile(dis);

				return;

			}

		}

		String version = s.substring(8, 12);

		String traceType = s.substring(13, s.length());

		System.out

				.println(Messages

						.getString("GraphicsMemoryTraceParser.foundVersion1") + version + Messages.getString("GraphicsMemoryTraceParser.foundVersion2") + traceType + Messages.getString("GraphicsMemoryTraceParser.foundVersion3")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		GeneralMessages

				.showErrorMessage(Messages

						.getString("GraphicsMemoryTraceParser.wrongTraceType1") + traceType + Messages.getString("GraphicsMemoryTraceParser.wrongTraceType2")); //$NON-NLS-1$ //$NON-NLS-2$

		throw new IOException(

				Messages.getString("GraphicsMemoryTraceParser.wrongTraceType1") + traceType + Messages.getString("GraphicsMemoryTraceParser.wrongTraceType2")); //$NON-NLS-1$ //$NON-NLS-2$

	}

	private GenericSampledTrace getTrace() {

		return (GenericSampledTrace) memTrace;

	}

	private int convertVersionStringToInt(String version) {

		// Coverts version number from string to int

		int i = 0;

		int versionInt = 0;

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

		// goes string thru and copies all digits into another string

		while (i < version.length()) {

			if (Character.isDigit(version.charAt(i))) {

				versionString += version.charAt(i);

			}

			i++;

		}

		// convert string to int

		try {

			versionInt = Integer.parseInt(versionString);

		} catch (Exception e) {

			e.printStackTrace();

		}

		return versionInt;

	}

}