/*

SDL_FontCache: A font cache for SDL and SDL_ttf

by Jonathan Dearborn

See fontcche.h for license info.

*/

#include "fontcche.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// Visual C does not support static inline

#ifndef static_inline

	#ifdef _MSC_VER

		#define static_inline static

	#else

		#define static_inline static inline

	#endif

#endif

#if SDL_VERSION_ATLEAST(2,0,0)

    #define FC_GET_ALPHA(sdl_color) ((sdl_color).a)

#else

    #define FC_GET_ALPHA(sdl_color) ((sdl_color).unused)

#endif

// Need SDL_RenderIsClipEnabled() for proper clipping support

#if SDL_VERSION_ATLEAST(2,0,4)

    #define ENABLE_SDL_CLIPPING

#endif

#define FC_MIN(a,b) ((a) < (b)? (a) : (b))

#define FC_MAX(a,b) ((a) > (b)? (a) : (b))

// vsnprintf replacement from Valentin Milea:

// http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010

#if defined(_MSC_VER) && _MSC_VER < 1900

#define snprintf c99_snprintf

#define vsnprintf c99_vsnprintf

__inline int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)

{

    int count = -1;

    if (size != 0)

        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);

    if (count == -1)

        count = _vscprintf(format, ap);

    return count;

}

__inline int c99_snprintf(char *outBuf, size_t size, const char *format, ...)

{

    int count;

    va_list ap;

    va_start(ap, format);

    count = c99_vsnprintf(outBuf, size, format, ap);

    va_end(ap);

    return count;

}

#endif

#define FC_EXTRACT_VARARGS(buffer, start_args) \

{ \

    va_list lst; \

    va_start(lst, start_args); \

    vsnprintf(buffer, fc_buffer_size, start_args, lst); \

    va_end(lst); \

}

// Extra pixels of padding around each glyph to avoid linear filtering artifacts

#define FC_CACHE_PADDING 1

static Uint8 has_clip(FC_Target* dest)

{

    #ifdef FC_USE_SDL_GPU

    return dest->use_clip_rect;

    #elif defined(ENABLE_SDL_CLIPPING)

    return SDL_RenderIsClipEnabled(dest);

    #else

    return 0;

    #endif

}

static FC_Rect get_clip(FC_Target* dest)

{

    #ifdef FC_USE_SDL_GPU

    return dest->clip_rect;

    #elif defined(ENABLE_SDL_CLIPPING)

    SDL_Rect r;

    SDL_RenderGetClipRect(dest, &r);

    return r;

    #else

    SDL_Rect r = {0, 0, 0, 0};

    return r;

    #endif

}

static void set_clip(FC_Target* dest, FC_Rect* rect)

{

    #ifdef FC_USE_SDL_GPU

    if(rect != NULL)

        GPU_SetClipRect(dest, *rect);

    else

        GPU_UnsetClip(dest);

    #elif defined(ENABLE_SDL_CLIPPING)

    SDL_RenderSetClipRect(dest, rect);

    #endif

}

static void set_color(FC_Image* src, Uint8 r, Uint8 g, Uint8 b, Uint8 a)

{

    #ifdef FC_USE_SDL_GPU

    GPU_SetRGBA(src, r, g, b, a);

    #else

    SDL_SetTextureColorMod(src, r, g, b);

    SDL_SetTextureAlphaMod(src, a);

    #endif

}

static char* new_concat(const char* a, const char* b)

{

    // Create new buffer

    unsigned int size = strlen(a) + strlen(b);

    char* new_string = (char*)malloc(size+1);

    // Concatenate strings in the new buffer

    strcpy(new_string, a);

    strcat(new_string, b);

    return new_string;

}

static char* replace_concat(char** a, const char* b)

{

    char* new_string = new_concat(*a, b);

    free(*a);

    *a = new_string;

    return *a;

}

// Width of a tab in units of the space width (sorry, no tab alignment!)

static unsigned int fc_tab_width = 4;

// Shared buffer for variadic text

static char* fc_buffer = NULL;

static unsigned int fc_buffer_size = 1024;

static Uint8 fc_has_render_target_support = 0;

// The number of fonts that has been created but not freed

static int NUM_EXISTING_FONTS = 0;

// Globals for GetString functions

