/*

 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)

 *

 * This is part of HarfBuzz, an OpenType Layout engine library.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and its documentation for any purpose, provided that the

 * above copyright notice and the following two paragraphs appear in

 * all copies of this software.

 *

 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR

 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 *

 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,

 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO

 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 */

#include <QtTest/QtTest>

#include <ft2build.h>

#include FT_FREETYPE_H

#include FT_TRUETYPE_TABLES_H

#include <harfbuzz-shaper.h>

#include <harfbuzz-global.h>

#include <harfbuzz-gpos.h>

static FT_Library freetype;

static FT_Face loadFace(const char *name)

{

    FT_Face face;

    char path[256];

    strcpy(path, SRCDIR);

    strcat(path, "/fonts/");

    strcat(path, name);

    if (FT_New_Face(freetype, path, /*index*/0, &face))

        return 0;

    return face;

}

static HB_UChar32 getChar(const HB_UChar16 *string, hb_uint32 length, hb_uint32 &i)

{

    HB_UChar32 ch;

    if (HB_IsHighSurrogate(string[i])

        && i < length - 1

        && HB_IsLowSurrogate(string[i + 1])) {

        ch = HB_SurrogateToUcs4(string[i], string[i + 1]);

        ++i;

    } else {

        ch = string[i];

    }

    return ch;

}

static HB_Bool hb_stringToGlyphs(HB_Font font, const HB_UChar16 *string, hb_uint32 length, HB_Glyph *glyphs, hb_uint32 *numGlyphs, HB_Bool /*rightToLeft*/)

{

    FT_Face face = (FT_Face)font->userData;

    if (length > *numGlyphs)

        return false;

    int glyph_pos = 0;

    for (hb_uint32 i = 0; i < length; ++i) {

        glyphs[glyph_pos] = FT_Get_Char_Index(face, getChar(string, length, i));

        ++glyph_pos;

    }

    *numGlyphs = glyph_pos;

    return true;

}

static void hb_getAdvances(HB_Font /*font*/, const HB_Glyph * /*glyphs*/, hb_uint32 numGlyphs, HB_Fixed *advances, int /*flags*/)

{

    for (hb_uint32 i = 0; i < numGlyphs; ++i)

        advances[i] = 0; // ### not tested right now

}

static HB_Bool hb_canRender(HB_Font font, const HB_UChar16 *string, hb_uint32 length)

{

    FT_Face face = (FT_Face)font->userData;

    for (hb_uint32 i = 0; i < length; ++i)

        if (!FT_Get_Char_Index(face, getChar(string, length, i)))

            return false;

    return true;

}

static HB_Error hb_getSFntTable(void *font, HB_Tag tableTag, HB_Byte *buffer, HB_UInt *length)

{

    FT_Face face = (FT_Face)font;

    FT_ULong ftlen = *length;

    FT_Error error = 0;

    if (!FT_IS_SFNT(face))

        return HB_Err_Invalid_Argument;

    error = FT_Load_Sfnt_Table(face, tableTag, 0, buffer, &ftlen);

    *length = ftlen;

    return (HB_Error)error;

}

HB_Error hb_getPointInOutline(HB_Font font, HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints)

{

    HB_Error error = HB_Err_Ok;

    FT_Face face = (FT_Face)font->userData;

    int load_flags = (flags & HB_ShaperFlag_UseDesignMetrics) ? FT_LOAD_NO_HINTING : FT_LOAD_DEFAULT;

    if ((error = (HB_Error)FT_Load_Glyph(face, glyph, load_flags)))

        return error;

    if (face->glyph->format != ft_glyph_format_outline)

        return (HB_Error)HB_Err_Invalid_SubTable;

    *nPoints = face->glyph->outline.n_points;

    if (!(*nPoints))

        return HB_Err_Ok;

    if (point > *nPoints)

        return (HB_Error)HB_Err_Invalid_SubTable;

    *xpos = face->glyph->outline.points[point].x;

    *ypos = face->glyph->outline.points[point].y;

    return HB_Err_Ok;

}

