/* 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "startrek/common.h"
#include "startrek/graphics.h"

#include "common/algorithm.h"
#include "common/config-manager.h"
#include "common/events.h"
#include "common/rendermode.h"
#include "graphics/cursorman.h"
#include "graphics/palette.h"
#include "graphics/surface.h"

namespace StarTrek {

Graphics::Graphics(StarTrekEngine *vm) : _vm(vm), _egaMode(false) {
	_font = nullptr;
	_egaData = nullptr;
	_lutData = nullptr;

	_screenRect = Common::Rect(SCREEN_WIDTH, SCREEN_HEIGHT);

	if (ConfMan.hasKey("render_mode"))
		_egaMode = (Common::parseRenderMode(ConfMan.get("render_mode").c_str()) == Common::kRenderEGA) && (_vm->getGameType() != GType_STJR) && !(_vm->getFeatures() & GF_DEMO);

	if (_vm->getGameType() == GType_ST25 && _vm->getPlatform() == Common::kPlatformDOS)
		_font = new Font(_vm);

	_numSprites = 0;
	_pushedNumSprites = -1;

	_palData = new byte[256 * 3];
	_lutData = new byte[256 * 3];

	memset(_palData, 0, 256 * 3);
	memset(_lutData, 0, 256 * 3);

	_paletteFadeLevel = 0;
	_mouseLocked = false;
	_mouseToBeShown = false;
	_mouseToBeHidden = false;
	_mouseWarpX = -1;
	_mouseWarpY = -1;

	setMouseBitmap(loadBitmap("pushbtn"));
	CursorMan.showMouse(true);
}

Graphics::~Graphics() {
	delete[] _egaData;

	delete _font;
}


void Graphics::setBackgroundImage(SharedPtr<Bitmap> bitmap) {
	_backgroundImage = bitmap;
}

/**
 * Note: this doesn't flush the palette to the screen (must call "setPaletteFadeLevel")
 */
void Graphics::loadPalette(const Common::String &paletteName) {
	// Set the palette from a PAL file
	Common::String palFile = paletteName + ".PAL";
	Common::String lutFile = paletteName + ".LUT";

	SharedPtr<FileStream> palStream = _vm->loadFile(palFile.c_str());
	palStream->read(_palData, 256 * 3);

	// Load LUT file
	SharedPtr<FileStream> lutStream = _vm->loadFile(lutFile.c_str());

	lutStream->read(_lutData, 256);
}

void Graphics::fadeinScreen() {
	while (_paletteFadeLevel <= 100) {
		TrekEvent event;
		do {
			if (!_vm->popNextEvent(&event))
				continue;
		}
		while (event.type != TREKEVENT_TICK);

		setPaletteFadeLevel(_palData, _paletteFadeLevel);
		_paletteFadeLevel += 10;
	}

	_paletteFadeLevel = 100;
}

void Graphics::fadeoutScreen() {
	while (_paletteFadeLevel >= 0) {
		TrekEvent event;
		do {
			if (!_vm->popNextEvent(&event))
				continue;
		}
		while (event.type != TREKEVENT_TICK);

		setPaletteFadeLevel(_palData, _paletteFadeLevel);
		_paletteFadeLevel -= 10;
	}

	_paletteFadeLevel = 0;
}

/**
 * This flushes the palette to the screen. fadeLevel ranges from 0-100.
 */
void Graphics::setPaletteFadeLevel(byte *palData, int fadeLevel) {
	byte palBuffer[256 * 3];

	int multiplier = (fadeLevel << 8) / 100;

	for (uint16 i = 0; i < 256 * 3; i++) {
		palBuffer[i] = (palData[i] * multiplier) >> 8;

		// Expand color components
		if (_vm->getPlatform() == Common::kPlatformDOS || _vm->getPlatform() == Common::kPlatformMacintosh)
			palBuffer[i] <<= 2;
	}

	_vm->_system->getPaletteManager()->setPalette(palBuffer, 0, 256);

	// FIXME: this isn't supposed to flush changes to graphics, only palettes.
	// Might not matter...
	_vm->_system->updateScreen();
}

void Graphics::incPaletteFadeLevel() {
	if (_paletteFadeLevel < 100) {
		_paletteFadeLevel += 10;
		setPaletteFadeLevel(_palData, _paletteFadeLevel);
	}
}

void Graphics::decPaletteFadeLevel() {
	if (_paletteFadeLevel > 0) {
		_paletteFadeLevel -= 10;
		setPaletteFadeLevel(_palData, _paletteFadeLevel);
	}
}


