/*

 * GraphLCD graphics library

 *

 * font.c  -  font handling

 *

 * based on graphlcd plugin 0.1.1 for the Video Disc Recorder

 *  (c) 2001-2004 Carsten Siebholz <c.siebholz AT t-online.de>

 *

 * This file is released under the GNU General Public License. Refer

 * to the COPYING file distributed with this package.

 *

 * (c) 2004 Andreas Regel <andreas.regel AT powarman.de>

 */

#include <stdio.h>

#include <stdint.h>

#include <syslog.h>

#include <fcntl.h>

#include <unistd.h>

#include <algorithm>

#include "common.h"

#include "font.h"

#ifdef HAVE_FREETYPE2

#include <ft2build.h>

#include FT_FREETYPE_H

#include <iconv.h>

#endif

namespace GLCD

{

static const char * kFontFileSign = "FNT3";

static const uint32_t kFontHeaderSize = 16;

static const uint32_t kCharHeaderSize = 4;

//#pragma pack(1)

//struct tFontHeader

//{

//    char sign[4];          // = FONTFILE_SIGN

//    unsigned short height; // total height of the font

//    unsigned short ascent; // ascender of the font

//    unsigned short line;   // line height

//    unsigned short reserved;

//    unsigned short space;  // space between characters of a string

//    unsigned short count;  // number of chars in this file

//};

//

//struct tCharHeader

//{

//    unsigned short character;

//    unsigned short width;

//};

//#pragma pack()

cFont::cFont()

{

    Init();

}

cFont::~cFont()

{

    Unload();

}

bool cFont::LoadFNT(const std::string & fileName)

{

    // cleanup if we already had a loaded font

    Unload();

    FILE * fontFile;

    int i;

    uint8_t buffer[10000];

    uint16_t fontHeight;

    uint16_t numChars;

    int maxWidth = 0;

    fontFile = fopen(fileName.c_str(), "rb");

    if (!fontFile)

        return false;

    fread(buffer, kFontHeaderSize, 1, fontFile);

    if (buffer[0] != kFontFileSign[0] ||

        buffer[1] != kFontFileSign[1] ||

        buffer[2] != kFontFileSign[2] ||

        buffer[3] != kFontFileSign[3])

    {

        fclose(fontFile);

        return false;

    }

    fontHeight = buffer[4] | (buffer[5] << 8);

    totalAscent = buffer[6] | (buffer[7] << 8);

    lineHeight = buffer[8] | (buffer[9] << 8);

    spaceBetween = buffer[12] | (buffer[13] << 8);

    numChars = buffer[14] | (buffer[15] << 8);

    for (i = 0; i < numChars; i++)

    {

        uint8_t chdr[kCharHeaderSize];

        uint16_t charWidth;

        uint16_t character;

        fread(chdr, kCharHeaderSize, 1, fontFile);

        character = chdr[0] | (chdr[1] << 8);

        charWidth = chdr[2] | (chdr[3] << 8);

        fread(buffer, fontHeight * ((charWidth + 7) / 8), 1, fontFile);

        if (characters[character])

            delete characters[character];

        characters[character] = new cBitmap(charWidth, fontHeight, buffer);

        if (characters[character]->Width() > maxWidth)

            maxWidth = characters[character]->Width();

    }

    fclose(fontFile);

    totalWidth = maxWidth;

    totalHeight = fontHeight;

    return true;

}

bool cFont::SaveFNT(const std::string & fileName) const

{

    FILE * fontFile;

    uint8_t fhdr[kFontHeaderSize];

    uint8_t chdr[kCharHeaderSize];

    uint16_t numChars;

    int i;

    fontFile = fopen(fileName.c_str(),"w+b");

    if (!fontFile)

    {

        syslog(LOG_ERR, "cFont::SaveFNT(): Cannot open file: %s for writing\n",fileName.c_str());

        return false;

    }

    numChars = 0;

    for (i = 0; i < 256; i++)

    {

        if (characters[i])

        {

            numChars++;

        }

    }

    memcpy(fhdr, kFontFileSign, 4);

    fhdr[4] = (uint8_t) totalHeight;

    fhdr[5] = (uint8_t) (totalHeight >> 8);

    fhdr[6] = (uint8_t) totalAscent;

    fhdr[7] = (uint8_t) (totalAscent >> 8);

    fhdr[8] = (uint8_t) lineHeight;

    fhdr[9] = (uint8_t) (lineHeight >> 8);

    fhdr[10] = 0;

    fhdr[11] = 0;

    fhdr[12] = (uint8_t) spaceBetween;

    fhdr[13] = (uint8_t) (spaceBetween >> 8);

    fhdr[14] = (uint8_t) numChars;

    fhdr[15] = (uint8_t) (numChars >> 8);

    // write font file header

    fwrite(fhdr, kFontHeaderSize, 1, fontFile);

    for (i = 0; i < 256; i++)

    {

        if (characters[i])

        {

            chdr[0] = (uint8_t) i;

            chdr[1] = (uint8_t) (i >> 8);

            chdr[2] = (uint8_t) characters[i]->Width();

            chdr[3] = (uint8_t) (characters[i]->Width() >> 8);

            fwrite(chdr, kCharHeaderSize, 1, fontFile);

            fwrite(characters[i]->Data(), totalHeight * characters[i]->LineSize(), 1, fontFile);

        }

    }

    fclose(fontFile);

    syslog(LOG_DEBUG, "cFont::SaveFNT(): Font file '%s' written successfully\n", fileName.c_str());

    return true;

}

bool cFont::LoadFT2(const std::string & fileName, const std::string & encoding,

                    int size, bool dingBats)

{

    // cleanup if we already had a loaded font

    Unload();

#ifdef HAVE_FREETYPE2

    if (access(fileName.c_str(), F_OK) != 0)

    {

        syslog(LOG_ERR, "cFont::LoadFT2: Font file (%s) does not exist!!", fileName.c_str());

        return false;

    }

    // file exists

    FT_Library library;

    FT_Face face;

    FT_GlyphSlot slot;

    int error = FT_Init_FreeType(&library);

    if (error)

    {

        syslog(LOG_ERR, "cFont::LoadFT2: Could not init freetype library");

        return false;

    }

    error = FT_New_Face(library, fileName.c_str(), 0, &face);

    // everything ok?

    if (error == FT_Err_Unknown_File_Format)

    {

        syslog(LOG_ERR, "cFont::LoadFT2: Font file (%s) could be opened and read, but it appears that its font format is unsupported", fileName.c_str());

        error = FT_Done_Face(face);

        syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_Face(..) returned (%d)", error);

        error = FT_Done_FreeType(library);

        syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_FreeType(..) returned (%d)", error);

        return false;

    }

    else if (error)

    {

        syslog(LOG_ERR, "cFont::LoadFT2: Font file (%s) could not be opened or read, or simply it is broken,\n error code was %x", fileName.c_str(), error);

        error = FT_Done_Face(face);

        syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_Face(..) returned (%d)", error);

        error = FT_Done_FreeType(library);

        syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_FreeType(..) returned (%d)", error);

        return false;

    }

    // set slot

    slot = face->glyph;

    // set Size

    FT_Set_Char_Size(face, 0, size * 64, 0, 0);

    wchar_t utf_buff[256];

    if (dingBats)

    {

/*

        FT_CharMap charmap = 0;

        for (int n = 0; n < face->num_charmaps; n++)

        {

            if (face->charmaps[n]->platform_id == 3 &&

                face->charmaps[n]->encoding_id == 0)

            {

                charmap = face->charmaps[n];

                //break;

            }

        }

        if (charmap)

            syslog(LOG_ERR, "cFont::LoadFT2: platform_id: %d, encoding_id: %d", charmap->platform_id, charmap->encoding_id);

        error = FT_Set_Charmap(_face, charmap);

        if (error)

        {

            syslog(LOG_ERR, "cFont::LoadFT2: FT_Select_Charmap encoding not supported: %d", charmap->encoding_id);

        }

*/

    }

    else

    {

        iconv_t cd;

        if ((cd = iconv_open("WCHAR_T", encoding.c_str())) == (iconv_t) -1)

        {

            syslog(LOG_ERR, "cFont::LoadFT2: Iconv encoding not supported: %s", encoding.c_str());

            error = FT_Done_Face(face);

            syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_Face(..) returned (%d)", error);

            error = FT_Done_FreeType(library);

            syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_FreeType(..) returned (%d)", error);

            return false;

        }

        for (int c = 0; c < 256; c++)

        {

            char char_buff = c;

            wchar_t wchar_buff;

            char * in_buff,* out_buff;

            size_t in_len, out_len, count;

            in_len = 1;

            out_len = 4;

            in_buff = (char *) &char_buff;

            out_buff = (char *) &wchar_buff;

            count = iconv(cd, &in_buff, &in_len, &out_buff, &out_len);

            if ((size_t) -1 == count)

            {

                utf_buff[c] = 0;

            }

            utf_buff[c] = wchar_buff;

        }

        iconv_close(cd);

    }

    // get some global parameters

    totalHeight = (face->size->metrics.ascender >> 6) - (face->size->metrics.descender >> 6);

    totalWidth = face->size->metrics.max_advance >> 6;

    totalAscent = face->size->metrics.ascender >> 6;

    lineHeight = face->size->metrics.height >> 6;

    spaceBetween = 0;

#if 0

    syslog(LOG_DEBUG, "cFont::LoadFT2: totalHeight = %d", totalHeight);

    syslog(LOG_DEBUG, "cFont::LoadFT2: totalWidth = %d", totalWidth);

    syslog(LOG_DEBUG, "cFont::LoadFT2: totalAscent = %d", totalAscent);

    syslog(LOG_DEBUG, "cFont::LoadFT2: lineHeight = %d", lineHeight);

    syslog(LOG_DEBUG, "cFont::LoadFT2: spaceBetween = %d", spaceBetween);

#endif

    // render glyphs for ASCII codes 0 to 255 in our bitmap class

    FT_UInt glyph_index;

    int num_char;

    for (num_char = 0; num_char < 256; num_char++)

    {

        if (dingBats)

        {

            //Get FT char index & load the char

            error = FT_Load_Char(face, num_char, FT_LOAD_DEFAULT);

        }

        else

        {

            //Get FT char index

            glyph_index = FT_Get_Char_Index(face, utf_buff[num_char]);

            //Load the char

            error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);

        }

        if (error)

        {

            syslog(LOG_ERR, "cFont::LoadFT2: ERROR when calling FT_Load_Glyph: %x", error);

        }

        // convert to a mono bitmap

        error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_MONO);

