/*
 * Copyright 2001-2024, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		DarkWyrm <bpmagic@columbus.rr.com>
 */


/*!	Handles the system's cursor infrastructure */


#include "CursorManager.h"

#include "ServerCursor.h"
#include "ServerConfig.h"
#include "ServerTokenSpace.h"

#include <Autolock.h>
#include <Directory.h>
#include <String.h>
#include <IconUtils.h>

#include <agg_pixfmt_rgba.h>
#include <agg_blur.h>

#include <new>
#include <stdio.h>

#include "CursorData.cpp"


CursorManager::CursorManager()
	:
	BLocker("CursorManager")
{
}


CursorManager::~CursorManager()
{
	ReleaseCursors();
}


void
CursorManager::InitializeCursors(float scale)
{
	if (scale < 1.0)
		scale = 1.0;

	const BPoint kHandHotspot(1, 1);
	const BPoint kResizeHotspot(8, 8);

	struct StandardCursor {
		ServerCursor*& member;
		BCursorID id;
		const uint8* data;
		uint32 dataLength;
		BPoint hotspot;

#define C(IDNAME, NAME, HOTSPOT) {fCursor##NAME, B_CURSOR_ID_##IDNAME, \
		kCursor##NAME, B_COUNT_OF(kCursor##NAME), HOTSPOT}
	} standardCursors[] = {
		{fCursorNoCursor, B_CURSOR_ID_NO_CURSOR, NULL, 0, BPoint(0, 0)},

		C(SYSTEM_DEFAULT,	SystemDefault,	kHandHotspot),
		C(CONTEXT_MENU,		ContextMenu,	kHandHotspot),
		C(COPY,				Copy,			kHandHotspot),
		C(CREATE_LINK,		CreateLink,		kHandHotspot),
		C(CROSS_HAIR,		CrossHair,		BPoint(10, 10)),
		C(FOLLOW_LINK,		FollowLink,		BPoint(5, 0)),
		C(GRAB,				Grab,			kHandHotspot),
		C(GRABBING,			Grabbing,		kHandHotspot),
		C(HELP,				Help,			BPoint(0, 8)),
		C(I_BEAM,			IBeam,			BPoint(7, 9)),
		C(I_BEAM_HORIZONTAL, IBeamHorizontal, BPoint(8, 8)),
		C(MOVE,				Move,			kResizeHotspot),
		C(NOT_ALLOWED,		NotAllowed,		BPoint(8, 8)),
		C(PROGRESS,			Progress,		BPoint(7, 10)),
		C(RESIZE_EAST,		ResizeEast,		kResizeHotspot),
		C(RESIZE_EAST_WEST, ResizeEastWest, kResizeHotspot),
		C(RESIZE_NORTH,		ResizeNorth,	kResizeHotspot),
		C(RESIZE_NORTH_EAST, ResizeNorthEast, kResizeHotspot),
		C(RESIZE_NORTH_EAST_SOUTH_WEST, ResizeNorthEastSouthWest, kResizeHotspot),
		C(RESIZE_NORTH_SOUTH, ResizeNorthSouth, kResizeHotspot),
		C(RESIZE_NORTH_WEST, ResizeNorthWest, kResizeHotspot),
		C(RESIZE_NORTH_WEST_SOUTH_EAST, ResizeNorthWestSouthEast, kResizeHotspot),
		C(RESIZE_SOUTH,		ResizeSouth,	kResizeHotspot),
		C(RESIZE_SOUTH_EAST, ResizeSouthEast, kResizeHotspot),
		C(RESIZE_SOUTH_WEST, ResizeSouthWest, kResizeHotspot),
		C(RESIZE_WEST,		ResizeWest,		kResizeHotspot),
		C(ZOOM_IN,			ZoomIn,			BPoint(6, 6)),
		C(ZOOM_OUT,			ZoomOut,		BPoint(6, 6))
	};
#undef C

	for (size_t i = 0; i < B_COUNT_OF(standardCursors); i++) {
		const StandardCursor& info = standardCursors[i];
		_InitCursor(info.member, info.id, info.data, info.dataLength, info.hotspot, scale);
	}
}


