// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

*******************************************************************************

*   Copyright (C) 1996-2015, International Business Machines

*   Corporation and others.  All Rights Reserved.

*******************************************************************************

*   file name:  ucol.cpp

*   encoding:   UTF-8

*   tab size:   8 (not used)

*   indentation:4

*

* Modification history

* Date        Name      Comments

* 1996-1999   various members of ICU team maintained C API for collation framework

* 02/16/2001  synwee    Added internal method getPrevSpecialCE

* 03/01/2001  synwee    Added maxexpansion functionality.

* 03/16/2001  weiv      Collation framework is rewritten in C and made UCA compliant

* 2012-2014   markus    Rewritten in C++ again.

*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_COLLATION

#include "unicode/coll.h"

#include "unicode/tblcoll.h"

#include "unicode/bytestream.h"

#include "unicode/coleitr.h"

#include "unicode/ucoleitr.h"

#include "unicode/ustring.h"

#include "cmemory.h"

#include "collation.h"

#include "cstring.h"

#include "putilimp.h"

#include "uassert.h"

#include "utracimp.h"

U_NAMESPACE_USE

U_CAPI UCollator* U_EXPORT2

ucol_openBinary(const uint8_t *bin, int32_t length,

                const UCollator *base,

                UErrorCode *status)

{

    if(U_FAILURE(*status)) { return NULL; }

    RuleBasedCollator *coll = new RuleBasedCollator(

            bin, length,

            RuleBasedCollator::rbcFromUCollator(base),

            *status);

    if(coll == NULL) {

        *status = U_MEMORY_ALLOCATION_ERROR;

        return NULL;

    }

    if(U_FAILURE(*status)) {

        delete coll;

        return NULL;

    }

    return coll->toUCollator();

}

U_CAPI int32_t U_EXPORT2

ucol_cloneBinary(const UCollator *coll,

                 uint8_t *buffer, int32_t capacity,

                 UErrorCode *status)

{

    if(U_FAILURE(*status)) {

        return 0;

    }

    const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll);

    if(rbc == NULL && coll != NULL) {

        *status = U_UNSUPPORTED_ERROR;

        return 0;

    }

    return rbc->cloneBinary(buffer, capacity, *status);

}

U_CAPI UCollator* U_EXPORT2

ucol_safeClone(const UCollator *coll, void * /*stackBuffer*/, int32_t * pBufferSize, UErrorCode *status)

{

    if (status == NULL || U_FAILURE(*status)){

        return NULL;

    }

    if (coll == NULL) {

       *status = U_ILLEGAL_ARGUMENT_ERROR;

        return NULL;

    }

    if (pBufferSize != NULL) {

        int32_t inputSize = *pBufferSize;

        *pBufferSize = 1;

        if (inputSize == 0) {

            return NULL;  // preflighting for deprecated functionality

        }

    }

    Collator *newColl = Collator::fromUCollator(coll)->clone();

    if (newColl == NULL) {

        *status = U_MEMORY_ALLOCATION_ERROR;

        return nullptr;

    } else {

        *status = U_SAFECLONE_ALLOCATED_WARNING;

    }

    return newColl->toUCollator();

}

U_CAPI void U_EXPORT2

ucol_close(UCollator *coll)

{

    UTRACE_ENTRY_OC(UTRACE_UCOL_CLOSE);

    UTRACE_DATA1(UTRACE_INFO, "coll = %p", coll);

    if(coll != NULL) {

        delete Collator::fromUCollator(coll);

    }

    UTRACE_EXIT();

}

