/*
 * Copyright 2013, Haiku, Inc. All rights reserved.
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ingo Weinhold, ingo_weinhold@gmx.de
 *		Siarzhuk Zharski, zharik@gmx.li
 */

#include "HistoryBuffer.h"

#include <new>

#include <OS.h>

#include "TermConst.h"


HistoryBuffer::HistoryBuffer()
	:
	fLines(NULL),
	fWidth(0),
	fCapacity(0),
	fNextLine(0),
	fSize(0),
	fBuffer(NULL),
	fBufferSize(0),
	fBufferAllocationOffset(0)
{
}


HistoryBuffer::~HistoryBuffer()
{
	delete[] fLines;
	delete[] fBuffer;
}


status_t
HistoryBuffer::Init(int32 width, int32 capacity)
{
	if (width <= 0 || capacity <= 0)
		return B_BAD_VALUE;

	int32 bufferSize = (width + 4) * capacity;

	if (capacity > 0) {
		fLines = new(std::nothrow) HistoryLine[capacity];
		fBuffer = new(std::nothrow) uint8[bufferSize];

		if (fLines == NULL || fBuffer == NULL)
			return B_NO_MEMORY;
	}

	fWidth = width;
	fCapacity = capacity;
	fNextLine = 0;
	fSize = 0;
	fBufferSize = bufferSize;
	fBufferAllocationOffset = 0;

	return B_OK;
}


void
HistoryBuffer::Clear()
{
	fNextLine = 0;
	fSize = 0;
	fBufferAllocationOffset = 0;
}


TerminalLine*
HistoryBuffer::GetTerminalLineAt(int32 index, TerminalLine* buffer) const
{
	HistoryLine* line = LineAt(index);
	if (line == NULL)
		return NULL;

	int32 charCount = 0;
	const char* chars = line->Chars();
	buffer->length = 0;
	Attributes attributes;
	AttributesRun* attributesRun = line->AttributesRuns();
	int32 attributesRunCount = line->attributesRunCount;
	int32 nextAttributesAt = attributesRunCount > 0
		? attributesRun->offset : INT_MAX;

	for (int32 i = 0; i < line->byteLength;) {
		// get attributes
		if (charCount == nextAttributesAt) {
			if (charCount < attributesRun->offset) {
				// the "hole" in attributes run
				attributes.Reset();
				nextAttributesAt = attributesRun->offset;
			} else if (attributesRunCount > 0) {
				attributes = attributesRun->attributes;
				nextAttributesAt = attributesRun->offset
					+ attributesRun->length;
				attributesRun++;
				attributesRunCount--;
			} else {
				attributes.Reset();
				nextAttributesAt = INT_MAX;
			}
		}

		// copy character
		TerminalCell& cell = buffer->cells[charCount++];
		int32 charLength = UTF8Char::ByteCount(chars[i]);
		cell.character.SetTo(chars + i, charLength);
		i += charLength;

		// set attributes
		cell.attributes = attributes;

		// full width char?
		if (cell.character.IsFullWidth()) {
			cell.attributes.state |= A_WIDTH;
			// attributes of the second, "invisible" cell must be
			// cleared to let full-width chars detection work properly
			buffer->cells[charCount++].attributes.Reset();
		}
	}

	buffer->length = charCount;
	buffer->softBreak = line->softBreak;
	buffer->attributes = line->attributes;

	return buffer;
}