static char* ASCII_STRING = NULL;

static char* LATIN_1_STRING = NULL;

static char* ASCII_LATIN_1_STRING = NULL;

char* FC_GetStringASCII(void)

{

    if(ASCII_STRING == NULL)

    {

        int i;

        char c;

        ASCII_STRING = (char*)malloc(512);

        memset(ASCII_STRING, 0, 512);

        i = 0;

        c = 32;

        while(1)

        {

            ASCII_STRING[i] = c;

            if(c == 126)

                break;

            ++i;

            ++c;

        }

    }

    return U8_strdup(ASCII_STRING);

}

char* FC_GetStringLatin1(void)

{

    if(LATIN_1_STRING == NULL)

    {

        int i;

        unsigned char c;

        LATIN_1_STRING = (char*)malloc(512);

        memset(LATIN_1_STRING, 0, 512);

        i = 0;

        c = 0xA0;

        while(1)

        {

            LATIN_1_STRING[i] = 0xC2;

            LATIN_1_STRING[i+1] = c;

            if(c == 0xBF)

                break;

            i += 2;

            ++c;

        }

        i += 2;

        c = 0x80;

        while(1)

        {

            LATIN_1_STRING[i] = 0xC3;

            LATIN_1_STRING[i+1] = c;

            if(c == 0xBF)

                break;

            i += 2;

            ++c;

        }

    }

    return U8_strdup(LATIN_1_STRING);

}

char* FC_GetStringASCII_Latin1(void)

{

    if(ASCII_LATIN_1_STRING == NULL)

		ASCII_LATIN_1_STRING = new_concat(FC_GetStringASCII(), FC_GetStringLatin1());

    return U8_strdup(ASCII_LATIN_1_STRING);

}

FC_Rect FC_MakeRect(float x, float y, float w, float h)

{

    FC_Rect r = {x, y, w, h};

    return r;

}

FC_Scale FC_MakeScale(float x, float y)

{

    FC_Scale s = {x, y};

    return s;

}

SDL_Color FC_MakeColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a)

{

    SDL_Color c = {r, g, b, a};

    return c;

}

FC_Effect FC_MakeEffect(FC_AlignEnum alignment, FC_Scale scale, SDL_Color color)

{

    FC_Effect e;

    e.alignment = alignment;

    e.scale = scale;

    e.color = color;

    return e;

}

FC_GlyphData FC_MakeGlyphData(int cache_level, Sint16 x, Sint16 y, Uint16 w, Uint16 h)

{

    FC_GlyphData gd;

    gd.rect.x = x;

    gd.rect.y = y;

    gd.rect.w = w;

    gd.rect.h = h;

    gd.cache_level = cache_level;

    return gd;

}

// Enough to hold all of the ascii characters and some.

#define FC_DEFAULT_NUM_BUCKETS 300

typedef struct FC_MapNode

{

    Uint32 key;

    FC_GlyphData value;

    struct FC_MapNode* next;

} FC_MapNode;

typedef struct FC_Map

{

    int num_buckets;

    FC_MapNode** buckets;

} FC_Map;

static FC_Map* FC_MapCreate(int num_buckets)

{

    int i;

    FC_Map* map = (FC_Map*)malloc(sizeof(FC_Map));

    map->num_buckets = num_buckets;

    map->buckets = (FC_MapNode**)malloc(num_buckets * sizeof(FC_MapNode*));

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

    {

        map->buckets[i] = NULL;

    }

    return map;

}

/*static void FC_MapClear(FC_Map* map)

{

    int i;

    if(map == NULL)

        return;

    // Go through each bucket

    for(i = 0; i < map->num_buckets; ++i)

    {

        // Delete the nodes in order

        FC_MapNode* node = map->buckets[i];

        while(node != NULL)

        {

            FC_MapNode* last = node;

            node = node->next;

            free(last);

        }

        // Set the bucket to empty

        map->buckets[i] = NULL;

    }

}*/

static void FC_MapFree(FC_Map* map)

{

    int i;

    if(map == NULL)

        return;

    // Go through each bucket

    for(i = 0; i < map->num_buckets; ++i)

    {

        // Delete the nodes in order

        FC_MapNode* node = map->buckets[i];

        while(node != NULL)

        {

            FC_MapNode* last = node;

            node = node->next;

            free(last);

        }

    }

    free(map->buckets);

    free(map);

}

