/*
 * (c) Copyright Ascensio System SIA 2010-2023
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */

#include "./TextShaper.h"
#include "./TextShaper_p.h"

namespace NSShaper
{
#define ALLOC_WRITER(size) result->Alloc((size)); unsigned char* pCurData = result->Data
#define WRITE_INT(value) result->WriteInt(pCurData, value); pCurData += 4
#define WRITE_UINT(value) result->WriteUInt(pCurData, value); pCurData += 4
#define WRITE_UCHAR(value) *pCurData++ = value

	CExternalPointer::CExternalPointer()
	{
		Data = NULL;
		Len = 0;
	}
	CExternalPointer::~CExternalPointer()
	{
	}

	void CExternalPointer::WriteInt(unsigned char* data, const int& value)
	{
		WriteUInt(data, (unsigned int)value);
	}
	void CExternalPointer::WriteUInt(unsigned char* data, const unsigned int& value)
	{
		data[0] = (value & 0xFF);
		data[1] = ((value >> 8) & 0xFF);
		data[2] = ((value >> 16) & 0xFF);
		data[3] = ((value >> 24) & 0xFF);
	}

	void CExternalPointer::Alloc(const unsigned int& len)
	{
		Len = len;
		Data = new unsigned char[Len];
	}
	void CExternalPointer::Free()
	{
		if (Data)
			delete [] Data;
	}

	// outline
#define FT_DECOMPOSE_OUTLINE_BUFFER_INIT_SIZE 200
	typedef struct  FT_Decompose_Outline_Buffer_
	{
		FT_Pos* buffer;
		FT_Int size;
		FT_Int pos;
	} FT_Decompose_Outline_Buffer;

	void FT_Decompose_Outline_Buffer_Init(FT_Decompose_Outline_Buffer* buffer)
	{
		buffer->buffer = NULL;
		buffer->size = 0;
		buffer->pos = 0;
	}

	void FT_Decompose_Outline_Buffer_Destroy(FT_Decompose_Outline_Buffer* buffer)
	{
		ft_sfree(buffer->buffer);
	}

	void FT_Decompose_Outline_Buffer_Check(FT_Decompose_Outline_Buffer* buffer, FT_Int add)
	{
		if ((buffer->pos + add) < buffer->size)
			return;

		if (NULL == buffer->buffer)
		{
			buffer->buffer = (FT_Pos*)ft_smalloc(FT_DECOMPOSE_OUTLINE_BUFFER_INIT_SIZE * sizeof(FT_Pos));
			buffer->size = FT_DECOMPOSE_OUTLINE_BUFFER_INIT_SIZE;
			buffer->pos = 0;
			return;
		}

		FT_Int sizeNew = 2 * buffer->size;
		FT_Pos* bufferNew = (FT_Pos*)ft_smalloc((size_t)sizeNew * sizeof(FT_Pos));
		memcpy(bufferNew, buffer->buffer, (size_t)buffer->pos * sizeof(FT_Pos));
		ft_sfree(buffer->buffer);
		buffer->buffer = bufferNew;
		buffer->size = sizeNew;
		// pos
	}

	int GlyphPathMoveTo(const FT_Vector *point, void *user)
	{
		FT_Decompose_Outline_Buffer* buffer = (FT_Decompose_Outline_Buffer*)user;
		FT_Decompose_Outline_Buffer_Check(buffer, 3);
		buffer->buffer[buffer->pos++] = 0;
		buffer->buffer[buffer->pos++] = point->x;
		buffer->buffer[buffer->pos++] = point->y;
		return 0;
	}

	int GlyphPathLineTo(const FT_Vector *point, void *user)
	{
		FT_Decompose_Outline_Buffer* buffer = (FT_Decompose_Outline_Buffer*)user;
		FT_Decompose_Outline_Buffer_Check(buffer, 3);
		buffer->buffer[buffer->pos++] = 1;
		buffer->buffer[buffer->pos++] = point->x;
		buffer->buffer[buffer->pos++] = point->y;
		return 0;
	}