U_CAPI int32_t U_EXPORT2

ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length,

                   const uint8_t *src2, int32_t src2Length,

                   uint8_t *dest, int32_t destCapacity) {

    /* check arguments */

    if( src1==NULL || src1Length<-1 || src1Length==0 || (src1Length>0 && src1[src1Length-1]!=0) ||

        src2==NULL || src2Length<-1 || src2Length==0 || (src2Length>0 && src2[src2Length-1]!=0) ||

        destCapacity<0 || (destCapacity>0 && dest==NULL)

    ) {

        /* error, attempt to write a zero byte and return 0 */

        if(dest!=NULL && destCapacity>0) {

            *dest=0;

        }

        return 0;

    }

    /* check lengths and capacity */

    if(src1Length<0) {

        src1Length=(int32_t)uprv_strlen((const char *)src1)+1;

    }

    if(src2Length<0) {

        src2Length=(int32_t)uprv_strlen((const char *)src2)+1;

    }

    int32_t destLength=src1Length+src2Length;

    if(destLength>destCapacity) {

        /* the merged sort key does not fit into the destination */

        return destLength;

    }

    /* merge the sort keys with the same number of levels */

    uint8_t *p=dest;

    for(;;) {

        /* copy level from src1 not including 00 or 01 */

        uint8_t b;

        while((b=*src1)>=2) {

            ++src1;

            *p++=b;

        }

        /* add a 02 merge separator */

        *p++=2;

        /* copy level from src2 not including 00 or 01 */

        while((b=*src2)>=2) {

            ++src2;

            *p++=b;

        }

        /* if both sort keys have another level, then add a 01 level separator and continue */

        if(*src1==1 && *src2==1) {

            ++src1;

            ++src2;

            *p++=1;

        } else {

            break;

        }

    }

    /*

     * here, at least one sort key is finished now, but the other one

     * might have some contents left from containing more levels;

     * that contents is just appended to the result

     */

    if(*src1!=0) {

        /* src1 is not finished, therefore *src2==0, and src1 is appended */

        src2=src1;

    }

    /* append src2, "the other, unfinished sort key" */

    while((*p++=*src2++)!=0) {}

    /* the actual length might be less than destLength if either sort key contained illegally embedded zero bytes */

    return (int32_t)(p-dest);

}

U_CAPI int32_t U_EXPORT2

ucol_getSortKey(const    UCollator    *coll,

        const    UChar        *source,

        int32_t        sourceLength,

        uint8_t        *result,

        int32_t        resultLength)

{

    UTRACE_ENTRY(UTRACE_UCOL_GET_SORTKEY);

    if (UTRACE_LEVEL(UTRACE_VERBOSE)) {

        UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source string = %vh ", coll, source,

            ((sourceLength==-1 && source!=NULL) ? u_strlen(source) : sourceLength));

    }

    int32_t keySize = Collator::fromUCollator(coll)->

            getSortKey(source, sourceLength, result, resultLength);

    UTRACE_DATA2(UTRACE_VERBOSE, "Sort Key = %vb", result, keySize);

    UTRACE_EXIT_VALUE(keySize);

    return keySize;

}

U_CAPI int32_t U_EXPORT2

ucol_nextSortKeyPart(const UCollator *coll,

                     UCharIterator *iter,

                     uint32_t state[2],

                     uint8_t *dest, int32_t count,

                     UErrorCode *status)

{

    /* error checking */

    if(status==NULL || U_FAILURE(*status)) {

        return 0;

    }

    UTRACE_ENTRY(UTRACE_UCOL_NEXTSORTKEYPART);

    UTRACE_DATA6(UTRACE_VERBOSE, "coll=%p, iter=%p, state=%d %d, dest=%p, count=%d",

                  coll, iter, state[0], state[1], dest, count);

    int32_t i = Collator::fromUCollator(coll)->

            internalNextSortKeyPart(iter, state, dest, count, *status);

    // Return number of meaningful sortkey bytes.

    UTRACE_DATA4(UTRACE_VERBOSE, "dest = %vb, state=%d %d",

                  dest,i, state[0], state[1]);

    UTRACE_EXIT_VALUE_STATUS(i, *status);

    return i;

}

/**

 * Produce a bound for a given sortkey and a number of levels.

 */

U_CAPI int32_t U_EXPORT2

ucol_getBound(const uint8_t       *source,

        int32_t             sourceLength,

        UColBoundMode       boundType,

        uint32_t            noOfLevels,

        uint8_t             *result,

        int32_t             resultLength,

        UErrorCode          *status)

