/*
 * DMLib
 * -- Bitmap and TTF text & font support
 * Programmed and designed by Matti 'ccr' Hamalainen
 * (C) Copyright 2012 Tecnic Software productions (TNSP)
 */
#include "dmtext.h"
#include "dmresw.h"


void dmDrawBMTextConst(SDL_Surface *screen, DMBitmapFont *font, int mode, int xc, int yc, const char *fmt)
{
    const char *ptr = fmt;
    DMScaledBlitFunc blit = dmGetScaledBlitFunc(font->glyphs[0]->format, screen->format, mode);

    while (*ptr)
    {
        SDL_Surface *glyph;
        int pos;
        int ch = *ptr++;

        if (ch == '_')
        {
            xc += 4;
            continue;
        }
        else
        if (ch >= 'A' && ch <= 'Z')
            pos = ch - 'A' + 256 + 1;
        else
        if (ch >= 'a' && ch <= 'z')
            pos = ch - 'a' + 1;
        else
        if (ch >= '0' && ch <= '9')
            pos = ch - '0' + 48;
        else
            pos = ch;
        
        if (pos >= 0 && pos < font->nglyphs)
        {
            glyph = font->glyphs[pos];
            blit(glyph, xc, yc, glyph->w, glyph->h, screen);
            xc += glyph->w;
        }
        else
            xc += font->width;
    }
}


void dmDrawBMTextVA(SDL_Surface *screen, DMBitmapFont *font, int mode, int xc, int yc, const char *fmt, va_list ap)
{
    char *tmp = dm_strdup_vprintf(fmt, ap);
    if (tmp != NULL)
    {
        dmDrawBMTextConst(screen, font, mode, xc, yc, tmp);
        dmFree(tmp);
    }
}


void dmDrawBMText(SDL_Surface *screen, DMBitmapFont *font, int mode, int xc, int yc, const char *fmt, ...)
{
    va_list ap;
    
    va_start(ap, fmt);
    dmDrawBMTextVA(screen, font, mode, xc, yc, fmt, ap);
    va_end(ap);
}


DMBitmapFont *dmNewBitmapFont(int nglyphs)
{
    DMBitmapFont *font = dmMalloc0(sizeof(DMBitmapFont));
    if (font == NULL)
        return NULL;
    
    font->nglyphs = nglyphs;
    font->glyphs = dmCalloc(nglyphs, sizeof(SDL_Surface *));
    
    return font;
}


int dmFreeBitmapFont(DMBitmapFont *font)
{
    int i;

    if (font == NULL)
        return DMERR_NULLPTR;
    
    for (i = 0; i < font->nglyphs; i++)
    {
        if (font->glyphs[i] != NULL)
        {
            SDL_FreeSurface(font->glyphs[i]);
            font->glyphs[i] = NULL;
        }
    }

    dmFree(font);
    return DMERR_OK;
}


int dmCreateBitmapFontFromImage(SDL_Surface *image, int width, int height, DMBitmapFont **pfont)
{
    int nglyph, xc, yc, xglyphs, yglyphs;
    DMBitmapFont *font;

    if (image->w < width || width < 4 || image->h < height || height < 4)
        return DMERR_INVALID_ARGS;
    
    xglyphs = image->w / width;
    yglyphs = image->h / height;
    
    if ((font = dmNewBitmapFont(xglyphs * yglyphs)) == NULL)
        return DMERR_MALLOC;

    font->width = width;
    font->height = height;

/*
    fprintf(stderr, "%d x %d split as %d x %d blocks => %d x %d = %d glyphs\n",
        image->w, image->h,
        width, height,
        xglyphs, yglyphs, xglyphs * yglyphs);
*/
    
    nglyph = 0;
    for (yc = 0; yc < yglyphs; yc++)
    for (xc = 0; xc < xglyphs; xc++)
    {
        SDL_Surface *glyph = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height,
            image->format->BitsPerPixel,
            image->format->Rmask,
            image->format->Gmask,
            image->format->Bmask,
            image->format->Amask);
        
        if (glyph == NULL)
        {
            dmFreeBitmapFont(font);
            return DMERR_MALLOC;
        }

        SDL_Rect r;
        r.x = xc * width;
        r.y = yc * height;
        r.w = width;
        r.h = height;
        
        SDL_BlitSurface(image, &r, glyph, NULL);
        
        font->glyphs[nglyph++] = glyph;
    }
    
    *pfont = font;
    return DMERR_OK;
}