	int GlyphPathConicTo(const FT_Vector *pControlPoint, const FT_Vector *pEndPoint, void *user)
	{
		FT_Decompose_Outline_Buffer* buffer = (FT_Decompose_Outline_Buffer*)user;
		FT_Decompose_Outline_Buffer_Check(buffer, 5);
		buffer->buffer[buffer->pos++] = 2;
		buffer->buffer[buffer->pos++] = pControlPoint->x;
		buffer->buffer[buffer->pos++] = pControlPoint->y;
		buffer->buffer[buffer->pos++] = pEndPoint->x;
		buffer->buffer[buffer->pos++] = pEndPoint->y;
		return 0;
	}

	int GlyphPathCubicTo(const FT_Vector *pFirstControlPoint, const FT_Vector *pSecondControlPoint, const FT_Vector *pEndPoint, void *user)
	{
		FT_Decompose_Outline_Buffer* buffer = (FT_Decompose_Outline_Buffer*)user;
		FT_Decompose_Outline_Buffer_Check(buffer, 7);
		buffer->buffer[buffer->pos++] = 3;
		buffer->buffer[buffer->pos++] = pFirstControlPoint->x;
		buffer->buffer[buffer->pos++] = pFirstControlPoint->y;
		buffer->buffer[buffer->pos++] = pSecondControlPoint->x;
		buffer->buffer[buffer->pos++] = pSecondControlPoint->y;
		buffer->buffer[buffer->pos++] = pEndPoint->x;
		buffer->buffer[buffer->pos++] = pEndPoint->y;
		return 0;
	}
	/////////////////////////////////////////////////////////////////////

	void FT_Free(void* data)
	{
		ft_sfree(data);
	}

	void* FT_Library_Init()
	{
		FT_Library library = NULL;
		FT_Init_FreeType(&library);
		FT_Library_SetLcdFilter(library, FT_LCD_FILTER_DEFAULT);
		return library;
	}
	void FT_Library_Destroy(void* library)
	{
		::FT_Done_FreeType((FT_Library)library);
	}
	void FT_Library_Reference(void* library)
	{
		FT_Reference_Library((FT_Library)library);
	}
	void FT_Library_UnReference(void* library_)
	{
		FT_Library library = (FT_Library)library_;
		if (library->refcount == 1)
			::FT_Done_FreeType(library);
		else
			::FT_Done_Library(library);
	}

	int FT_Set_TrueType_HintProp(void* library, unsigned int interpreter_version)
	{
		FT_UInt ft_interpreter_version = interpreter_version;
		return FT_Property_Set((FT_Library)library, "truetype", "interpreter-version", &ft_interpreter_version);
	}

	void* FT_Open_Face(void* library, unsigned char* memory, unsigned int size, int face_index)
	{
		FT_Open_Args oOpenArgs;
		oOpenArgs.flags			= FT_OPEN_MEMORY | FT_OPEN_PARAMS;
		oOpenArgs.memory_base	= memory;
		oOpenArgs.memory_size	= (FT_Long)size;

		FT_Parameter *pParams = (FT_Parameter *)ft_smalloc( sizeof(FT_Parameter) * 4 );
		pParams[0].tag  = FT_MAKE_TAG( 'i', 'g', 'p', 'f' );
		pParams[0].data = NULL;
		pParams[1].tag  = FT_MAKE_TAG( 'i', 'g', 'p', 's' );
		pParams[1].data = NULL;
		pParams[2].tag  = FT_PARAM_TAG_IGNORE_PREFERRED_FAMILY;
		pParams[2].data = NULL;
		pParams[3].tag  = FT_PARAM_TAG_IGNORE_PREFERRED_SUBFAMILY;
		pParams[3].data = NULL;

		oOpenArgs.params = pParams;
		oOpenArgs.num_params = 4;

		FT_Face face;
		int error = ::FT_Open_Face( (FT_Library)library, &oOpenArgs, face_index, &face );

		ft_sfree(pParams);

		if (error)
			return NULL;

		return face;
	}

