/* 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/>.
 *
 */

#include "common/debug.h"
#include "common/file.h"

#include "sludge/graphics.h"
#include "sludge/newfatal.h"
#include "sludge/variable.h"

namespace Sludge {

#if 0
// Raised
static int s_matrixEffectDivide = 2;
static int s_matrixEffectWidth = 3;
static int s_matrixEffectHeight = 3;
static int s_matrixEffectData[9] = {0, 0, 0, 0, -1, 0, 0, 0, 2};
static int s_matrixEffectBase = 0;
#elif 0
// Stay put
static int s_matrixEffectDivide = 1;
static int s_matrixEffectWidth = 3;
static int s_matrixEffectHeight = 3;
static int s_matrixEffectData[9] = {0, 0, 0, 0, 1, 0, 0, 0, 0};
static int s_matrixEffectBase = 0;
#elif 0
// Brighten
static int s_matrixEffectDivide = 9;
static int s_matrixEffectWidth = 1;
static int s_matrixEffectHeight = 1;
static int s_matrixEffectData[9] = {10};
static int s_matrixEffectBase = 15;
#elif 0
// Raised up/left
static int s_matrixEffectDivide = 4;
static int s_matrixEffectWidth = 3;
static int s_matrixEffectHeight = 3;
static int s_matrixEffectData[9] = {-2, -1, 0, -1, 1, 1, 0, 1, 2};
static int s_matrixEffectBase = 16;
#elif 0
// Standard emboss
static int s_matrixEffectDivide = 2;
static int s_matrixEffectWidth = 3;
static int s_matrixEffectHeight = 3;
static int s_matrixEffectData[9] = {-1, 0, 0, 0, 0, 0, 0, 0, 1};
static int s_matrixEffectBase = 128;
#elif 0
// Horizontal blur
static int s_matrixEffectDivide = 11;
static int s_matrixEffectWidth = 5;
static int s_matrixEffectHeight = 1;
static int s_matrixEffectData[9] = {1, 3, 3, 3, 1};
static int s_matrixEffectBase = 0;
#elif 0
// Double vision
static int s_matrixEffectDivide = 6;
static int s_matrixEffectWidth = 13;
static int s_matrixEffectHeight = 2;
static int s_matrixEffectData[26] = {2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3};
static int s_matrixEffectBase = 0;
#elif 0
// Negative
static int s_matrixEffectDivide = 1;
static int s_matrixEffectWidth = 1;
static int s_matrixEffectHeight = 1;
static int s_matrixEffectData[9] = {-1};
static int s_matrixEffectBase = 255;
#elif 0
// Fog
static int s_matrixEffectDivide = 4;
static int s_matrixEffectWidth = 1;
static int s_matrixEffectHeight = 1;
static int s_matrixEffectData[9] = {3};
static int s_matrixEffectBase = 45;
#elif 0
// Blur
static int s_matrixEffectDivide = 14;
static int s_matrixEffectWidth = 3;
static int s_matrixEffectHeight = 3;
static int s_matrixEffectData[9] = {1, 2, 1, 2, 2, 2, 1, 2, 1};
static int s_matrixEffectBase = 0;
#else
static int s_matrixEffectDivide = 0;
static int s_matrixEffectWidth = 0;
static int s_matrixEffectHeight = 0;
static int *s_matrixEffectData = NULL;
static int s_matrixEffectBase = 0;
#endif

void GraphicsManager::blur_saveSettings(Common::WriteStream *stream) {
	if (s_matrixEffectData) {
		stream->writeUint32LE(s_matrixEffectDivide);
		stream->writeUint32LE(s_matrixEffectWidth);
		stream->writeUint32LE(s_matrixEffectHeight);
		stream->writeUint32LE(s_matrixEffectBase);
		stream->write(s_matrixEffectData, sizeof(int) * s_matrixEffectWidth * s_matrixEffectHeight);
	} else {
		stream->writeUint32LE(0);
		stream->writeUint32LE(0);
		stream->writeUint32LE(0);
		stream->writeUint32LE(0);
	}
}

static int *blur_allocateMemoryForEffect() {
	free(s_matrixEffectData);
	s_matrixEffectData = NULL;

	if (s_matrixEffectWidth && s_matrixEffectHeight) {
		s_matrixEffectData = (int *)malloc(sizeof(int) * s_matrixEffectHeight * s_matrixEffectWidth);
		checkNew(s_matrixEffectData);
	}
	return s_matrixEffectData;
}

void GraphicsManager::blur_loadSettings(Common::SeekableReadStream *stream) {
	s_matrixEffectDivide = stream->readUint32LE();
	s_matrixEffectWidth = stream->readUint32LE();
	s_matrixEffectHeight = stream->readUint32LE();
	s_matrixEffectBase = stream->readUint32LE();

	if (blur_allocateMemoryForEffect()) {
		uint bytes_read = stream->read(s_matrixEffectData, sizeof(int) * s_matrixEffectWidth * s_matrixEffectHeight);
		if (bytes_read != sizeof(int) * s_matrixEffectWidth * s_matrixEffectHeight && stream->err()) {
			debug("Reading error in blur_loadSettings.");
		}
	} else {
		stream->seek(sizeof(int) * s_matrixEffectWidth * s_matrixEffectHeight, SEEK_CUR);
	}
}

bool GraphicsManager::blur_createSettings(int numParams, VariableStack *&stack) {
	bool createNullThing = true;
	Common::String error = "";

	if (numParams >= 3) {
		// PARAMETERS: base, divide, stack (, stack (, stack...))

		int height = numParams - 2;
		int width = 0;

		VariableStack *justToCheckSizes = stack;
		for (int a = 0; a < height; a++) {
			if (justToCheckSizes->thisVar.varType != SVT_STACK) {
				error = "Third and subsequent parameters in setBackgroundEffect should be arrays";
				break;
			} else {
				int w = justToCheckSizes->thisVar.varData.theStack->getStackSize();
				if (a) {
					if (w != width) {
						error = "Arrays in setBackgroundEffect must be the same size";
						break;
					}
					if (w < width) {
						width = w;
					}
				} else {
					width = w;
				}
			}
		}

		if (width == 0 && error.empty()) {
			error = "Empty arrays found in setBackgroundEffect parameters";
		}

		if (error.empty()) {
			s_matrixEffectWidth = width;
			s_matrixEffectHeight = height;

			if (blur_allocateMemoryForEffect()) {
				for (int y = height - 1; y >= 0; y--) {
					VariableStack *eachNumber = stack->thisVar.varData.theStack->first;
					if (error.empty()) {
						for (int x = 0; x < width; x++) {
							int arraySlot = x + (y * width);
//							s_matrixEffectData[arraySlot] = (rand() % 4);
							if (!eachNumber->thisVar.getValueType(s_matrixEffectData[arraySlot], SVT_INT)) {
								error = "";
								break;
							}
							eachNumber = eachNumber->next;
						}
						trimStack(stack);
					}
				}
				if (error.empty() && !stack->thisVar.getValueType(s_matrixEffectDivide, SVT_INT))
					error = "";
				trimStack(stack);
				if (error.empty() && !stack->thisVar.getValueType(s_matrixEffectBase, SVT_INT))
					error = "";
				trimStack(stack);
				if (error.empty()) {
					if (s_matrixEffectDivide) {
						createNullThing = false;
					} else {
						error = "Second parameter of setBackgroundEffect (the 'divide' value) should not be 0!";
					}
				}
			} else {
				error = "Couldn't allocate memory for effect";
			}
		}
	} else {
		if (numParams) {
			error = "setBackgroundEffect should either have 0 parameters or more than 2";
		}
	}

	if (createNullThing) {
		s_matrixEffectDivide = 0;
		s_matrixEffectWidth = 0;
		s_matrixEffectHeight = 0;
		s_matrixEffectBase = 0;
		delete s_matrixEffectData;
		s_matrixEffectData = NULL;
	}

	if (!error.empty()) {
		fatal(error);
	}

	return !createNullThing;
}

static inline void blur_createSourceLine(byte *createLine, byte *fromLine, int overlapOnLeft, int width) {
	int miniX;
	memcpy(createLine + overlapOnLeft * 4, fromLine, width * 4);

	for (miniX = 0; miniX < overlapOnLeft; miniX++) {
		createLine[miniX * 4] = fromLine[0];
		createLine[miniX * 4 + 1] = fromLine[1];
		createLine[miniX * 4 + 2] = fromLine[2];
	}

	for (miniX = width + overlapOnLeft; miniX < width + s_matrixEffectWidth - 1; miniX++) {
		createLine[miniX * 4] = fromLine[width * 4 - 4];
		createLine[miniX * 4 + 1] = fromLine[width * 4 - 3];
		createLine[miniX * 4 + 2] = fromLine[width * 4 - 2];
	}
}

bool GraphicsManager::blurScreen() {
	if (s_matrixEffectWidth && s_matrixEffectHeight && s_matrixEffectDivide && s_matrixEffectData) {
		byte *thisLine;
		int y, x;
		bool ok = true;
		int overlapOnLeft = s_matrixEffectWidth / 2;
		int overlapAbove = s_matrixEffectHeight / 2;

		byte **sourceLine = new byte *[s_matrixEffectHeight];
		if (!checkNew(sourceLine))
			return false;

		for (y = 0; y < s_matrixEffectHeight; y++) {
			sourceLine[y] = new byte[(s_matrixEffectWidth - 1 + _sceneWidth) * 4];
			ok &= (sourceLine[y] != NULL);
		}

		if (ok) {
			for (y = 0; y < s_matrixEffectHeight; y++) {
				int miniY = CLIP<int>(y - overlapAbove - 1, 0, _sceneHeight - 1);

				blur_createSourceLine(sourceLine[y], (byte *)_origBackdropSurface.getBasePtr(0, miniY), overlapOnLeft, _sceneWidth);
			}

			for (y = 0; y < (int)_sceneHeight; y++) {
				thisLine = (byte *)_origBackdropSurface.getBasePtr(0, y);

				//-------------------------
				// Scroll source lines
				//-------------------------
				byte *tempLine = sourceLine[0];
				for (int miniY = 0; miniY < s_matrixEffectHeight - 1; miniY++) {
					sourceLine[miniY] = sourceLine[miniY + 1];
				}
				sourceLine[s_matrixEffectHeight - 1] = tempLine;
				{
					int h = s_matrixEffectHeight - 1;
					int miniY = CLIP<int>(y + (s_matrixEffectHeight - overlapAbove - 1), 0, _sceneHeight - 1);

					blur_createSourceLine(sourceLine[h], (byte *)_origBackdropSurface.getBasePtr(0, miniY), overlapOnLeft, _sceneWidth);
				}
				for (x = 0; x < (int)_sceneWidth; x++) {
					int totalRed = 0;
					int totalGreen = 0;
					int totalBlue = 0;
					int *matrixElement = s_matrixEffectData;
					for (int miniY = 0; miniY < s_matrixEffectHeight; ++miniY) {
						byte *pixel = &sourceLine[miniY][x * 4];
						for (int miniX = 0; miniX < s_matrixEffectWidth; ++miniX) {

							totalRed += pixel[0] **matrixElement;
							totalGreen += pixel[1] **matrixElement;
							totalBlue += pixel[2] **matrixElement;
							++matrixElement;
							pixel += 4;
						}
					}
					totalRed = (totalRed + s_matrixEffectDivide / 2) / s_matrixEffectDivide + s_matrixEffectBase;
					totalRed = (totalRed < 0) ? 0 : ((totalRed > 255) ? 255 : totalRed);

					totalGreen = (totalGreen + s_matrixEffectDivide / 2) / s_matrixEffectDivide + s_matrixEffectBase;
					totalGreen = (totalGreen < 0) ? 0 : ((totalGreen > 255) ? 255 : totalGreen);

					totalBlue = (totalBlue + s_matrixEffectDivide / 2) / s_matrixEffectDivide + s_matrixEffectBase;
					totalBlue = (totalBlue < 0) ? 0 : ((totalBlue > 255) ? 255 : totalBlue);

					*thisLine = totalRed;
					++thisLine;
					*thisLine = totalGreen;
					++thisLine;
					*thisLine = totalBlue;
					++thisLine;
//					*thisLine = totalAlpha;
					++thisLine;
				}
			}
		}

		for (y = 0; y < s_matrixEffectHeight; y++) {
			delete sourceLine[y];
		}
		delete[] sourceLine;
		sourceLine = NULL;

		return true;
	}
	return false;
}

} // End of namespace Sludge
