/*
 * 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:
 *
 * Base DataReader class
 *
 */
package com.nokia.traceviewer.engine;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * Base DataReader class
 */
public abstract class BaseDataReader extends Thread implements DataReader,
		TraceViewerConst, BTraceConstants {

	/**
	 * Sleeping time
	 */
	protected static final int SLEEP_TIME = 200;

	/**
	 * Pause waiting time
	 */
	protected static final int PAUSE_TIME = 300;

	/**
	 * Trace configuration to be used in this Reader
	 */
	protected TraceConfiguration traceConfiguration;

	/**
	 * Trace properties, passed to MediaCallback
	 */
	protected TraceProperties trace;

	/**
	 * Data source
	 */
	protected FileChannel sourceChannel;

	/**
	 * Buffer for data received from data source
	 */
	protected ByteBuffer receiveBuffer;

	/**
	 * Media processor
	 */
	protected MediaCallback mediaCallback;

	/**
	 * File path from where to read
	 */
	protected String filePath;

	/**
	 * Random access file we use to read the binary
	 */
	protected RandomAccessFile readFile;

	/**
	 * Filemap that hold the trace block positions
	 */
	protected FileMap fileMap;

	/**
	 * Trace count in this file
	 */
	protected int traceCount;

	/**
	 * File start offset
	 */
	protected long fileStartOffset;

	/**
	 * Multipart trace array
	 */
	protected static Map<Integer, MultiPartItem> multiPartTraceArray;

	/**
	 * Constructor
	 */
	public BaseDataReader() {
		fileMap = new FileMap();
	}

	/**
	 * Creates file channel
	 */
	protected void createFileChannel() {
		try {
			if (readFile != null) {
				// Close previous file channel
				readFile.close();
			}
			readFile = new RandomAccessFile(filePath, "r"); //$NON-NLS-1$
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (readFile != null) {
			sourceChannel = readFile.getChannel();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#getFilePath()
	 */
	public String getFilePath() {
		return filePath;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * com.nokia.traceviewer.engine.DataReader#setFilePath(java.lang.String)
	 */
	public void setFilePath(String filePath) {
		this.filePath = filePath;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#setFileStartOffset(long)
	 */
	public void setFileStartOffset(long fileStartOffset) {
		this.fileStartOffset = fileStartOffset;
	}

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

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#getFileMap()
	 */
	public FileMap getFileMap() {
		return fileMap;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#clearFile()
	 */
	public void clearFile() {
		fileMap.clearMap();
		traceCount = 0;
		fileStartOffset = 0;
		if (readFile != null) {
			createFileChannel();

			// Set everything to zero
			setFilePosition(0);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#getTraceCount()
	 */
	public int getTraceCount() {
		return traceCount;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * com.nokia.traceviewer.engine.DataReader#createScrollReader(com.nokia.
	 * traceviewer.engine.MediaCallback,
	 * com.nokia.traceviewer.engine.TraceConfiguration)
	 */
	public DataScrollReader createScrollReader(MediaCallback mediaCallback,
			TraceConfiguration conf) {
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#getTraceConfiguration()
	 */
	public TraceConfiguration getTraceConfiguration() {
		return traceConfiguration;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#setFilePosition(long)
	 */
	public void setFilePosition(long filePos) {
		try {
			if (readFile != null) {
				readFile.seek(filePos);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Parses BTrace variables
	 * 
	 * @param buf
	 *            buffer where the data is located
	 * @param bTraceHeaderOffset
	 *            BTrace header offset
	 * @param trace
	 *            trace where the variables are inserted
	 */
	protected void parseBTraceVariables(ByteBuffer buf, int bTraceHeaderOffset,
			TraceProperties trace) {
		int variablesFound = 0;

		// Get BTrace header bytes
		byte recordSize = buf.get(bTraceHeaderOffset);
		byte flags = buf.get(bTraceHeaderOffset + 1);
		byte category = buf.get(bTraceHeaderOffset + 2);
		byte subCategory = buf.get(bTraceHeaderOffset + 3);

		// Set BTrace header bytes
		trace.bTraceInformation.setRecordSize(recordSize);
		trace.bTraceInformation.setFlags(flags);
		trace.bTraceInformation.setCategory(category);
		trace.bTraceInformation.setSubCategory(subCategory);

		// Loop through flags
		for (int i = 0; i < FLAGS_LENGTH; i++) {
			if ((flags & (1 << i)) != 0) {

				switch (i) {

				// Header2 present (bit number 0)
				case HEADER2_PRESENT_BIT:
					trace.bTraceInformation.setHeader2Present(true);

					// CPU Id
					int cpuId = buf.getInt(bTraceHeaderOffset
							+ BTRACE_HEADER_LENGTH);
					cpuId = Integer.reverseBytes(cpuId);
					cpuId = (cpuId & CPU_ID_MASK) >> CPU_ID_SHIFT;
					trace.bTraceInformation.setCpuId(cpuId);

					// Multipart trace
					int multipart = 0;
					multipart |= buf.getInt(bTraceHeaderOffset
							+ BTRACE_HEADER_LENGTH);
					multipart = Integer.reverseBytes(multipart);
					multipart = multipart & MULTIPART_MASK;
					trace.bTraceInformation.setMultiPart(multipart);
					break;

				// Timestamp present (bit number 1)
				case TIMESTAMP_PRESENT_BIT:
					int timestamp = buf.getInt(bTraceHeaderOffset
							+ BTRACE_HEADER_LENGTH
							+ (variablesFound * BTRACE_VARIABLE_LENGTH));

					timestamp = Integer.reverseBytes(timestamp);
					trace.bTraceInformation.setTimestampPresent(true);
					trace.bTraceInformation.setTimestamp(timestamp);
					break;

				// Timestamp2 present (bit number 2)
				case TIMESTAMP2_PRESENT_BIT:
					int timestamp2 = buf.getInt(bTraceHeaderOffset
							+ BTRACE_HEADER_LENGTH
							+ (variablesFound * BTRACE_VARIABLE_LENGTH));

					timestamp2 = Integer.reverseBytes(timestamp2);
					trace.bTraceInformation.setTimestamp2Present(true);
					trace.bTraceInformation.setTimestamp2(timestamp2);
					break;

				// Context ID present (bit number 3)
				case CONTEXT_ID_PRESENT_BIT:
					int contextId = buf.getInt(bTraceHeaderOffset
							+ BTRACE_HEADER_LENGTH
							+ (variablesFound * BTRACE_VARIABLE_LENGTH));

					contextId = Integer.reverseBytes(contextId);
					trace.bTraceInformation.setContextIdPresent(true);
					trace.bTraceInformation.setThreadId(contextId);
					break;

				// Program counter present (bit number 4)
				case PROGRAM_COUNTER_PRESENT_BIT:
					int programCounter = buf.getInt(bTraceHeaderOffset
							+ BTRACE_HEADER_LENGTH
							+ (variablesFound * BTRACE_VARIABLE_LENGTH));

					programCounter = Integer.reverseBytes(programCounter);
					trace.bTraceInformation.setProgramCounterPresent(true);
					trace.bTraceInformation.setProgramCounter(programCounter);
					break;

				// Extra value present (bit number 5)
				case EXTRA_VALUE_PRESENT_BIT:
					int extraValue = buf.getInt(bTraceHeaderOffset
							+ BTRACE_HEADER_LENGTH
							+ (variablesFound * BTRACE_VARIABLE_LENGTH));

					extraValue = Integer.reverseBytes(extraValue);
					trace.bTraceInformation.setExtraValuePresent(true);
					trace.bTraceInformation.setExtraValue(extraValue);
					break;

				// Record truncated (bit number 6)
				case RECORD_TRUNCATED_BIT:
					trace.bTraceInformation.setTruncated(true);
					variablesFound--;
					break;

				// Record missing (bit number 7)
				case RECORD_MISSING_BIT:
					trace.bTraceInformation.setTraceMissing(true);
					variablesFound--;
					break;
				}

				// Add variable count for each found flag
				variablesFound++;
			}
		}

		// Data starts after BTrace header + possible variables
		trace.dataStart = bTraceHeaderOffset + BTRACE_HEADER_LENGTH
				+ (variablesFound * BTRACE_VARIABLE_LENGTH);

		// Get length of the BTrace data
		int btraceDataLength = buf.get(bTraceHeaderOffset) & BYTE_MASK;

		// If length is FF, use the length from header instead
		if (btraceDataLength == BYTE_MASK) {
			trace.dataLength = trace.messageLength
					- (trace.dataStart - trace.messageStart);
		} else {
			trace.dataLength = btraceDataLength
					- ((variablesFound + 1) * BTRACE_VARIABLE_LENGTH);
		}
	}

	/**
	 * Handles multipart trace
	 * 
	 * @param trace
	 *            trace properties
	 * @param multiPartValue
	 *            multi part value
	 * @param bTraceHeaderOffset
	 *            BTrace header offset
	 * @return true if trace should be given to DataProcessors
	 */
	protected boolean handleMultiPart(TraceProperties trace,
			int multiPartValue, int bTraceHeaderOffset) {
		boolean valid = true;
		if (multiPartTraceArray == null) {
			multiPartTraceArray = Collections
					.synchronizedMap(new HashMap<Integer, MultiPartItem>());
		}

		Integer key = Integer.valueOf(trace.bTraceInformation.getExtraValue());
		MultiPartItem item = multiPartTraceArray.get(key);

		// First or middle part
		if (multiPartValue == 1 || multiPartValue == 2) {
			valid = false;

			// Add trace to array
			if (item == null) {
				MultiPartItem newItem = new MultiPartItem();
				newItem.addPart(trace, false);
				multiPartTraceArray.put(key, newItem);

				// Don't add parts if trace is already completed
			} else if (!item.isCompleted()) {
				item.addPart(trace, false);
			}

			// Last part
		} else if (multiPartValue == 3 && item != null) {
			if (!item.isCompleted()) {
				item.addPart(trace, true);
				item.setCompleted(true);
			}

			// Create byte array
			int totalMessageLength = item.getTotalMessageLength();
			byte byteArr[] = new byte[totalMessageLength];

			// First copy the header from the last trace part
			int initialHeaderSize = trace.dataStart - trace.messageStart;
			trace.byteBuffer.position(trace.messageStart);
			trace.byteBuffer.get(byteArr, 0, initialHeaderSize);

			// Then the old data
			Iterator<Integer> headerLenIterator = item
					.getTracePartHeaderSizes().iterator();
			Iterator<byte[]> byteIterator = item.getTraceParts().iterator();
			int startOffset = initialHeaderSize;

			// Copy all the stuff from parts
			while (headerLenIterator.hasNext()) {
				int headerLen = headerLenIterator.next().intValue();
				byte[] partBytes = byteIterator.next();
				System.arraycopy(partBytes, headerLen, byteArr, startOffset,
						partBytes.length - headerLen);
				startOffset += (partBytes.length - headerLen);
			}

			// Set multipart item to the trace
			trace.bTraceInformation.setMultiPartTraceParts(item);

			// Set record size
			int recordSize = totalMessageLength;
			if (recordSize > 0xFF) {
				recordSize = 0xFF;
			}
			bTraceHeaderOffset -= trace.messageStart;
			byteArr[bTraceHeaderOffset] = (byte) recordSize;
			trace.bTraceInformation.setRecordSize((byte) recordSize);

			// Remove multipart info from BTrace header
			int bTraceHeader2Offset = bTraceHeaderOffset + BTRACE_HEADER_LENGTH;
			byteArr[bTraceHeader2Offset] &= ~MULTIPART_MASK;

			// Set protocol specific stuff to multi part trace
			byteArr = setProtocolSpecificStuffToMultiPartTrace(byteArr, trace);

			trace.byteBuffer = ByteBuffer.wrap(byteArr);
		}

		return valid;
	}

	/**
	 * Sets protocol specific stuff to multi part trace
	 * 
	 * @param byteArr
	 *            byte array containing the multi part trace
	 * @param trace
	 *            Trace properties
	 * @return byte array containing the trace after procotol specific stuff is
	 *         added
	 */
	protected abstract byte[] setProtocolSpecificStuffToMultiPartTrace(
			byte[] byteArr, TraceProperties trace);
}