{

    // ###

    metrics->x = metrics->y = metrics->width = metrics->height = metrics->xOffset = metrics->yOffset = 0;

}

{

    return 0; // ####

}

const HB_FontClass hb_fontClass = {

    hb_stringToGlyphs, hb_getAdvances, hb_canRender,

    hb_getPointInOutline, hb_getGlyphMetrics, hb_getFontMetric

};

//TESTED_CLASS=

//TESTED_FILES= gui/text/qscriptengine.cpp

class tst_QScriptEngine : public QObject

{

Q_OBJECT

public:

    tst_QScriptEngine();

    virtual ~tst_QScriptEngine();

public slots:

    void initTestCase();

    void cleanupTestCase();

private slots:

    void devanagari();

    void bengali();

    void gurmukhi();

    // gujarati missing

    void oriya();

    void tamil();

    void telugu();

    void kannada();

    void malayalam();

    void sinhala();

    void khmer();

    void nko();

    void linearB();

};

tst_QScriptEngine::tst_QScriptEngine()

{

}

tst_QScriptEngine::~tst_QScriptEngine()

{

}

void tst_QScriptEngine::initTestCase()

{

    FT_Init_FreeType(&freetype);

}

void tst_QScriptEngine::cleanupTestCase()

{

    FT_Done_FreeType(freetype);

}

};

{

    HB_Face hbFace = HB_NewFace(face, hb_getSFntTable);

    hbFont.klass = &hb_fontClass;

    hbFont.userData = face;

    hbFont.x_ppem  = face->size->metrics.x_ppem;

    hbFont.y_ppem  = face->size->metrics.y_ppem;

    hbFont.x_scale = face->size->metrics.x_scale;

    hbFont.y_scale = face->size->metrics.y_scale;

    shaper_item.kerning_applied = false;

    shaper_item.string = reinterpret_cast<const HB_UChar16 *>(str.constData());

    shaper_item.stringLength = str.length();

    shaper_item.item.script = script;

    shaper_item.item.pos = 0;

    shaper_item.item.length = shaper_item.stringLength;

    shaper_item.item.bidiLevel = 0; // ###

    shaper_item.shaperFlags = 0;

    shaper_item.font = &hbFont;

    shaper_item.face = hbFace;

    shaper_item.num_glyphs = shaper_item.item.length;

    shaper_item.glyphIndicesPresent = false;

    shaper_item.initialGlyphCount = 0;

    while (1) {

        hb_glyphs.resize(shaper_item.num_glyphs);

        hb_attributes.resize(shaper_item.num_glyphs);

        hb_advances.resize(shaper_item.num_glyphs);

        hb_offsets.resize(shaper_item.num_glyphs);

        hb_logClusters.resize(shaper_item.num_glyphs);

        memset(hb_glyphs.data(), 0, hb_glyphs.size() * sizeof(HB_Glyph));

        memset(hb_attributes.data(), 0, hb_attributes.size() * sizeof(HB_GlyphAttributes));

        memset(hb_advances.data(), 0, hb_advances.size() * sizeof(HB_Fixed));

        memset(hb_offsets.data(), 0, hb_offsets.size() * sizeof(HB_FixedPoint));

        shaper_item.glyphs = hb_glyphs.data();

        shaper_item.attributes = hb_attributes.data();

        shaper_item.advances = hb_advances.data();

        shaper_item.offsets = hb_offsets.data();

        shaper_item.log_clusters = hb_logClusters.data();

        if (HB_ShapeItem(&shaper_item))

            break;

    }

    HB_FreeFace(hbFace);

    hb_uint32 nglyphs = 0;

    const unsigned short *g = s->glyphs;

    while ( *g ) {

	nglyphs++;

	g++;

    }

	goto error;

    for (hb_uint32 i = 0; i < nglyphs; ++i) {

	    goto error;

    }

    return true;

 error:

    const unsigned short *uc = s->unicode;

    while (*uc) {

	str += QString("%1 ").arg(*uc, 4, 16);

	++uc;

    }

    qDebug("%s: shaping of string %s failed, nglyphs=%d, expected %d",

           face->family_name,

           str.toLatin1().constData(),

    str = "";

    hb_uint32 i = 0;

	++i;

    }

    qDebug("    glyph result = %s", str.toLatin1().constData());

    return false;

}

