/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifdef ENABLE_HE

#include "common/system.h"
#include "scumm/he/intern_he.h"
#include "scumm/he/wiz_he.h"

namespace Scumm {

static void mrleFLIPHorzFlipAlignWithRect(Common::Rect *rectToAlign, const Common::Rect *baseRect) {
	int dx = (baseRect->right - rectToAlign->right) - (rectToAlign->left - baseRect->left);
	rectToAlign->left += dx;
	rectToAlign->right += dx;
}

static void mrleFLIPVertFlipAlignWithRect(Common::Rect *rectToAlign, const Common::Rect *baseRect) {
	int dy = (baseRect->bottom - rectToAlign->bottom) - (rectToAlign->top - baseRect->top);
	rectToAlign->top += dy;
	rectToAlign->bottom += dy;
}

#define MRLE_HANDLE_SKIP_PIXELS_STEP() {                \
		/* Decompress bytes to do simple clipping... */ \
		while (skipAmount > 0) {                        \
			if ((runCount = *dataStream++) & 1) {       \
                                                        \
				/* Handle the transparent color... */   \
				runCount >>= 1;                         \
				if (runCount > skipAmount) {            \
					runCount -= skipAmount;             \
					goto DoTransparentRun;              \
				} else {                                \
					skipAmount -= runCount;             \
				}                                       \
                                                        \
			} else { /* xxxxxxx0 */                     \
				/* Handle a run of color... */          \
				runCount >>= 1;                         \
				if (runCount > skipAmount) {            \
					runCount -= skipAmount;             \
					goto WriteRunData;                  \
				} else {                                \
					skipAmount -= runCount;             \
				}                                       \
			}                                           \
		}                                               \
	}

#define MRLE_HANDLE_RUN_DECOMPRESS_STEP(_TransparentCode_, _RunCode_) {  \
		while (decompAmount > 0) {                                       \
			runCount = *dataStream++;                                    \
                                                                         \
			if (runCount & 1) { /* xxxxxxx1 */                           \
				runCount >>= 1;                                          \
			DoTransparentRun:                                            \
				decompAmount -= runCount;                                \
				_TransparentCode_                                        \
                                                                         \
			} else { /* xxxxxxx0 */                                      \
                                                                         \
				runCount >>= 1;                                          \
			WriteRunData:                                                \
				decompAmount -= runCount;                                \
				if (decompAmount < 0) {                                  \
					runCount += decompAmount;                            \
				}                                                        \
				_RunCode_                                                \
			}                                                            \
		}                                                                \
	}

static void mrleFLIPAltSourceForwardXBppToXBpp(Wiz *wiz,
	WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
	int skipAmount, int decompAmount, const WizRawPixel *conversionTable) {
	const WizRawPixel *srcPtr = (const WizRawPixel *)altSourcePtr;

	const WizRawPixel8 *src8 = (const WizRawPixel8 *)srcPtr;
	const WizRawPixel16 *src16 = (const WizRawPixel16 *)srcPtr;

	WizRawPixel8 *dest8 = (WizRawPixel8 *)destPtr;
	WizRawPixel16 *dest16 = (WizRawPixel16 *)destPtr;

	int runCount;

	// Decompress bytes to do simple clipping...
	MRLE_HANDLE_SKIP_PIXELS_STEP();

	// Really decompress to the dest buffer...
	MRLE_HANDLE_RUN_DECOMPRESS_STEP(
		{
			if (!wiz->_uses16BitColor) {
				dest8 += runCount;
				src8 += runCount;
			} else {
				dest16 += runCount;
				src16 += runCount;
			}
		},
		{
			if (!wiz->_uses16BitColor) {
				memcpy(dest8, src8, (runCount * sizeof(WizRawPixel8)));
				dest8 += runCount;
				src8 += runCount;
			} else {
				// memcpy(dest16, src16, (runCount * sizeof(WizRawPixel16)));
				for (int i = 0; i < runCount; i++) {
					dest16[i] = FROM_LE_16(src16[i]);
				}

				dest16 += runCount;
				src16 += runCount;
			}
		}
	);
}