void
HistoryBuffer::AddLine(const TerminalLine* line)
{
//debug_printf("HistoryBuffer::AddLine(%p): length: %d\n", line, line->length);
	// determine the amount of memory we need for the line
	Attributes attributes;
	int32 attributesRuns = 0;
	int32 byteLength = 0;
	for (int32 i = 0; i < line->length; i++) {
		const TerminalCell& cell = line->cells[i];
		byteLength += cell.character.ByteCount();
		if (cell != attributes) {
			attributes.state = cell.attributes.state & CHAR_ATTRIBUTES;
			attributes.foreground = cell.attributes.foreground;
			attributes.background = cell.attributes.background;
			if (attributes.state != 0)
				attributesRuns++;
		}
		if (cell.attributes.IsWidth())
			i++;
	}

//debug_printf("  attributesRuns: %ld, byteLength: %ld\n", attributesRuns, byteLength);

	// allocate and translate the line
	HistoryLine* historyLine = _AllocateLine(attributesRuns, byteLength);

	attributes.Reset();
	AttributesRun* attributesRun = historyLine->AttributesRuns();

	char* chars = historyLine->Chars();
	for (int32 i = 0; i < line->length; i++) {
		const TerminalCell& cell = line->cells[i];

		// copy char
		int32 charLength = cell.character.ByteCount();
		memcpy(chars, cell.character.bytes, charLength);
		chars += charLength;

		// deal with attributes
		if (cell != attributes) {
			// terminate the previous attributes run
			if (attributes.state != 0) {
				attributesRun->length = i - attributesRun->offset;
				attributesRun++;
			}

			attributes.state = cell.attributes.state & CHAR_ATTRIBUTES;
			attributes.foreground = cell.attributes.foreground;
			attributes.background = cell.attributes.background;

			// init the new one
			if (attributes.state != 0) {
				attributesRun->attributes = attributes;
				attributesRun->offset = i;
			}
		}

		if (cell.attributes.IsWidth())
			i++;
	}

	// set the last attributes run's length
	if (attributes.state != 0)
		attributesRun->length = line->length - attributesRun->offset;

	historyLine->softBreak = line->softBreak;
	historyLine->attributes = line->attributes;
//debug_printf("  line: \"%.*s\", history size now: %ld\n", historyLine->byteLength, historyLine->Chars(), fSize);
}


void
HistoryBuffer::AddEmptyLines(int32 count)
{
	if (count <= 0)
		return;

	if (count > fCapacity)
		count = fCapacity;

	if (count + fSize > fCapacity)
		DropLines(count + fSize - fCapacity);

	// All lines use the same buffer address, since they don't use any memory.
	AttributesRun* attributesRun
		= (AttributesRun*)(fBuffer + fBufferAllocationOffset);

	for (int32 i = 0; i < count; i++) {
		HistoryLine* line = &fLines[fNextLine];
		fNextLine = (fNextLine + 1) % fCapacity;
		line->attributesRuns = attributesRun;
		line->attributesRunCount = 0;
		line->byteLength = 0;
		line->softBreak = false;
	}

	fSize += count;
}


void
HistoryBuffer::DropLines(int32 count)
{
	if (count <= 0)
		return;

	if (count < fSize) {
		fSize -= count;
	} else {
		fSize = 0;
		fNextLine = 0;
		fBufferAllocationOffset = 0;
	}
}


HistoryLine*
HistoryBuffer::_AllocateLine(int32 attributesRuns, int32 byteLength)
{
	// we need at least one spare line slot
	int32 toDrop = 0;
	if (fSize == fCapacity)
		toDrop = 1;

	int32 bytesNeeded = attributesRuns * sizeof(AttributesRun) + byteLength;

	if (fBufferAllocationOffset + bytesNeeded > fBufferSize) {
		// drop all lines after the allocation index
		for (; toDrop < fSize; toDrop++) {
			HistoryLine* line = _LineAt(fSize - toDrop - 1);
			int32 offset = (uint8*)line->AttributesRuns() - fBuffer;
			if (offset < fBufferAllocationOffset)
				break;
		}

		fBufferAllocationOffset = 0;
	}

	// drop all lines interfering
	int32 nextOffset = (fBufferAllocationOffset + bytesNeeded + 1) & ~1;
	for (; toDrop < fSize; toDrop++) {
		HistoryLine* line = _LineAt(fSize - toDrop - 1);
		int32 offset = (uint8*)line->AttributesRuns() - fBuffer;
		if (offset + line->BufferSize() <= fBufferAllocationOffset
				|| offset >= nextOffset) {
			break;
		}
	}

	DropLines(toDrop);

	// init the line
	HistoryLine* line = &fLines[fNextLine];
	fNextLine = (fNextLine + 1) % fCapacity;
	fSize++;
	line->attributesRuns = (AttributesRun*)(fBuffer + fBufferAllocationOffset);
	line->attributesRunCount = attributesRuns;
	line->byteLength = byteLength;

	fBufferAllocationOffset = (fBufferAllocationOffset + bytesNeeded + 1) & ~1;
		// DropLines() may have changed fBufferAllocationOffset, so don't use
		// nextOffset.

	return line;
}