/* Freetype GL - A C OpenGL Freetype engine
 *
 * Distributed under the OSI-approved BSD 2-Clause License.  See accompanying
 * file `LICENSE` for more details.
 */
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_STROKER_H
// #include FT_ADVANCES_H
#include FT_LCD_FILTER_H
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <math.h>
#include "distance-field.h"
#include "texture-font.h"
#include "platform.h"
#include "utf8-utils.h"

#define HRES 64
#define HRESf 64.f
#define DPI 72

#undef __FTERRORS_H__
#define FT_ERRORDEF(e, v, s) { e, s },
#define FT_ERROR_START_LIST {
#define FT_ERROR_END_LIST                                                      \
    {                                                                          \
        0, 0                                                                   \
    }                                                                          \
    }                                                                          \
    ;
const struct
{
    int code;
    const char *message;
} FT_Errors[] =
#include FT_ERRORS_H

    // ------------------------------------------------- texture_font_load_face
    // ---
    static int texture_font_load_face(texture_font_t * self, float size,
                                      FT_Library *library, FT_Face *face)
{
    FT_Error error;
    FT_Matrix matrix = { (int) ((1.0 / HRES) * 0x10000L),
                         (int) ((0.0) * 0x10000L), (int) ((0.0) * 0x10000L),
                         (int) ((1.0) * 0x10000L) };

    assert(library);
    assert(size);

    /* Initialize library */
    error = FT_Init_FreeType(library);
    if (error)
    {
        fprintf(stderr, "FT_Error (0x%02x) : %s\n", FT_Errors[error].code,
                FT_Errors[error].message);
        goto cleanup;
    }

    /* Load face */
    switch (self->location)
    {
    case TEXTURE_FONT_FILE:
        error = FT_New_Face(*library, self->filename, 0, face);
        break;

    case TEXTURE_FONT_MEMORY:
        error = FT_New_Memory_Face(*library, self->memory.base,
                                   self->memory.size, 0, face);
        break;
    }

    if (error)
    {
        fprintf(stderr, "FT_Error (line %d, code 0x%02x) : %s\n", __LINE__,
                FT_Errors[error].code, FT_Errors[error].message);
        goto cleanup_library;
    }

    /* Select charmap */
    error = FT_Select_Charmap(*face, FT_ENCODING_UNICODE);
    if (error)
    {
        fprintf(stderr, "FT_Error (line %d, code 0x%02x) : %s\n", __LINE__,
                FT_Errors[error].code, FT_Errors[error].message);
        goto cleanup_face;
    }

    /* Set char size */
    error = FT_Set_Char_Size(*face, (int) (size * HRES), 0, DPI * HRES, DPI);

    if (error)
    {
        fprintf(stderr, "FT_Error (line %d, code 0x%02x) : %s\n", __LINE__,
                FT_Errors[error].code, FT_Errors[error].message);
        goto cleanup_face;
    }

    /* Set transform matrix */
    FT_Set_Transform(*face, &matrix, NULL);

    return 1;

cleanup_face:
    FT_Done_Face(*face);
cleanup_library:
    FT_Done_FreeType(*library);
cleanup:
    return 0;
}

// ------------------------------------------------------ texture_glyph_new ---
texture_glyph_t *texture_glyph_new(void)
{
    texture_glyph_t *self = (texture_glyph_t *) malloc(sizeof(texture_glyph_t));
    if (self == NULL)
    {
        fprintf(stderr, "line %d: No more memory for allocating data\n",
                __LINE__);
        return NULL;
    }

    self->codepoint         = -1;
    self->width             = 0;
    self->height            = 0;
    self->rendermode        = RENDER_NORMAL;
    self->outline_thickness = 0.0;
    self->offset_x          = 0;
    self->offset_y          = 0;
    self->advance_x         = 0.0;
    self->advance_y         = 0.0;
    self->s0                = 0.0;
    self->t0                = 0.0;
    self->s1                = 0.0;
    self->t1                = 0.0;
    self->kerning           = vector_new(sizeof(kerning_t));
    return self;
}

