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

#include "kyra/resource/resource.h"
#include "graphics/sjis.h"

namespace Kyra {

void Screen_EoB::selectPC98Palette(int palID, Palette &dest, int brightness, bool set) {
	if (palID < 0 || palID > 9)
		return;
	if (!_use16ColorMode)
		return;

	int temp = 0;
	const uint8 *pal16c = _vm->staticres()->loadRawData(kEoB1Palettes16c, temp);
	if (!pal16c)
		return;

	uint8 pal[48];
	for (int i = 0; i < 48; ++i)
		pal[i] = CLIP<int>(pal16c[palID * 48 + i] + brightness, 0, 15);
	loadPalette(pal, dest, 48);

	if (set)
		setScreenPalette(dest);
}

void Screen_EoB::decodeBIN(const uint8 *src, uint8 *dst, uint16 inSize) {
	const uint8 *end = src + inSize;
	memset(_dsTempPage, 0, 2048);
	int tmpDstOffs = 0;

	while (src < end) {
		uint8 code = *src++;
		if (!(code & 0x80)) {
			int offs = code << 4;
			code = *src++;
			offs |= (code >> 4);
			int len = (code & 0x0F) + 2;
			int tmpSrcOffs = (tmpDstOffs - offs) & 0x7FF;
			const uint8 *tmpSrc2 = dst;

			for (int len2 = len; len2; len2--) {
				*dst++ = _dsTempPage[tmpSrcOffs++];
				tmpSrcOffs &= 0x7FF;
			}

			while (len--) {
				_dsTempPage[tmpDstOffs++] = *tmpSrc2++;
				tmpDstOffs &= 0x7FF;
			}

		} else if (code & 0x40) {
			int len = code & 7;
			if (code & 0x20)
				len = (len << 8) | *src++;
			len += 2;

			int planes = ((code >> 3) & 3) + 1;
			while (len--) {
				for (int i = 0; i < planes; ++i) {
					*dst++ = _dsTempPage[tmpDstOffs++] = src[i];
					tmpDstOffs &= 0x7FF;
				}
			}
			src += planes;
		} else {
			for (int len = (code & 0x3F) + 1; len; len--) {
				*dst++ = _dsTempPage[tmpDstOffs++] = *src++;
				tmpDstOffs &= 0x7FF;
			}
		}
	}
}

void Screen_EoB::decodePC98PlanarBitmap(uint8 *srcDstBuffer, uint8 *tmpBuffer, uint16 size) {
	assert(tmpBuffer != srcDstBuffer);
	memcpy(tmpBuffer, srcDstBuffer, size);
	const uint8 *src = tmpBuffer;
	uint8 *dst1 = srcDstBuffer;
	uint8 *dst2 = srcDstBuffer + 4;
	size >>= 3;
	while (size--) {
		for (int i = 0; i < 4; ++i) {
			uint8 col1 = 0;
			uint8 col2 = 0;
			for (int ii = 0; ii < 4; ++ii) {
				col1 |= ((src[ii] >> (7 - i)) & 1) << ii;
				col2 |= ((src[ii] >> (3 - i)) & 1) << ii;
			}
			*dst1++ = col1;
			*dst2++ = col2;
		}
		src += 4;
		dst1 += 4;
		dst2 += 4;
	}
}

void Screen_EoB::initPC98PaletteCycle(int palID, PalCycleData *data) {
	if (!_use16ColorMode || !_cyclePalette)
		return;
	if (palID < 0 || palID > 9)
		return;

	_activePalCycle = data;
	int temp = 0;
	const uint8 *pal16c = _vm->staticres()->loadRawData(kEoB1Palettes16c, temp);
	if (!pal16c)
		return;

	if (data)
		memcpy(_cyclePalette, &pal16c[palID * 48], 48);
	else
		memset(_cyclePalette, 0, 48);
}

void Screen_EoB::updatePC98PaletteCycle(int brightness) {
	if (_activePalCycle) {
		for (int i = 0; i < 48; ++i) {
			if (--_activePalCycle[i].delay)
				continue;
			for (int8 in = 32; in == 32; ) {
				in = *_activePalCycle[i].data++;
				if (in < 16 && in > -16) {
					_cyclePalette[i] += in;
					_activePalCycle[i].delay = *_activePalCycle[i].data++;
				} else if (in < 32) {
					_cyclePalette[i] = in - 16;
					_activePalCycle[i].delay = *_activePalCycle[i].data++;
				} else if (in == 32)
					_activePalCycle[i].data += READ_BE_INT16(_activePalCycle[i].data);
			}
		}
	}

	uint8 pal[48];
	for (int i = 0; i < 48; ++i)
		pal[i] = CLIP<int>(_cyclePalette[i] + brightness, 0, 15);
	loadPalette(pal, *_palettes[0], 48);
	setScreenPalette(*_palettes[0]);
}

SJISFontEoB1PC98::SJISFontEoB1PC98(Common::SharedPtr<Graphics::FontSJIS> &font, /*uint8 shadowColor,*/ const uint16 *convTable1, const uint16 *convTable2) : SJISFont(font, 0, false, false, 0),
/*_shadowColor(shadowColor),*/ _convTable1(convTable1), _convTable2(convTable2), _defaultConv(true) {
	assert(_convTable1);
	assert(_convTable2);
}

int SJISFontEoB1PC98::getCharWidth(uint16 c) const {
	return SJISFont::getCharWidth(convert(c));
}

void SJISFontEoB1PC98::drawChar(uint16 c, byte *dst, int pitch, int) const {
	c = convert(c);
	_font->setDrawingMode(_style == kStyleLeftShadow ? Graphics::FontSJIS::kShadowLeftMode : Graphics::FontSJIS::kDefaultMode);
	_font->toggleFatPrint(false);
	_font->drawChar(dst, c, 640, 1, _colorMap[1], _colorMap[0], 640, 400);
}

uint16 SJISFontEoB1PC98::convert(uint16 c) const {
	uint8 l = c & 0xFF;
	uint8 h = c >> 8;

	if (c < 128) {
		assert(l > 31);
		c = _convTable2[l - 32];
	} else if (l > 160 && l < 225) {
		bool done = false;
		if (_defaultConv) {
			if (h == 0xDE) {
				if ((l >= 182 && l <= 196) || (l >= 202 && l <= 206)) {
					c = _convTable1[l - 182];
					done = true;
				}
			} else if (h == 0xDF) {
				if (l >= 202 && l <= 206) {
					c = _convTable1[l - 177];
					done = true;
				}
			}
		}
		if (!done)
			c = _convTable2[l - 64];
	}

	return c;
}

SJISFontEoB2PC98::SJISFontEoB2PC98(Common::SharedPtr<Graphics::FontSJIS> &font, /*uint8 shadowColor,*/ const char *convTable1, const char *convTable2) : SJISFont(font, 0, false, false, 0),
/*_shadowColor(shadowColor),*/ _convTable1(convTable1), _convTable2(convTable2)/*, _defaultConv(true)*/ {
	assert(_convTable1);
	assert(_convTable2);
}

int SJISFontEoB2PC98::getCharWidth(uint16 c) const {
	return SJISFont::getCharWidth(convert(c));
}

void SJISFontEoB2PC98::drawChar(uint16 c, byte *dst, int pitch, int) const {
	SJISFont::drawChar(convert(c), dst, pitch, 0);
}

uint16 SJISFontEoB2PC98::convert(uint16 c) const {
	uint8 l = c & 0xFF;
	uint8 h = c >> 8;

	if (h || l < 32 || l == 127) {
		return c;
	} else if (l < 127) {
		c = (l - 32) * 2;
		assert(c < 190);
		l = _convTable1[c];
		h = _convTable1[c + 1];
	} else if (l < 212) {
		h = l - 64;
		l = 0x83;
	} else {
		c = (l - 212) * 2;
		assert(c < 8);
		l = _convTable2[c];
		h = _convTable2[c + 1];
	}

	return (h << 8) | l;
}

Font12x12PC98::Font12x12PC98(uint8 shadowColor, const uint16 *convTable1, const uint16 *convTable2, const uint8 *lookupTable) : OldDOSFont(Common::kRenderDefault, 12), _convTable1(convTable1), _convTable2(convTable2) {
	assert(convTable1);
	assert(convTable2);
	assert(lookupTable);

	_width = _height = 12;
	_numGlyphs = 275;
	_bmpOffs = new uint16[_numGlyphs];
	for (int i = 0; i < _numGlyphs; ++i)
		_bmpOffs[i] = lookupTable[i] * 24;
}

Font12x12PC98::~Font12x12PC98() {
	delete[] _bmpOffs;
}

bool Font12x12PC98::load(Common::SeekableReadStream &file) {
	unload();

	_width = _height = 12;
	_numGlyphs = 275;
	_bitmapOffsets = _bmpOffs;

	_data = new uint8[file.size()];
	assert(_data);

	file.read(_data, file.size());
	if (file.err())
		return false;

	return true;
}

uint16 Font12x12PC98::convert(uint16 c) const {
	uint8 l = c & 0xFF;
	uint8 h = c >> 8;

	if (c < 128) {
		c = _convTable2[l - 32];
	} else if (l > 160 && l < 225) {
		bool done = false;
		if (h == 0xDE) {
			if ((l >= 182 && l <= 196) || (l >= 202 && l <= 206)) {
				c = _convTable1[l - 182];
				done = true;
			}
		} else if (h == 0xDF) {
			if (l >= 202 && l <= 206) {
				c = _convTable1[l - 177];
				done = true;
			}
		}
		if (!done)
			c = _convTable2[l - 64];
	}

	c = SWAP_BYTES_16(c);
	if (c < 0x813F)
		c = 1;
	else if (c < 0x824F)
		c -= 0x813F;
	else if (c < 0x833F)
		c -= 0x81EE;
	else if (c > 0x839F)
		c = 1;
	else
		c -= 0x828D;

	return c;
}

PC98Font::PC98Font(uint8 shadowColor, bool useOverlay, int scaleV, const uint8 *convTable1, const char *convTable2, const char *convTable3) : OldDOSFont(Common::kRenderVGA, shadowColor),
	_convTable1(convTable1), _convTable2(convTable2), _convTable3(convTable3), _outputWidth(0), _outputHeight(0), _type(convTable1 && convTable2 && convTable3 ? kSJIS : kASCII) {
	_numGlyphsMax = 256;
	_useOverlay = useOverlay;
	_scaleV = scaleV;

}

bool PC98Font::load(Common::SeekableReadStream &file) {
	bool res = OldDOSFont::load(file);

	_outputWidth = _width;
	_outputHeight = _height * _scaleV;

	if (_useOverlay) {
		_outputWidth >>= 1;
		_outputHeight >>= 1;
	}

	return res;
}

uint16 PC98Font::convert(uint16 c) const {
	if (_type == kSJIS)
		c = makeTwoByte(c);

	if (!_convTable1 || c < 128)
		return c;

	uint8 lo = c & 0xff;
	uint8 hi = c >> 8;

	if (lo == 0x81) {
		if (hi >= 0x40 && hi <= 0xac)
			return _convTable1[hi - 0x40];
	} else if (lo == 0x82) {
		if (hi >= 0x4f && hi <= 0x58)
			return hi - 31;
		if (hi >= 0x60 && hi <= 0x79)
			return hi - 31;
		if (hi >= 0x81 && hi <= 0x9a)
			return hi - 32;
	} else if (lo == 0x83 && hi >= 0x40 && hi <= 0x93) {
		return hi + 64;
	}

	return 0;
}

uint16 PC98Font::makeTwoByte(uint16 c) const {
	if (!_convTable2 || !_convTable3)
		return c;

	uint8 l = c & 0xFF;
	uint8 h = c >> 8;

	if (h || l < 32 || l == 127) {
		return c;
	} else if (l < 127) {
		c = (l - 32) * 2;
		assert(c < 190);
		l = _convTable2[c];
		h = _convTable2[c + 1];
	} else if (l < 212) {
		h = l - 64;
		l = 0x83;
	} else {
		c = (l - 212) * 2;
		assert(c < 8);
		l = _convTable3[c];
		h = _convTable3[c + 1];
	}

	return (h << 8) | l;
}

} // End of namespace Kyra

#endif // ENABLE_EOB