static void mrleFLIPAltSourceBackwardXBppToXBpp(Wiz *wiz,
	WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
	int skipAmount, int decompAmount, const WizRawPixel *conversionTable) {
	const WizRawPixel *srcPtr = (const WizRawPixel *)altSourcePtr;

	const WizRawPixel8 *src8 = (const WizRawPixel8 *)srcPtr;
	const WizRawPixel16 *src16 = (const WizRawPixel16 *)srcPtr;

	WizRawPixel8 *dest8 = (WizRawPixel8 *)destPtr;
	WizRawPixel16 *dest16 = (WizRawPixel16 *)destPtr;

	int runCount;

	// Decompress bytes to do simple clipping...
	MRLE_HANDLE_SKIP_PIXELS_STEP();

	// Really decompress to the dest buffer...
	MRLE_HANDLE_RUN_DECOMPRESS_STEP(
		{
			if (!wiz->_uses16BitColor) {
				dest8 -= runCount;
				src8 -= runCount;
			} else {
				dest16 -= runCount;
				src16 -= runCount;
			}
		},
		{
			if (!wiz->_uses16BitColor) {
				dest8 -= runCount;
				src8 -= runCount;
				memcpy(dest8 + 1, src8 + 1, (runCount * sizeof(WizRawPixel8)));
			} else {
				dest16 -= runCount;
				src16 -= runCount;
				// memcpy(dest16 + 1, src16 + 1, (runCount * sizeof(WizRawPixel16)));
				for (int i = 1; i < runCount; i++) {
					dest16[i] = FROM_LE_16(src16[i]);
				}
			}
		}
	);
}

static void mrleFLIPAltSourceForward8BppToXBpp(Wiz *wiz,
	WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
	int skipAmount, int decompAmount, const WizRawPixel *conversionTable) {
	const byte *srcPtr = (const byte *)altSourcePtr;

	WizRawPixel8 *dest8 = (WizRawPixel8 *)destPtr;
	WizRawPixel16 *dest16 = (WizRawPixel16 *)destPtr;

	int runCount;

	// Decompress bytes to do simple clipping...
	MRLE_HANDLE_SKIP_PIXELS_STEP();

	// Really decompress to the dest buffer...
	MRLE_HANDLE_RUN_DECOMPRESS_STEP(
		{
			if (!wiz->_uses16BitColor) {
				dest8 += runCount;
				srcPtr += runCount;
				destPtr = (WizRawPixel *)dest8;
			} else {
				dest16 += runCount;
				srcPtr += runCount;
				destPtr = (WizRawPixel *)dest16;
			}
		},
		{
			if (!wiz->_uses16BitColor) {
				wiz->memcpy8BppConversion(destPtr, srcPtr, runCount, conversionTable);
				dest8 += runCount;
				srcPtr += runCount;
				destPtr = (WizRawPixel *)dest8;
			} else {
				wiz->memcpy8BppConversion(destPtr, srcPtr, runCount, conversionTable);
				dest16 += runCount;
				srcPtr += runCount;
				destPtr = (WizRawPixel *)dest16;
			}
		}
	);
}

static void mrleFLIPAltSourceBackward8BppToXBpp(Wiz *wiz,
	WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
	int skipAmount, int decompAmount, const WizRawPixel *conversionTable) {

	// NOTE: This looks like it should be a const byte pointer, but the original
	// says it's a WizRawPixel pointer; I'm going to follow the original for now...
	const WizRawPixel *srcPtr = (const WizRawPixel *)altSourcePtr;

	const WizRawPixel8 *src8 = (const WizRawPixel8 *)srcPtr;
	const WizRawPixel16 *src16 = (const WizRawPixel16 *)srcPtr;

	WizRawPixel8 *dest8 = (WizRawPixel8 *)destPtr;
	WizRawPixel16 *dest16 = (WizRawPixel16 *)destPtr;

	int runCount;

	// Decompress bytes to do simple clipping...
	MRLE_HANDLE_SKIP_PIXELS_STEP();

	// Really decompress to the dest buffer...
	MRLE_HANDLE_RUN_DECOMPRESS_STEP(
		{
			if (!wiz->_uses16BitColor) {
				dest8 -= runCount;
				src8 -= runCount;
				destPtr = (WizRawPixel *)dest8;
				srcPtr = (const WizRawPixel *)src8;
			} else {
				dest16 -= runCount;
				src16 -= runCount;
				destPtr = (WizRawPixel *)dest16;
				srcPtr = (const WizRawPixel *)src16;
			}
		},
		{
			if (!wiz->_uses16BitColor) {
				wiz->memcpy8BppConversion(destPtr + 1, srcPtr + 1, runCount, conversionTable);
				dest8 -= runCount;
				src8 -= runCount;
				destPtr = (WizRawPixel *)dest8;
				srcPtr = (const WizRawPixel *)src8;
			} else {
				wiz->memcpy8BppConversion(destPtr + 1, srcPtr + 1, runCount, conversionTable);
				dest16 -= runCount;
				src16 -= runCount;
				destPtr = (WizRawPixel *)dest16;
				srcPtr = (const WizRawPixel *)src16;
			}
		}
	);
}