// --------------------------------------------------- texture_glyph_delete ---
void texture_glyph_delete(texture_glyph_t *self)
{
    assert(self);
    vector_delete(self->kerning);
    free(self);
}

// ---------------------------------------------- texture_glyph_get_kerning ---
float texture_glyph_get_kerning(const texture_glyph_t *self,
                                const char *codepoint)
{
    size_t i;
    uint32_t ucodepoint = utf8_to_utf32(codepoint);

    assert(self);
    for (i = 0; i < vector_size(self->kerning); ++i)
    {
        kerning_t *kerning = (kerning_t *) vector_get(self->kerning, i);
        if (kerning->codepoint == ucodepoint)
        {
            return kerning->kerning;
        }
    }
    return 0;
}

// ------------------------------------------ texture_font_generate_kerning ---
void texture_font_generate_kerning(texture_font_t *self, FT_Library *library,
                                   FT_Face *face)
{
    size_t i, j;
    FT_UInt glyph_index, prev_index;
    texture_glyph_t *glyph, *prev_glyph;
    FT_Vector kerning;

    assert(self);

    /* For each glyph couple combination, check if kerning is necessary */
    /* Starts at index 1 since 0 is for the special backgroudn glyph */
    for (i = 1; i < self->glyphs->size; ++i)
    {
        glyph       = *(texture_glyph_t **) vector_get(self->glyphs, i);
        glyph_index = FT_Get_Char_Index(*face, glyph->codepoint);
        vector_clear(glyph->kerning);

        for (j = 1; j < self->glyphs->size; ++j)
        {
            prev_glyph = *(texture_glyph_t **) vector_get(self->glyphs, j);
            prev_index = FT_Get_Char_Index(*face, prev_glyph->codepoint);
            FT_Get_Kerning(*face, prev_index, glyph_index, FT_KERNING_UNFITTED,
                           &kerning);
            // printf("%c(%d)-%c(%d): %ld\n",
            //       prev_glyph->codepoint, prev_glyph->codepoint,
            //       glyph_index, glyph_index, kerning.x);
            if (kerning.x)
            {
                kerning_t k = { prev_glyph->codepoint,
                                kerning.x / (float) (HRESf * HRESf) };
                vector_push_back(glyph->kerning, &k);
            }
        }
    }
}

// ------------------------------------------------------ texture_font_init ---
static int texture_font_init(texture_font_t *self)
{
    FT_Library library;
    FT_Face face;
    FT_Size_Metrics metrics;

    assert(self->atlas);
    assert(self->size > 0);
    assert((self->location == TEXTURE_FONT_FILE && self->filename) ||
           (self->location == TEXTURE_FONT_MEMORY && self->memory.base &&
            self->memory.size));

    self->glyphs            = vector_new(sizeof(texture_glyph_t *));
    self->height            = 0;
    self->ascender          = 0;
    self->descender         = 0;
    self->rendermode        = RENDER_NORMAL;
    self->outline_thickness = 0.0;
    self->hinting           = 1;
    self->kerning           = 1;
    self->filtering         = 1;

    // FT_LCD_FILTER_LIGHT   is (0x00, 0x55, 0x56, 0x55, 0x00)
    // FT_LCD_FILTER_DEFAULT is (0x10, 0x40, 0x70, 0x40, 0x10)
    self->lcd_weights[0] = 0x10;
    self->lcd_weights[1] = 0x40;
    self->lcd_weights[2] = 0x70;
    self->lcd_weights[3] = 0x40;
    self->lcd_weights[4] = 0x10;

    if (!texture_font_load_face(self, self->size * 100.f, &library, &face))
        return -1;

    self->underline_position =
        face->underline_position / (float) (HRESf * HRESf) * self->size;
    self->underline_position = roundf(self->underline_position);
    if (self->underline_position > -2)
    {
        self->underline_position = -2.0;
    }

    self->underline_thickness =
        face->underline_thickness / (float) (HRESf * HRESf) * self->size;
    self->underline_thickness = roundf(self->underline_thickness);
    if (self->underline_thickness < 1)
    {
        self->underline_thickness = 1.0;
    }

    metrics         = face->size->metrics;
    self->ascender  = (metrics.ascender >> 6) / 100.0;
    self->descender = (metrics.descender >> 6) / 100.0;
    self->height    = (metrics.height >> 6) / 100.0;
    self->linegap   = self->height - self->ascender + self->descender;
    FT_Done_Face(face);
    FT_Done_FreeType(library);

    /* NULL is a special glyph */
    texture_font_get_glyph(self, NULL);

    return 0;
}

