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

// Font management and font drawing header file

#ifndef SAGA_FONT_H
#define SAGA_FONT_H

#include "common/list.h"
#include "saga/gfx.h"

namespace Graphics {
	class FontSJIS;
}

namespace Saga {

#define FONT_SHOWUNDEFINED 1	// Define to draw undefined characters * as ?'s

// The first defined character (!) is the only one that may
// have a valid offset of '0'
#define FONT_FIRSTCHAR 33

#define FONT_CH_TAB 9
#define FONT_CH_SPACE 32
#define FONT_CH_QMARK 63

// Minimum font header size without font data
// (6 + 512 + 256 + 256 + 256 )
#define FONT_DESCSIZE 1286

#define FONT_CHARCOUNT 256
#define FONT_CHARMASK 0xFFU

#define SAGA_FONT_HEADER_LEN 6

#define TEXT_CENTERLIMIT 50
#define TEXT_MARGIN 10
#define TEXT_LINESPACING 2

enum FontEffectFlags {
	kFontNormal   = 0,
	kFontOutline  = 1 << 0,
	kFontShadow   = 1 << 1,
	kFontBold     = 1 << 2,
	kFontCentered = 1 << 3,
	kFontDontmap  = 1 << 4
};

enum KnownFont {
	kKnownFontSmall,
	kKnownFontMedium,
	kKnownFontBig,

	kKnownFontPause,
	kKnownFontScript,
	kKnownFontVerb
};

struct TextListEntry {
	bool display;
	bool useRect;
	Common::Point point;
	Common::Rect rect;
	KnownColor knownColor;
	KnownColor effectKnownColor;
	FontEffectFlags flags;
	KnownFont font;
	const char *text;

	TextListEntry() {
		display = false;
		useRect = false;
		// point initialized by Common::Point constructor
		// rect initialized by Common::Rect constructor
		knownColor = kKnownColorTransparent;
		effectKnownColor = kKnownColorTransparent;
		flags = kFontNormal;
		font = kKnownFontSmall;
		text = nullptr;
	}

	bool operator==(const TextListEntry &e) const {
		return 0 == memcmp(this, &e, sizeof(*this));
	}
};

class TextList: public Common::List<TextListEntry> {
public:

	TextListEntry *addEntry(const TextListEntry &entry) {
		Common::List<TextListEntry>::push_back(entry);
		return &*--Common::List<TextListEntry>::end();
	}
};

struct FontHeader {
	int charHeight;
	int charWidth;
	int rowLength;
};

struct FontCharEntry {
	int index;
	int byteWidth;
	int width;
	int flag;
	int tracking;
};

struct FontStyle {
	FontHeader header;
	FontCharEntry fontCharEntry[256];
#ifndef __DS__
	ByteArray font;
#else
	byte* font;
#endif
};

struct FontData {
	FontStyle normal;
	FontStyle outline;
};

class Font {
public:
	Font(SagaEngine *vm) : _vm(vm) {}
	virtual ~Font() {}

	int getStringWidth(KnownFont font, const char *text, size_t count, FontEffectFlags flags) {
		return getStringWidth(knownFont2FontIdx(font), text, count, flags);
	}

	int getHeight(KnownFont font) {
		return getHeight(knownFont2FontIdx(font));
	}

	int getHeight(KnownFont font, const char *text, int width, FontEffectFlags flags) {
		return getHeight(knownFont2FontIdx(font), text, width, flags);
	}

	void textDraw(KnownFont font, const char *string, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) {
		textDraw(knownFont2FontIdx(font), string, point, color, effectColor, flags);
	}

	void textDrawRect(KnownFont font, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) {
		textDrawRect(knownFont2FontIdx(font), text, rect, color, effectColor, flags);
	}

	virtual void setFontMapping(int) {}

protected:
	enum FontId {
		kSmallFont,
		kMediumFont,
		kBigFont,
		kIHNMUnknown,
		kIHNMFont8,
		kIHNMUnknown2,
		kIHNMMainFont
	};

	SagaEngine *_vm;

private:
	FontId knownFont2FontIdx(KnownFont font);
	void textDraw(FontId fontId, const char *string, const Common::Point &point, int color, int effectColor, FontEffectFlags flags);

