/*
 * Copyright 2014-2015, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Adrien Destugues <pulkomandy@pulkomandy.tk>
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Julian Harnath <julian.harnath@rwth-aachen.de>
 */


#include "AlphaMask.h"

#include "AlphaMaskCache.h"
#include "BitmapHWInterface.h"
#include "BitmapManager.h"
#include "Canvas.h"
#include "DrawingEngine.h"
#include "PictureBoundingBoxPlayer.h"
#include "ServerBitmap.h"
#include "ServerPicture.h"
#include "Shape.h"
#include "ShapePrivate.h"

#include <AutoLocker.h>


// #pragma mark - AlphaMask


AlphaMask::AlphaMask(AlphaMask* previousMask, bool inverse)
	:
	fPreviousMask(previousMask),
	fBounds(),
	fClippedToCanvas(true),
	fCanvasOrigin(),
	fCanvasBounds(),
	fInverse(inverse),
	fBackgroundOpacity(0),
	fNextMaskCount(0),
	fInCache(false),
	fIndirectCacheReferences(0),
	fBits(NULL),
	fBuffer(),
	fMask(),
	fScanline(fMask)
{
	recursive_lock_init(&fLock, "AlphaMask");

	if (previousMask != NULL)
		atomic_add(&previousMask->fNextMaskCount, 1);

	_SetOutsideOpacity();
}


AlphaMask::AlphaMask(AlphaMask* previousMask, AlphaMask* other)
	:
	fPreviousMask(previousMask),
	fBounds(other->fBounds),
	fClippedToCanvas(other->fClippedToCanvas),
	fCanvasOrigin(other->fCanvasOrigin),
	fCanvasBounds(other->fCanvasBounds),
	fInverse(other->fInverse),
	fBackgroundOpacity(other->fBackgroundOpacity),
	fNextMaskCount(0),
	fInCache(false),
	fIndirectCacheReferences(0),
	fBits(other->fBits),
	fBuffer(other->fBuffer),
	fMask(other->fMask),
	fScanline(fMask)
{
	recursive_lock_init(&fLock, "AlphaMask");

	fMask.attach(fBuffer);

	if (previousMask != NULL)
		atomic_add(&previousMask->fNextMaskCount, 1);

	_SetOutsideOpacity();
}


AlphaMask::AlphaMask(uint8 backgroundOpacity)
	:
	fPreviousMask(),
	fBounds(),
	fClippedToCanvas(true),
	fCanvasOrigin(),
	fCanvasBounds(),
	fInverse(false),
	fBackgroundOpacity(backgroundOpacity),
	fNextMaskCount(0),
	fInCache(false),
	fIndirectCacheReferences(0),
	fBits(NULL),
	fBuffer(),
	fMask(),
	fScanline(fMask)
{
	recursive_lock_init(&fLock, "AlphaMask");

	_SetOutsideOpacity();
}


AlphaMask::~AlphaMask()
{
	if (fPreviousMask.IsSet())
		atomic_add(&fPreviousMask->fNextMaskCount, -1);

	recursive_lock_destroy(&fLock);
}


IntPoint
AlphaMask::SetCanvasGeometry(IntPoint origin, IntRect bounds)
{
	RecursiveLocker locker(fLock);

	if (origin == fCanvasOrigin && bounds.Width() == fCanvasBounds.Width()
		&& bounds.Height() == fCanvasBounds.Height())
		return fCanvasOrigin;

	IntPoint oldOrigin = fCanvasOrigin;
	fCanvasOrigin = origin;
	IntRect oldBounds = fCanvasBounds;
	fCanvasBounds = IntRect(0, 0, bounds.Width(), bounds.Height());

	if (fPreviousMask != NULL)
		fPreviousMask->SetCanvasGeometry(origin, bounds);

	if (fClippedToCanvas && (fCanvasBounds.Width() > oldBounds.Width()
		|| fCanvasBounds.Height() > oldBounds.Height())) {
		// The canvas is now larger than before and we previously
		// drew the alpha mask clipped to the (old) bounds of the
		// canvas. So we now have to redraw the alpha mask with the
		// new size.
		_Generate();
	}

	_AttachMaskToBuffer();

	return oldOrigin;
}