// --------------------------------------------- texture_font_new_from_file ---
texture_font_t *texture_font_new_from_file(texture_atlas_t *atlas,
                                           const float pt_size,
                                           const char *filename)
{
    texture_font_t *self;

    assert(filename);

    self = calloc(1, sizeof(*self));
    if (!self)
    {
        fprintf(stderr, "line %d: No more memory for allocating data\n",
                __LINE__);
        return NULL;
    }

    self->atlas = atlas;
    self->size  = pt_size;

    self->location = TEXTURE_FONT_FILE;
    self->filename = strdup(filename);

    if (texture_font_init(self))
    {
        texture_font_delete(self);
        return NULL;
    }

    return self;
}

// ------------------------------------------- texture_font_new_from_memory ---
texture_font_t *texture_font_new_from_memory(texture_atlas_t *atlas,
                                             float pt_size,
                                             const void *memory_base,
                                             size_t memory_size)
{
    texture_font_t *self;

    assert(memory_base);
    assert(memory_size);

    self = calloc(1, sizeof(*self));
    if (!self)
    {
        fprintf(stderr, "line %d: No more memory for allocating data\n",
                __LINE__);
        return NULL;
    }

    self->atlas = atlas;
    self->size  = pt_size;

    self->location    = TEXTURE_FONT_MEMORY;
    self->memory.base = memory_base;
    self->memory.size = memory_size;

    if (texture_font_init(self))
    {
        texture_font_delete(self);
        return NULL;
    }

    return self;
}

// ---------------------------------------------------- texture_font_delete ---
void texture_font_delete(texture_font_t *self)
{
    size_t i;
    texture_glyph_t *glyph;

    assert(self);

    if (self->location == TEXTURE_FONT_FILE && self->filename)
        free(self->filename);

    for (i = 0; i < vector_size(self->glyphs); ++i)
    {
        glyph = *(texture_glyph_t **) vector_get(self->glyphs, i);
        texture_glyph_delete(glyph);
    }

    vector_delete(self->glyphs);
    free(self);
}

texture_glyph_t *texture_font_find_glyph(texture_font_t *self,
                                         const char *codepoint)
{
    size_t i;
    texture_glyph_t *glyph;
    uint32_t ucodepoint = utf8_to_utf32(codepoint);

    for (i = 0; i < self->glyphs->size; ++i)
    {
        glyph = *(texture_glyph_t **) vector_get(self->glyphs, i);
        // If codepoint is -1, we don't care about outline type or thickness
        if ((glyph->codepoint == ucodepoint) &&
            ((ucodepoint == -1) ||
             ((glyph->rendermode == self->rendermode) &&
              (glyph->outline_thickness == self->outline_thickness))))
        {
            return glyph;
        }
    }

    return NULL;
}