void Graphics::loadPri(const Common::String &priFile) {
	SharedPtr<FileStream> priStream = _vm->loadFile(priFile + ".pri");
	priStream->read(_priData, SCREEN_WIDTH * SCREEN_HEIGHT / 2);
}

void Graphics::clearPri() {
	memset(_priData, 0, sizeof(_priData));
}

byte Graphics::getPriValue(int x, int y) {
	assert(_screenRect.contains(x, y));

	int priOffset = y * SCREEN_WIDTH + x;
	byte b = _priData[priOffset / 2];
	if ((priOffset % 2) == 1)
		return b & 0xf;
	else
		return b >> 4;
}

SharedPtr<Bitmap> Graphics::loadBitmap(Common::String basename) {
	return SharedPtr<Bitmap>(new Bitmap(_vm->loadFile(basename + ".BMP")));
}

Common::Point Graphics::getMousePos() {
	if (_mouseWarpX != -1)
		return Common::Point(_mouseWarpX, _mouseWarpY);

	return _vm->_system->getEventManager()->getMousePos();
}

/**
 * The change to the mouse's bitmap won't take effect until drawAllSprites is called
 * again.
 */
void Graphics::setMouseBitmap(SharedPtr<Bitmap> bitmap) {
	_mouseBitmap = bitmap;

	if (_mouseLocked)
		_lockedMouseSprite.setBitmap(_mouseBitmap);
}

/**
 * This function is a workaround for when the mouse position needs to be locked in a set
 * position (used in the action menu). This only affects the position it is drawn at; the
 * sprite's "real" position is still updated normally.
 *
 * This does not call updateScreen.
 */
void Graphics::lockMousePosition(int16 x, int16 y) {
	if (_mouseLocked) {
		if (x != _lockedMouseSprite.pos.x || y != _lockedMouseSprite.pos.y) {
			_lockedMouseSprite.pos.x = x;
			_lockedMouseSprite.pos.y = y;
			_lockedMouseSprite.bitmapChanged = true;
		}
		return;
	}

	_mouseLocked = true;
	_mouseToBeHidden = true;
	_mouseToBeShown = false;

	_lockedMouseSprite = Sprite();
	_lockedMouseSprite.setBitmap(_mouseBitmap);
	_lockedMouseSprite.drawPriority = 15;
	_lockedMouseSprite.drawPriority2 = 16;
	_lockedMouseSprite.pos.x = x;
	_lockedMouseSprite.pos.y = y;

	addSprite(&_lockedMouseSprite);
}

void Graphics::unlockMousePosition() {
	if (!_mouseLocked)
		return;

	_mouseLocked = false;
	_mouseToBeShown = true;
	_mouseToBeHidden = false;

	_lockedMouseSprite.dontDrawNextFrame();
	drawAllSprites(false);
	delSprite(&_lockedMouseSprite);
}

SharedPtr<Bitmap> Graphics::getMouseBitmap() {
	return _mouseBitmap;
}

void Graphics::warpMouse(int16 x, int16 y) {
	_mouseWarpX = x;
	_mouseWarpY = y;
}

void Graphics::drawSprite(const Sprite &sprite, ::Graphics::Surface *surface) {
	int left = sprite.drawX;
	int top = sprite.drawY;
	int right = left + sprite.bitmap->width;
	int bottom = top + sprite.bitmap->height;
	drawSprite(sprite, surface, Common::Rect(left, top, right, bottom));
}

