/*
 * Copyright 2009, Adrien Destugues, pulkomandy@gmail.com. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include <HashMapCatalog.h>

#include <ByteOrder.h>

#include <stdlib.h>


namespace BPrivate {


/*
 * This is the standard implementation of a localization catalog, using a hash
 * map. This class is abstract, you need to inherit it and provide methodes for
 * reading and writing the catalog to a file. Classes doing that are
 * HashMapCatalog and PlainTextCatalog.
 * If you ever need to create a catalog not built around an hash map, inherit
 * BCatalogData instead. Note that in this case you will not be able to use our
 * development tools anymore.
 */


CatKey::CatKey(const char *str, const char *ctx, const char *cmt)
        :
        fString(str),
        fContext(ctx),
        fComment(cmt),
        fFlags(0)
{
        fHashVal = HashFun(fString.String(),0);
        fHashVal = HashFun(fContext.String(),fHashVal);
        fHashVal = HashFun(fComment.String(),fHashVal);
}


CatKey::CatKey(uint32 id)
        :
        fHashVal(id),
        fFlags(0)
{
}


CatKey::CatKey()
        :
        fHashVal(0),
        fFlags(0)
{
}


bool
CatKey::operator== (const CatKey& right) const
{
        // Two keys are equal if their hashval and key (string,context,comment)
        // are equal (testing only the hash would not filter out collisions):
        return fHashVal == right.fHashVal
                && fString == right.fString
                && fContext == right.fContext
                && fComment == right.fComment;
}


bool
CatKey::operator!= (const CatKey& right) const
{
        // Two keys are equal if their hashval and key (string,context,comment)
        // are equal (testing only the hash would not filter out collisions):
        return fHashVal != right.fHashVal
                || fString != right.fString
                || fContext != right.fContext
                || fComment != right.fComment;
}


status_t
CatKey::GetStringParts(BString* str, BString* ctx, BString* cmt) const
{
        if (str) *str = fString;
        if (ctx) *ctx = fContext;
        if (cmt) *cmt = fComment;

        return B_OK;
}


uint32
CatKey::HashFun(const char* s, int startValue) {
        unsigned long h = startValue;
        for ( ; *s; ++s)
                h = 5 * h + *s;

        // Add 1 to differenciate ("ab","cd","ef") from ("abcd","e","f")
        h = 5 * h + 1;

        return size_t(h);
}


// HashMapCatalog


void
HashMapCatalog::MakeEmpty()
{
        fCatMap.Clear();
}


int32
HashMapCatalog::CountItems() const
{
        return fCatMap.Size();
}


const char *
HashMapCatalog::GetString(const char *string, const char *context,
        const char *comment)
{
        CatKey key(string, context, comment);
        return GetString(key);
}


const char *
HashMapCatalog::GetString(uint32 id)
{
        CatKey key(id);
        return GetString(key);
}


const char *
HashMapCatalog::GetString(const CatKey& key)
{
        BString value = fCatMap.Get(key);
        if (value.Length() == 0)
                return NULL;
        else
                return value.String();
}


static status_t
parseQuotedChars(BString& stringToParse)
{
        char* in = stringToParse.LockBuffer(0);
        if (in == NULL)
                return B_ERROR;
        char* out = in;
        int newLength = 0;
        bool quoted = false;

        while (*in != 0) {
                if (quoted) {
                        if (*in == 'a')
                                *out = '\a';
                        else if (*in == 'b')
                                *out = '\b';
                        else if (*in == 'f')
                                *out = '\f';
                        else if (*in == 'n')
                                *out = '\n';
                        else if (*in == 'r')
                                *out = '\r';
                        else if (*in == 't')
                                *out = '\t';
                        else if (*in == 'v')
                                *out = '\v';
                        else if (*in == '"')
                                *out = '"';
                        else if (*in == 'x') {
                                if (in[1] == '\0' || in[2] == '\0')
                                        break;
                                // Parse the 2-digit hex integer that follows
                                char tmp[3];
                                tmp[0] = in[1];
                                tmp[1] = in[2];
                                tmp[2] = '\0';
                                unsigned int hexchar = strtoul(tmp, NULL, 16);
                                *out = hexchar;
                                // skip the number
                                in += 2;
                        } else {
                                // drop quote from unknown quoting-sequence:
                                *out = *in ;
                        }
                        quoted = false;
                        out++;
                        newLength++;
                } else {
                        quoted = (*in == '\\');
                        if (!quoted) {
                                *out = *in;
                                out++;
                                newLength++;
                        }
                }
                in++;
        }
        *out = '\0';
        stringToParse.UnlockBuffer(newLength);

        return B_OK;
}


status_t
HashMapCatalog::SetString(const char *string, const char *translated,
        const char *context, const char *comment)
{
        BString stringCopy(string);
        status_t result = parseQuotedChars(stringCopy);
        if (result != B_OK)
                return result;

        BString translatedCopy(translated);
        if ((result = parseQuotedChars(translatedCopy)) != B_OK)
                return result;

        BString commentCopy(comment);
        if ((result = parseQuotedChars(commentCopy)) != B_OK)
                return result;

        CatKey key(stringCopy.String(), context, commentCopy.String());
        return fCatMap.Put(key, translatedCopy.String());
                // overwrite existing element
}


status_t
HashMapCatalog::SetString(int32 id, const char *translated)
{
        BString translatedCopy(translated);
        status_t result = parseQuotedChars(translatedCopy);
        if (result != B_OK)
                return result;
        CatKey key(id);
        return fCatMap.Put(key, translatedCopy.String());
                // overwrite existing element
}


status_t
HashMapCatalog::SetString(const CatKey& key, const char *translated)
{
        BString translatedCopy(translated);
        status_t result = parseQuotedChars(translatedCopy);
        if (result != B_OK)
                return result;
        return fCatMap.Put(key, translatedCopy.String());
                // overwrite existing element
}


/*
 * computes a checksum (we call it fingerprint) on all the catalog-keys. We do
 * not include the values, since we want catalogs for different languages of the
 * same app to have the same fingerprint, since we use it to separate different
 * catalog-versions. We use a simple sum because there is no well known
 * checksum algorithm that gives the same result if the string are sorted in the
 * wrong order, and this does happen, as an hash map is an unsorted container.
 */
uint32
HashMapCatalog::ComputeFingerprint() const
{
        uint32 checksum = 0;

        int32 hash;
        CatMap::Iterator iter = fCatMap.GetIterator();
        CatMap::Entry entry;
        while (iter.HasNext()) {
                entry = iter.Next();
                hash = B_HOST_TO_LENDIAN_INT32(entry.key.fHashVal);
                checksum += hash;
        }
        return checksum;
}


void
HashMapCatalog::UpdateFingerprint()
{
        fFingerprint = ComputeFingerprint();
}


}       // namespace BPrivate