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

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

/**
 * PlainText Scroll Reader class
 * 
 */
public class PlainTextScrollReader extends BaseDataReader implements
		DataScrollReader {

	/**
	 * Running boolean
	 */
	private boolean running;

	/**
	 * 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;

	/**
	 * Indicates that not all traces can be fit in one buffer
	 */
	private boolean tracesDontFitInBuffer;

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

	/**
	 * Possible middle of line break
	 */
	private boolean middleOfLineBreak;

	/**
	 * Constructor
	 * 
	 * @param mediaCallback
	 *            callback
	 * @param configuration
	 *            trace configuration used in this reader
	 */
	public PlainTextScrollReader(MediaCallback mediaCallback,
			TraceConfiguration configuration) {
		filePath = TraceViewerGlobals.getTraceViewer().getDataReaderAccess()
				.getCurrentDataReader().getFilePath();
		createFileChannel();
		this.mediaCallback = mediaCallback;
		trace = new TraceProperties(configuration);
		traceConfiguration = configuration;

		receiveBuffer = ByteBuffer.allocateDirect(RECEIVE_BUFFER_SIZE);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Thread#run()
	 */
	@Override
	public synchronized void run() {
		try {
			running = true;
			receiveBuffer.position(0);
			while (running) {

				// Set buffer limit
				if (!tracesDontFitInBuffer) {
					tracesDontFitInBuffer = setBufferLimit();
				}

				// Reads data to buffer. ReceiveBuffer position is always zero
				// here so readBytes will read until the limit or to the end of
				// file
				int readBytes = readFile.getChannel().read(receiveBuffer);
				if (readBytes <= 0) {
					putToSleep();
					// If data is found, process buffer
				} else {
					// If file is at end, set limit according
					if (readBytes < receiveBuffer.limit()) {
						receiveBuffer.limit(readBytes);
					}
					// Start processing
					processBuffer();
				}
			}
		} catch (Throwable t) {
			t.printStackTrace();
		}
	}

	/**
	 * Sets buffer limit
	 * 
	 * @return true if traces fitted into the buffer
	 * @throws IOException
	 */
	private boolean setBufferLimit() throws IOException {
		boolean tracesDontFitInBuffer = false;
		FileMap fileMap = TraceViewerGlobals.getTraceViewer()
				.getDataReaderAccess().getCurrentDataReader().getFileMap();
		int index = startReadingTracesFrom / TraceViewerGlobals.blockSize;

		// Filemap must have the offset for end trace
		if (fileMap.size() > index + numberOfBlocks) {

			// Get positions and the difference
			long pos = readFile.getFilePointer();
			long pos2 = fileMap.getItem(index + numberOfBlocks).longValue();
			long limit = pos2 - pos;

			// If difference is smaller than capacity, set as limit
			if (limit < receiveBuffer.capacity()) {
				receiveBuffer.limit((int) limit);
			} else {
				receiveBuffer.limit(receiveBuffer.capacity());
				tracesDontFitInBuffer = true;
			}
		} else {
			receiveBuffer.limit(receiveBuffer.capacity());
			tracesDontFitInBuffer = true;
		}
		return tracesDontFitInBuffer;
	}

	/**
	 * Process character buffer
	 */
	private void processBuffer() {
		receiveBuffer.position(0);
		StringBuffer buf = new StringBuffer();
		boolean traceReady = false;

		// Loop until there is characters left
		while (receiveBuffer.hasRemaining()) {
			byte c = receiveBuffer.get();

			// If in the middle of a line break from previous buffer, skip first
			// character
			if (middleOfLineBreak && c == '\n' && receiveBuffer.hasRemaining()) {
				c = receiveBuffer.get();
			}
			middleOfLineBreak = false;

			// Check the character
			switch ((char) c) {
			case '\n':
				traceReady = true;
				break;
			case '\r':
				if (!receiveBuffer.hasRemaining()) {
					middleOfLineBreak = true;
				} else if (((char) receiveBuffer.get()) == '\n') {
				} else {
					receiveBuffer.position(receiveBuffer.position() - 1);
				}
				traceReady = true;
				break;
			default:
				buf.append((char) c);
				traceReady = false;
			}

			// Trace is ready, insert it
			if (traceReady) {
				String traceString = buf.toString();
				buf.setLength(0);
				processTrace(traceString);
				traceReady = false;
			}
		}

		// File at end, process last trace
		try {
			if (readFile.getFilePointer() >= readFile.length()) {
				String traceString = buf.toString();
				buf.setLength(0);
				processTrace(traceString);
				traceReady = false;
			}

			// If data left in buffer, move file backwards the same amount
			else if (buf.length() > 0) {
				setFilePosition(readFile.getFilePointer() - buf.length());

			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		receiveBuffer.position(0);
	}

	/**
	 * Process plain text trace line
	 * 
	 * @param traceString
	 *            trace string
	 */
	private void processTrace(String traceString) {
		numberOfTracesRead++;
		trace = new TraceProperties(traceConfiguration);
		trace.traceString = traceString;
		trace.traceNumber = startReadingTracesFrom + numberOfTracesRead;

		// Not the last trace yet
		if (!lastTrace()) {
			trace.lastTrace = false;
			mediaCallback.processTrace(trace);

			// Last trace
		} else {
			tracesDontFitInBuffer = false;
			trace.lastTrace = true;
			blocking = true;
			numberOfTracesRead = 0;

			mediaCallback.processTrace(trace);

			putToSleep();
		}
	}

	/**
	 * Tells if this is the last trace
	 * 
	 * @return indication of if this is the last trace or not
	 */
	public boolean lastTrace() {
		boolean lastTrace = false;

		// 1 or 2 blocks read
		if (numberOfTracesRead >= TraceViewerGlobals.blockSize * numberOfBlocks) {
			lastTrace = true;
			// Last block
		} else if (startReadingTracesFrom + numberOfTracesRead >= TraceViewerGlobals
				.getTraceViewer().getDataReaderAccess().getCurrentDataReader()
				.getTraceCount()) {
			lastTrace = true;
		}
		return lastTrace;
	}

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

		} catch (InterruptedException e) {
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#shutdown()
	 */
	public void shutdown() {
		running = false;
		try {
			sourceChannel.close();
			readFile.close();
		} catch (IOException 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.DataScrollReader#setFilePosition(long)
	 */
	@Override
	public void setFilePosition(long filePos) {
		try {
			readFile.seek(filePos);

			if (filePos == fileStartOffset) {
				receiveBuffer.limit(receiveBuffer.capacity());
				receiveBuffer.position(receiveBuffer.capacity());
			}

		} catch (IOException e) {
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#pause(boolean)
	 */
	public void pause(boolean pause) {
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.traceviewer.engine.DataReader#isPaused()
	 */
	public boolean isPaused() {
		return false;
	}

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

	@Override
	protected byte[] setProtocolSpecificStuffToMultiPartTrace(byte[] byteArr,
			TraceProperties trace) {
		// There isn't any multipart traces in plain text
		return byteArr;
	}
}