// ------------------------------------------------ texture_font_load_glyph ---
int texture_font_load_glyph(texture_font_t *self, const char *codepoint)
{
    size_t i, x, y;

    FT_Library library;
    FT_Error error;
    FT_Face face;
    FT_Glyph ft_glyph;
    FT_GlyphSlot slot;
    FT_Bitmap ft_bitmap;

    FT_UInt glyph_index;
    texture_glyph_t *glyph;
    FT_Int32 flags    = 0;
    int ft_glyph_top  = 0;
    int ft_glyph_left = 0;

    ivec4 region;
    size_t missed = 0;

    if (!texture_font_load_face(self, self->size, &library, &face))
        return 0;

    /* Check if codepoint has been already loaded */
    if (texture_font_find_glyph(self, codepoint))
    {
        FT_Done_Face(face);
        FT_Done_FreeType(library);
        return 1;
    }

    /* codepoint NULL is special : it is used for line drawing (overline,
     * underline, strikethrough) and background.
     */
    if (!codepoint)
    {
        ivec4 region           = texture_atlas_get_region(self->atlas, 5, 5);
        texture_glyph_t *glyph = texture_glyph_new();
        static unsigned char data[4 * 4 * 3] = {
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
        };
        if (region.x < 0)
        {
            fprintf(stderr, "Texture atlas is full (line %d)\n", __LINE__);
            FT_Done_Face(face);
            FT_Done_FreeType(library);
            return 0;
        }
        texture_atlas_set_region(self->atlas, region.x, region.y, 4, 4, data,
                                 0);
        glyph->codepoint = -1;
        glyph->s0        = (region.x + 2) / (float) self->atlas->width;
        glyph->t0        = (region.y + 2) / (float) self->atlas->height;
        glyph->s1        = (region.x + 3) / (float) self->atlas->width;
        glyph->t1        = (region.y + 3) / (float) self->atlas->height;
        vector_push_back(self->glyphs, &glyph);

        FT_Done_Face(face);
        FT_Done_FreeType(library);
        return 1;
    }

    flags         = 0;
    ft_glyph_top  = 0;
    ft_glyph_left = 0;
    glyph_index = FT_Get_Char_Index(face, (FT_ULong) utf8_to_utf32(codepoint));
    // WARNING: We use texture-atlas depth to guess if user wants
    //          LCD subpixel rendering

    if (self->rendermode != RENDER_NORMAL &&
        self->rendermode != RENDER_SIGNED_DISTANCE_FIELD)
    {
        flags |= FT_LOAD_NO_BITMAP;
    }
    else
    {
        flags |= FT_LOAD_RENDER;
    }

    if (!self->hinting)
    {
        flags |= FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT;
    }
    else
    {
        flags |= FT_LOAD_FORCE_AUTOHINT;
    }

    if (self->atlas->depth == 3)
    {
        FT_Library_SetLcdFilter(library, FT_LCD_FILTER_LIGHT);
        flags |= FT_LOAD_TARGET_LCD;

        if (self->filtering)
        {
            FT_Library_SetLcdFilterWeights(library, self->lcd_weights);
        }
    }

    error = FT_Load_Glyph(face, glyph_index, flags);
    if (error)
    {
        fprintf(stderr, "FT_Error (line %d, code 0x%02x) : %s\n", __LINE__,
                FT_Errors[error].code, FT_Errors[error].message);
        FT_Done_Face(face);
        FT_Done_FreeType(library);
        return 0;
    }

    if (self->rendermode == RENDER_NORMAL ||
        self->rendermode == RENDER_SIGNED_DISTANCE_FIELD)
    {
        slot          = face->glyph;
        ft_bitmap     = slot->bitmap;
        ft_glyph_top  = slot->bitmap_top;
        ft_glyph_left = slot->bitmap_left;
    }
    else
    {
        FT_Stroker stroker;
        FT_BitmapGlyph ft_bitmap_glyph;

        error = FT_Stroker_New(library, &stroker);

        if (error)
        {
            fprintf(stderr, "FT_Error (0x%02x) : %s\n", FT_Errors[error].code,
                    FT_Errors[error].message);
            goto cleanup_stroker;
        }

        FT_Stroker_Set(stroker, (int) (self->outline_thickness * HRES),
                       FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);

        error = FT_Get_Glyph(face->glyph, &ft_glyph);

        if (error)
        {
            fprintf(stderr, "FT_Error (0x%02x) : %s\n", FT_Errors[error].code,
                    FT_Errors[error].message);
            goto cleanup_stroker;
        }

        if (self->rendermode == RENDER_OUTLINE_EDGE)
            error = FT_Glyph_Stroke(&ft_glyph, stroker, 1);
        else if (self->rendermode == RENDER_OUTLINE_POSITIVE)
            error = FT_Glyph_StrokeBorder(&ft_glyph, stroker, 0, 1);
        else if (self->rendermode == RENDER_OUTLINE_NEGATIVE)
            error = FT_Glyph_StrokeBorder(&ft_glyph, stroker, 1, 1);

        if (error)
        {
            fprintf(stderr, "FT_Error (0x%02x) : %s\n", FT_Errors[error].code,
                    FT_Errors[error].message);
            goto cleanup_stroker;
        }

        if (self->atlas->depth == 1)
            error = FT_Glyph_To_Bitmap(&ft_glyph, FT_RENDER_MODE_NORMAL, 0, 1);
        else
            error = FT_Glyph_To_Bitmap(&ft_glyph, FT_RENDER_MODE_LCD, 0, 1);

        if (error)
        {
            fprintf(stderr, "FT_Error (0x%02x) : %s\n", FT_Errors[error].code,
                    FT_Errors[error].message);
            goto cleanup_stroker;
        }

        ft_bitmap_glyph = (FT_BitmapGlyph) ft_glyph;
        ft_bitmap       = ft_bitmap_glyph->bitmap;
        ft_glyph_top    = ft_bitmap_glyph->top;
        ft_glyph_left   = ft_bitmap_glyph->left;

    cleanup_stroker:
        FT_Stroker_Done(stroker);

        if (error)
        {
            FT_Done_Face(face);
            FT_Done_FreeType(library);
            return 0;
        }
    }

    struct
    {
        int left;
        int top;
        int right;
        int bottom;
    } padding = { 0, 0, 1, 1 };

    if (self->rendermode == RENDER_SIGNED_DISTANCE_FIELD)
    {
        padding.top  = 1;
        padding.left = 1;
    }

    size_t src_w = ft_bitmap.width / self->atlas->depth;
    size_t src_h = ft_bitmap.rows;

    size_t tgt_w = src_w + padding.left + padding.right;
    size_t tgt_h = src_h + padding.top + padding.bottom;

    region = texture_atlas_get_region(self->atlas, tgt_w, tgt_h);

    if (region.x < 0)
    {
        fprintf(stderr, "Texture atlas is full (line %d)\n", __LINE__);
        FT_Done_Face(face);
        FT_Done_FreeType(library);
        return 0;
    }

    x = region.x;
    y = region.y;

    unsigned char *buffer =
        calloc(tgt_w * tgt_h * self->atlas->depth, sizeof(unsigned char));

    unsigned char *dst_ptr =
        buffer + (padding.top * tgt_w + padding.left) * self->atlas->depth;
    unsigned char *src_ptr = ft_bitmap.buffer;
    for (i = 0; i < src_h; i++)
    {
        // difference between width and pitch:
        // https://www.freetype.org/freetype2/docs/reference/ft2-basic_types.html#FT_Bitmap
        memcpy(dst_ptr, src_ptr, ft_bitmap.width);
        dst_ptr += tgt_w * self->atlas->depth;
        src_ptr += ft_bitmap.pitch;
    }

    if (self->rendermode == RENDER_SIGNED_DISTANCE_FIELD)
    {
        unsigned char *sdf = make_distance_mapb(buffer, tgt_w, tgt_h);
        free(buffer);
        buffer = sdf;
    }

    texture_atlas_set_region(self->atlas, x, y, tgt_w, tgt_h, buffer,
                             tgt_w * self->atlas->depth);

    free(buffer);

    glyph                    = texture_glyph_new();
    glyph->codepoint         = utf8_to_utf32(codepoint);
    glyph->width             = tgt_w;
    glyph->height            = tgt_h;
    glyph->rendermode        = self->rendermode;
    glyph->outline_thickness = self->outline_thickness;
    glyph->offset_x          = ft_glyph_left;
    glyph->offset_y          = ft_glyph_top;
    glyph->s0                = x / (float) self->atlas->width;
    glyph->t0                = y / (float) self->atlas->height;
    glyph->s1                = (x + glyph->width) / (float) self->atlas->width;
    glyph->t1 = (y + glyph->height) / (float) self->atlas->height;

    // Discard hinting to get advance
    FT_Load_Glyph(face, glyph_index, FT_LOAD_RENDER | FT_LOAD_NO_HINTING);
    slot             = face->glyph;
    glyph->advance_x = slot->advance.x / HRESf;
    glyph->advance_y = slot->advance.y / HRESf;

    vector_push_back(self->glyphs, &glyph);

    if (self->rendermode != RENDER_NORMAL &&
        self->rendermode != RENDER_SIGNED_DISTANCE_FIELD)
        FT_Done_Glyph(ft_glyph);

    texture_font_generate_kerning(self, &library, &face);

    FT_Done_Face(face);
    FT_Done_FreeType(library);

    return 1;
}

