/*
 * Copyright 2009, Christian Packmann.
 * Copyright 2008, Andrej Spielmann <andrej.spielmann@seh.ox.ac.uk>.
 * Copyright 2005-2014, Stephan Aßmus <superstippi@gmx.de>.
 * Copyright 2015, Julian Harnath <julian.harnath@rwth-aachen.de>
 * All rights reserved. Distributed under the terms of the MIT License.
 */
#ifndef DRAW_BITMAP_NO_SCALE_H
#define DRAW_BITMAP_NO_SCALE_H

#include "IntPoint.h"
#include "IntRect.h"
#include "Painter.h"
#include "SystemPalette.h"


template<class BlendType>
struct DrawBitmapNoScale {
public:
	void
	Draw(PainterAggInterface& aggInterface, agg::rendering_buffer& bitmap,
		uint32 bytesPerSourcePixel, IntPoint offset, BRect destinationRect)
	{
		// NOTE: this would crash if destinationRect was large enough to read
		// outside the bitmap, so make sure this is not the case before calling
		// this function!
		uint8* dst = aggInterface.fBuffer.row_ptr(0);
		const uint32 dstBPR = aggInterface.fBuffer.stride();

		const uint8* src = bitmap.row_ptr(0);
		const uint32 srcBPR = bitmap.stride();

		const int32 left = (int32)destinationRect.left;
		const int32 top = (int32)destinationRect.top;
		const int32 right = (int32)destinationRect.right;
		const int32 bottom = (int32)destinationRect.bottom;

#if DEBUG_DRAW_BITMAP
	if (left - offset.x < 0
		|| left  - offset.x >= (int32)bitmap.width()
		|| right - offset.x >= (int32)srcBuffer.width()
		|| top - offset.y < 0
		|| top - offset.y >= (int32)bitmap.height()
		|| bottom - offset.y >= (int32)bitmap.height()) {
		char message[256];
		sprintf(message, "reading outside of bitmap (%ld, %ld, %ld, %ld) "
				"(%d, %d) (%ld, %ld)",
			left - offset.x, top - offset.y,
			right - offset.x, bottom - offset.y,
			bitmap.width(), bitmap.height(), offset.x, offset.y);
		debugger(message);
	}
#endif

		fColorMap = SystemPalette();
		fAlphaMask = aggInterface.fClippedAlphaMask;
		renderer_base& baseRenderer = aggInterface.fBaseRenderer;

		// copy rects, iterate over clipping boxes
		baseRenderer.first_clip_box();
		do {
			fRect.left  = max_c(baseRenderer.xmin(), left);
			fRect.right = min_c(baseRenderer.xmax(), right);
			if (fRect.left <= fRect.right) {
				fRect.top    = max_c(baseRenderer.ymin(), top);
				fRect.bottom = min_c(baseRenderer.ymax(), bottom);
				if (fRect.top <= fRect.bottom) {
					uint8* dstHandle = dst + fRect.top * dstBPR
						+ fRect.left * 4;
					const uint8* srcHandle = src
						+ (fRect.top  - offset.y) * srcBPR
						+ (fRect.left - offset.x) * bytesPerSourcePixel;

					for (; fRect.top <= fRect.bottom; fRect.top++) {
						static_cast<BlendType*>(this)->BlendRow(dstHandle,
							srcHandle, fRect.right - fRect.left + 1);

						dstHandle += dstBPR;
						srcHandle += srcBPR;
					}
				}
			}
		} while (baseRenderer.next_clip_box());
	}

protected:
	IntRect fRect;
	const rgb_color* fColorMap;
	const agg::clipped_alpha_mask* fAlphaMask;
};


struct CMap8Copy : public DrawBitmapNoScale<CMap8Copy>
{
	void BlendRow(uint8* dst, const uint8* src, int32 numPixels)
	{
		uint32* d = (uint32*)dst;
		const uint8* s = src;
		while (numPixels--) {
			const rgb_color c = fColorMap[*s++];
			*d++ = (c.alpha << 24) | (c.red << 16) | (c.green << 8) | (c.blue);
		}
	}
};


struct CMap8Over : public DrawBitmapNoScale<CMap8Over>
{
	void BlendRow(uint8* dst, const uint8* src, int32 numPixels)
	{
		uint32* d = (uint32*)dst;
		const uint8* s = src;
		while (numPixels--) {
			const rgb_color c = fColorMap[*s++];
			if (c.alpha)
				*d = (c.alpha << 24) | (c.red << 16)
					| (c.green << 8) | (c.blue);
			d++;
		}
	}
};


struct Bgr32Copy : public DrawBitmapNoScale<Bgr32Copy>
{
	void BlendRow(uint8* dst, const uint8* src, int32 numPixels)
	{
		memcpy(dst, src, numPixels * 4);
	}
};


struct Bgr32Over : public DrawBitmapNoScale<Bgr32Over>
{
	void BlendRow(uint8* dst, const uint8* src, int32 numPixels)
	{
		uint32* d = (uint32*)dst;
		uint32* s = (uint32*)src;
		while (numPixels--) {
			if (*s != B_TRANSPARENT_MAGIC_RGBA32)
				*(uint32*)d = *(uint32*)s;
			d++;
			s++;
		}
	}
};


struct Bgr32Alpha : public DrawBitmapNoScale<Bgr32Alpha>
{
	void BlendRow(uint8* dst, const uint8* src, int32 numPixels)
	{
		uint32* d = (uint32*)dst;
		int32 bytes = numPixels * 4;
		uint8 buffer[bytes];
		uint8* b = buffer;
		while (numPixels--) {
			if (src[3] == 255) {
				*(uint32*)b = *(uint32*)src;
			} else {
				*(uint32*)b = *d;
				b[0] = ((src[0] - b[0]) * src[3] + (b[0] << 8)) >> 8;
				b[1] = ((src[1] - b[1]) * src[3] + (b[1] << 8)) >> 8;
				b[2] = ((src[2] - b[2]) * src[3] + (b[2] << 8)) >> 8;
			}
			d++;
			b += 4;
			src += 4;
		}
		memcpy(dst, buffer, bytes);
	}
};


struct Bgr32CopyMasked : public DrawBitmapNoScale<Bgr32CopyMasked>
{
	void BlendRow(uint8* dst, const uint8* src, int32 numPixels)
	{
		uint8 covers[numPixels];
		fAlphaMask->get_hspan(fRect.left, fRect.top, covers, numPixels);

		uint32* destination = (uint32*)dst;
		uint32* source = (uint32*)src;
		uint8* mask = (uint8*)&covers[0];

		while (numPixels--) {
			if (*mask != 0)
				*destination = *source;
			destination++;
			source++;
			mask++;
		}
	}
};


#endif // DRAW_BITMAP_NO_SCALE_H