void
CursorManager::ReleaseCursors()
{
	for (int32 i = 0; i < fCursorList.CountItems(); i++) {
		ServerCursor* cursor = ((ServerCursor*)fCursorList.ItemAtFast(i));
		cursor->fManager = NULL;
		fTokenSpace.RemoveToken(cursor->Token());
		cursor->ReleaseReference();
	}
	fCursorList.MakeEmpty();
}


ServerCursor*
CursorManager::CreateCursor(team_id clientTeam, const uint8* cursorData)
{
	if (!Lock())
		return NULL;

	ServerCursorReference cursor(_FindCursor(clientTeam, cursorData), false);

	if (!cursor) {
		cursor.SetTo(new (std::nothrow) ServerCursor(cursorData), true);
		if (cursor) {
			cursor->SetOwningTeam(clientTeam);
			if (AddCursor(cursor) < B_OK)
				cursor = NULL;
		}
	}

	Unlock();

	return cursor.Detach();
}


ServerCursor*
CursorManager::CreateCursor(team_id clientTeam, BRect r, color_space format,
	int32 flags, BPoint hotspot, int32 bytesPerRow)
{
	if (!Lock())
		return NULL;

	ServerCursor* cursor = new (std::nothrow) ServerCursor(r, format, flags,
		hotspot, bytesPerRow);
	if (cursor != NULL) {
		cursor->SetOwningTeam(clientTeam);
		if (AddCursor(cursor) < B_OK) {
			delete cursor;
			cursor = NULL;
		}
	}

	Unlock();

	return cursor;
}


/*!	\brief Registers a cursor with the manager.
	\param cursor ServerCursor object to register
	\return The token assigned to the cursor or B_ERROR if cursor is NULL
*/
int32
CursorManager::AddCursor(ServerCursor* cursor, int32 token)
{
	if (cursor == NULL)
		return B_BAD_VALUE;
	if (!Lock())
		return B_ERROR;

	ServerCursor* oldCursor = FindCursor(token);
	if (oldCursor != NULL) {
		fCursorList.ReplaceItem(fCursorList.IndexOf(oldCursor), cursor);
		oldCursor->ReleaseReference();
	} else {
		if (!fCursorList.AddItem(cursor)) {
			Unlock();
			return B_NO_MEMORY;
		}
	}

	if (token == -1)
		token = fTokenSpace.NewToken(kCursorToken, cursor);
	else
		fTokenSpace.SetToken(token, kCursorToken, cursor);

	cursor->fToken = token;
	cursor->AttachedToManager(this);

	Unlock();
	return token;
}


/*!	\brief Removes a cursor.

	If this was the last reference to this cursor, it will be deleted.
*/
void
CursorManager::RemoveCursor(ServerCursor* cursor)
{
	if (!Lock())
		return;

	_RemoveCursor(cursor);
	cursor->ReleaseReference();

	Unlock();
}


/*!	\brief Removes and deletes all of an application's cursors
	\param signature Signature to which the cursors belong
*/
void
CursorManager::DeleteCursors(team_id team)
{
	if (!Lock())
		return;

	for (int32 index = fCursorList.CountItems(); index-- > 0;) {
		ServerCursor* cursor = (ServerCursor*)fCursorList.ItemAtFast(index);
		if (cursor->OwningTeam() != team)
			continue;

		_RemoveCursor(cursor);
		cursor->ReleaseReference();
	}

	Unlock();
}