	void FT_Done_Face(void* face)
	{
		::FT_Done_Face((FT_Face)face);
	}

	void FT_Done_Face_With_Library(void* face)
	{
		FT_Face ftface = (FT_Face)face;
		FT_Library library = ftface->driver->root.library;

		bool bIsNeedUnreferenceLibrary = (1 == ftface->internal->refcount) ? true : false;
		::FT_Done_Face(ftface);

		if (bIsNeedUnreferenceLibrary)
			FT_Library_UnReference(library);
	}

	unsigned int FT_SetCMapForCharCode(void* face_pointer, unsigned int unicode)
	{
		if (!face_pointer)
			return 0;

		FT_Face face = (FT_Face)face_pointer;

		if ( 0 == face->num_charmaps )
			return unicode;

		unsigned int nCharIndex = 0;

		for ( int nIndex = 0; nIndex < face->num_charmaps; ++nIndex )
		{
			FT_CharMap pCharMap = face->charmaps[nIndex];

			if ( FT_Set_Charmap( face, pCharMap ) )
				continue;

			FT_Encoding pEncoding = pCharMap->encoding;

			if ( FT_ENCODING_UNICODE == pEncoding )
			{
				nCharIndex = FT_Get_Char_Index( face, unicode );
				if ( nCharIndex )
				{
					return nCharIndex;
				}
			}
			else if ( FT_ENCODING_NONE == pEncoding || FT_ENCODING_MS_SYMBOL == pEncoding || FT_ENCODING_APPLE_ROMAN == pEncoding )
			{
#if 0
				FT_ULong  charcode;
				FT_UInt   gindex;

				charcode = FT_Get_First_Char( face, &gindex );
				while ( gindex != 0 )
				{
					charcode = FT_Get_Next_Char( face, charcode, &gindex );
					if ( charcode == unicode )
					{
						nCharIndex = gindex;
						break;
					}
				}
#endif

				nCharIndex = FT_Get_Char_Index( face, unicode );
			}
		}

		return nCharIndex;
	}

	int FT_GetFaceMaxAdvanceX(void* face_pointer)
	{
		if (!face_pointer)
			return 0;

		FT_Face face = (FT_Face)face_pointer;
		if (!face->size)
			return 0;

		return (int)face->size->metrics.max_advance;
	}

	int FT_GetKerningX(void* face, unsigned int prev_gid, unsigned int gid)
	{
		FT_Vector vec;
		vec.x = 0;
		vec.y = 0;
		FT_Get_Kerning((FT_Face)face, prev_gid, gid, 0, &vec);
		return vec.x;
	}

	void FT_Set_Transform(void* face, int xx, int yx, int xy, int yy)
	{
		FT_Matrix m;
		m.xx = xx;
		m.yx = yx;
		m.xy = xy;
		m.yy = yy;
		::FT_Set_Transform((FT_Face)face, &m, NULL);
	}

	int FT_Load_Glyph(void* face, unsigned int glyph_index, int load_flags)
	{
		return ::FT_Load_Glyph((FT_Face)face, glyph_index, load_flags);
	}

	int FT_Set_Char_Size(void* face, int char_width, int char_height, unsigned int hres, unsigned int vres)
	{
		return ::FT_Set_Char_Size((FT_Face)face, char_width, char_height, hres, vres);
	}

	void FT_Glyph_Get_CBox(void* glyph, unsigned int bbox_mode, CExternalPointer* result)
	{
		FT_BBox bbox;
		FT_Glyph_Get_CBox((FT_Glyph)glyph, bbox_mode, &bbox);
		ALLOC_WRITER(4 * 4);
		WRITE_INT(bbox.xMin);
		WRITE_INT(bbox.yMin);
		WRITE_INT(bbox.xMax);
		WRITE_INT(bbox.yMax);
	}