// rect is the portion of the sprite to update. It must be entirely contained within the
// sprite's actual, full rectangle.
void Graphics::drawSprite(const Sprite &sprite, ::Graphics::Surface *surface, const Common::Rect &rect) {
	Common::Rect spriteRect = Common::Rect(sprite.drawX, sprite.drawY,
			sprite.drawX+sprite.bitmap->width, sprite.drawY+sprite.bitmap->height);

	assert(_screenRect.contains(rect));
	assert(spriteRect.contains(rect));

	byte *dest = (byte*)surface->getPixels() + rect.top*SCREEN_WIDTH + rect.left;

	switch(sprite.drawMode) {
	case 0: { // Normal sprite
		byte *src = sprite.bitmap->pixels + (rect.left - sprite.drawX)
			+ (rect.top - sprite.drawY) * sprite.bitmap->width;

		int priOffset = rect.top*SCREEN_WIDTH + rect.left;

		for (int y = rect.top; y < rect.bottom; y++) {
			for (int x = rect.left; x < rect.right; x++) {
				byte priByte = _priData[priOffset / 2];
				byte bgPriority;
				if ((priOffset % 2) == 1)
					bgPriority = priByte & 0xf;
				else
					bgPriority = priByte >> 4;
				priOffset++;

				byte b = *src++;
				if (b == 0 || sprite.drawPriority < bgPriority) {
					dest++;
					continue;
				}
				*dest++ = b;
			}

			src       += sprite.bitmap->width - rect.width();
			dest      += SCREEN_WIDTH - rect.width();
			priOffset += SCREEN_WIDTH - rect.width();
		}
		break;
	}

	case 1: // Invisible
		break;

	case 2: { // Normal sprite with darkened background for "transparent" pixels (and no priority)
		byte *src = sprite.bitmap->pixels + (rect.left - sprite.drawX)
			+ (rect.top - sprite.drawY) * sprite.bitmap->width;

		for (int y = rect.top; y < rect.bottom; y++) {
			for (int x = rect.left; x < rect.right; x++) {
				byte b = *src;

				if (b == 0) // Transparent (darken the pixel)
					*dest = _lutData[*dest];
				else // Solid color
					*dest = b;

				src++;
				dest++;
			}

			src += sprite.bitmap->width - rect.width();
			dest += SCREEN_WIDTH - rect.width();
		}

		break;
	}

	case 3: { // Text
		// The sprite's "bitmap" is not actually a bitmap, but instead the list of
		// characters to display.

		// Units of this rect are "characters" instead of pixels. This contains all
		// characters to be drawn.
		Common::Rect rectangle1;

		rectangle1.left   = (rect.left   - sprite.drawX) / 8;
		rectangle1.top    = (rect.top    - sprite.drawY) / 8;
		rectangle1.right  = (rect.right  - sprite.drawX + 7) / 8;
		rectangle1.bottom = (rect.bottom - sprite.drawY + 7) / 8;

		int drawWidth = rectangle1.width();
		int drawHeight = rectangle1.height();

		dest = (byte*)surface->getPixels() + sprite.drawY*SCREEN_WIDTH + sprite.drawX
			+ rectangle1.top*8*SCREEN_WIDTH + rectangle1.left*8;

		byte *src = sprite.bitmap->pixels + rectangle1.top * sprite.bitmap->width / 8 + rectangle1.left;

		for (int y=0; y < drawHeight; y++) {
			for (int x=0; x < drawWidth; x++) {
				byte c = *src;

				int textColor;
				if (c >= 0x10 && c <= 0x1A) // Border characters
					textColor = 0xb3;
				else
					textColor = sprite.textColor;

				byte *fontData = _font->getCharData(c);

				for (int i = 0; i < 8; i++) {
					for (int j = 0; j < 8; j++) {
						byte b = *fontData;

						if (b == 0) // Transparent: use lookup table to darken this pixel
							*dest = _lutData[*dest];
						else if (b == 0x78) // Inner part of character
							*dest = textColor;
						else // Outline of character
							*dest = b;

						fontData++;
						dest++;
					}
					dest += SCREEN_WIDTH - 8;
				}

				dest -= (SCREEN_WIDTH * 8 - 8);
				src++;
			}

			src += (sprite.bitmap->width / 8) - drawWidth;
			dest += (SCREEN_WIDTH * 8) - drawWidth * 8;

		}

		break;
	}

	default:
		error("drawSprite: draw mode %d invalid", sprite.drawMode);
		break;
	}
}

/**
 * Compare 2 sprites for the purpose of sorting them by layer before drawing.
 * FIXME: Original returned an int, not a bool. This may affect the stability of the sort...
 */
bool compareSpritesByLayer(Sprite *s1, Sprite *s2) {
	if (s1->drawPriority != s2->drawPriority)
		return s1->drawPriority < s2->drawPriority;
	if (s1->drawPriority2 != s2->drawPriority2)
		return s1->drawPriority2 < s2->drawPriority2;
	if (s1->pos.y != s2->pos.y)
		return s1->pos.y < s2->pos.y;
	return s1->pos.x < s2->pos.x;
}

