/*
 * synergy-plus -- mouse and keyboard sharing utility
 * Copyright (C) 2009 The Synergy+ Project
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "CStreamBuffer.h"

//
// CStreamBuffer
//

const UInt32			CStreamBuffer::kChunkSize = 4096;

CStreamBuffer::CStreamBuffer() :
	m_size(0),
	m_headUsed(0)
{
	// do nothing
}

CStreamBuffer::~CStreamBuffer()
{
	// do nothing
}

const void*
CStreamBuffer::peek(UInt32 n)
{
	assert(n <= m_size);

	// if requesting no data then return NULL so we don't try to access
	// an empty list.
	if (n == 0) {
		return NULL;
	}

	// reserve space in first chunk
	ChunkList::iterator head = m_chunks.begin();
	head->reserve(n + m_headUsed);

	// consolidate chunks into the first chunk until it has n bytes
	ChunkList::iterator scan = head;
	++scan;
	while (head->size() - m_headUsed < n && scan != m_chunks.end()) {
		head->insert(head->end(), scan->begin(), scan->end());
		scan = m_chunks.erase(scan);
	}

	return reinterpret_cast<const void*>(&(head->begin()[m_headUsed]));
}

void
CStreamBuffer::pop(UInt32 n)
{
	// discard all chunks if n is greater than or equal to m_size
	if (n >= m_size) {
		m_size     = 0;
		m_headUsed = 0;
		m_chunks.clear();
		return;
	}

	// update size
	m_size -= n;

	// discard chunks until more than n bytes would've been discarded
	ChunkList::iterator scan = m_chunks.begin();
	assert(scan != m_chunks.end());
	while (scan->size() - m_headUsed <= n) {
		n         -= (UInt32)scan->size() - m_headUsed;
		m_headUsed = 0;
		scan       = m_chunks.erase(scan);
		assert(scan != m_chunks.end());
	}

	// remove left over bytes from the head chunk
	if (n > 0) {
		m_headUsed += n;
	}
}

void
CStreamBuffer::write(const void* vdata, UInt32 n)
{
	assert(vdata != NULL);

	// ignore if no data, otherwise update size
	if (n == 0) {
		return;
	}
	m_size += n;

	// cast data to bytes
	const UInt8* data = reinterpret_cast<const UInt8*>(vdata);

	// point to last chunk if it has space, otherwise append an empty chunk
	ChunkList::iterator scan = m_chunks.end();
	if (scan != m_chunks.begin()) {
		--scan;
		if (scan->size() >= kChunkSize) {
			++scan;
		}
	}
	if (scan == m_chunks.end()) {
		scan = m_chunks.insert(scan, Chunk());
	}

	// append data in chunks
	while (n > 0) {
		// choose number of bytes for next chunk
		assert(scan->size() <= kChunkSize);
		UInt32 count = kChunkSize - (UInt32)scan->size();
		if (count > n)
			count = n;

		// transfer data
		scan->insert(scan->end(), data, data + count);
		n    -= count;
		data += count;

		// append another empty chunk if we're not done yet
		if (n > 0) {
			++scan;
			scan = m_chunks.insert(scan, Chunk());
		}
	}
}

UInt32
CStreamBuffer::getSize() const
{
	return m_size;
}