{

    // consistency checks

    if(status == NULL || U_FAILURE(*status)) {

        return 0;

    }

    if(source == NULL) {

        *status = U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    int32_t sourceIndex = 0;

    // Scan the string until we skip enough of the key OR reach the end of the key

    do {

        sourceIndex++;

        if(source[sourceIndex] == Collation::LEVEL_SEPARATOR_BYTE) {

            noOfLevels--;

        }

    } while (noOfLevels > 0

        && (source[sourceIndex] != 0 || sourceIndex < sourceLength));

    if((source[sourceIndex] == 0 || sourceIndex == sourceLength)

        && noOfLevels > 0) {

            *status = U_SORT_KEY_TOO_SHORT_WARNING;

    }

    // READ ME: this code assumes that the values for boundType

    // enum will not changes. They are set so that the enum value

    // corresponds to the number of extra bytes each bound type

    // needs.

    if(result != NULL && resultLength >= sourceIndex+boundType) {

        uprv_memcpy(result, source, sourceIndex);

        switch(boundType) {

            // Lower bound just gets terminated. No extra bytes

        case UCOL_BOUND_LOWER: // = 0

            break;

            // Upper bound needs one extra byte

        case UCOL_BOUND_UPPER: // = 1

            result[sourceIndex++] = 2;

            break;

            // Upper long bound needs two extra bytes

        case UCOL_BOUND_UPPER_LONG: // = 2

            result[sourceIndex++] = 0xFF;

            result[sourceIndex++] = 0xFF;

            break;

        default:

            *status = U_ILLEGAL_ARGUMENT_ERROR;

            return 0;

        }

        result[sourceIndex++] = 0;

        return sourceIndex;

    } else {

        return sourceIndex+boundType+1;

    }

}

U_CAPI void U_EXPORT2

ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCode) {

    if(U_FAILURE(*pErrorCode)) { return; }

    Collator::fromUCollator(coll)->setMaxVariable(group, *pErrorCode);

}

U_CAPI UColReorderCode U_EXPORT2

ucol_getMaxVariable(const UCollator *coll) {

    return Collator::fromUCollator(coll)->getMaxVariable();

}

U_CAPI uint32_t  U_EXPORT2

ucol_setVariableTop(UCollator *coll, const UChar *varTop, int32_t len, UErrorCode *status) {

    if(U_FAILURE(*status) || coll == NULL) {

        return 0;

    }

    return Collator::fromUCollator(coll)->setVariableTop(varTop, len, *status);

}

U_CAPI uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status) {

    if(U_FAILURE(*status) || coll == NULL) {

        return 0;

    }

    return Collator::fromUCollator(coll)->getVariableTop(*status);

}

U_CAPI void  U_EXPORT2

ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status) {

    if(U_FAILURE(*status) || coll == NULL) {

        return;

    }

    Collator::fromUCollator(coll)->setVariableTop(varTop, *status);

}

U_CAPI void  U_EXPORT2

ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status) {

    if(U_FAILURE(*status) || coll == NULL) {

      return;

    }

    Collator::fromUCollator(coll)->setAttribute(attr, value, *status);

}

U_CAPI UColAttributeValue  U_EXPORT2

ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status) {

    if(U_FAILURE(*status) || coll == NULL) {

      return UCOL_DEFAULT;

    }

    return Collator::fromUCollator(coll)->getAttribute(attr, *status);

}

U_CAPI void U_EXPORT2

ucol_setStrength(    UCollator                *coll,

            UCollationStrength        strength)

{

    UErrorCode status = U_ZERO_ERROR;

    ucol_setAttribute(coll, UCOL_STRENGTH, strength, &status);

}

U_CAPI UCollationStrength U_EXPORT2

ucol_getStrength(const UCollator *coll)

{

    UErrorCode status = U_ZERO_ERROR;

    return ucol_getAttribute(coll, UCOL_STRENGTH, &status);

}

U_CAPI int32_t U_EXPORT2 

ucol_getReorderCodes(const UCollator *coll,

                    int32_t *dest,

                    int32_t destCapacity,

                    UErrorCode *status) {

    if (U_FAILURE(*status)) {

        return 0;

    }

    return Collator::fromUCollator(coll)->getReorderCodes(dest, destCapacity, *status);

}

U_CAPI void U_EXPORT2 