int dmLoadBitmapFont(DMResource *res, DMBitmapFont **pfont)
{
    DMBitmapFont *font;
    char magic[8];
    Uint16 version;
    Uint32 width, height, nglyphs;
    
    // Check magic and version
    dmf_read_str(res, (Uint8 *) &magic, 6);
    dmf_read_le16(res, &version);
    
    if (memcmp(magic, DMFONT_MAGIC, 6) != 0)
        return DMERR_INVALID;

    if (version != DMFONT_VERSION)
        return DMERR_VERSION;
    
    // Check other data
    dmf_read_le32(res, &width);
    dmf_read_le32(res, &height);
    dmf_read_le32(res, &nglyphs);

    if (width > 128 || height > 128 || nglyphs > 1024)
        return DMERR_INVALID_DATA;

    // Allocate font
    if ((*pfont = font = dmNewBitmapFont(nglyphs)) == NULL)
        return DMERR_MALLOC;

    font->width = width;
    font->height = height;
    font->nglyphs = nglyphs;

    // Read glyph data, if any
    if (nglyphs > 0)
    {
        Uint32 i, BitsPerPixel, Rmask, Gmask, Bmask, Amask, pitch;

        BitsPerPixel = dmfgetc(res);
        dmf_read_le32(res, &Rmask);
        dmf_read_le32(res, &Gmask);
        dmf_read_le32(res, &Bmask);
        dmf_read_le32(res, &Amask);

        for (i = 0; i < nglyphs; i++)
        {
            int y;
            Uint8 *pixels;
            SDL_Surface *glyph;
            dmf_read_le32(res, &width);
            dmf_read_le32(res, &height);
            dmf_read_le32(res, &pitch);
            
            font->glyphs[i] = glyph = SDL_CreateRGBSurface(
                SDL_SWSURFACE, width, height,
                BitsPerPixel, Rmask, Gmask,
                Bmask,
                Amask);
            
            if (glyph == NULL)
                return DMERR_MALLOC;

            pixels = glyph->pixels;
            for (y = 0; y < glyph->h; y++)
            {
                if (dmfread(pixels, glyph->format->BytesPerPixel, glyph->w, res) != glyph->w)
                    return DMERR_FREAD;
                pixels += glyph->pitch;
            }
        }
    }

    return DMERR_OK;
}


int dmSaveBitmapFont(DMResource *res, DMBitmapFont *font)
{
    if (font == NULL)
        return DMERR_NULLPTR;
    
    if (!dmf_write_str(res, (Uint8 *) DMFONT_MAGIC, 6))
        return DMERR_FWRITE;
    
    dmf_write_le16(res, DMFONT_VERSION);
    dmf_write_le32(res, font->width);
    dmf_write_le32(res, font->height);
    dmf_write_le32(res, font->nglyphs);
    
    if (font->nglyphs > 0)
    {
        int i;
        SDL_Surface *glyph = font->glyphs[0];

        dmfputc(glyph->format->BitsPerPixel, res);
        dmf_write_le32(res, glyph->format->Rmask);
        dmf_write_le32(res, glyph->format->Gmask);
        dmf_write_le32(res, glyph->format->Bmask);
        dmf_write_le32(res, glyph->format->Amask);

        for (i = 0; i < font->nglyphs; i++)
        {
            int y;
            glyph = font->glyphs[i];
            Uint8 *pixels = glyph->pixels;

            dmf_write_le32(res, glyph->w);
            dmf_write_le32(res, glyph->h);

            for (y = 0; y < glyph->h; y++)
            {
                if (dmfwrite(pixels, glyph->format->BytesPerPixel, glyph->w, res) != glyph->w)
                    return DMERR_FWRITE;
                pixels += glyph->pitch;
            }
        }
    }

    return DMERR_OK;
}