// ----------------------------------------------- texture_font_load_glyphs ---
size_t texture_font_load_glyphs(texture_font_t *self, const char *codepoints)
{
    size_t i, c;

    /* Load each glyph */
    for (i = 0; i < strlen(codepoints); i += utf8_surrogate_len(codepoints + i))
    {
        if (!texture_font_load_glyph(self, codepoints + i))
            return utf8_strlen(codepoints + i);
    }

    return 0;
}

// ------------------------------------------------- texture_font_get_glyph ---
texture_glyph_t *texture_font_get_glyph(texture_font_t *self,
                                        const char *codepoint)
{
    texture_glyph_t *glyph;

    assert(self);
    assert(self->filename);
    assert(self->atlas);

    /* Check if codepoint has been already loaded */
    if ((glyph = texture_font_find_glyph(self, codepoint)))
        return glyph;

    /* Glyph has not been already loaded */
    if (texture_font_load_glyph(self, codepoint))
        return texture_font_find_glyph(self, codepoint);

    return NULL;
}

// ------------------------------------------------- texture_font_enlarge_atlas
// ---
void texture_font_enlarge_atlas(texture_font_t *self, size_t width_new,
                                size_t height_new)
{
    assert(self);
    assert(self->atlas);
    // ensure size increased
    assert(width_new >= self->atlas->width);
    assert(height_new >= self->atlas->height);
    assert(width_new + height_new > self->atlas->width + self->atlas->height);
    texture_atlas_t *ta = self->atlas;
    size_t width_old    = ta->width;
    size_t height_old   = ta->height;
    // allocate new buffer
    unsigned char *data_old = ta->data;
    ta->data = calloc(1, width_new * height_new * sizeof(char) * ta->depth);
    // update atlas size
    ta->width  = width_new;
    ta->height = height_new;
    // add node reflecting the gained space on the right
    if (width_new > width_old)
    {
        ivec3 node;
        node.x = width_old - 1;
        node.y = 1;
        node.z = width_new - width_old;
        vector_push_back(ta->nodes, &node);
    }
    // copy over data from the old buffer, skipping first row and column because
    // of the margin
    size_t pixel_size   = sizeof(char) * ta->depth;
    size_t old_row_size = width_old * pixel_size;
    texture_atlas_set_region(ta, 1, 1, width_old - 2, height_old - 2,
                             data_old + old_row_size + pixel_size,
                             old_row_size);
    free(data_old);
    // change uv coordinates of existing glyphs to reflect size change
    float mulw = (float) width_old / width_new;
    float mulh = (float) height_old / height_new;
    size_t i;
    for (i = 0; i < vector_size(self->glyphs); i++)
    {
        texture_glyph_t *g = *(texture_glyph_t **) vector_get(self->glyphs, i);
        g->s0 *= mulw;
        g->s1 *= mulw;
        g->t0 *= mulh;
        g->t1 *= mulh;
    }
}