static void mrleFLIPAltSourceDecompImageHull(Wiz *wiz,
	WizRawPixel *bufferPtr, int bufferWidth, const Common::Rect *destRect,
	const byte *altSourceBuffer, int altBytesPerLine,
	int altBytesPerPixel, const Common::Rect *altRect,
	const byte *compData, const Common::Rect *sourceRect,
	const WizRawPixel *conversionTable,
	void (*functionPtr)(Wiz *wiz,
		WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
		int skipAmount, int decompAmount, const WizRawPixel *conversionTable)) {

	int decompWidth, decompHeight, counter, sX1, lineSize;
	WizRawPixel8 *buffer8 = (WizRawPixel8 *)bufferPtr;
	WizRawPixel16 *buffer16 = (WizRawPixel16 *)bufferPtr;

	// Yet more general setup...
	sX1 = sourceRect->left;

	decompWidth = sourceRect->right - sourceRect->left + 1;
	decompHeight = sourceRect->bottom - sourceRect->top + 1;

	// Quickly skip down to the lines to be compressed & dest position...
	if (!wiz->_uses16BitColor) {
		buffer8 += bufferWidth * destRect->top + destRect->left;
		bufferPtr = (WizRawPixel *)buffer8;
	} else {
		buffer16 += bufferWidth * destRect->top + destRect->left;
		bufferPtr = (WizRawPixel *)buffer16;
	}

	for (counter = sourceRect->top; counter > 0; counter--) {
		compData += READ_LE_UINT16(compData) + 2;
	}

	// Calc the ALT buffer location...
	altSourceBuffer += (altBytesPerLine * altRect->top) + (altRect->left * altBytesPerPixel);

	// Flip the dest offset if vertical flipping...
	if (destRect->top > destRect->bottom) {
		bufferWidth = -bufferWidth;
		altBytesPerLine = -altBytesPerLine;
	}

	// Decompress all the lines that are visible...
	while (decompHeight-- > 0) {
		lineSize = READ_LE_UINT16(compData);

		if (lineSize != 0) {
			(*functionPtr)(wiz,
				bufferPtr, altSourceBuffer, compData + 2, sX1,
				decompWidth, conversionTable);

			compData += lineSize + 2;
		} else {
			// Handle a completely transparent line!
			compData += 2;
		}

		if (!wiz->_uses16BitColor) {
			buffer8 += bufferWidth;
			bufferPtr = (WizRawPixel *)buffer8;
		} else {
			buffer16 += bufferWidth;
			bufferPtr = (WizRawPixel *)buffer16;
		}

		altSourceBuffer += altBytesPerLine;
	}
}