void Graphics::drawAllSprites(bool updateScreen) {
	// TODO: different video modes?

	if (_numSprites == 0)
		return;

	// Sort sprites by layer
	Common::sort(_sprites, _sprites + _numSprites, &compareSpritesByLayer);

	// Update sprite rectangles
	for (int i=0; i<_numSprites; i++) {
		Sprite *spr = _sprites[i];
		Common::Rect rect;

		rect.left   = spr->pos.x - spr->bitmap->xoffset;
		rect.top    = spr->pos.y - spr->bitmap->yoffset;
		rect.right  = rect.left + spr->bitmap->width;
		rect.bottom = rect.top + spr->bitmap->height;

		spr->drawX = rect.left;
		spr->drawY = rect.top;

		spr->drawRect = rect.findIntersectingRect(_screenRect);

		if (!spr->drawRect.isEmpty()) { // At least partly on-screen
			if (spr->lastDrawRect.left < spr->lastDrawRect.right) {
				// If the sprite's position is close to where it was last time it was
				// drawn, combine the two rectangles and redraw that whole section.
				// Otherwise, redraw the old position and current position separately.
				rect = spr->drawRect.findIntersectingRect(spr->lastDrawRect);

				if (rect.isEmpty())
					spr->rect2Valid = 0;
				else {
					spr->rectangle2 = getRectEncompassing(spr->drawRect, spr->lastDrawRect);
					spr->rect2Valid = 1;
				}
			}
			else {
				spr->rectangle2 = spr->drawRect;
				spr->rect2Valid = 1;
			}

			spr->isOnScreen = 1;
		}
		else { // Off-screen
			spr->rect2Valid = 0;
			spr->isOnScreen = 0;
		}
	}

	// Determine what portions of the screen need to be updated
	Common::Rect dirtyRects[MAX_SPRITES * 2];
	int numDirtyRects = 0;

	for (int i = 0; i < _numSprites; i++) {
		Sprite *spr = _sprites[i];

		if (spr->bitmapChanged) {
			if (spr->isOnScreen) {
				if (spr->rect2Valid) {
					dirtyRects[numDirtyRects++] = spr->rectangle2;
				}
				else {
					dirtyRects[numDirtyRects++] = spr->drawRect;
					dirtyRects[numDirtyRects++] = spr->lastDrawRect;
				}
			}
			else {
				dirtyRects[numDirtyRects++] = spr->lastDrawRect;
			}
		}
	}

	// Redraw the background on every dirty rectangle
	const ::Graphics::PixelFormat format = ::Graphics::PixelFormat::createFormatCLUT8();
	::Graphics::Surface surface;
	surface.create(SCREEN_WIDTH, SCREEN_HEIGHT, format);

	for (int i = 0; i < numDirtyRects; i++) {
		Common::Rect &r = dirtyRects[i];
		if (r.width() == 0 || r.height() == 0)
			continue;

		int offset = r.top * SCREEN_WIDTH + r.left;
		surface.copyRectToSurface(_backgroundImage->pixels + offset, SCREEN_WIDTH, r.left, r.top, r.width(), r.height());
	}

	// For each sprite, merge the rectangles that overlap with it and redraw the sprite.
	for (int i = 0; i < _numSprites; i++) {
		Sprite *spr = _sprites[i];

		if (!spr->field16 && spr->isOnScreen) {
			bool mustRedrawSprite = false;
			Common::Rect rect2;

			for (int j = 0; j < numDirtyRects; j++) {
				Common::Rect rect1 = spr->drawRect.findIntersectingRect(dirtyRects[j]);

				if (rect1.width() != 0 && rect1.height() != 0) {
					if (mustRedrawSprite)
						rect2 = getRectEncompassing(rect1, rect2);
					else
						rect2 = rect1;
					mustRedrawSprite = true;
				}
			}

			if (mustRedrawSprite)
				drawSprite(*spr, &surface, rect2);
		}

		spr->field16 = false;
		spr->bitmapChanged = false;
		spr->lastDrawRect = spr->drawRect;
	}

	// Copy dirty rects to screen
	for (int j = 0; j < numDirtyRects; j++) {
		Common::Rect &r = dirtyRects[j];
		if (r.width() == 0 || r.height() == 0)
			continue;

		int offset = r.left + r.top * SCREEN_WIDTH;
		_vm->_system->copyRectToScreen((byte *)surface.getPixels() + offset, SCREEN_WIDTH, r.left, r.top, r.width(), r.height());
	}

	surface.free();

	if (updateScreen) {
		// Check if there are any pending updates to the mouse.
		if (_mouseBitmap != _mouseBitmapLastFrame) {
			_mouseBitmapLastFrame = _mouseBitmap;
			_vm->_system->setMouseCursor(_mouseBitmap->pixels, _mouseBitmap->width, _mouseBitmap->height, _mouseBitmap->xoffset, _mouseBitmap->yoffset, 0);
		}
		if (_mouseToBeShown) {
			CursorMan.showMouse(true);
			_mouseToBeShown = false;
		}
		else if (_mouseToBeHidden) {
			CursorMan.showMouse(false);
			_mouseToBeHidden = false;
		}

		if (_mouseWarpX != -1) {
			_vm->_system->warpMouse(_mouseWarpX, _mouseWarpY);
			_mouseWarpX = -1;
			_mouseWarpY = -1;
		}

		_vm->_system->updateScreen();
	}
}