/*!	\brief Sets all the cursors from a specified CursorSet
	\param path Path to the cursor set

	All cursors in the set will be assigned. If the set does not specify a
	cursor for a particular cursor specifier, it will remain unchanged.
	This function will fail if passed a NULL path, an invalid path, or the
	path to a non-CursorSet file.
*/
void
CursorManager::SetCursorSet(const char* path)
{
	BAutolock locker (this);

	CursorSet cursorSet(NULL);

	if (!path || cursorSet.Load(path) != B_OK)
		return;

	_LoadCursor(fCursorSystemDefault, cursorSet, B_CURSOR_ID_SYSTEM_DEFAULT);
	_LoadCursor(fCursorContextMenu, cursorSet, B_CURSOR_ID_CONTEXT_MENU);
	_LoadCursor(fCursorCopy, cursorSet, B_CURSOR_ID_COPY);
	_LoadCursor(fCursorCreateLink, cursorSet, B_CURSOR_ID_CREATE_LINK);
	_LoadCursor(fCursorCrossHair, cursorSet, B_CURSOR_ID_CROSS_HAIR);
	_LoadCursor(fCursorFollowLink, cursorSet, B_CURSOR_ID_FOLLOW_LINK);
	_LoadCursor(fCursorGrab, cursorSet, B_CURSOR_ID_GRAB);
	_LoadCursor(fCursorGrabbing, cursorSet, B_CURSOR_ID_GRABBING);
	_LoadCursor(fCursorHelp, cursorSet, B_CURSOR_ID_HELP);
	_LoadCursor(fCursorIBeam, cursorSet, B_CURSOR_ID_I_BEAM);
	_LoadCursor(fCursorIBeamHorizontal, cursorSet,
		B_CURSOR_ID_I_BEAM_HORIZONTAL);
	_LoadCursor(fCursorMove, cursorSet, B_CURSOR_ID_MOVE);
	_LoadCursor(fCursorNotAllowed, cursorSet, B_CURSOR_ID_NOT_ALLOWED);
	_LoadCursor(fCursorProgress, cursorSet, B_CURSOR_ID_PROGRESS);
	_LoadCursor(fCursorResizeEast, cursorSet, B_CURSOR_ID_RESIZE_EAST);
	_LoadCursor(fCursorResizeEastWest, cursorSet,
		B_CURSOR_ID_RESIZE_EAST_WEST);
	_LoadCursor(fCursorResizeNorth, cursorSet, B_CURSOR_ID_RESIZE_NORTH);
	_LoadCursor(fCursorResizeNorthEast, cursorSet,
		B_CURSOR_ID_RESIZE_NORTH_EAST);
	_LoadCursor(fCursorResizeNorthEastSouthWest, cursorSet,
		B_CURSOR_ID_RESIZE_NORTH_EAST_SOUTH_WEST);
	_LoadCursor(fCursorResizeNorthSouth, cursorSet,
		B_CURSOR_ID_RESIZE_NORTH_SOUTH);
	_LoadCursor(fCursorResizeNorthWest, cursorSet,
		B_CURSOR_ID_RESIZE_NORTH_WEST);
	_LoadCursor(fCursorResizeNorthWestSouthEast, cursorSet,
		B_CURSOR_ID_RESIZE_NORTH_WEST_SOUTH_EAST);
	_LoadCursor(fCursorResizeSouth, cursorSet, B_CURSOR_ID_RESIZE_SOUTH);
	_LoadCursor(fCursorResizeSouthEast, cursorSet,
		B_CURSOR_ID_RESIZE_SOUTH_EAST);
	_LoadCursor(fCursorResizeSouthWest, cursorSet,
		B_CURSOR_ID_RESIZE_SOUTH_WEST);
	_LoadCursor(fCursorResizeWest, cursorSet, B_CURSOR_ID_RESIZE_WEST);
	_LoadCursor(fCursorZoomIn, cursorSet, B_CURSOR_ID_ZOOM_IN);
	_LoadCursor(fCursorZoomOut, cursorSet, B_CURSOR_ID_ZOOM_OUT);
}