void tst_QScriptEngine::devanagari()

{

    {

        FT_Face face = loadFace("raghu.ttf");

        if (face) {

	    const ShapeTable shape_table [] = {

		// Ka

		{ { 0x0915, 0x0 },

		  { 0x0080, 0x0 } },

		// Ka Halant

		{ { 0x0915, 0x094d, 0x0 },

		  { 0x0080, 0x0051, 0x0 } },

		// Ka Halant Ka

		{ { 0x0915, 0x094d, 0x0915, 0x0 },

		  { 0x00c8, 0x0080, 0x0 } },

		// Ka MatraI

		{ { 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x0 } },

		// Ra Halant Ka

		{ { 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0080, 0x005b, 0x0 } },

		// Ra Halant Ka MatraI

		{ { 0x0930, 0x094d, 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x005b, 0x0 } },

		// MatraI

		{ { 0x093f, 0x0 },

		  { 0x01d4, 0x029c, 0x0 } },

		// Ka Nukta

		{ { 0x0915, 0x093c, 0x0 },

		  { 0x00a4, 0x0 } },

		// Ka Halant Ra

		{ { 0x0915, 0x094d, 0x0930, 0x0 },

		  { 0x0110, 0x0 } },

		// Ka Halant Ra Halant Ka

		{ { 0x0915, 0x094d, 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0158, 0x0080, 0x0 } },

		{ { 0x0930, 0x094d, 0x200d, 0x0 },

		  { 0x00e2, 0x0 } },

		{ { 0x0915, 0x094d, 0x0930, 0x094d, 0x200d, 0x0 },

		  { 0x0158, 0x0 } },

		{ {0}, {0} }

	    };

	    const ShapeTable *s = shape_table;

	    while (s->unicode[0]) {

		QVERIFY( shaping(face, s, HB_Script_Devanagari) );

		++s;

	    }

            FT_Done_Face(face);

	} else {

	    QSKIP("couln't find raghu.ttf", SkipAll);

	}

    }

    {

        FT_Face face = loadFace("mangal.ttf");

        if (face) {

	    const ShapeTable shape_table [] = {

		// Ka

		{ { 0x0915, 0x0 },

		  { 0x0080, 0x0 } },

		// Ka Halant

		{ { 0x0915, 0x094d, 0x0 },

		  { 0x0080, 0x0051, 0x0 } },

		// Ka Halant Ka

		{ { 0x0915, 0x094d, 0x0915, 0x0 },

		  { 0x00c8, 0x0080, 0x0 } },

		// Ka MatraI

		{ { 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x0 } },

		// Ra Halant Ka

		{ { 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0080, 0x005b, 0x0 } },

		// Ra Halant Ka MatraI

		{ { 0x0930, 0x094d, 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x005b, 0x0 } },

		// MatraI

		{ { 0x093f, 0x0 },

		  { 0x01d4, 0x029c, 0x0 } },

		// Ka Nukta

		{ { 0x0915, 0x093c, 0x0 },

		  { 0x00a4, 0x0 } },

		// Ka Halant Ra

		{ { 0x0915, 0x094d, 0x0930, 0x0 },

		  { 0x0110, 0x0 } },

		// Ka Halant Ra Halant Ka

		{ { 0x0915, 0x094d, 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0158, 0x0080, 0x0 } },