ucol_setReorderCodes(UCollator* coll,

                    const int32_t* reorderCodes,

                    int32_t reorderCodesLength,

                    UErrorCode *status) {

    if (U_FAILURE(*status)) {

        return;

    }

    Collator::fromUCollator(coll)->setReorderCodes(reorderCodes, reorderCodesLength, *status);

}

U_CAPI int32_t U_EXPORT2 

ucol_getEquivalentReorderCodes(int32_t reorderCode,

                    int32_t* dest,

                    int32_t destCapacity,

                    UErrorCode *pErrorCode) {

    return Collator::getEquivalentReorderCodes(reorderCode, dest, destCapacity, *pErrorCode);

}

U_CAPI void U_EXPORT2

ucol_getVersion(const UCollator* coll,

                UVersionInfo versionInfo)

{

    Collator::fromUCollator(coll)->getVersion(versionInfo);

}

U_CAPI UCollationResult U_EXPORT2

ucol_strcollIter( const UCollator    *coll,

                 UCharIterator *sIter,

                 UCharIterator *tIter,

                 UErrorCode         *status)

{

    if(!status || U_FAILURE(*status)) {

        return UCOL_EQUAL;

    }

    UTRACE_ENTRY(UTRACE_UCOL_STRCOLLITER);

    UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, sIter=%p, tIter=%p", coll, sIter, tIter);

    if(sIter == NULL || tIter == NULL || coll == NULL) {

        *status = U_ILLEGAL_ARGUMENT_ERROR;

        UTRACE_EXIT_VALUE_STATUS(UCOL_EQUAL, *status);

        return UCOL_EQUAL;

    }

    UCollationResult result = Collator::fromUCollator(coll)->compare(*sIter, *tIter, *status);

    UTRACE_EXIT_VALUE_STATUS(result, *status);

    return result;

}

/*                                                                      */

/* ucol_strcoll     Main public API string comparison function          */

/*                                                                      */

U_CAPI UCollationResult U_EXPORT2

ucol_strcoll( const UCollator    *coll,

              const UChar        *source,

              int32_t            sourceLength,

              const UChar        *target,

              int32_t            targetLength)

{

    UTRACE_ENTRY(UTRACE_UCOL_STRCOLL);

    if (UTRACE_LEVEL(UTRACE_VERBOSE)) {

        UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source=%p, target=%p", coll, source, target);

        UTRACE_DATA2(UTRACE_VERBOSE, "source string = %vh ", source, sourceLength);

        UTRACE_DATA2(UTRACE_VERBOSE, "target string = %vh ", target, targetLength);

    }

    UErrorCode status = U_ZERO_ERROR;

    UCollationResult returnVal = Collator::fromUCollator(coll)->

            compare(source, sourceLength, target, targetLength, status);

    UTRACE_EXIT_VALUE_STATUS(returnVal, status);

    return returnVal;

}

U_CAPI UCollationResult U_EXPORT2

ucol_strcollUTF8(

        const UCollator *coll,

        const char      *source,

        int32_t         sourceLength,

        const char      *target,

        int32_t         targetLength,

        UErrorCode      *status)

{

    UTRACE_ENTRY(UTRACE_UCOL_STRCOLLUTF8);

    if (UTRACE_LEVEL(UTRACE_VERBOSE)) {

        UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source=%p, target=%p", coll, source, target);

        UTRACE_DATA2(UTRACE_VERBOSE, "source string = %vb ", source, sourceLength);

        UTRACE_DATA2(UTRACE_VERBOSE, "target string = %vb ", target, targetLength);

    }

    if (U_FAILURE(*status)) {

        /* do nothing */

        UTRACE_EXIT_VALUE_STATUS(UCOL_EQUAL, *status);

        return UCOL_EQUAL;

    }

    UCollationResult returnVal = Collator::fromUCollator(coll)->internalCompareUTF8(

            source, sourceLength, target, targetLength, *status);

    UTRACE_EXIT_VALUE_STATUS(returnVal, *status);

    return returnVal;

}

/* convenience function for comparing strings */

U_CAPI UBool U_EXPORT2

