/*
 * Copyright 2003-2008, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 * 
 * Authors :
 *		Michael Wilber
 *		Jérôme Duval
 */

#include <stdio.h>
#include <string.h>
#include "StreamBuffer.h"

#ifndef min
#define min(x,y) (((x) < (y)) ? (x) : (y))
#endif

#ifndef max
#define max(x,y) (((x) > (y)) ? (x) : (y))
#endif

// ---------------------------------------------------------------
// Constructor
//
// Initializes the StreamBuffer to read from pstream, buffering
// nbuffersize bytes of data at a time. Note that if nbuffersize
// is smaller than MIN_BUFFER_SIZE, MIN_BUFFER_SIZE is used
// as the buffer size.
//
// Preconditions:
//
// Parameters: pstream,	the stream to be buffered
//
//             nbuffersize,	number of bytes to be read from
//			                pstream at a time
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
StreamBuffer::StreamBuffer(BPositionIO *pstream, size_t nbuffersize, bool toRead)
{
	fStream = pstream;
	fBuffer = NULL;
	fBufferSize = 0;
	fLen = 0;
	fPos = 0;
	fToRead = toRead;
	
	if (!pstream)
		return;

	fBufferSize = max(nbuffersize, MIN_BUFFER_SIZE);
	fBuffer = new uint8[fBufferSize];
}

// ---------------------------------------------------------------
// Destructor
//
// Destroys data allocated for this object
//
// Preconditions:
//
// Parameters: 
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
StreamBuffer::~StreamBuffer()
{
	if (!fToRead && fLen > 0)
		fStream->Write(fBuffer, fLen);
	delete[] fBuffer;
	fBuffer = NULL;
}

// ---------------------------------------------------------------
// InitCheck
//
// Determines whether the constructor failed or not
//
// Preconditions: 
//
// Parameters:	
//
// Postconditions:
//
// Returns: B_OK if object has been initialized successfully,
// B_ERROR if not
// ---------------------------------------------------------------
status_t
StreamBuffer::InitCheck()
{
	if (fStream && fBuffer)
		return B_OK;
	else
		return B_ERROR;
}

// ---------------------------------------------------------------
// Read
//
// Copies up to nbytes of data from the stream into pinto
//
// Preconditions: ReadStream() must be called once before this
// function is called (the constructor does this)
//
// Parameters:	pinto,	the buffer to be copied to
//
//				nbytes,	the maximum number of bytes to copy
//
// Postconditions:
//
// Returns: the number of bytes successfully read or an
// error code returned by BPositionIO::Read()
// ---------------------------------------------------------------
ssize_t
StreamBuffer::Read(void *_pinto, size_t nbytes)
{
	if (_pinto == NULL)
		return B_BAD_VALUE;
	if (nbytes == 0)
		return 0;

	ssize_t result = B_ERROR;
	uint8 *pinto = (uint8 *)_pinto;
		
	size_t totalRead = min(nbytes, fLen - fPos);
	memcpy(pinto, fBuffer + fPos, totalRead);
	fPos += totalRead;
	pinto += totalRead;
	nbytes -= totalRead;
	
	while (nbytes > 0) {
		result = _ReadStream();
		if (result <= 0)
			return result;
		if (result > 0) {
			size_t left = min(nbytes, fLen - fPos);
			memcpy(pinto, fBuffer + fPos, left);
			fPos += left;
			pinto += left;
			nbytes -= left;
			totalRead += left;
		}
	}
	
	return totalRead;
}


// ---------------------------------------------------------------
// Write
//
// Copies up to nbytes of data from pinto into the stream
//
// Parameters:	pinto,	the buffer to be copied from
//				nbytes,	the maximum number of bytes to copy
//
// Returns: the number of bytes successfully read or an
// error code returned by BPositionIO::Read()
// ---------------------------------------------------------------
void
StreamBuffer::Write(void *pinto, size_t nbytes)
{
	if (nbytes < fBufferSize - fLen) {
		memcpy(fBuffer + fLen, pinto, nbytes);
		fLen += nbytes;
	} else {
		if (fLen > 0) {
			fStream->Write(fBuffer, fLen);
			fLen = 0;
		}
		fStream->Write(pinto, nbytes);
	}
}


// ---------------------------------------------------------------
// Seek
//
// Seeks the stream to the given position. If the seek operation fails, 
// the read buffer will be reset.
//
// Preconditions: fBuffer must be allocated and fBufferSize
// must be valid
//
// Parameters:	
//
// Postconditions:
//
// Returns: the new position
// ---------------------------------------------------------------
off_t
StreamBuffer::Seek(off_t position, uint32 seekMode)
{
	// just seek in the current buffer if the new position is in it
	if (seekMode == SEEK_CUR) {
		if (fToRead
			&& (fPos + position < fLen)
			&& (fPos + position >= 0)) {
			fPos += position;
			return Position();
		} else if (!fToRead
			&& (fLen + position < fBufferSize)
			&& (fLen + position >= 0)) {
			fLen += position;
			return Position();
		}
	} 
	
	// flush if something to write
	if (!fToRead
		&& fLen > 0) {
			fStream->Write(fBuffer, fLen);	
	}
	
	fLen = 0;
	fPos = 0;
		
	return fStream->Seek(position, seekMode);
}


// ---------------------------------------------------------------
// Position
//
// Returns the current position in the stream.
//
// Preconditions: fBuffer must be allocated and fBufferSize
// must be valid
//
// Parameters:	
//
// Postconditions:
//
// Returns: the position
// ---------------------------------------------------------------
off_t
StreamBuffer::Position()
{
	off_t position = fStream->Position();
	if (fToRead)
		position -= (fLen - fPos);
	else
		position += fLen;
	return position;
}


// ---------------------------------------------------------------
// _ReadStream
//
// Fills the stream buffer with data read in from the stream
//
// Preconditions: fBuffer must be allocated and fBufferSize
// must be valid
//
// Parameters:	
//
// Postconditions:
//
// Returns: the number of bytes successfully read or an
// error code returned by BPositionIO::Read()
// ---------------------------------------------------------------
ssize_t
StreamBuffer::_ReadStream()
{
	ssize_t len = fStream->Read(fBuffer, fBufferSize);
	if (len < 0)
		return len;
	fLen = len;
	fPos = 0;
	return fLen;
}