size_t
AlphaMask::BitmapSize() const
{
	return fBits->BitsLength();
}


ServerBitmap*
AlphaMask::_CreateTemporaryBitmap(BRect bounds) const
{
	BReference<UtilityBitmap> bitmap(new(std::nothrow) UtilityBitmap(bounds,
		B_RGBA32, 0), true);
	if (bitmap == NULL)
		return NULL;

	if (!bitmap->IsValid())
		return NULL;

	memset(bitmap->Bits(), fBackgroundOpacity, bitmap->BitsLength());

	return bitmap.Detach();
}


void
AlphaMask::_Generate()
{
	RecursiveLocker locker(fLock);
	RecursiveLocker previousLocker;
	if (fPreviousMask != NULL)
		previousLocker.SetTo(fPreviousMask->fLock, false);

	ServerBitmap* const bitmap = _RenderSource(fCanvasBounds);
	BReference<ServerBitmap> bitmapRef(bitmap, true);
	if (bitmap == NULL) {
		_SetNoClipping();
		return;
	}

	fBits.SetTo(new(std::nothrow) UtilityBitmap(fBounds, B_GRAY8, 0), true);
	if (fBits == NULL)
		return;

	const int32 width = fBits->Width();
	const int32 height = fBits->Height();
	uint8* source = bitmap->Bits();
	uint8* destination = fBits->Bits();
	uint32 numPixels = width * height;

	if (fPreviousMask != NULL) {
		uint8 previousOutsideOpacity = fPreviousMask->OutsideOpacity();

		if (fPreviousMask->fBounds.Intersects(fBounds)) {
			IntRect previousBounds(fBounds.OffsetByCopy(
				-fPreviousMask->fBounds.left, -fPreviousMask->fBounds.top));
			if (previousBounds.right > fPreviousMask->fBounds.Width())
				previousBounds.right = fPreviousMask->fBounds.Width();
			if (previousBounds.bottom > fPreviousMask->fBounds.Height())
				previousBounds.bottom = fPreviousMask->fBounds.Height();

			int32 y = previousBounds.top;

			for (; y < 0; y++) {
				for (int32 x = 0; x < width; x++) {
					*destination = (fInverse ? 255 - source[3] : source[3])
						* previousOutsideOpacity / 255;
					destination++;
					source += 4;
				}
			}

			for (; y <= previousBounds.bottom; y++) {
				int32 x = previousBounds.left;
				for (; x < 0; x++) {
					*destination = (fInverse ? 255 - source[3] : source[3])
						* previousOutsideOpacity / 255;
					destination++;
					source += 4;
				}
				uint8* previousRow = fPreviousMask->fBuffer.row_ptr(y);
				for (; x <= previousBounds.right; x++) {
					uint8 sourceAlpha = fInverse ? 255 - source[3] : source[3];
					*destination = sourceAlpha * previousRow[x] / 255;
					destination++;
					source += 4;
				}
				for (; x < previousBounds.left + width; x++) {
					*destination = (fInverse ? 255 - source[3] : source[3])
						* previousOutsideOpacity / 255;
					destination++;
					source += 4;
				}
			}

			for (; y < previousBounds.top + height; y++) {
				for (int32 x = 0; x < width; x++) {
					*destination = (fInverse ? 255 - source[3] : source[3])
						* previousOutsideOpacity / 255;
					destination++;
					source += 4;
				}
			}

		} else {
			while (numPixels--) {
				*destination = (fInverse ? 255 - source[3] : source[3])
					* previousOutsideOpacity / 255;
				destination++;
				source += 4;
			}
		}
	} else {
		while (numPixels--) {
			*destination = fInverse ? 255 - source[3] : source[3];
			destination++;
			source += 4;
		}
	}

	fBuffer.attach(fBits->Bits(), width, height, width);
	_AttachMaskToBuffer();

	_AddToCache();
}


void
AlphaMask::_SetNoClipping()
{
	fBuffer.attach(NULL, 0, 0, 0);
	_AttachMaskToBuffer();
}


const IntRect&
AlphaMask::_PreviousMaskBounds() const
{
	return fPreviousMask->fBounds;
}


