#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <gctypes.h>
#include "gettext.h"

typedef struct _MSG
{
    u32 id;
    char* msgstr;
    struct _MSG *next;
} MSG;
static MSG *baseMSG = 0;


#define HASHWORDBITS 32

/* Defines the so called `hashpjw' function by P.J. Weinberger
   [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
   1986, 1987 Bell Telephone Laboratories, Inc.]  */
static inline u32
hash_string ( const char *str_param )
{
    u32 hval, g;
    const char *str = str_param;

    /* Compute the hash value for the given string.  */
    hval = 0;
    while ( *str != '\0' )
    {
        hval <<= 4;
        hval += ( u8 ) * str++;
        g = hval & ( ( u32 ) 0xf << ( HASHWORDBITS - 4 ) );
        if ( g != 0 )
        {
            hval ^= g >> ( HASHWORDBITS - 8 );
            hval ^= g;
        }
    }
    return hval;
}

/* Expand some escape sequences found in the argument string.  */
static char *
expand_escape ( const char *str )
{
    char *retval, *rp;
    const char *cp = str;

    retval = ( char * ) malloc ( strlen ( str ) + 1 );
    if ( retval == NULL ) return NULL;
    rp = retval;

    while ( cp[0] != '\0' && cp[0] != '\\' )
        *rp++ = *cp++;
    if ( cp[0] == '\0' )
        goto terminate;
    do
    {

        /* Here cp[0] == '\\'.  */
        switch ( *++cp )
        {
            case '\"':      /* " */
                *rp++ = '\"';
                ++cp;
                break;
            case 'a':       /* alert */
                *rp++ = '\a';
                ++cp;
                break;
            case 'b':       /* backspace */
                *rp++ = '\b';
                ++cp;
                break;
            case 'f':       /* form feed */
                *rp++ = '\f';
                ++cp;
                break;
            case 'n':       /* new line */
                *rp++ = '\n';
                ++cp;
                break;
            case 'r':       /* carriage return */
                *rp++ = '\r';
                ++cp;
                break;
            case 't':       /* horizontal tab */
                *rp++ = '\t';
                ++cp;
                break;
            case 'v':       /* vertical tab */
                *rp++ = '\v';
                ++cp;
                break;
            case '\\':
                *rp = '\\';
                ++cp;
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
                {
                    int ch = *cp++ - '0';

                    if ( *cp >= '0' && *cp <= '7' )
                    {
                        ch *= 8;
                        ch += *cp++ - '0';

                        if ( *cp >= '0' && *cp <= '7' )
                        {
                            ch *= 8;
                            ch += *cp++ - '0';
                        }
                    }
                    *rp = ch;
                }
                break;
            default:
                *rp = '\\';
                break;
        }

        while ( cp[0] != '\0' && cp[0] != '\\' )
            *rp++ = *cp++;
    }
    while ( cp[0] != '\0' );

    /* Terminate string.  */
terminate:
    *rp = '\0';
    return retval;
}

static MSG *findMSG( u32 id )
{
    MSG *msg;
    for ( msg = baseMSG; msg; msg = msg->next )
    {
        if ( msg->id == id )
            return msg;
    }
    return NULL;
}

static MSG *setMSG( const char *msgid, const char *msgstr )
{
    u32 id = hash_string( msgid );
    MSG *msg = findMSG( id );
    if ( !msg )
    {
        msg = ( MSG * )malloc( sizeof( MSG ) );
        msg->id     = id;
        msg->msgstr = NULL;
        msg->next   = baseMSG;
        baseMSG     = msg;
    }
    if ( msg )
    {
        if ( msgstr )
        {
            if ( msg->msgstr ) free( msg->msgstr );
            //msg->msgstr = strdup(msgstr);
            msg->msgstr = expand_escape( msgstr );
        }
        return msg;
    }
    return NULL;
}
void gettextCleanUp( void )
{
    while ( baseMSG )
    {
        MSG *nextMsg = baseMSG->next;
        free( baseMSG->msgstr );
        free( baseMSG );
        baseMSG = nextMsg;
    }
}


bool gettextLoadLanguage( const char* langFile )
{
    FILE *f;
    char line[200];
    char *lastID = NULL;

    gettextCleanUp();
    f = fopen( langFile, "r" );
    if ( !f )
        return false;

    while ( fgets( line, sizeof( line ), f ) )
    {
        // lines starting with # are comments
        if ( line[0] == '#' )
            continue;
        else if ( strncmp( line, "msgid \"", 7 ) == 0 )
        {
            char *msgid, *end;
            if ( lastID )
            {
                free( lastID );
                lastID = NULL;
            }
            msgid = &line[7];
            end = strrchr( msgid, '"' );
            if ( end && end - msgid > 1 )
            {
                *end = 0;
                lastID = strdup( msgid );
            }
        }
        else if ( strncmp( line, "msgstr \"", 8 ) == 0 )
        {
            char *msgstr, *end;

            if ( lastID == NULL )
                continue;

            msgstr = &line[8];
            end = strrchr( msgstr, '"' );
            if ( end && end - msgstr > 1 )
            {
                *end = 0;
                setMSG( lastID, msgstr );
            }
            free( lastID );
            lastID = NULL;
        }

    }

    fclose( f );
    return true;
}
const char *gettext( const char *msgid )
{
    MSG *msg = findMSG( hash_string( msgid ) );
    if ( msg && msg->msgstr ) return msg->msgstr;
    return msgid;
}