	unsigned char* FT_Get_Glyph_Render_Buffer(void* face)
	{
		return ((FT_Face)face)->glyph->bitmap.buffer;
	}

	int FT_Get_Glyph_Render_BufferSize(void* face)
	{
		FT_GlyphSlot slot = ((FT_Face)face)->glyph;
		return slot->bitmap.pitch * slot->bitmap.rows;
	}

	bool FT_Get_Glyph_Render_Params(void* face, int render_mode, CExternalPointer* result)
	{
		FT_GlyphSlot slot = ((FT_Face)face)->glyph;
		if (FT_Render_Glyph(slot, (FT_Render_Mode)render_mode))
			return false;

		ALLOC_WRITER(6 * 4);
		WRITE_INT(slot->bitmap_left);
		WRITE_INT(slot->bitmap_top);
		WRITE_UINT(slot->bitmap.width);
		WRITE_UINT(slot->bitmap.rows);
		WRITE_INT(slot->bitmap.pitch);
		WRITE_INT(slot->bitmap.pixel_mode);
		return true;
	}

	bool FT_GetFaceInfo(void* face_pointer, CExternalPointer* result)
	{
		if (!face_pointer)
			return false;

		FT_Face face = (FT_Face)face_pointer;

		//face->units_per_EM
		//face->ascender
		//face->descender
		//face->height
		//face->face_flags
		//face->num_faces
		//face->num_glyphs
		//face->num_charmaps
		//face->style_flags
		//face->face_index
		//face->family_name
		//face->style_name

		TT_OS2* os2 = (TT_OS2*)FT_Get_Sfnt_Table( face, ft_sfnt_os2 );
		//os2->version
		//os2->usWeightClass
		//os2->fsSelection
		//os2->usWinAscent
		//os2->usWinDescent
		//os2->usDefaultChar
		//os2->sTypoAscender;
		//os2->sTypoDescender;
		//os2->sTypoLineGap;

		//os2->ulUnicodeRange1
		//os2->ulUnicodeRange2
		//os2->ulUnicodeRange3
		//os2->ulUnicodeRange4
		//os2->ulCodePageRange1
		//os2->ulCodePageRange2

		int isSymbolic = -1;
		if (os2 && 0xFFFF != os2->version)
		{
			FT_ULong ulCodePageRange1 = os2->ulCodePageRange1;
			FT_ULong ulCodePageRange2 = os2->ulCodePageRange2;

			if ((ulCodePageRange1 & 0x80000000) || (ulCodePageRange1 == 0 && ulCodePageRange2 == 0))
			{
				for( int nIndex = 0; nIndex < face->num_charmaps; nIndex++ )
				{
					if (0 == face->charmaps[nIndex]->encoding_id && 3 == face->charmaps[nIndex]->platform_id)
					{
						isSymbolic = nIndex;
						break;
					}
				}
			}
		}

		int nHeader_yMin = face->descender;
		int nHeader_yMax = face->ascender;
		if (face && FT_IS_SFNT(face))
		{
			TT_Face ttface = (TT_Face)face;
			nHeader_yMin = ttface->header.yMin;
			nHeader_yMax = ttface->header.yMax;
		}

		//isSymbolic

		int* family_name = NULL;
		unsigned int family_name_len = 0;
		CheckUnicodeFaceName(face, family_name, family_name_len);

		unsigned int nLen1 = (unsigned int)family_name_len;
		unsigned int nLen2 = (unsigned int)((face->style_name != NULL) ? strlen(face->style_name) : 0);

		unsigned int nLen = 28 + nLen1 + 1 + nLen2 + 1 + 1 + (int)face->num_fixed_sizes;

		ALLOC_WRITER(nLen * 4);
		WRITE_INT((int)face->units_per_EM);
		WRITE_INT((int)face->ascender);
		WRITE_INT((int)face->descender);
		WRITE_INT((int)face->height);
		WRITE_INT((int)face->face_flags);
		WRITE_INT((int)face->num_faces);
		WRITE_INT((int)face->num_glyphs);
		WRITE_INT((int)face->num_charmaps);
		WRITE_INT((int)face->style_flags);
		WRITE_INT((int)face->face_index);

		for (unsigned int i = 0; i < nLen1; ++i)
		{
			WRITE_INT(family_name[i]);
		}
		WRITE_INT(0);

		for (unsigned int i = 0; i < nLen2; ++i)
		{
			WRITE_INT(face->style_name[i]);
		}
		WRITE_INT(0);

		if (os2)
		{
			WRITE_INT((int)os2->version);
			WRITE_INT((int)os2->usWeightClass);
			WRITE_INT((int)os2->fsSelection);
			WRITE_INT((int)os2->usWinAscent);
			WRITE_INT((int)os2->usWinDescent);
			WRITE_INT((int)os2->usDefaultChar);
			WRITE_INT((int)os2->sTypoAscender);
			WRITE_INT((int)os2->sTypoDescender);
			WRITE_INT((int)os2->sTypoLineGap);

			WRITE_INT((int)os2->ulUnicodeRange1);
			WRITE_INT((int)os2->ulUnicodeRange2);
			WRITE_INT((int)os2->ulUnicodeRange3);
			WRITE_INT((int)os2->ulUnicodeRange4);
			WRITE_INT((int)os2->ulCodePageRange1);
			WRITE_INT((int)os2->ulCodePageRange2);
		}
		else
		{
			WRITE_INT((int)0xFFFF);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);

			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
			WRITE_INT((int)0);
		}

