/*
 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "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:
 *
 * OST Message Processor 
 *
 */
package com.nokia.traceviewer.ost;

import java.io.IOException;
import java.nio.ByteBuffer;

import com.nokia.traceviewer.engine.TraceViewerConst;

/**
 * OST Message Processor
 * 
 */
public class OstMessageProcessor implements OstConsts, TraceViewerConst {

	/**
	 * Buffer where data is located
	 */
	private final ByteBuffer receiveBuffer;

	/**
	 * Temporary buffer for data
	 */
	private final ByteBuffer tempBuffer;

	/**
	 * Callback class
	 */
	private final OstMessageCallback callback;

	/**
	 * If true, stop processing the messages
	 */
	private boolean stopped;

	/**
	 * @param callback
	 *            callback where messages are returned
	 * @param receiveBuffer
	 *            buffer where data is located
	 */
	public OstMessageProcessor(OstMessageCallback callback,
			ByteBuffer receiveBuffer) {
		this.callback = callback;
		this.receiveBuffer = receiveBuffer;
		tempBuffer = ByteBuffer.allocateDirect(MAX_MESSAGE_SIZE);
	}

	/**
	 * Processes buffer to messages
	 * 
	 * @throws IOException
	 */
	public void processBuffer() throws IOException {

		boolean messageFound = false;
		boolean processorResult = false;
		int msgLength = 0;
		int versionNr = 0;
		int msgStart = 0;
		// Parses all complete messages
		int position = receiveBuffer.position();
		do {
			messageFound = false;
			// Reads next message length if there is enough data
			if (position - msgStart > OST_V01_HEADER_LENGTH) {
				versionNr = 0;
				msgLength = 0;

				// Get OST version and check the base header length
				versionNr |= (receiveBuffer.get(msgStart + OST_VERSION_OFFSET) & BYTE_MASK);

				int headerLength = 0;

				// OST version 0.1
				if (versionNr == OST_V01) {
					headerLength = OST_V01_HEADER_LENGTH;

					// Get message length
					msgLength |= (receiveBuffer.getShort(msgStart
							+ OST_V01_LENGTH_OFFSET_1) & SHORT_MASK)
							+ headerLength;

					// OST version 0.0
				} else if (versionNr == OST_V00) {
					headerLength = OST_V00_HEADER_LENGTH;

					// Get message length
					msgLength |= (receiveBuffer.getShort(msgStart
							+ OST_V01_LENGTH_OFFSET_1) & SHORT_MASK)
							+ headerLength;

					// OST version 0.5 or 1.0
				} else if (versionNr == OST_V05 || versionNr == OST_V10) {
					headerLength = OST_V05_HEADER_LENGTH;

					// Get message length
					msgLength |= (receiveBuffer.get(msgStart
							+ OST_V05_LENGTH_OFFSET) & BYTE_MASK)
							+ headerLength;

					// If length is only the header length, there are 4 bytes
					// extended length in Little Endian (LE)
					if (msgLength == headerLength) {
						headerLength += OST_V05_EXT_LENGTH_LENGTH;
						msgLength = receiveBuffer.getInt(msgStart
								+ OST_V05_EXT_LENGTH_OFFSET);

						// Reverse because of Little Endian
						msgLength = Integer.reverseBytes(msgLength);
						msgLength += headerLength;
					}
				} else {
					// Unsupported OST version.
					System.out
							.println("Unsupported OST version: 0x" + Integer.toHexString(versionNr)); //$NON-NLS-1$
				}

				// Parses message if it is completely in buffer
				if (position >= msgStart + msgLength) {
					processorResult = callback.processMessage(msgStart,
							msgLength, headerLength, versionNr);
					msgStart += msgLength;
					messageFound = true;
				}
			}
		} while (messageFound && processorResult && !stopped);

		if (!stopped) {
			// Writes the remaining data into beginning of receive
			// buffer. The next socket read operation will append data
			// into buffer
			int remainderLength = position - msgStart;
			if (remainderLength > 0 && processorResult) {
				receiveBuffer.position(msgStart);
				receiveBuffer.limit(msgStart + remainderLength);
				tempBuffer.position(0);
				tempBuffer.limit(MAX_MESSAGE_SIZE);
				tempBuffer.put(receiveBuffer);

				receiveBuffer.position(0);
				receiveBuffer.limit(RECEIVE_BUFFER_SIZE);
				tempBuffer.position(0);
				tempBuffer.limit(remainderLength);

				receiveBuffer.put(tempBuffer);
				receiveBuffer.position(remainderLength);
			} else {
				receiveBuffer.position(0);
				receiveBuffer.limit(RECEIVE_BUFFER_SIZE);
			}
		}
	}

	/**
	 * Reads the 8 byte timestamp from the data buffer
	 * 
	 * @param msgStart
	 *            message start offset
	 * @param timestampOffset
	 *            offset to the timestamp in the message
	 * @return the timestamp
	 */
	public long parseTimeStampToNanosecs(int msgStart, int timestampOffset) {
		long timestamp = 0;
		try {
			timestamp = receiveBuffer.getLong(msgStart + timestampOffset)
					& TIMESTAMP_MASK;
		} catch (Throwable t) {
			t.printStackTrace();
			// Couldn't get timestamp, return MIN_VALUE to set trace as non
			// valid
			timestamp = Long.MIN_VALUE;
		}
		return timestamp;
	}

	/**
	 * Close the processor
	 */
	void close() {
		stopped = true;
	}
}