/* 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/file.h"
#include "common/system.h"
#include "graphics/cursorman.h"
#include "sci/graphics/drivers/gfxdriver_intern.h"

namespace Sci {

class SCI1_PC98Gfx8ColorsDriver final : public UpscaledGfxDriver {
public:
	SCI1_PC98Gfx8ColorsDriver(bool rgbRendering);
	~SCI1_PC98Gfx8ColorsDriver() override;
	void initScreen(const Graphics::PixelFormat *format) override;
	void setPalette(const byte*, uint, uint, bool, const PaletteMod*, const byte*) override {}
	void copyRectToScreen(const byte *src, int srcX, int srcY, int pitch, int destX, int destY, int w, int h, const PaletteMod *palMods, const byte *palModMapping) override;
	void replaceCursor(const void *cursor, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor) override;
	byte remapTextColor(byte) const override;
	static bool validateMode(Common::Platform p) { return (p == Common::kPlatformPC98) && checkDriver(&_driverFile, 1); }
private:
	const byte *_ditheringTable;
	const byte *_convPalette;
	static const char *_driverFile;
};

SCI1_PC98Gfx8ColorsDriver::SCI1_PC98Gfx8ColorsDriver(bool rgbRendering) : UpscaledGfxDriver(1, true, rgbRendering), _ditheringTable(nullptr), _convPalette(nullptr) {
	Common::File drv;
	if (!drv.open(_driverFile))
		GFXDRV_ERR_OPEN(_driverFile);

	uint16 eprcOffs = 0;

	uint32 cmd = drv.readUint32LE();
	if ((cmd & 0xFF) == 0xE9)
		eprcOffs = ((cmd >> 8) & 0xFFFF) + 3;

	if (!eprcOffs || drv.readUint32LE() != 0x87654321 || !drv.skip(1) || !drv.seek(drv.readByte(), SEEK_CUR) || !drv.seek(drv.readByte(), SEEK_CUR))
		GFXDRV_ERR_VERSION(_driverFile);

	uint32 pos = (drv.pos() + 1) & ~1;

	drv.seek(pos + 2);
	drv.seek(drv.readUint16LE());
	byte *buff = new byte[190];
	drv.read(buff, 190);

	uint16 tableOffs = 0;
	int step = 0;
	for (int i = 0; i < 182 && !tableOffs; ++i) {
		uint32 c = READ_BE_UINT32(buff + i);
		if (step == 0 && ((c & 0xFFF0FFF0) != 0xD1E0D1E0 || (READ_BE_UINT32(buff + i + 4) ^ c)))
			continue;

		if (step == 0) {
			step = 1;
			i += 7;
			continue;
		}

		if (c >> 20 != 0x81C || ((READ_BE_UINT32(buff + i + 4) >> 20) ^ (c >> 20)))
			continue;

		if ((c & 0xFFFF) == READ_BE_UINT16(buff + i + 6))
			tableOffs = FROM_BE_16(c);
	}
	delete[] buff;

	if (!tableOffs)
		error("SCI1_PC98Gfx8ColorsDriver: Failed to load dithering data from '%s'", _driverFile);

	drv.seek(tableOffs);
	byte *dmx = new byte[96]();
	drv.read(dmx, 96);

	if (drv.readUint16LE() != 0xA800 || drv.readUint16LE() != 0xB000)
		GFXDRV_ERR_VERSION(_driverFile);

	drv.close();

	byte *dt = new byte[1536]();
	_ditheringTable = dt;

	for (uint16 i = 0; i < 256; ++i) {
		for (int ii = 0; ii < 6; ++ii)
			*dt++ = (dmx[(i >> 4) * 6 + ii] & 0xCC) | (dmx[(i & 0x0f) * 6 + ii] & 0x33);
	}

	delete[] dmx;

	_textAlignX = 1;

	byte *col = new byte[8 * 3]();
	_convPalette = col;

	for (uint8 i = 0; i < 8; ++i) {
		*col++ = (i & 2) ? 0xff : 0;
		*col++ = (i & 1) ? 0xff : 0;
		*col++ = (i & 4) ? 0xff : 0;
	}
}

SCI1_PC98Gfx8ColorsDriver::~SCI1_PC98Gfx8ColorsDriver() {
	delete[] _ditheringTable;
	delete[] _convPalette;
}

void renderPlanarMatrix(byte *dst, const byte *src, int pitch, int w, int h, const byte *tbl) {
	int dstPitch = pitch << 1;
	byte *d1 = dst;
	byte *d2 = d1 + dstPitch;
	pitch -= w;
	dstPitch += (pitch << 1);

	while (h--) {
		byte sh = 0;
		for (int i = 0; i < (w >> 1); ++i) {
			const byte *c = &tbl[(src[0] << 4 | src[1]) * 6];
			for (int ii = sh; ii < sh + 4; ++ii) {
				*d1++ = (((c[0] >> (7 - ii)) & 1) << 2) | (((c[1] >> (7 - ii)) & 1) << 1) | ((c[2] >> (7 - ii)) & 1);
				*d2++ = (((c[3] >> (7 - ii)) & 1) << 2) | (((c[4] >> (7 - ii)) & 1) << 1) | ((c[5] >> (7 - ii)) & 1);
			}
			src += 2;
			sh ^= 4;
		}

		src += pitch;
		d1 += dstPitch;
		d2 += dstPitch;
	}
}

void SCI1_PC98Gfx8ColorsDriver::initScreen(const Graphics::PixelFormat *format) {
	UpscaledGfxDriver::initScreen(format);

	_renderGlyph = &SciGfxDrvInternal::renderPC98GlyphFat;

	assert(_convPalette);
	GfxDefaultDriver::setPalette(_convPalette, 0, 8, true, nullptr, nullptr);
}

void SCI1_PC98Gfx8ColorsDriver::copyRectToScreen(const byte *src, int srcX, int srcY, int pitch, int destX, int destY, int w, int h, const PaletteMod *palMods, const byte *palModMapping) {
	GFXDRV_ASSERT_READY;
	assert (h >= 0 && w >= 0);

	byte diff = srcX & 7;
	srcX &= ~7;
	destX &= ~7;
	w = (w + diff + 7) & ~7;

	src += (srcY * pitch + srcX * _srcPixelSize);
	if (src != _currentBitmap)
		SciGfxDrvInternal::updateBitmapBuffer(_currentBitmap, _virtualW * _srcPixelSize, src, pitch, destX * _srcPixelSize, destY, w * _srcPixelSize, h);

	byte *scb = _scaledBitmap + (destY << 1) * _screenW * _srcPixelSize + (destX << 1) * _srcPixelSize;
	renderPlanarMatrix(scb, src, pitch, w, h, _ditheringTable);

	updateScreen(destX << 1, destY << 1,  w << 1, h << 1, palMods, palModMapping);
}

void SCI1_PC98Gfx8ColorsDriver::replaceCursor(const void *cursor, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor) {
	GFXDRV_ASSERT_READY;
	adjustCursorBuffer(w << 1, h << 1);
	const byte *s = reinterpret_cast<const byte*>(cursor);
	byte *d1 = _compositeBuffer;
	uint32 newKeyColor = 0xFF;

	int dstPitch = (w << 1);
	byte *d2 = _compositeBuffer + dstPitch;

	for (uint i = 0; i < h; ++i) {
		for (uint ii = 0; ii < w; ++ii) {
			byte col = *s++;
			if (col == keycolor) {
				*d1++ = *d2++ = newKeyColor;
				*d1++ = *d2++ = newKeyColor;
			} else {
				*d1++ = *d2++ = (col & 7);
				*d1++ = *d2++ = (col & 8) ? (col & 7) : 0;
			}
		}
		d1 += dstPitch;
		d2 += dstPitch;
	}

	CursorMan.replaceCursor(_compositeBuffer, w << 1, h << 1, hotspotX << 1, hotspotY << 1, newKeyColor);
}

byte SCI1_PC98Gfx8ColorsDriver::remapTextColor(byte) const {
	// Always black. The driver opcode actually has a pen color argument, but it isn't put to any use. Not sure if it is intended.
	return 0;
}

const char *SCI1_PC98Gfx8ColorsDriver::_driverFile = "9801V8.DRV";

SCI_GFXDRV_VALIDATE_IMPL(SCI1_PC98Gfx8Colors)

GfxDriver *SCI1_PC98Gfx8ColorsDriver_create(int rgbRendering, ...) {
	return new SCI1_PC98Gfx8ColorsDriver(rgbRendering != 0);
}

} // End of namespace Sci