		WRITE_INT((int)isSymbolic);
		WRITE_INT((int)nHeader_yMin);
		WRITE_INT((int)nHeader_yMax);

		WRITE_INT((int)face->num_fixed_sizes);

		for (int i = 0; i < face->num_fixed_sizes; ++i)
		{
			WRITE_INT((int)face->available_sizes[i].size);
		}

		if (family_name)
			delete [] family_name;

		return true;
	}

	bool FT_Get_Glyph_Measure_Params(void* face, bool isVector, CExternalPointer* result)
	{
		FT_GlyphSlot slot = ((FT_Face)face)->glyph;

		if (!isVector && slot->bitmap.buffer != NULL && slot->format == FT_GLYPH_FORMAT_BITMAP)
		{
			ALLOC_WRITER(15 * 4);
			WRITE_INT(15);
			WRITE_INT(0);
			WRITE_INT(0);
			WRITE_INT(slot->metrics.width);
			WRITE_INT(slot->metrics.height);

			WRITE_INT(slot->metrics.width);
			WRITE_INT(slot->metrics.height);

			WRITE_INT(slot->metrics.horiAdvance);
			WRITE_INT(slot->metrics.horiBearingX);
			WRITE_INT(slot->metrics.horiBearingY);

			WRITE_INT(slot->metrics.vertAdvance);
			WRITE_INT(slot->metrics.vertBearingX);
			WRITE_INT(slot->metrics.vertBearingY);

			WRITE_INT(slot->linearHoriAdvance);
			WRITE_INT(slot->linearVertAdvance);
			return true;
		}

		FT_Glyph glyph;
		FT_Get_Glyph(slot, &glyph);
		if (!glyph)
			return false;

		FT_BBox bbox;
		FT_Glyph_Get_CBox(glyph, 1, &bbox);

		if (isVector)
		{
			FT_Decompose_Outline_Buffer buffer;
			FT_Decompose_Outline_Buffer_Init(&buffer);

			static FT_Outline_Funcs pOutlineFuncs =
			{
				&GlyphPathMoveTo,
				&GlyphPathLineTo,
				&GlyphPathConicTo,
				&GlyphPathCubicTo,
				0, 0
			};

			FT_Outline_Decompose(&((FT_OutlineGlyph)glyph)->outline, &pOutlineFuncs, &buffer);

			int nCount = buffer.pos;

			ALLOC_WRITER((nCount + 15) * 4);
			WRITE_INT((nCount + 15));
			WRITE_INT(bbox.xMin);
			WRITE_INT(bbox.yMin);
			WRITE_INT(bbox.xMax);
			WRITE_INT(bbox.yMax);

			WRITE_INT(slot->metrics.width);
			WRITE_INT(slot->metrics.height);

			WRITE_INT(slot->metrics.horiAdvance);
			WRITE_INT(slot->metrics.horiBearingX);
			WRITE_INT(slot->metrics.horiBearingY);

			WRITE_INT(slot->metrics.vertAdvance);
			WRITE_INT(slot->metrics.vertBearingX);
			WRITE_INT(slot->metrics.vertBearingY);

			WRITE_INT(slot->linearHoriAdvance);
			WRITE_INT(slot->linearVertAdvance);

			for (int i = 0; i < nCount; i++)
			{
				WRITE_INT(buffer.buffer[i]);
			}

			FT_Decompose_Outline_Buffer_Destroy(&buffer);
		}
		else
		{
			ALLOC_WRITER(15 * 4);
			WRITE_INT(15);
			WRITE_INT(bbox.xMin);
			WRITE_INT(bbox.yMin);
			WRITE_INT(bbox.xMax);
			WRITE_INT(bbox.yMax);

			WRITE_INT(slot->metrics.width);
			WRITE_INT(slot->metrics.height);

			WRITE_INT(slot->metrics.horiAdvance);
			WRITE_INT(slot->metrics.horiBearingX);
			WRITE_INT(slot->metrics.horiBearingY);

			WRITE_INT(slot->metrics.vertAdvance);
			WRITE_INT(slot->metrics.vertBearingX);
			WRITE_INT(slot->metrics.vertBearingY);

			WRITE_INT(slot->linearHoriAdvance);
			WRITE_INT(slot->linearVertAdvance);
		}

		FT_Done_Glyph(glyph);
		return true;
	}
}