void Wiz::mrleFLIPAltSourceDecompressPrim(
	WizRawPixel *destBufferPtr, int destBufferWidth, int destBufferHeight,
	const void *altBufferPtr, int altBitsPerPixel,
	const WizCompressedImage *imagePtr, int destX, int destY,
	const Common::Rect *sourceCoords, const Common::Rect *clipRectPtr,
	int32 flags, const WizRawPixel *conversionTable,
	void (*forwardFunctionPtr)(Wiz *wiz,
		WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
		int skipAmount, int decompAmount, const WizRawPixel *conversionTable),
	void (*backwardFunctionPtr)(Wiz *wiz,
		WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
		int skipAmount, int decompAmount, const WizRawPixel *conversionTable)) {

	Common::Rect sourceRect, destRect, clipRect, workRect, inSourceRect;
	int width, height;

	void (*functionPtr)(Wiz * wiz,
		WizRawPixel *destPtr, const void *altSourcePtr, const byte *dataStream,
		int skipAmount, int decompAmount, const WizRawPixel *conversionTable);

	if (!sourceCoords) {
		width = imagePtr->width;
		height = imagePtr->height;

		sourceRect.left = 0;
		sourceRect.top = 0;
		sourceRect.right = width - 1;
		sourceRect.bottom = height - 1;
	} else {
		width = sourceCoords->right - sourceCoords->left + 1;
		height = sourceCoords->bottom - sourceCoords->top + 1;
		sourceRect = *sourceCoords;
	}

	inSourceRect = sourceRect;

	destRect.left = destX;
	destRect.top = destY;
	destRect.right = destX + width - 1;
	destRect.bottom = destY + height - 1;

	// Custom clip rect...
	if (clipRectPtr) {
		clipRect = *clipRectPtr;

		workRect.left = 0;
		workRect.top = 0;
		workRect.right = destBufferWidth - 1;
		workRect.bottom = destBufferHeight - 1;

		if (!findRectOverlap(&clipRect, &workRect)) {
			return;
		}
	} else {
		clipRect.left = 0;
		clipRect.top = 0;
		clipRect.right = destBufferWidth - 1;
		clipRect.bottom = destBufferHeight - 1;
	}

	// Clip the source & dest coords to the clipping rectangle...
	clipRectCoords(&sourceRect, &destRect, &clipRect);

	if (destRect.right < destRect.left) {
		return;
	}

	if (destRect.bottom < destRect.top) {
		return;
	}

	if (sourceRect.right < sourceRect.left) {
		return;
	}

	if (sourceRect.bottom < sourceRect.top) {
		return;
	}

	// Handle the flip coords source adjustment...
	if (flags & kWRFHFlip) {
		functionPtr = backwardFunctionPtr;
		mrleFLIPHorzFlipAlignWithRect(&sourceRect, &inSourceRect);
		SWAP<int16>(destRect.left, destRect.right);
	} else {
		functionPtr = forwardFunctionPtr;
	}

	if (flags & kWRFVFlip) {
		mrleFLIPVertFlipAlignWithRect(&sourceRect, &inSourceRect);
		SWAP<int16>(destRect.top, destRect.bottom);
	}

	// Call the primitive image renderer...
	mrleFLIPAltSourceDecompImageHull(this,
		destBufferPtr, destBufferWidth, &destRect,
		(const byte *)altBufferPtr, ((destBufferWidth * altBitsPerPixel) / 8),
		(altBitsPerPixel / 8), &destRect, imagePtr->data, &sourceRect,
		conversionTable, functionPtr);
}

void Wiz::mrleFLIPAltSourceDecompressImage(
	WizRawPixel *destBufferPtr, const byte *compData, int destBufferWidth, int destBufferHeight,
	const void *altBufferPtr, int altWidth, int altHeight, int altBitsPerPixel,
	int x, int y, int width, int height, Common::Rect *clipRectPtr,
	int32 wizFlags, const WizRawPixel *conversionTable) {

	Common::Rect srcRect, clipRect;
	WizCompressedImage fakeImage;

	// General setup
	fakeImage.data = compData;
	fakeImage.width = width;
	fakeImage.height = height;

	makeSizedRect(&srcRect, width, height);
	makeSizedRect(&clipRect, destBufferWidth, destBufferHeight);

	if (clipRectPtr) {
		if (!findRectOverlap(&clipRect, clipRectPtr)) {
			return;
		}
	}

	// Check the assumptions about the alt src buffer matching the dest buffer
	if ((altWidth != destBufferWidth) || (altHeight != destBufferHeight)) {
		return;
	}

	// Dispatch to the next level of code. (8bpp or conversion)
	if (altBitsPerPixel == 16) {
		mrleFLIPAltSourceDecompressPrim(
			destBufferPtr, destBufferWidth, destBufferHeight,
			altBufferPtr, altBitsPerPixel, &fakeImage, x, y,
			&srcRect, &clipRect, wizFlags, conversionTable,
			mrleFLIPAltSourceForwardXBppToXBpp,
			mrleFLIPAltSourceBackwardXBppToXBpp);
	} else if (altBitsPerPixel == 8) {
		mrleFLIPAltSourceDecompressPrim(
			destBufferPtr, destBufferWidth, destBufferHeight,
			altBufferPtr, altBitsPerPixel, &fakeImage, x, y,
			&srcRect, &clipRect, wizFlags, conversionTable,
			mrleFLIPAltSourceForward8BppToXBpp,
			mrleFLIPAltSourceBackward8BppToXBpp);
	}
}

} // End of namespace Scumm

#endif // ENABLE_HE