/*!	\brief Acquire the cursor which is used for a particular system cursor
	\param which Which system cursor to get
	\return Pointer to the particular cursor used or NULL if which is
	invalid or the cursor has not been assigned
*/
ServerCursor*
CursorManager::GetCursor(BCursorID which)
{
	BAutolock locker(this);

	switch (which) {
		case B_CURSOR_ID_SYSTEM_DEFAULT:
			return fCursorSystemDefault;
		case B_CURSOR_ID_CONTEXT_MENU:
			return fCursorContextMenu;
		case B_CURSOR_ID_COPY:
			return fCursorCopy;
		case B_CURSOR_ID_CREATE_LINK:
			return fCursorCreateLink;
		case B_CURSOR_ID_CROSS_HAIR:
			return fCursorCrossHair;
		case B_CURSOR_ID_FOLLOW_LINK:
			return fCursorFollowLink;
		case B_CURSOR_ID_GRAB:
			return fCursorGrab;
		case B_CURSOR_ID_GRABBING:
			return fCursorGrabbing;
		case B_CURSOR_ID_HELP:
			return fCursorHelp;
		case B_CURSOR_ID_I_BEAM:
			return fCursorIBeam;
		case B_CURSOR_ID_I_BEAM_HORIZONTAL:
			return fCursorIBeamHorizontal;
		case B_CURSOR_ID_MOVE:
			return fCursorMove;
		case B_CURSOR_ID_NO_CURSOR:
			return fCursorNoCursor;
		case B_CURSOR_ID_NOT_ALLOWED:
			return fCursorNotAllowed;
		case B_CURSOR_ID_PROGRESS:
			return fCursorProgress;
		case B_CURSOR_ID_RESIZE_EAST:
			return fCursorResizeEast;
		case B_CURSOR_ID_RESIZE_EAST_WEST:
			return fCursorResizeEastWest;
		case B_CURSOR_ID_RESIZE_NORTH:
			return fCursorResizeNorth;
		case B_CURSOR_ID_RESIZE_NORTH_EAST:
			return fCursorResizeNorthEast;
		case B_CURSOR_ID_RESIZE_NORTH_EAST_SOUTH_WEST:
			return fCursorResizeNorthEastSouthWest;
		case B_CURSOR_ID_RESIZE_NORTH_SOUTH:
			return fCursorResizeNorthSouth;
		case B_CURSOR_ID_RESIZE_NORTH_WEST:
			return fCursorResizeNorthWest;
		case B_CURSOR_ID_RESIZE_NORTH_WEST_SOUTH_EAST:
			return fCursorResizeNorthWestSouthEast;
		case B_CURSOR_ID_RESIZE_SOUTH:
			return fCursorResizeSouth;
		case B_CURSOR_ID_RESIZE_SOUTH_EAST:
			return fCursorResizeSouthEast;
		case B_CURSOR_ID_RESIZE_SOUTH_WEST:
			return fCursorResizeSouthWest;
		case B_CURSOR_ID_RESIZE_WEST:
			return fCursorResizeWest;
		case B_CURSOR_ID_ZOOM_IN:
			return fCursorZoomIn;
		case B_CURSOR_ID_ZOOM_OUT:
			return fCursorZoomOut;

		default:
			return NULL;
	}
}


/*!	\brief Internal function which finds the cursor with a particular ID
	\param token ID of the cursor to find
	\return The cursor or NULL if not found
*/
ServerCursor*
CursorManager::FindCursor(int32 token)
{
	if (!Lock())
		return NULL;

	ServerCursor* cursor;
	if (fTokenSpace.GetToken(token, kCursorToken, (void**)&cursor) != B_OK)
		cursor = NULL;

	Unlock();

	return cursor;
}