#ifdef SUPPORT_HARFBUZZ_SHAPER

#include <hb.h>
#include <hb-ft.h>
#include <hb-ot.h>

namespace NSShaper
{
#define g_userfeatures_count 5
	hb_feature_t g_userfeatures[g_userfeatures_count];
	bool g_userfeatures_init = false;

	void* HB_LanguageFromString(const std::string language_bcp_47)
	{
		return (void*)hb_language_from_string(language_bcp_47.c_str(), language_bcp_47.length());
	}

	static void _hb_ft_face_destroy_js(void *data)
	{
		FT_Done_Face_With_Library(data);
	}

	inline void HB_ShapeTextRaw(void* face, void*& font, char* text_str, const size_t& text_length,
								unsigned int nFeatures, unsigned int nScript, unsigned int nDirection, void* nLanguage,
								CExternalPointer* result, bool bIsJSVersion)
	{
		// init features
		if (!g_userfeatures_init)
		{
			hb_tag_t tags[] = {
				HB_TAG('l','i','g','a'),
				HB_TAG('c','l','i','g'),
				HB_TAG('h','l','i','g'),
				HB_TAG('d','l','i','g'),
				HB_TAG('k','e','r','n')
			};
			for (int nTag = 0; nTag < g_userfeatures_count; ++nTag)
			{
				g_userfeatures[nTag].tag = tags[nTag];
				g_userfeatures[nTag].value = 0;
				g_userfeatures[nTag].start = HB_FEATURE_GLOBAL_START;
				g_userfeatures[nTag].end = HB_FEATURE_GLOBAL_END;
			}
			g_userfeatures_init = true;
		}

		// Turn on ligatures on arabic script
		if (nScript == HB_SCRIPT_ARABIC ||
			nScript == HB_SCRIPT_SYRIAC)
		{
			nFeatures |= 1;
		}

		// font
		hb_font_t* pFont;
		if (NULL == font)
		{
			if (!bIsJSVersion)
			{
				pFont = hb_ft_font_create_referenced((FT_Face)face);
			}
			else
			{
				FT_Reference_Face((FT_Face)face);
				pFont = hb_ft_font_create((FT_Face)face, _hb_ft_face_destroy_js);
			}
			hb_ft_font_set_funcs(pFont);
			font = (void*)pFont;
		}
		else
			pFont = (hb_font_t*)font;

		// features
		for (int nTag = 0; nTag < g_userfeatures_count; ++nTag)
			g_userfeatures[nTag].value = (nFeatures & (1 << nTag)) ? 1 : 0;

		// buffer
		hb_buffer_t* hbBuffer = hb_buffer_create();
		hb_buffer_set_direction(hbBuffer, (hb_direction_t)nDirection);
		hb_buffer_set_script(hbBuffer, (hb_script_t)nScript);
		hb_buffer_set_language(hbBuffer, (hb_language_t)nLanguage);
		hb_buffer_set_cluster_level(hbBuffer, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES);
		int text_len = (int)text_length;
		hb_buffer_add_utf8(hbBuffer, text_str, text_len, 0, text_len);
		hb_buffer_guess_segment_properties(hbBuffer);

		// shape
		hb_shape(pFont, hbBuffer, g_userfeatures, g_userfeatures_count);

		unsigned int glyph_count;
		hb_glyph_info_t* glyph_info = hb_buffer_get_glyph_infos(hbBuffer, &glyph_count);
		hb_glyph_position_t* glyph_pos = hb_buffer_get_glyph_positions(hbBuffer, &glyph_count);

		int nSize = 4 + 8 + glyph_count * (1 + 1 + 4 * 6);

		ALLOC_WRITER(nSize);

		WRITE_UINT(nSize);

		uint64_t pFontPointer = (uint64_t)pFont;
		WRITE_UINT(pFontPointer & 0xFFFFFFFF);
		WRITE_UINT((pFontPointer >> 32) & 0xFFFFFFFF);

		for (unsigned i = 0; i < glyph_count; ++i)
		{
			unsigned char nGlyphType = (unsigned char)hb_ot_layout_get_glyph_class(hb_font_get_face(pFont), glyph_info[i].codepoint);
			unsigned char nGlyphFlags = (unsigned char)hb_glyph_info_get_glyph_flags(&glyph_info[i]);

			WRITE_UCHAR(nGlyphType);
			WRITE_UCHAR(nGlyphFlags);

			WRITE_UINT(glyph_info[i].codepoint);
			WRITE_UINT(glyph_info[i].cluster);

			WRITE_INT(glyph_pos[i].x_advance);
			WRITE_INT(glyph_pos[i].y_advance);
			WRITE_INT(glyph_pos[i].x_offset);
			WRITE_INT(glyph_pos[i].y_offset);
		}

		hb_buffer_destroy(hbBuffer);
	}

	void HB_ShapeText(void* face, void*& font, char* text,
					  unsigned int nFeatures, unsigned int nScript, unsigned int nDirection, void* nLanguage,
					  CExternalPointer* result, bool bIsJSVersion)
	{
		HB_ShapeTextRaw(face, font, text, strlen(text), nFeatures, nScript, nDirection, nLanguage, result, bIsJSVersion);
	}

	void HB_ShapeText(void* face, void*& font, const std::string& text,
					  unsigned int nFeatures, unsigned int nScript, unsigned int nDirection, void* nLanguage,
					  CExternalPointer* result, bool bIsJSVersion)
	{
		HB_ShapeTextRaw(face, font, (char*)text.c_str(), text.length(), nFeatures, nScript, nDirection, nLanguage, result, bIsJSVersion);
	}

	void HB_FontFree(void* font)
	{
		if (NULL == font)
			return;
		hb_font_destroy((hb_font_t*)font);
	}
}
#endif