/**
 * Sets "bitmapChanged" to true on all sprites before calling drawAllSprites.
 */
void Graphics::forceDrawAllSprites(bool updateScreen) {
	for (int i = 0; i < _numSprites; i++)
		_sprites[i]->bitmapChanged = true;
	drawAllSprites(updateScreen);
}

/**
 * Returns the sprite at the given position (ignores mouse).
 */
Sprite *Graphics::getSpriteAt(int16 x, int16 y) {
	for (int i = _numSprites - 1; i >= 0; i--) {
		Sprite *sprite = _sprites[i];

		if (sprite == &_lockedMouseSprite)
			continue;
		if (sprite->drawMode == 1) // Invisible
			continue;

		if (sprite->drawRect.contains(Common::Point(x, y))) {
			if (sprite->drawMode == 2 || sprite->drawMode == 3) // Button or text
				return sprite;

			// For draw mode 0 only, check that we're not clicking on a transparent part.
			int16 relX = x - sprite->drawX;
			int16 relY = y - sprite->drawY;
			byte pixel = sprite->bitmap->pixels[relY * sprite->bitmap->width + relX];
			if (pixel != 0)
				return sprite;
		}
	}

	return nullptr;
}

void Graphics::addSprite(Sprite *sprite) {
	if (_numSprites >= MAX_SPRITES)
		error("addSprite: too many sprites");

	// Initialize some fields
	sprite->drawMode = 0;
	sprite->field8 = 0;
	sprite->field16 = false;
	sprite->bitmapChanged = true; // FIXME (delete this later?)

	sprite->lastDrawRect.top = -1;
	sprite->lastDrawRect.left = -1;
	sprite->lastDrawRect.bottom = -2;
	sprite->lastDrawRect.right = -2;

	_sprites[_numSprites++] = sprite;
}

void Graphics::delSprite(Sprite *sprite) {
	for (int i=0; i<_numSprites; i++) {
		if (sprite != _sprites[i])
			continue;

		_numSprites--;
		_sprites[i] = _sprites[_numSprites];
		return;
	}

	error("delSprite: sprite not in list");
}

void Graphics::pushSprites() {
	if (_pushedNumSprites != -1)
		error("Tried to push sprites more than once");
	_pushedNumSprites = _numSprites;
	memcpy(_pushedSprites, _sprites, sizeof(_sprites));

	_numSprites = 0;
}

void Graphics::popSprites() {
	if (_pushedNumSprites == -1)
		error("Tried to pop sprites without a prior push");
	_numSprites = _pushedNumSprites;
	memcpy(_sprites, _pushedSprites, sizeof(_sprites));

	_pushedNumSprites = -1;
}


void Graphics::copyBackgroundScreen() {
	drawDirectToScreen(_backgroundImage);
}

void Graphics::drawDirectToScreen(SharedPtr<Bitmap> bitmap) {
	int xoffset = bitmap->xoffset;
	int yoffset = bitmap->yoffset;

	_vm->_system->copyRectToScreen(bitmap->pixels, bitmap->width, xoffset, yoffset, bitmap->width, bitmap->height);
}


void Graphics::loadEGAData(const char *filename) {
	// Load EGA palette data
	if (!_egaMode)
		return;

	if (!_egaData)
		_egaData = new byte[256];

	SharedPtr<FileStream> egaStream = _vm->loadFile(filename);
	egaStream->read(_egaData, 256);
}

void Graphics::drawBackgroundImage(const char *filename) {
	// Draw an stjr BGD image (palette built-in)

	SharedPtr<FileStream> imageStream = _vm->loadFile(filename);
	byte *palette = new byte[256 * 3];
	imageStream->read(palette, 256 * 3);

	// Expand color components
	for (uint16 i = 0; i < 256 * 3; i++)
		palette[i] <<= 2;

	uint16 xoffset = imageStream->readUint16();
	uint16 yoffset = imageStream->readUint16();
	uint16 width = imageStream->readUint16();
	uint16 height = imageStream->readUint16();

	byte *pixels = new byte[width * height];
	imageStream->read(pixels, width * height);

	_vm->_system->getPaletteManager()->setPalette(palette, 0, 256);
	_vm->_system->copyRectToScreen(pixels, width, xoffset, yoffset, width, height);
	_vm->_system->updateScreen();

	delete[] palette;
}

}