// Note: Does not handle duplicates in any special way.

static FC_GlyphData* FC_MapInsert(FC_Map* map, Uint32 codepoint, FC_GlyphData glyph)

{

    Uint32 index;

    FC_MapNode* node;

    if(map == NULL)

        return NULL;

    // Get index for bucket

    index = codepoint % map->num_buckets;

    // If this bucket is empty, create a node and return its value

    if(map->buckets[index] == NULL)

    {

        node = map->buckets[index] = (FC_MapNode*)malloc(sizeof(FC_MapNode));

        node->key = codepoint;

        node->value = glyph;

        node->next = NULL;

        return &node->value;

    }

    for(node = map->buckets[index]; node != NULL; node = node->next)

    {

        // Find empty node and add a new one on.

        if(node->next == NULL)

        {

            node->next = (FC_MapNode*)malloc(sizeof(FC_MapNode));

            node = node->next;

            node->key = codepoint;

            node->value = glyph;

            node->next = NULL;

            return &node->value;

        }

    }

    return NULL;

}

static FC_GlyphData* FC_MapFind(FC_Map* map, Uint32 codepoint)

{

    Uint32 index;

    FC_MapNode* node;

    if(map == NULL)

        return NULL;

    // Get index for bucket

    index = codepoint % map->num_buckets;

    // Go through list until we find a match

    for(node = map->buckets[index]; node != NULL; node = node->next)

    {

        if(node->key == codepoint)

            return &node->value;

    }

    return NULL;

}

struct FC_Font

{

    #ifndef FC_USE_SDL_GPU

    SDL_Renderer* renderer;

    #endif

    TTF_Font* ttf_source;  // TTF_Font source of characters

    Uint8 owns_ttf_source;  // Can we delete the TTF_Font ourselves?

    FC_FilterEnum filter;

    SDL_Color default_color;

    Uint16 height;

    Uint16 maxWidth;

    Uint16 baseline;

    int ascent;

    int descent;

    int lineSpacing;

    int letterSpacing;

    // Uses 32-bit (4-byte) Unicode codepoints to refer to each glyph

    // Codepoints are little endian (reversed from UTF-8) so that something like 0x00000005 is ASCII 5 and the map can be indexed by ASCII values

    FC_Map* glyphs;

    FC_GlyphData last_glyph;  // Texture packing cursor

    int glyph_cache_size;

    int glyph_cache_count;

    FC_Image** glyph_cache;

    char* loading_string;

};

// Private

static FC_GlyphData* FC_PackGlyphData(FC_Font* font, Uint32 codepoint, Uint16 width, Uint16 maxWidth, Uint16 maxHeight);

static FC_Rect FC_RenderLeft(FC_Font* font, FC_Target* dest, float x, float y, FC_Scale scale, const char* text);

static FC_Rect FC_RenderCenter(FC_Font* font, FC_Target* dest, float x, float y, FC_Scale scale, const char* text);

static FC_Rect FC_RenderRight(FC_Font* font, FC_Target* dest, float x, float y, FC_Scale scale, const char* text);

static_inline SDL_Surface* FC_CreateSurface32(Uint32 width, Uint32 height)

{

    #if SDL_BYTEORDER == SDL_BIG_ENDIAN

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);

    #else

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000);

    #endif

}

char* U8_alloc(unsigned int size)

{

    char* result;

    if(size == 0)

        return NULL;

    result = (char*)malloc(size);

    result[0] = '\0';

    return result;

}

void U8_free(char* string)

{

    free(string);

}

char* U8_strdup(const char* string)

{

    char* result;

    if(string == NULL)

        return NULL;

    result = (char*)malloc(strlen(string)+1);

    strcpy(result, string);

    return result;

}

int U8_strlen(const char* string)

{

    int length = 0;

    if(string == NULL)

        return 0;

    while(*string != '\0')

    {

        string = U8_next(string);

        ++length;

    }

    return length;

}

int U8_charsize(const char* character)

{

    if(character == NULL)

        return 0;

    if((unsigned char)*character <= 0x7F)

        return 1;

    else if((unsigned char)*character < 0xE0)

        return 2;

    else if((unsigned char)*character < 0xF0)