/*************************************************************************
** OS2Table.cpp                                                         **
**                                                                      **
** This file is part of dvisvgm -- a fast DVI to SVG converter          **
** Copyright (C) 2005-2023 Martin Gieseking <martin.gieseking@uos.de>   **
**                                                                      **
** 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 <algorithm>
#include <array>
#include <cmath>
#include <vector>
#include "OS2Table.hpp"
#include "TTFWriter.hpp"
#include "../Font.hpp"

using namespace std;
using namespace ttf;


/** Returns the average width of all non-zero width glyphs.
 *  https://docs.microsoft.com/en-us/typography/opentype/spec/os2#acw */
int16_t OS2Table::averageCharWidth () const {
	const RangeMap &charmap = ttfWriter()->getUnicodeCharMap();
	if (charmap.empty())
		return 0;
	int sum=ttfWriter()->hAdvance(0);  // width of .notdef character
	int count=1;
	for (auto uc2charcode : charmap) {
		int c = int(uc2charcode.second);
		if (int w = ttfWriter()->hAdvance(c)) {
			sum += w;
			count++;
		}
	}
	return int16_t(double(sum)/count);
}

static vector<uint32_t> compute_unicode_range_bits (const RangeMap &charmap);


void OS2Table::write (ostream &os) const {
	const PhysicalFont &font = ttfWriter()->getFont();
	int upem = ttfWriter()->targetUnitsPerEm();
	double scale = ttfWriter()->unitsPerEmFactor();
	const RangeMap &charmap = ttfWriter()->getUnicodeCharMap();

	writeUInt16(os, 3);   // table version
	writeInt16(os, averageCharWidth());  // average char width
	writeUInt16(os, 400);   // usWeightClass, "normal" for now
	writeUInt16(os, 5);     // usWidthClass, "medium" for now
	writeUInt16(os, 0);     // fsType
	writeInt16(os, round(0.65*upem));  // ySubscriptXSize
	writeInt16(os, round(0.7*upem));   // ySubscriptYSize
	writeInt16(os, round(-0.48*upem)); // ySubscriptXOffset
	writeInt16(os, round(0.14*upem));  // ySubscriptYOffset
	writeInt16(os, round(0.65*upem));  // ySuperscriptXSize
	writeInt16(os, round(0.7*upem));   // ySuperscriptYSize
	writeInt16(os, round(0.48*upem));  // ySuperscriptXOffset
	writeInt16(os, round(0.48*upem));  // ySuperscriptYOffset
	writeInt16(os, 102*upem/2048);     // yStrikeoutSize
	writeInt16(os, 530*upem/2048);     // yStrikeoutPosition
	writeInt16(os, 0);                 // sFamilyClass (no classification)
	for (uint8_t p : {0, 0, 6, 0, 0, 0, 0, 0, 0, 0})  // Panose
		writeUInt8(os, p);
	for (uint32_t bits : compute_unicode_range_bits(charmap))
		writeUInt32(os, bits);
	writeUInt32(os, name2id("dsvg"));
	writeUInt16(os, 6);        // fsSelection, "regular" for now
	writeUInt16(os, min(charmap.minKey(), uint32_t(0xFFFF)));  // usFirstCharIndex
	writeUInt16(os, min(charmap.maxKey(), uint32_t(0xFFFF)));  // usLastCharIndex
	writeInt16(os, round(scale*font.ascent()));   // sTypoAscender
	writeInt16(os, round(-scale*font.descent())); // sTypoDescender
	writeInt16(os, 0);        // sTypoLineGap
	writeUInt16(os, round(scale*font.ascent()));
	writeUInt16(os, round(scale*font.descent()));
	writeUInt32(os, 1);  // ulCodePageRange1, "Latin 1" for now
	writeUInt32(os, 0);  // ulCodePageRange2
	writeInt16(os, 0);   // sxHeight
	writeInt16(os, charmap.valueExists(0x48) ? 0x48 : 0);   // sCapHeight
	writeUInt16(os, 0);  // usDefaultChar
	writeUInt16(os, charmap.valueExists(0x20) ? 0x20 : 0xffff);  // usBreakChar (space or .notdef)
	writeUInt16(os, 0);  // usMaxContext
}

#if 0
void OS2Table::updateYMinMax (int16_t ymin, int16_t ymax) {
	_usWinAscent = max(_usWinAscent, uint16_t(ymax));
	_usWinDescent = max(_usWinDescent, uint16_t(ymin < 0 ? -ymin : 0));
}
#endif


/** Returns the bit number denoting the Unicode range for a codepoint according to
 *  the OS/2 table specification. If there's no matching range for the codepoint,
 *  the function returns -1. Currently, only the ranges specified by OS/2 table
 *  version 1 are considered. */