void
AlphaMask::_AttachMaskToBuffer()
{
	const IntPoint maskOffset = _Offset();
	const int32 offsetX = fBounds.left + maskOffset.x + fCanvasOrigin.x;
	const int32 offsetY = fBounds.top + maskOffset.y + fCanvasOrigin.y;

	fMask.attach(fBuffer, offsetX, offsetY, fOutsideOpacity);
}


void
AlphaMask::_SetOutsideOpacity()
{
	fOutsideOpacity = fInverse ? 255 - fBackgroundOpacity
		: fBackgroundOpacity;

	if (fPreviousMask != NULL) {
		fOutsideOpacity = fOutsideOpacity * fPreviousMask->OutsideOpacity()
			/ 255;
	}
}


// #pragma mark - UniformAlphaMask


UniformAlphaMask::UniformAlphaMask(uint8 opacity)
	:
	AlphaMask(opacity)
{
	fBounds.Set(0, 0, 0, 0);
	_SetNoClipping();
}


ServerBitmap*
UniformAlphaMask::_RenderSource(const IntRect&)
{
	return NULL;
}


IntPoint
UniformAlphaMask::_Offset()
{
	return IntPoint(0, 0);
}


void
UniformAlphaMask::_AddToCache()
{
}


// #pragma mark - VectorAlphaMask


template<class VectorMaskType>
VectorAlphaMask<VectorMaskType>::VectorAlphaMask(AlphaMask* previousMask,
	BPoint where, bool inverse)
	:
	AlphaMask(previousMask, inverse),
	fWhere(where)
{
}


template<class VectorMaskType>
VectorAlphaMask<VectorMaskType>::VectorAlphaMask(AlphaMask* previousMask,
	VectorAlphaMask* other)
	:
	AlphaMask(previousMask, other),
	fWhere(other->fWhere)
{
}


template<class VectorMaskType>
ServerBitmap*
VectorAlphaMask<VectorMaskType>::_RenderSource(const IntRect& canvasBounds)
{
	fBounds = static_cast<VectorMaskType*>(this)->DetermineBoundingBox();

	if (fBounds.Width() > canvasBounds.Width()
		|| fBounds.Height() > canvasBounds.Height()) {
		fBounds = fBounds & canvasBounds;
		fClippedToCanvas = true;
	} else
		fClippedToCanvas = false;

	if (fPreviousMask != NULL) {
		if (IsInverted()) {
			if (fPreviousMask->OutsideOpacity() != 0) {
				IntRect previousBounds = _PreviousMaskBounds();
				if (previousBounds.IsValid())
					fBounds = fBounds | previousBounds;
			} else
				fBounds = _PreviousMaskBounds();
			fClippedToCanvas = fClippedToCanvas || fPreviousMask->IsClipped();
		} else if (fPreviousMask->OutsideOpacity() == 0)
			fBounds = fBounds & _PreviousMaskBounds();
	}
	if (!fBounds.IsValid())
		return NULL;

	BReference<ServerBitmap> bitmap(_CreateTemporaryBitmap(fBounds), true);
	if (bitmap == NULL)
		return NULL;

	// Render the picture to the bitmap
	BitmapHWInterface interface(bitmap);
	ObjectDeleter<DrawingEngine> engine(interface.CreateDrawingEngine());
	if (!engine.IsSet())
		return NULL;

	engine->SetRendererOffset(fBounds.left, fBounds.top);

	OffscreenCanvas canvas(engine.Get(),
		static_cast<VectorMaskType*>(this)->GetDrawState(), fBounds);

	DrawState* const drawState = canvas.CurrentState();
	drawState->SetDrawingMode(B_OP_ALPHA);
	drawState->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
	drawState->SetDrawingModeLocked(true);
	canvas.PushState();

	canvas.ResyncDrawState();

	if (engine->LockParallelAccess()) {
		BRegion clipping;
		clipping.Set((clipping_rect)fBounds);
		engine->ConstrainClippingRegion(&clipping);
		static_cast<VectorMaskType*>(this)->DrawVectors(&canvas);
		engine->UnlockParallelAccess();
	}

	canvas.PopState();

	return bitmap.Detach();
}