        if (error)

        {

            syslog(LOG_ERR, "cFont::LoadFT2: ERROR when calling FT_Render_Glyph: %x", error);

        }

        // now, fill our pixel data

        cBitmap * charBitmap = new cBitmap(face->glyph->advance.x >> 6, totalHeight);

        charBitmap->Clear();

        unsigned char * bufPtr = face->glyph->bitmap.buffer;

        unsigned char pixel;

        for (int y = 0; y < face->glyph->bitmap.rows; y++)

        {

            for (int x = 0; x < face->glyph->bitmap.width; x++)

            {

                pixel = (bufPtr[x / 8] >> (7 - x % 8)) & 1;

                if (pixel)

                    charBitmap->DrawPixel((face->glyph->metrics.horiBearingX >> 6) + x,

                                          (face->size->metrics.ascender >> 6) - (face->glyph->metrics.horiBearingY >> 6) + y,

                                          GLCD::clrBlack);

            }

            bufPtr += face->glyph->bitmap.pitch;

        }

        SetCharacter((char) num_char, charBitmap);

    }

    error = FT_Done_Face(face);

    if (error)

    {

        syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_Face(..) returned (%d)", error);

    }

    error = FT_Done_FreeType(library);

    if (error)

    {

        syslog(LOG_ERR, "cFont::LoadFT2: FT_Done_FreeType(..) returned (%d)", error);

    }

    return true;