static int unicode_range_bit (uint32_t codepoint) {
	struct UCRange {
		UCRange (uint32_t cp) : first(cp), last(cp), os2bit(0) {}
		UCRange (uint32_t cp1, uint32_t cp2, int bit) : first(cp1), last(cp2), os2bit(bit) {}
		uint32_t first, last;
		int os2bit;
	};
	// Unicode ranges according to http://unicode.org/Public/UNIDATA/Blocks.txt
	static array<UCRange, 100> ucranges {{
		{0x00020, 0x0007E,   0},  // Basic Latin
		{0x000A0, 0x000FF,   1},  // Latin-1 Supplement
		{0x00100, 0x0017F,   2},  // Latin Extended-A
		{0x00180, 0x0024F,   3},  // Latin Extended-B
		{0x00250, 0x002AF,   4},  // IPA Extensions
		{0x002B0, 0x002FF,   5},  // Spacing Modifier Letters
		{0x00300, 0x0036F,   6},  // Combining Diacritical Marks
		{0x00370, 0x003FF,   7},  // Greek and Coptic
		{0x00400, 0x0052F,   9},  // Cyrillic / Cyrillic Supplement
		{0x00530, 0x0058F,  10},  // Armenian
		{0x00590, 0x005FF,  11},  // Hebrew
		{0x00600, 0x006FF,  13},  // Arabic
		{0x00700, 0x0074F,  71},  // Syriac
		{0x00750, 0x0077F,  13},  // Arabic Supplement
		{0x00780, 0x007BF,  72},  // Thaana
		{0x007C0, 0x007FF,  14},  // N'Ko
		{0x00800, 0x0083F,  12},  // Samaritan
		{0x00900, 0x0097F,  15},  // Devanagari
		{0x00980, 0x009FF,  16},  // Bengali
		{0x00A00, 0x00A7F,  17},  // Gurmukhi
		{0x00A80, 0x00AFF,  18},  // Gujarati
		{0x00B00, 0x00B7F,  19},  // Oriya
		{0x00B80, 0x00BFF,  20},  // Tamil
		{0x00C00, 0x00C7F,  21},  // Telugu
		{0x00C80, 0x00CFF,  22},  // Kannada
		{0x00D00, 0x00D7F,  23},  // Malayalam
		{0x00E00, 0x00E7F,  24},  // Thai
		{0x00E80, 0x00EFF,  25},  // Lao
		{0x010A0, 0x010FF,  26},  // Georgian
		{0x01100, 0x011FF,  28},  // Hangul Jamo
		{0x01B00, 0x01B7F,  27},  // Balinese
		{0x01D00, 0x01DBF,   4},  // Phonetic Extensions & Supplement
		{0x01D80, 0x01DFF,   6},  // Combining Diacritical Marks Supplement
		{0x01E00, 0x01EFF,  29},  // Latin Extended Additional
		{0x01F00, 0x01FFF,  30},  // Greek Extended
		{0x02000, 0x0206F,  31},  // General Punctuation
		{0x02070, 0x0209F,  32},  // Superscripts and Subscripts
		{0x020A0, 0x020CF,  33},  // Currency Symbols
		{0x020D0, 0x020FF,  34},  // Combining Marks for Symbols
		{0x02100, 0x0214F,  35},  // Letterlike Symbols
		{0x02150, 0x0218F,  36},  // Number Forms
		{0x02190, 0x021FF,  37},  // Arrows
		{0x02200, 0x022FF,  38},  // Mathematical Operators
		{0x02300, 0x0237F,  39},  // Miscellaneous Technical
		{0x02400, 0x0243F,  40},  // Control Pictures
		{0x02440, 0x0245F,  41},  // Optical Character Recognition
		{0x02460, 0x024FF,  42},  // Enclosed Alphanumerics
		{0x02500, 0x0257F,  43},  // Box Drawing
		{0x02580, 0x0259F,  44},  // Block Elements
		{0x025A0, 0x025FF,  45},  // Geometric Shapes
		{0x02600, 0x0267F,  46},  // Miscellaneous Symbols
		{0x02700, 0x027BF,  47},  // Dingbats
		{0x027C0, 0x027EF,  38},  // Miscellaneous Mathematical Symbols-A
		{0x027F0, 0x027FF,  37},  // Supplementary Arrows-A
		{0x02800, 0x028FF,  82},  // Braille Patterns
		{0x02900, 0x0297F,  37},  // Supplementary Arrows-B
		{0x02980, 0x02AFF,  38},  // Miscellaneous Mathematical Symbols-B + Supplemental Mathematical Operators
		{0x02B00, 0x02BFF,  37},  // Miscellaneous Symbols and Arrows
		{0x02C60, 0x02C7F,  29},  // Latin Extended-C
		{0x02C80, 0x02CFF,   8},  // Coptic
		{0x02D00, 0x02D25,  26},  // Georgian Supplement
		{0x02DE0, 0x02DFF,   9},  // Cyrillic Extended-A
		{0x02E00, 0x02E7F,  31},  // Supplemental Punctuation
		{0x02E80, 0x02FFF,  59},  // CJK Radicals Supplement + Kangxi Radicals + Ideographic Description Characters
		{0x03000, 0x0303F,  48},  // CJK Symbols and Punctuation
		{0x03040, 0x0309F,  49},  // Hiragana
		{0x030A0, 0x030FF,  50},  // Katakana
		{0x03100, 0x0312F,  51},  // Bopomofo
		{0x03130, 0x0318F,  52},  // Hangul Compatibility Jamo
		{0x03190, 0x0319F,  59},  // Kanbun
		{0x031A0, 0x031BF,  51},  // Bopomofo Extended
		{0x031F0, 0x031FF,  50},  // Katakana Phonetic Extensions
		{0x03200, 0x032FF,  54},  // Enclosed CJK Letters and Months
		{0x03300, 0x033FF,  55},  // CJK compatability
		{0x03400, 0x04DBF,  59},  // CJK Unified Ideographs Extension A
		{0x04E00, 0x09FFF,  59},  // CJK Unified Ideographs
		{0x0A500, 0x0A62B,  12},  // Vai
		{0x0A640, 0x0A69F,   9},  // Cyrillic Extended-B
		{0x0A700, 0x0A71F,   5},  // Modifier Tone Letters
		{0x0A720, 0x0A7FF,  29},  // Latin Extended-D
		{0x0A840, 0x0A87F,  53},  // Phags-pa
		{0x0AC00, 0x0D7AF,  56},  // Hangul Syllables
		{0x0D800, 0x0DFFF,  57},  // Non-Plane 0
		{0x0E000, 0x0F8FF,  60},  // Private Use Area
		{0x0F900, 0x0FAFF,  61},  // CJK Compatibility Ideographs
		{0x0FA2A, 0x0FAFF,  61},  // CJK Compatibility Ideographs
		{0x0FB00, 0x0FB4F,  62},  // Alphabetic Presentation Forms
		{0x0FB50, 0x0FDFF,  63},  // Arabic Presentation Forms-A
		{0x0FE00, 0x0FE0F,  91},  // Variation Selectors
		{0x0FE20, 0x0FE2F,  64},  // Combining Half Marks
		{0x0FE30, 0x0FE4F,  65},  // CJK Compatibility Forms
		{0x0FE50, 0x0FE6F,  66},  // Small Form Variants
		{0x0FE70, 0x0FEEF,  67},  // Arabic Presentation Forms-B
		{0x0FF00, 0x0FFEF,  68},  // Halfwidth and Fullwidth Forms
		{0x0FFF0, 0x0FFFF,  69},  // Specials
		{0x10900, 0x1091F,  58},  // Phoenician
		{0x20000, 0x2A6DF,  59},  // CJK Unified Ideographs Extension B
		{0x2A700, 0x2B73F,  59},  // CJK Unified Ideographs Extension C
		{0x2B740, 0x2B81F,  59},  // CJK Unified Ideographs Extension D
		{0x2F800, 0x2FA1F,  61},  // CJK Compatibility Ideographs Supplement
	}};
	auto it = lower_bound(ucranges.begin(), ucranges.end(), UCRange(codepoint), [](const UCRange &r1, const UCRange &r2) {
		return r1.last < r2.first;
	});
	if (it != ucranges.end() && codepoint >= it->first && codepoint <= it->last)
		return it->os2bit;
	return -1;
}


/** Returns the Unicode ranges encompassed by the font. The ranges are encoded by four dwords,
 *  where each of the 128 bits represents a certain range. The returned vector contains the
 *  dwords in little-endian order, i.e. [bits 0-31, bits 32-63, bits 64-95, bits 96-127]. */
static vector<uint32_t> compute_unicode_range_bits (const RangeMap &charmap) {
	vector<uint32_t> rangeBits(4, 0);
	for (auto uc2charcode : charmap) {
		int bit = unicode_range_bit(uc2charcode.first);
		if (bit >= 0) {
			for (int i=0; i < 4; i++) {
				if (bit < 32*(i+1)) {
					rangeBits[i] |= (1 << (bit-32*i));
					break;
				}
			}
		}
	}
	return rangeBits;
}