	virtual void textDrawRect(FontId fontId, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) = 0;
	virtual int translateChar(int charId) = 0;
	virtual int getStringLength(const char *text) = 0;
	virtual int getStringWidth(FontId fontId, const char *text, size_t count, FontEffectFlags flags) = 0;
	virtual int getHeight(FontId fontId, const char *text, int width, FontEffectFlags flags) = 0;
	virtual int getHeight(FontId fontId) = 0;
	virtual bool valid(FontId) = 0;
	virtual void draw(FontId fontId, const char *text, size_t count, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) = 0;
};

class DefaultFont : public Font {
 public:
	DefaultFont(SagaEngine *vm);
	~DefaultFont() override;

	void setFontMapping(int mapping) override {
		_fontMapping = mapping;
	}

 private:
	 void textDrawRect(FontId fontId, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) override;
	 int translateChar(int charId) override;
	 int getStringLength(const char *text) override {
		 return strlen(text);
	 }

	 int getStringWidth(FontId fontId, const char *text, size_t count, FontEffectFlags flags) override;
	 int getHeight(FontId fontId, const char *text, int width, FontEffectFlags flags) override;
	 int getHeight(FontId fontId) override {
		 return getFont(fontId)->normal.header.charHeight;
	 }

	 int getHeight(FontId fontId, const char *text);

	 void validate(FontId fontId) {
		 if (!valid(fontId)) {
			 error("Font::validate: Invalid font id");
		 }
	 }

	 bool valid(FontId fontId) override {
		 return (uint(fontId) < _fonts.size());
	 }

	 FontData *getFont(FontId fontId) {
		 validate(fontId);
		 return &_fonts[fontId];
	 }

	 void draw(FontId fontId, const char *text, size_t count, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) override;
	 void outFont(const FontStyle &drawFont, const char *text, size_t count, const Common::Point &point, int color, FontEffectFlags flags);
	 void loadFont(FontData *font, uint32 fontResourceId);
	 void loadFont(FontData *font, const ByteArray& fontResourceData, bool isBigEndian);
	 void loadChineseFontIHNM(FontData *font, uint32 fontResourceId);
	 void loadChineseFontITE(const Common::Path &fileName);
	 void loadKoreanFontIHNM(const Common::Path &fileName);
	 void saveBig5Index(byte head, byte tail, uint curIdx);
	 void createOutline(FontData *font);
	 void blitGlyph(const Common::Point &textPoint, const byte* bitmap, int charWidth, int charHeight, int rowLength, byte color);

	 int getByteLen(int numBits) const {
		 int byteLength = numBits / 8;

		 if (numBits % 8) {
			 byteLength++;
		 }

		 return byteLength;
	 }

	static const int _charMap[128];

	Common::Array<FontData> _fonts;
	int _fontMapping;

	byte *_chineseFont;
	Common::Array<int> _chineseFontIndex;
	int _cjkFontWidth;
	int _cjkFontHeight;

	byte *_koreanFont;

	static const int kIHNMKoreanGlyphBytes = 32;
	static const int kIHNMKoreanInitials = 20;
	static const int kIHNMKoreanInitialVariants = 8;
	static const int kIHNMKoreanMidOffset = kIHNMKoreanInitialVariants * kIHNMKoreanInitials;
	static const int kIHNMKoreanMids = 22;
	static const int kIHNMKoreanMidVariants = 4;
	static const int kIHNMKoreanFinalsOffset = kIHNMKoreanMidOffset + kIHNMKoreanMids * kIHNMKoreanMidVariants;
	static const int kIHNMKoreanFinals = 28;
	static const int kIHNMKoreanFinalVariants = 4;
	static const int kIHNMKoreanNonJamoOffset = kIHNMKoreanFinalsOffset + kIHNMKoreanFinals * kIHNMKoreanFinalVariants;
	static const int kIHNMKoreanNonJamo = 126;
};

class SJISFont : public Font {
public:
	SJISFont(SagaEngine *vm);
	~SJISFont() override;

private:
	void textDrawRect(FontId fontId, const char *text, const Common::Rect &rect, int color, int effectColor, FontEffectFlags flags) override;
	int translateChar(int charId) override { return charId; }
	int getStringLength(const char *text) override;
	int getStringWidth(FontId fontId, const char *text, size_t count, FontEffectFlags flags) override;
	int getHeight(FontId fontId, const char *text, int width, FontEffectFlags flags) override;
	int getHeight(FontId fontId) override;
	bool valid(FontId fontId) override { return fontId != kBigFont; }

	void draw(FontId fontId, const char *text, size_t count, const Common::Point &point, int color, int effectColor, FontEffectFlags flags) override;

	uint16 fetchChar(const char *&s) const;
	bool preventLineBreakForCharacter(uint16 ch) const;

	Graphics::FontSJIS *_font;
};

} // End of namespace Saga

#endif