#else

    syslog(LOG_ERR, "cFont::LoadFT2: glcdgraphics was compiled without FreeType2 support!!!");

    return false;

#endif

}

int cFont::Width(char ch) const

{

    if (characters[(unsigned char) ch])

        return characters[(unsigned char) ch]->Width();

    else

        return 0;

}

int cFont::Width(const std::string & str) const

{

    unsigned int i;

    int sum = 0;

    for (i = 0; i < str.length(); i++)

    {

        sum += Width(str[i]);

    }

    if (str.length() > 1)

    {

        sum += spaceBetween * (str.length() - 1);

    }

    return sum;

}

int cFont::Width(const std::string & str, unsigned int len) const

{

    unsigned int i;

    int sum = 0;

    for (i = 0; i < str.length() && i < len; i++)

    {

        sum += Width(str[i]);

    }

    if (std::min(str.length(), (size_t) len) > 1)

    {

        sum += spaceBetween * (std::min(str.length(), (size_t) len) - 1);

    }

    return sum;

}

int cFont::Height(char ch) const

{

    if (characters[(unsigned char) ch])

        return characters[(unsigned char) ch]->Height();

    else

        return 0;

}

int cFont::Height(const std::string & str) const

{

    unsigned int i;

    int sum = 0;

    for (i = 0; i < str.length(); i++)

        sum = std::max(sum, Height(str[i]));

    return sum;

}

