/*
 * 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 ScrollReader class
 *
 */
package com.nokia.traceviewer.ost;

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

import com.nokia.traceviewer.engine.DataScrollReader;
import com.nokia.traceviewer.engine.MediaCallback;
import com.nokia.traceviewer.engine.TraceConfiguration;
import com.nokia.traceviewer.engine.TraceProperties;
import com.nokia.traceviewer.engine.TraceViewerGlobals;

/**
 * OST ScrollReader class
 */
public class OstScrollReader extends OstBaseReader implements DataScrollReader,
		OstMessageCallback {

	/**
	 * Number of blocks to process when reader is block-reader
	 */
	private int numberOfBlocks = 1;

	/**
	 * Starting offset when reader is block-reader
	 */
	private int startReadingTracesFrom;

	/**
	 * Number of traces read when reader is block-reader
	 */
	private int numberOfTracesRead;

	/**
	 * Number of bytes received
	 */
	private int bytesRead;

	/**
	 * Number of bytes in previous message
	 */
	private int previousMessageBytes;

	/**
	 * Is this reader blocking
	 */
	private boolean blocking;

	/**
	 * Constructor
	 * 
	 * @param mediaCallback
	 *            callback
	 * @param configuration
	 *            Trace Configuration
	 */
	public OstScrollReader(MediaCallback mediaCallback,
			TraceConfiguration configuration) {
		// OstBaseReader constructor
		super();

		filePath = TraceViewerGlobals.getTraceViewer().getDataReaderAccess()
				.getCurrentDataReader().getFilePath();
		createFileChannel();

		this.mediaCallback = mediaCallback;
		receiveBuffer = ByteBuffer.allocateDirect(RECEIVE_BUFFER_SIZE);
		messageProcessor = new OstMessageProcessor(this, receiveBuffer);
		traceConfiguration = configuration;
		trace = new TraceProperties(configuration);
		trace.byteBuffer = receiveBuffer;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Thread#run()
	 */
	@Override
	public synchronized void run() {
		try {
			running = true;
			receiveBuffer.position(0);
			while (running) {
				// Get bytes in buffer before read operation
				if (receiveBuffer.position() != 0) {
					previousMessageBytes = receiveBuffer.position();
				} else {
					previousMessageBytes = 0;
				}

				// Reads data to buffer
				bytesRead = sourceChannel.read(receiveBuffer);
				if (bytesRead > 0) {

					// If data is found, the processor is used to split
					// thedata into OST messages. processMessage is
					// called for each message found from the buffer and
					// the buffer is re-positioned for next read
					// operation
					messageProcessor.processBuffer();
				} else {
					putToSleep();
				}
			}
		} catch (Throwable t) {
			t.printStackTrace();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.ost.OstMessageCallback#processMessage(int,
	 * int, int)
	 */
	public boolean processMessage(int msgStart, int msgLen, int headerLen,
			int headerVersion) throws IOException {
		boolean valid = true;
		boolean returnValue = true;
		int protocolId = 0;

		// Create new TraceProperties
		trace = new TraceProperties(traceConfiguration);

		// Save buffer and message and data offsets
		trace.byteBuffer = receiveBuffer;
		trace.messageStart = msgStart;
		trace.messageLength = msgLen;

		// Get protocol ID offset
		int protocolIdOffset = 0;
		if (headerVersion == OST_V01) {
			protocolIdOffset = OST_V01_PROTOCOLID_OFFSET;
		} else if (headerVersion == OST_V05) {
			protocolIdOffset = OST_V05_PROTOCOLID_OFFSET;
		} else if (headerVersion == OST_V10) {
			protocolIdOffset = OST_V10_PROTOCOLID_OFFSET;
		} else if (headerVersion == OST_V00) {
			protocolIdOffset = OST_V00_PROTOCOLID_OFFSET;
		} else {
			// Unsupported header version
			System.out.println("Unsupported header version: " + headerVersion); //$NON-NLS-1$
		}

		// Read protocol ID
		protocolId |= receiveBuffer.get(msgStart + protocolIdOffset)
				& BYTE_MASK;

		// OST Ascii Trace (0x02)
		if (protocolId == OST_ASCII_TRACE_ID && msgLen >= headerLen) {

			// Get the timestamp
			trace.timestamp = messageProcessor.parseTimeStampToNanosecs(
					msgStart, headerLen + OST_ASCII_TRACE_TIMESTAMP_OFFSET);

			// Process the trace
			processOstAsciiTrace(msgStart, msgLen, headerLen);

			// OST Simple Application Trace Protocol (0x03)
		} else if (protocolId == OST_SIMPLE_TRACE_ID) {

			// Get the timestamp
			trace.timestamp = messageProcessor.parseTimeStampToNanosecs(
					msgStart, headerLen + OST_SIMPLE_TRACE_TIMESTAMP_OFFSET);

			// Process the trace
			valid = processOstSimpleTrace(msgStart, headerLen);

			// Unknown protocol ID
		} else {
			trace.binaryTrace = true;
			valid = false;
		}

		// Trace is valid
		if (valid) {
			returnValue = processScrolledTrace(msgStart, msgLen, returnValue);

		}
		return returnValue;
	}

	/**
	 * Processes scrolled trace
	 * 
	 * @param msgStart
	 *            message start offset
	 * @param msgLen
	 *            message length
	 * @param returnValue
	 *            implication of success of processing trace
	 * @return implication of success of processing trace
	 * @throws IOException
	 */
	public boolean processScrolledTrace(int msgStart, int msgLen,
			boolean returnValue) throws IOException {

		// In case of multi part trace, set trace properties now so
		// that DataProcessor can use it properly
		if (trace.bTraceInformation.getMultiPart() != 0) {
			int initialHeaderSize = trace.dataStart - trace.messageStart;
			trace.messageStart = 0;
			trace.messageLength = trace.byteBuffer.capacity();
			trace.dataStart = initialHeaderSize;
			trace.dataLength = trace.messageLength - initialHeaderSize;
		}

		numberOfTracesRead++;
		trace.traceNumber = startReadingTracesFrom + numberOfTracesRead;

		// Not processed full block of traces yet, keep processing
		if (!lastTrace(msgStart, msgLen)) {

			trace.lastTrace = false;
			mediaCallback.processTrace(trace);

			// Last trace
		} else {
			trace.lastTrace = true;
			blocking = true;
			numberOfTracesRead = 0;
			mediaCallback.processTrace(trace);

			putToSleep();
			returnValue = false;
		}
		return returnValue;
	}

	/**
	 * Tells if this trace is the last one to process
	 * 
	 * @param msgStart
	 *            message start offset
	 * @param msgLen
	 *            message length
	 * @return true if this is the last trace
	 * @throws IOException
	 */
	public boolean lastTrace(int msgStart, int msgLen) throws IOException {
		return sourceChannelPosition(msgStart, msgLen) >= sourceChannel.size()
				|| lastTraceToShow() || isBlockSizeRead();
	}

	/**
	 * Checks if we are now read the whole block what we want
	 * 
	 * @return true if block is fully read
	 */
	private boolean isBlockSizeRead() {
		boolean isBlockRead = false;
		if (numberOfTracesRead == TraceViewerGlobals.blockSize * numberOfBlocks) {
			isBlockRead = true;
		}
		return isBlockRead;
	}

	/**
	 * Tells if this is the last trace we want to show during pause because
	 * there propably is more traces in the file
	 * 
	 * @return true if this is the last trace to show during pause
	 */
	public boolean lastTraceToShow() {
		boolean lastTraceToShow = (startReadingTracesFrom + numberOfTracesRead
				+ 1 > TraceViewerGlobals.getTraceViewer().getDataReaderAccess()
				.getCurrentDataReader().getTraceCount());

		return lastTraceToShow;
	}

	/**
	 * Gets position of source channel after this trace
	 * 
	 * @param msgStart
	 *            message start offset
	 * @param msgLen
	 *            message length
	 * @return source channel position after this trace
	 * @throws IOException
	 */
	public long sourceChannelPosition(int msgStart, int msgLen)
			throws IOException {
		return sourceChannel.position() - bytesRead + msgStart + msgLen
				- previousMessageBytes;
	}

	/**
	 * Puts this thread to sleep
	 */
	public void putToSleep() {
		try {
			// Null variables if this reader is only for blocks
			if (TraceViewerGlobals.getTraceViewer().getStateHolder()
					.isScrolling()) {
				receiveBuffer.position(receiveBuffer.capacity());
				numberOfTracesRead = 0;
			}
			if (blocking) {
				this.notifyAll();
				this.wait();
			}
		} catch (InterruptedException e) {
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataScrollReader#setBlockReader(int,
	 * int, boolean)
	 */
	public void setBlockReader(int numberOfBlocks, int startingTrace,
			boolean blocking) {
		this.numberOfBlocks = numberOfBlocks;
		this.startReadingTracesFrom = startingTrace;
		this.blocking = blocking;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#getTracePositionInFile()
	 */
	public long getTracePositionInFile() {
		return 0;
	}
}