/*
 * Copyright 2013-2023, 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
 *		Simon South, simon@simonsouth.net
 *		Siarzhuk Zharski, zharik@gmx.li
 */

#include "TerminalBuffer.h"

#include <algorithm>

#include <Message.h>

#include "Colors.h"
#include "TermApp.h"
#include "TermConst.h"


// #pragma mark - public methods


TerminalBuffer::TerminalBuffer()
	:
	BLocker("terminal buffer"),
	fEncoding(M_UTF8),
	fAlternateScreen(NULL),
	fAlternateHistory(NULL),
	fAlternateScreenOffset(0),
	fAlternateAttributes(),
	fColorsPalette(NULL),
	fListenerValid(false),
	fMode(MODE_INTERPRET_META_KEY | MODE_META_KEY_SENDS_ESCAPE | MODE_CURSOR_BLINKING),
	fCursorStyle(BLOCK_CURSOR),
	fNextOSCRef(1)
{
}


TerminalBuffer::~TerminalBuffer()
{
	free(fAlternateScreen);
	delete fAlternateHistory;
	delete[] fColorsPalette;

	HyperLinkRefMap::Iterator iterator = fHyperLinkForRef.GetIterator();
	while (iterator.HasNext()) {
		HyperLinkRefMap::Entry entry = iterator.Next();
		delete entry.value;
	}
	fHyperLinkForID.Clear();
	fHyperLinkForRef.Clear();
}


status_t
TerminalBuffer::Init(int32 width, int32 height, int32 historySize)
{
	if (BLocker::InitCheck() < 0)
		return BLocker::InitCheck();

	fAlternateScreen = _AllocateLines(width, height);
	if (fAlternateScreen == NULL)
		return B_NO_MEMORY;

	for (int32 i = 0; i < height; i++)
		fAlternateScreen[i]->Clear();

	fColorsPalette = new(std::nothrow) rgb_color[kTermColorCount];
	if (fColorsPalette == NULL)
		return B_NO_MEMORY;

	for (uint i = 0; i < kTermColorCount; i++)
		fColorsPalette[i] = TermApp::DefaultPalette()[i];

	return BasicTerminalBuffer::Init(width, height, historySize);
}


void
TerminalBuffer::SetListener(BMessenger listener)
{
	fListener = listener;
	fListenerValid = true;
}


void
TerminalBuffer::UnsetListener()
{
	fListenerValid = false;
}


int
TerminalBuffer::Encoding() const
{
	return fEncoding;
}


bool
TerminalBuffer::IsMode(uint32 mode) const
{
	return (fMode & mode) != 0;
}


void
TerminalBuffer::SetMode(uint32 mode)
{
	fMode |= mode;
	if (fListenerValid && (mode & MODE_CURSOR_BLINKING) != 0)
		fListener.SendMessage(MSG_SET_CURSOR_STYLE);
}


void
TerminalBuffer::ResetMode(uint32 mode)
{
	fMode &= ~mode;
	if (fListenerValid && (mode & MODE_CURSOR_BLINKING) != 0)
		fListener.SendMessage(MSG_SET_CURSOR_STYLE);
}


void
TerminalBuffer::SetEncoding(int encoding)
{
	fEncoding = encoding;
}


void
TerminalBuffer::SetTitle(const char* title)
{
	if (fListenerValid) {
		BMessage message(MSG_SET_TERMINAL_TITLE);
		message.AddString("title", title);
		fListener.SendMessage(&message);
	}
}


void
TerminalBuffer::SetColors(uint8* indexes, rgb_color* colors,
		int32 count, bool dynamic)
{
	if (fListenerValid) {
		BMessage message(MSG_SET_TERMINAL_COLORS);
		message.AddInt32("count", count);
		message.AddBool("dynamic", dynamic);
		message.AddData("index", B_UINT8_TYPE,
					indexes, sizeof(uint8), true, count);
		message.AddData("color", B_RGB_COLOR_TYPE,
					colors, sizeof(rgb_color), true, count);

		for (int i = 1; i < count; i++) {
			message.AddData("index", B_UINT8_TYPE, &indexes[i], sizeof(uint8));
			message.AddData("color", B_RGB_COLOR_TYPE, &colors[i],
					sizeof(rgb_color));
		}

		fListener.SendMessage(&message);
	}
}


void
TerminalBuffer::ResetColors(uint8* indexes, int32 count, bool dynamic)
{
	if (fListenerValid) {
		BMessage message(MSG_RESET_TERMINAL_COLORS);
		message.AddInt32("count", count);
		message.AddBool("dynamic", dynamic);
		message.AddData("index", B_UINT8_TYPE,
					indexes, sizeof(uint8), true, count);

		for (int i = 1; i < count; i++)
			message.AddData("index", B_UINT8_TYPE, &indexes[i], sizeof(uint8));

		fListener.SendMessage(&message);
	}
}