int cFont::Height(const std::string & str, unsigned int len) const

{

    unsigned int i;

    int sum = 0;

    for (i = 0; i < str.length() && i < len; i++)

        sum = std::max(sum, Height(str[i]));

    return sum;

}

const cBitmap * cFont::GetCharacter(char ch) const

{

    return characters[(unsigned char) ch];

}

void cFont::SetCharacter(char ch, cBitmap * bitmapChar)

{

    // adjust maxwidth if necessary

    if (totalWidth < bitmapChar->Width())

        totalWidth = bitmapChar->Width();

    // delete if already allocated

    if (characters[(unsigned char) ch])

        delete characters[(unsigned char) ch];

    // store new character

    characters[(unsigned char) ch] = bitmapChar;

}

void cFont::Init()

{

    totalWidth = 0;

    totalHeight = 0;

    totalAscent = 0;

    spaceBetween = 0;

    lineHeight = 0;

    for (int i = 0; i < 256; i++)

    {

        characters[i] = NULL;

    }

}

void cFont::Unload()

{

    // cleanup

    for (int i = 0; i < 256; i++)

    {

        if (characters[i])

        {

            delete characters[i];

        }

    }

    // re-init

    Init();

}

void cFont::WrapText(int Width, int Height, std::string & Text,

                     std::vector <std::string> & Lines, int * ActualWidth) const

{

    int maxLines;

    int lineCount;

    int textWidth;

    std::string::size_type start;

    std::string::size_type pos;

    std::string::size_type posLast;

    Lines.clear();

    maxLines = 2000;

    if (Height > 0)

    {

        maxLines = Height / LineHeight();

        if (maxLines == 0)

            maxLines = 1;

    }

    lineCount = 0;

    pos = 0;

    start = 0;

    posLast = 0;

    textWidth = 0;

    while (pos < Text.length() && (Height == 0 || lineCount < maxLines))

    {

        if (Text[pos] == '\n')

        {

            Lines.push_back(trim(Text.substr(start, pos - start)));

            start = pos + 1;

            posLast = pos + 1;

            textWidth = 0;

            lineCount++;

        }

        else if (textWidth > Width && (lineCount + 1) < maxLines)

        {

            if (posLast > start)

            {

                Lines.push_back(trim(Text.substr(start, posLast - start)));

                start = posLast + 1;

                posLast = start;

                textWidth = this->Width(Text.substr(start, pos - start + 1)) + spaceBetween;

            }

            else

            {

                Lines.push_back(trim(Text.substr(start, pos - start)));

                start = pos + 1;

                posLast = start;

                textWidth = this->Width(Text[pos]) + spaceBetween;

            }

            lineCount++;

        }

        else if (Text[pos] == ' ')

        {

            posLast = pos;

            textWidth += this->Width(Text[pos]) + spaceBetween;

        }

        else

        {

            textWidth += this->Width(Text[pos]) + spaceBetween;

        }

        pos++;

    }

    if (Height == 0 || lineCount < maxLines)

    {

        if (textWidth > Width && (lineCount + 1) < maxLines)

        {

            if (posLast > start)

            {

                Lines.push_back(trim(Text.substr(start, posLast - start)));

                start = posLast + 1;

                posLast = start;

                textWidth = this->Width(Text.substr(start, pos - start + 1)) + spaceBetween;

            }

            else

            {

                Lines.push_back(trim(Text.substr(start, pos - start)));

                start = pos + 1;

                posLast = start;

                textWidth = this->Width(Text[pos]) + spaceBetween;

            }

            lineCount++;

        }

        if (pos > start)

        {

            Lines.push_back(trim(Text.substr(start)));

            lineCount++;

        }

        textWidth = 0;

        for (int i = 0; i < lineCount; i++)

            textWidth = std::max(textWidth, this->Width(Lines[i]));

        textWidth = std::min(textWidth, Width);

    }

    else

        textWidth = Width;

    if (ActualWidth)

        *ActualWidth = textWidth;

}

} // end of namespace