BBitmap
CursorManager::_RenderVectorCursor(uint32 size, const uint8* vector,
	uint32 vectorSize, float shadowStrength)
{
	const uint32 flags = B_BITMAP_NO_SERVER_LINK;

	// The cursor HVIFs need to be rendered at an equivalent of 32x32,
	// with everything outside the 22x22 area discarded.
	const int32 renderRectSize = (int32)(size * (32.0f / 22.0f));

	BBitmap renderCursor(BRect(0, 0, renderRectSize - 1, renderRectSize - 1), flags, B_RGBA32);
	status_t status = BIconUtils::GetVectorIcon(vector, vectorSize, &renderCursor);
	if (status != B_OK) {
		BBitmap fallback(BRect(0, 0, 21, 21), B_BITMAP_NO_SERVER_LINK, B_RGBA32);
		fallback.SetBits(kCursorFallbackBits, 22 * 22 * 4, 0, B_RGBA32);
		return fallback;
	}

	const BRect rect(0, 0, size - 1, size - 1);
	BBitmap cursor(rect, flags, B_RGBA32);
	cursor.ImportBits(&renderCursor, B_ORIGIN, B_ORIGIN, rect.Size());

	BBitmap shadow(rect, flags, B_RGBA32);
	memset(shadow.Bits(), 0, shadow.BitsLength());

	{
		int32 offset = size / 32;
		if (offset == 0)
			offset = 1; // <32px cursors

		shadow.ImportBits(&cursor, BPoint(0, 0), BPoint(offset, offset),
			BSize(size - offset - 1, size - offset - 1));

		agg::rendering_buffer buffer((unsigned char*)shadow.Bits(),
			size, size, shadow.BytesPerRow());
		agg::pixfmt_rgba32 pixFmt(buffer);

		agg::recursive_blur<agg::rgba8, agg::recursive_blur_calc_rgba<> > blur;
		blur.blur(pixFmt, 1);

		for (int32 i = 0; i < shadow.BitsLength(); i += 4) {
			uint8* bits = (uint8*)shadow.Bits() + i;
			bits[0] = 0;
			bits[1] = 0;
			bits[2] = 0;
			bits[3] = (uint8)(bits[3] * shadowStrength);
		}
	}

	BBitmap composite(rect, flags, B_RGBA32);

	uint8* s = (uint8*)shadow.Bits();
	uint8* c = (uint8*)cursor.Bits();
	uint8* d = (uint8*)composite.Bits();
	for (uint32 y = 0; y < size; y++) {
		for (uint32 x = 0; x < size; x++) {
			uint8 a = (uint8)(c[3] + (255 - c[3]) * (s[3] / 255.0));
			d[3] = a;
			for (int32 i = 0; i < 3; ++i) {
				d[i] = ((s[i] * (255 - c[3]) + 255) >> 8) + c[i];

				// premultiply
				d[i] = (uint8)(d[i] * int32(a) / 255.0);
			}
			s += 4;
			c += 4;
			d += 4;
		}
	}

	return composite;
}


/*!	\brief Initializes a predefined system cursor.

	This method must only be called in the CursorManager's constructor,
	as it may throw exceptions.
*/
void
CursorManager::_InitCursor(ServerCursor*& cursorMember, BCursorID id,
	const uint8* vector, uint32 vectorSize, const BPoint& hotSpot, float scale)
{
	int32 cursorSize = (int32)(22 * scale);
	float shadow = 3 / 10.0;
	BPoint scaledHotspot((int32)(hotSpot.x * scale), (int32)(hotSpot.y * scale));

	if (vector != NULL) {
		BBitmap bitmap = _RenderVectorCursor(cursorSize, vector, vectorSize, shadow);
		cursorMember = new ServerCursor((uint8*)bitmap.Bits(), cursorSize,
			cursorSize, bitmap.ColorSpace());
	} else {
		const unsigned char noCursor[] = {0x00, 0x00, 0x00, 0x00};
		cursorMember = new ServerCursor(noCursor, 1, 1, B_RGBA32);
	}

	cursorMember->SetHotSpot(scaledHotspot);
	AddCursor(cursorMember, id);
}


void
CursorManager::_LoadCursor(ServerCursor*& cursorMember, const CursorSet& set,
	BCursorID id)
{
	ServerCursor* cursor;
	if (set.FindCursor(id, &cursor) == B_OK) {
		AddCursor(cursor, id);
		cursorMember = cursor;
	}
}


ServerCursor*
CursorManager::_FindCursor(team_id clientTeam, const uint8* cursorData)
{
	int32 count = fCursorList.CountItems();
	for (int32 i = 0; i < count; i++) {
		ServerCursor* cursor = (ServerCursor*)fCursorList.ItemAtFast(i);
		if (cursor->OwningTeam() == clientTeam
			&& cursor->CursorData()
			&& memcmp(cursor->CursorData(), cursorData, 68) == 0) {
			return cursor;
		}
	}
	return NULL;
}


void
CursorManager::_RemoveCursor(ServerCursor* cursor)
{
	fCursorList.RemoveItem(cursor);
	fTokenSpace.RemoveToken(cursor->fToken);
	cursor->fToken = -1;
}