ucol_greater(    const    UCollator        *coll,

        const    UChar            *source,

        int32_t            sourceLength,

        const    UChar            *target,

        int32_t            targetLength)

{

    return (ucol_strcoll(coll, source, sourceLength, target, targetLength)

        == UCOL_GREATER);

}

/* convenience function for comparing strings */

U_CAPI UBool U_EXPORT2

ucol_greaterOrEqual(    const    UCollator    *coll,

            const    UChar        *source,

            int32_t        sourceLength,

            const    UChar        *target,

            int32_t        targetLength)

{

    return (ucol_strcoll(coll, source, sourceLength, target, targetLength)

        != UCOL_LESS);

}

/* convenience function for comparing strings */

U_CAPI UBool U_EXPORT2

ucol_equal(        const    UCollator        *coll,

            const    UChar            *source,

            int32_t            sourceLength,

            const    UChar            *target,

            int32_t            targetLength)

{

    return (ucol_strcoll(coll, source, sourceLength, target, targetLength)

        == UCOL_EQUAL);

}

U_CAPI void U_EXPORT2

ucol_getUCAVersion(const UCollator* coll, UVersionInfo info) {

    const Collator *c = Collator::fromUCollator(coll);

    if(c != NULL) {

        UVersionInfo v;

        c->getVersion(v);

        // Note: This is tied to how the current implementation encodes the UCA version

        // in the overall getVersion().

        // Alternatively, we could load the root collator and get at lower-level data from there.

        // Either way, it will reflect the input collator's UCA version only

        // if it is a known implementation.

        // It would be cleaner to make this a virtual Collator method.

        info[0] = v[1] >> 3;

        info[1] = v[1] & 7;

        info[2] = v[2] >> 6;

        info[3] = 0;

    }

}

U_CAPI const UChar * U_EXPORT2

ucol_getRules(const UCollator *coll, int32_t *length) {

    const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll);

    // OK to crash if coll==NULL: We do not want to check "this" pointers.

    if(rbc != NULL || coll == NULL) {

        const UnicodeString &rules = rbc->getRules();

        U_ASSERT(rules.getBuffer()[rules.length()] == 0);

        *length = rules.length();

        return rules.getBuffer();

    }

    static const UChar _NUL = 0;

    *length = 0;

    return &_NUL;

}

U_CAPI int32_t U_EXPORT2

ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen) {

    UnicodeString rules;

    const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll);

    if(rbc != NULL || coll == NULL) {

        rbc->getRules(delta, rules);

    }

    if(buffer != NULL && bufferLen > 0) {

        UErrorCode errorCode = U_ZERO_ERROR;

        return rules.extract(buffer, bufferLen, errorCode);

    } else {

        return rules.length();

    }

}

U_CAPI const char * U_EXPORT2

ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status) {

    return ucol_getLocaleByType(coll, type, status);

}

U_CAPI const char * U_EXPORT2

ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status) {

    if(U_FAILURE(*status)) {

        return NULL;

    }

    UTRACE_ENTRY(UTRACE_UCOL_GETLOCALE);

    UTRACE_DATA1(UTRACE_INFO, "coll=%p", coll);

    const char *result;

    const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll);

    if(rbc == NULL && coll != NULL) {

        *status = U_UNSUPPORTED_ERROR;

        result = NULL;

    } else {

        result = rbc->internalGetLocaleID(type, *status);

    }

    UTRACE_DATA1(UTRACE_INFO, "result = %s", result);

    UTRACE_EXIT_STATUS(*status);

    return result;

}

U_CAPI USet * U_EXPORT2

ucol_getTailoredSet(const UCollator *coll, UErrorCode *status) {

    if(U_FAILURE(*status)) {

        return NULL;

    }

    UnicodeSet *set = Collator::fromUCollator(coll)->getTailoredSet(*status);

    if(U_FAILURE(*status)) {

        delete set;

        return NULL;

    }

    return set->toUSet();

}

U_CAPI UBool U_EXPORT2

ucol_equals(const UCollator *source, const UCollator *target) {

    return source == target ||

        (*Collator::fromUCollator(source)) == (*Collator::fromUCollator(target));

}

#endif /* #if !UCONFIG_NO_COLLATION */