/*
 * Copyright 2010-2011, Oliver Tappe, zooey@hirschkaefer.de.
 * Distributed under the terms of the MIT License.
 */


#include "ICUCollateData.h"

#include <assert.h>
#include <string.h>
#include <strings.h>
#include <wchar.h>

#include <unicode/unistr.h>

#include <AutoDeleter.h>


U_NAMESPACE_USE


namespace BPrivate {
namespace Libroot {


ICUCollateData::ICUCollateData(pthread_key_t tlsKey)
        :
        inherited(tlsKey),
        fCollator(NULL)
{
}


ICUCollateData::~ICUCollateData()
{
        delete fCollator;
}


status_t
ICUCollateData::SetTo(const Locale& locale, const char* posixLocaleName)
{
        status_t result = inherited::SetTo(locale, posixLocaleName);

        if (result == B_OK) {
                UErrorCode icuStatus = U_ZERO_ERROR;
                delete fCollator;
                fCollator = Collator::createInstance(fLocale, icuStatus);
                if (!U_SUCCESS(icuStatus))
                        return B_NO_MEMORY;
        }

        return result;
}


status_t
ICUCollateData::SetToPosix()
{
        status_t result = inherited::SetToPosix();

        if (result == B_OK) {
                delete fCollator;
                fCollator = NULL;
        }

        return result;
}


status_t
ICUCollateData::Strcoll(const char* a, const char* b, int& result)
{
        if (fCollator == NULL || strcmp(fPosixLocaleName, "POSIX") == 0) {
                // handle POSIX here as the collator ICU uses for that (english) is
                // incompatible in too many ways
                result = strcmp(a, b);
                for (const char* aIter = a; *aIter != 0; ++aIter) {
                        if (*aIter < 0)
                                return B_BAD_VALUE;
                }
                for (const char* bIter = b; *bIter != 0; ++bIter) {
                        if (*bIter < 0)
                                return B_BAD_VALUE;
                }
                return B_OK;
        }

        status_t status = B_OK;
        UErrorCode icuStatus = U_ZERO_ERROR;

        if (strcasecmp(fGivenCharset, "utf-8") == 0) {
                UCharIterator aIter, bIter;
                uiter_setUTF8(&aIter, a, -1);
                uiter_setUTF8(&bIter, b, -1);

                result = fCollator->compare(aIter, bIter, icuStatus);
        } else {
                UnicodeString unicodeA;
                UnicodeString unicodeB;

                if (_ToUnicodeString(a, unicodeA) != B_OK
                        || _ToUnicodeString(b, unicodeB) != B_OK) {
                        status = B_BAD_VALUE;
                }

                result = fCollator->compare(unicodeA, unicodeB, icuStatus);
        }

        if (!U_SUCCESS(icuStatus))
                status = B_BAD_VALUE;

        return status;
}


status_t
ICUCollateData::Strxfrm(char* out, const char* in,
        size_t outSize, size_t& requiredSize)
{
        if (in == NULL) {
                requiredSize = 0;
                return B_OK;
        }

        if (fCollator == NULL || strcmp(fPosixLocaleName, "POSIX") == 0) {
                // handle POSIX here as the collator ICU uses for that (english) is
                // incompatible in too many ways
                requiredSize = strlcpy(out, in, outSize);
                for (const char* inIter = in; *inIter != 0; ++inIter) {
                        if (*inIter < 0)
                                return B_BAD_VALUE;
                }
                return B_OK;
        }

        UnicodeString unicodeIn;
        if (_ToUnicodeString(in, unicodeIn) != B_OK)
                return B_BAD_VALUE;

        requiredSize = fCollator->getSortKey(unicodeIn, (uint8_t*)out, outSize);

        // Do not include terminating NULL byte in the required-size.
        if (requiredSize > 0) {
                if (outSize >= requiredSize)
                        assert(out[requiredSize - 1] == '\0');
                requiredSize--;
        }

        return B_OK;
}


status_t
ICUCollateData::Wcscoll(const wchar_t* a, const wchar_t* b, int& result)
{
        if (fCollator == NULL || strcmp(fPosixLocaleName, "POSIX") == 0) {
                // handle POSIX here as the collator ICU uses for that (english) is
                // incompatible in too many ways
                result = wcscmp(a, b);
                for (const wchar_t* aIter = a; *aIter != 0; ++aIter) {
                        if (*aIter > 127)
                                return B_BAD_VALUE;
                }
                for (const wchar_t* bIter = b; *bIter != 0; ++bIter) {
                        if (*bIter > 127)
                                return B_BAD_VALUE;
                }
                return B_OK;
        }

        UnicodeString unicodeA = UnicodeString::fromUTF32((UChar32*)a, -1);
        UnicodeString unicodeB = UnicodeString::fromUTF32((UChar32*)b, -1);

        UErrorCode icuStatus = U_ZERO_ERROR;
        result = fCollator->compare(unicodeA, unicodeB, icuStatus);

        if (!U_SUCCESS(icuStatus))
                return B_BAD_VALUE;

        return B_OK;
}


status_t
ICUCollateData::Wcsxfrm(wchar_t* out, const wchar_t* in, size_t outSize,
        size_t& requiredSize)
{
        if (in == NULL) {
                requiredSize = 0;
                return B_OK;
        }

        if (fCollator == NULL || strcmp(fPosixLocaleName, "POSIX") == 0) {
                // handle POSIX here as the collator ICU uses for that (english) is
                // incompatible in too many ways
                requiredSize = wcslcpy(out, in, outSize);
                for (const wchar_t* inIter = in; *inIter != 0; ++inIter) {
                        if (*inIter > 127)
                                return B_BAD_VALUE;
                }
                return B_OK;
        }

        UnicodeString unicodeIn = UnicodeString::fromUTF32((UChar32*)in, -1);
        requiredSize = fCollator->getSortKey(unicodeIn, NULL, 0);

        if (outSize == 0)
                return B_OK;

        uint8_t* buffer = (uint8_t*)out;
        fCollator->getSortKey(unicodeIn, buffer, outSize);

        // convert 1-byte characters to 4-byte wide characters:
        for (size_t i = 0; i < outSize; ++i)
                out[outSize - 1 - i] = buffer[outSize - 1 - i];

        // Do not include terminating NULL character in the required-size.
        if (requiredSize > 0) {
                if (outSize >= requiredSize)
                        assert(out[requiredSize - 1] == 0);
                requiredSize--;
        }

        return B_OK;
}


status_t
ICUCollateData::_ToUnicodeString(const char* in, UnicodeString& out)
{
        out.remove();

        if (in == NULL)
                return B_OK;

        size_t inLen = strlen(in);
        if (inLen == 0)
                return B_OK;

        UConverter* converter;
        status_t result = _GetConverter(converter);
        if (result != B_OK)
                return result;

        UErrorCode icuStatus = U_ZERO_ERROR;
        int32_t outLen = ucnv_toUChars(converter, NULL, 0, in, inLen, &icuStatus);
        if (icuStatus != U_BUFFER_OVERFLOW_ERROR)
                return B_BAD_VALUE;
        if (outLen < 0)
                return B_ERROR;
        if (outLen == 0)
                return B_OK;

        UChar* outBuf = out.getBuffer(outLen + 1);
        icuStatus = U_ZERO_ERROR;
        outLen
                = ucnv_toUChars(converter, outBuf, outLen + 1, in, inLen, &icuStatus);
        if (!U_SUCCESS(icuStatus)) {
                out.releaseBuffer(0);
                return B_BAD_VALUE;
        }

        out.releaseBuffer(outLen);

        return B_OK;
}


}       // namespace Libroot
}       // namespace BPrivate