template<class VectorMaskType>
IntPoint
VectorAlphaMask<VectorMaskType>::_Offset()
{
	return fWhere;
}



// #pragma mark - PictureAlphaMask


PictureAlphaMask::PictureAlphaMask(AlphaMask* previousMask,
	ServerPicture* picture, const DrawState& drawState, BPoint where,
	bool inverse)
	:
	VectorAlphaMask<PictureAlphaMask>(previousMask, where, inverse),
	fPicture(picture),
	fDrawState(new(std::nothrow) DrawState(drawState))
{
}


PictureAlphaMask::~PictureAlphaMask()
{
}


void
PictureAlphaMask::DrawVectors(Canvas* canvas)
{
	fPicture->Play(canvas);
}


BRect
PictureAlphaMask::DetermineBoundingBox() const
{
	BRect boundingBox;
	PictureBoundingBoxPlayer::Play(fPicture, fDrawState.Get(), &boundingBox);

	if (!boundingBox.IsValid())
		return boundingBox;

	// Round up and add an additional 2 pixels on the bottom/right to
	// compensate for the various types of rounding used in Painter.
	boundingBox.left = floorf(boundingBox.left);
	boundingBox.right = ceilf(boundingBox.right) + 2;
	boundingBox.top = floorf(boundingBox.top);
	boundingBox.bottom = ceilf(boundingBox.bottom) + 2;

	return boundingBox;
}


const DrawState&
PictureAlphaMask::GetDrawState() const
{
	return *fDrawState.Get();
}


void
PictureAlphaMask::_AddToCache()
{
	// currently not implemented
}


// #pragma mark - ShapeAlphaMask


DrawState* ShapeAlphaMask::fDrawState = NULL;


ShapeAlphaMask::ShapeAlphaMask(AlphaMask* previousMask,
	const shape_data& shape, BPoint where, bool inverse)
	:
	VectorAlphaMask<ShapeAlphaMask>(previousMask, where, inverse),
	fShape(new(std::nothrow) shape_data(shape), true)
{
	if (fDrawState == NULL)
		fDrawState = new(std::nothrow) DrawState();

	fShapeBounds = fShape->DetermineBoundingBox();
}


ShapeAlphaMask::ShapeAlphaMask(AlphaMask* previousMask,
	ShapeAlphaMask* other)
	:
	VectorAlphaMask<ShapeAlphaMask>(previousMask, other),
	fShape(other->fShape),
	fShapeBounds(other->fShapeBounds)
{
}


ShapeAlphaMask::~ShapeAlphaMask()
{
}


/* static */ ShapeAlphaMask*
ShapeAlphaMask::Create(AlphaMask* previousMask, const shape_data& shape,
	BPoint where, bool inverse)
{
	// Look if we have a suitable cached mask
	BReference<ShapeAlphaMask> mask(AlphaMaskCache::Default()->Get(shape,
		previousMask, inverse), true);

	if (mask == NULL) {
		// No cached mask, create new one
		mask.SetTo(new(std::nothrow) ShapeAlphaMask(previousMask, shape,
			BPoint(0, 0), inverse), true);
	} else {
		// Create new mask which reuses the parameters and the mask bitmap
		// of the cache entry
		// TODO: don't make a new mask if the cache entry has no drawstate
		// using it anymore, because then we ca just immediately reuse it
		RecursiveLocker locker(mask->fLock);
		mask.SetTo(new(std::nothrow) ShapeAlphaMask(previousMask, mask), true);
	}

	return mask.Detach();
}


void
ShapeAlphaMask::DrawVectors(Canvas* canvas)
{
	canvas->GetDrawingEngine()->DrawShape(fBounds,
		fShape->opCount, fShape->opList,
		fShape->ptCount, fShape->ptList,
		true, BPoint(0, 0), 1.0);
}


BRect
ShapeAlphaMask::DetermineBoundingBox() const
{
	return fShapeBounds;
}


const DrawState&
ShapeAlphaMask::GetDrawState() const
{
	return *fDrawState;
}


void
ShapeAlphaMask::_AddToCache()
{
	AlphaMaskCache::Default()->Put(this);
}