void
TerminalBuffer::GetColor(uint8 index)
{
	if (fListenerValid) {
		BMessage message(MSG_GET_TERMINAL_COLOR);
		message.AddUInt8("index", index);
		fListener.SendMessage(&message);
	}
}


void
TerminalBuffer::SetCursorStyle(int32 style)
{
	fCursorStyle = style;
}


void
TerminalBuffer::SetPaletteColor(uint8 index, rgb_color color)
{
	fColorsPalette[index] = color;
}


void
TerminalBuffer::NotifyQuit(int32 reason)
{
	if (fListenerValid) {
		BMessage message(MSG_QUIT_TERMNAL);
		message.AddInt32("reason", reason);
		fListener.SendMessage(&message);
	}
}


void
TerminalBuffer::NotifyListener()
{
	if (fListenerValid)
		fListener.SendMessage(MSG_TERMINAL_BUFFER_CHANGED);
}


status_t
TerminalBuffer::ResizeTo(int32 width, int32 height)
{
	int32 historyCapacity = 0;
	if (!fAlternateScreenActive)
		historyCapacity = HistoryCapacity();
	else if (fAlternateHistory != NULL)
		historyCapacity = fAlternateHistory->Capacity();

	return ResizeTo(width, height, historyCapacity);
}


status_t
TerminalBuffer::ResizeTo(int32 width, int32 height, int32 historyCapacity)
{
	// switch to the normal screen buffer first
	bool alternateScreenActive = fAlternateScreenActive;
	if (alternateScreenActive)
		_SwitchScreenBuffer();

	int32 oldWidth = fWidth;
	int32 oldHeight = fHeight;

	// Resize the normal screen buffer/history.
	status_t error = BasicTerminalBuffer::ResizeTo(width, height,
		historyCapacity);
	if (error != B_OK) {
		if (alternateScreenActive)
			_SwitchScreenBuffer();
		return error;
	}

	// Switch to the alternate screen buffer and resize it.
	if (fAlternateScreen != NULL) {
		TermPos cursor = fCursor;
		fCursor.SetTo(0, 0);
		fWidth = oldWidth;
		fHeight = oldHeight;

		_SwitchScreenBuffer();

		error = BasicTerminalBuffer::ResizeTo(width, height, 0);

		fWidth = width;
		fHeight = height;
		fCursor = cursor;

		// Switch back.
		if (!alternateScreenActive)
			_SwitchScreenBuffer();

		if (error != B_OK) {
			// This sucks -- we can't do anything about it. Delete the
			// alternate screen buffer.
			_FreeLines(fAlternateScreen, oldHeight);
			fAlternateScreen = NULL;
		}
	}

	return error;
}


void
TerminalBuffer::UseAlternateScreenBuffer(bool clear)
{
	if (fAlternateScreenActive || fAlternateScreen == NULL)
		return;

	_SwitchScreenBuffer();

	if (clear)
		Clear(false);

	_InvalidateAll();
}


void
TerminalBuffer::UseNormalScreenBuffer()
{
	if (!fAlternateScreenActive)
		return;

	_SwitchScreenBuffer();
	_InvalidateAll();
}


void
TerminalBuffer::_SwitchScreenBuffer()
{
	std::swap(fScreen, fAlternateScreen);
	std::swap(fHistory, fAlternateHistory);
	std::swap(fScreenOffset, fAlternateScreenOffset);
	std::swap(fAttributes, fAlternateAttributes);
	fAlternateScreenActive = !fAlternateScreenActive;
}


uint32
TerminalBuffer::PutHyperLink(const char* id, BString& uri)
{
	HyperLink* hyperLink = NULL;
	if (id != NULL)
		hyperLink = fHyperLinkForID.Get(id);
	if (hyperLink == NULL) {
		hyperLink = new (std::nothrow) HyperLink(uri, fNextOSCRef++, id);
		if (id != NULL)
			fHyperLinkForID.Put(id, hyperLink);
		HyperLink* oldHyperLink = fHyperLinkForRef.Get(hyperLink->OSCRef());
		fHyperLinkForRef.Put(hyperLink->OSCRef(), hyperLink);
		delete oldHyperLink;
	}
	return hyperLink->OSCRef();
}


bool
TerminalBuffer::GetHyperLink(uint32 ref, HyperLink &_link)
{
	HyperLink* hyperLink = fHyperLinkForRef.Get(ref);
	if (hyperLink == NULL) {
		return false;
	}
	_link = *hyperLink;
	return true;
}