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

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

// characterproperties.cpp

// created: 2018sep03 Markus W. Scherer

#include "unicode/utypes.h"

#include "unicode/localpointer.h"

#include "unicode/uchar.h"

#include "unicode/ucpmap.h"

#include "unicode/ucptrie.h"

#include "unicode/umutablecptrie.h"

#include "unicode/uniset.h"

#include "unicode/uscript.h"

#include "unicode/uset.h"

#include "cmemory.h"

#include "mutex.h"

#include "normalizer2impl.h"

#include "uassert.h"

#include "ubidi_props.h"

#include "ucase.h"

#include "ucln_cmn.h"

#include "umutex.h"

#include "uprops.h"

using icu::LocalPointer;

#if !UCONFIG_NO_NORMALIZATION

using icu::Normalizer2Factory;

using icu::Normalizer2Impl;

#endif

using icu::UInitOnce;

using icu::UnicodeSet;

namespace {

UBool U_CALLCONV characterproperties_cleanup();

constexpr int32_t NUM_INCLUSIONS = UPROPS_SRC_COUNT + UCHAR_INT_LIMIT - UCHAR_INT_START;

struct Inclusion {

    UnicodeSet  *fSet = nullptr;

    UInitOnce    fInitOnce = U_INITONCE_INITIALIZER;

};

Inclusion gInclusions[NUM_INCLUSIONS]; // cached getInclusions()

UnicodeSet *sets[UCHAR_BINARY_LIMIT] = {};

UCPMap *maps[UCHAR_INT_LIMIT - UCHAR_INT_START] = {};

icu::UMutex cpMutex;

//----------------------------------------------------------------

// Inclusions list

//----------------------------------------------------------------

// USetAdder implementation

// Does not use uset.h to reduce code dependencies

void U_CALLCONV

_set_add(USet *set, UChar32 c) {

    ((UnicodeSet *)set)->add(c);

}

void U_CALLCONV

_set_addRange(USet *set, UChar32 start, UChar32 end) {

    ((UnicodeSet *)set)->add(start, end);

}

void U_CALLCONV

_set_addString(USet *set, const UChar *str, int32_t length) {

    ((UnicodeSet *)set)->add(icu::UnicodeString((UBool)(length<0), str, length));

}

UBool U_CALLCONV characterproperties_cleanup() {

    for (Inclusion &in: gInclusions) {

        delete in.fSet;

        in.fSet = nullptr;

        in.fInitOnce.reset();

    }

    for (int32_t i = 0; i < UPRV_LENGTHOF(sets); ++i) {

        delete sets[i];

        sets[i] = nullptr;

    }

    for (int32_t i = 0; i < UPRV_LENGTHOF(maps); ++i) {

        ucptrie_close(reinterpret_cast<UCPTrie *>(maps[i]));

        maps[i] = nullptr;

    }

    return TRUE;

}

void U_CALLCONV initInclusion(UPropertySource src, UErrorCode &errorCode) {

    // This function is invoked only via umtx_initOnce().

    U_ASSERT(0 <= src && src < UPROPS_SRC_COUNT);

    if (src == UPROPS_SRC_NONE) {

        errorCode = U_INTERNAL_PROGRAM_ERROR;

        return;

    }

    U_ASSERT(gInclusions[src].fSet == nullptr);

    LocalPointer<UnicodeSet> incl(new UnicodeSet());

    if (incl.isNull()) {

        errorCode = U_MEMORY_ALLOCATION_ERROR;

        return;

    }

    USetAdder sa = {

        (USet *)incl.getAlias(),

        _set_add,

        _set_addRange,

        _set_addString,

        nullptr, // don't need remove()

        nullptr // don't need removeRange()

    };

    switch(src) {

    case UPROPS_SRC_CHAR:

        uchar_addPropertyStarts(&sa, &errorCode);

        break;

    case UPROPS_SRC_PROPSVEC:

        upropsvec_addPropertyStarts(&sa, &errorCode);

        break;

    case UPROPS_SRC_CHAR_AND_PROPSVEC:

        uchar_addPropertyStarts(&sa, &errorCode);

        upropsvec_addPropertyStarts(&sa, &errorCode);

        break;

#if !UCONFIG_NO_NORMALIZATION

    case UPROPS_SRC_CASE_AND_NORM: {

        const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode);

        if(U_SUCCESS(errorCode)) {

            impl->addPropertyStarts(&sa, errorCode);

        }

        ucase_addPropertyStarts(&sa, &errorCode);

        break;

    }

    case UPROPS_SRC_NFC: {

        const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode);

        if(U_SUCCESS(errorCode)) {

            impl->addPropertyStarts(&sa, errorCode);

        }

        break;

    }

    case UPROPS_SRC_NFKC: {

        const Normalizer2Impl *impl=Normalizer2Factory::getNFKCImpl(errorCode);

        if(U_SUCCESS(errorCode)) {

            impl->addPropertyStarts(&sa, errorCode);

        }

        break;

    }

    case UPROPS_SRC_NFKC_CF: {

        const Normalizer2Impl *impl=Normalizer2Factory::getNFKC_CFImpl(errorCode);

        if(U_SUCCESS(errorCode)) {

            impl->addPropertyStarts(&sa, errorCode);

        }

        break;

    }

    case UPROPS_SRC_NFC_CANON_ITER: {

        const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode);

        if(U_SUCCESS(errorCode)) {

            impl->addCanonIterPropertyStarts(&sa, errorCode);

        }

        break;

    }

#endif

    case UPROPS_SRC_CASE:

        ucase_addPropertyStarts(&sa, &errorCode);

        break;

    case UPROPS_SRC_BIDI:

        ubidi_addPropertyStarts(&sa, &errorCode);

        break;

    case UPROPS_SRC_INPC:

    case UPROPS_SRC_INSC:

    case UPROPS_SRC_VO:

        uprops_addPropertyStarts((UPropertySource)src, &sa, &errorCode);

        break;

    default:

        errorCode = U_INTERNAL_PROGRAM_ERROR;

        break;

    }

    if (U_FAILURE(errorCode)) {

        return;

    }

    if (incl->isBogus()) {

        errorCode = U_MEMORY_ALLOCATION_ERROR;

        return;

    }

    // Compact for caching.

    incl->compact();

    gInclusions[src].fSet = incl.orphan();

    ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup);

}

const UnicodeSet *getInclusionsForSource(UPropertySource src, UErrorCode &errorCode) {

    if (U_FAILURE(errorCode)) { return nullptr; }

    if (src < 0 || UPROPS_SRC_COUNT <= src) {

        errorCode = U_ILLEGAL_ARGUMENT_ERROR;

        return nullptr;

    }

    Inclusion &i = gInclusions[src];

    umtx_initOnce(i.fInitOnce, &initInclusion, src, errorCode);

    return i.fSet;

}

void U_CALLCONV initIntPropInclusion(UProperty prop, UErrorCode &errorCode) {

    // This function is invoked only via umtx_initOnce().

    U_ASSERT(UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT);

    int32_t inclIndex = UPROPS_SRC_COUNT + prop - UCHAR_INT_START;

    U_ASSERT(gInclusions[inclIndex].fSet == nullptr);

    UPropertySource src = uprops_getSource(prop);

    const UnicodeSet *incl = getInclusionsForSource(src, errorCode);

    if (U_FAILURE(errorCode)) {

        return;

    }

    LocalPointer<UnicodeSet> intPropIncl(new UnicodeSet(0, 0));

    if (intPropIncl.isNull()) {

        errorCode = U_MEMORY_ALLOCATION_ERROR;

        return;

    }

    int32_t numRanges = incl->getRangeCount();

    int32_t prevValue = 0;

    for (int32_t i = 0; i < numRanges; ++i) {

        UChar32 rangeEnd = incl->getRangeEnd(i);

        for (UChar32 c = incl->getRangeStart(i); c <= rangeEnd; ++c) {

            // TODO: Get a UCharacterProperty.IntProperty to avoid the property dispatch.

            int32_t value = u_getIntPropertyValue(c, prop);

            if (value != prevValue) {

                intPropIncl->add(c);

                prevValue = value;

            }

        }

    }

    if (intPropIncl->isBogus()) {

        errorCode = U_MEMORY_ALLOCATION_ERROR;

        return;

    }

    // Compact for caching.

    intPropIncl->compact();

    gInclusions[inclIndex].fSet = intPropIncl.orphan();

    ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup);

}

}  // namespace

U_NAMESPACE_BEGIN

const UnicodeSet *CharacterProperties::getInclusionsForProperty(

        UProperty prop, UErrorCode &errorCode) {

    if (U_FAILURE(errorCode)) { return nullptr; }

    if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) {

        int32_t inclIndex = UPROPS_SRC_COUNT + prop - UCHAR_INT_START;

        Inclusion &i = gInclusions[inclIndex];

        umtx_initOnce(i.fInitOnce, &initIntPropInclusion, prop, errorCode);

        return i.fSet;

    } else {

        UPropertySource src = uprops_getSource(prop);

        return getInclusionsForSource(src, errorCode);

    }

}

U_NAMESPACE_END

namespace {

UnicodeSet *makeSet(UProperty property, UErrorCode &errorCode) {

    if (U_FAILURE(errorCode)) { return nullptr; }

    LocalPointer<UnicodeSet> set(new UnicodeSet());

    if (set.isNull()) {

        errorCode = U_MEMORY_ALLOCATION_ERROR;

        return nullptr;

    }

    const UnicodeSet *inclusions =

        icu::CharacterProperties::getInclusionsForProperty(property, errorCode);

    if (U_FAILURE(errorCode)) { return nullptr; }

    int32_t numRanges = inclusions->getRangeCount();

    UChar32 startHasProperty = -1;

    for (int32_t i = 0; i < numRanges; ++i) {

        UChar32 rangeEnd = inclusions->getRangeEnd(i);

        for (UChar32 c = inclusions->getRangeStart(i); c <= rangeEnd; ++c) {

            // TODO: Get a UCharacterProperty.BinaryProperty to avoid the property dispatch.

            if (u_hasBinaryProperty(c, property)) {

                if (startHasProperty < 0) {

                    // Transition from false to true.

                    startHasProperty = c;

                }

            } else if (startHasProperty >= 0) {

                // Transition from true to false.

                set->add(startHasProperty, c - 1);

                startHasProperty = -1;

            }

        }

    }

    if (startHasProperty >= 0) {

        set->add(startHasProperty, 0x10FFFF);

    }

    set->freeze();

    return set.orphan();

}

UCPMap *makeMap(UProperty property, UErrorCode &errorCode) {

    if (U_FAILURE(errorCode)) { return nullptr; }

    uint32_t nullValue = property == UCHAR_SCRIPT ? USCRIPT_UNKNOWN : 0;

    icu::LocalUMutableCPTriePointer mutableTrie(

        umutablecptrie_open(nullValue, nullValue, &errorCode));

    const UnicodeSet *inclusions =

        icu::CharacterProperties::getInclusionsForProperty(property, errorCode);

    if (U_FAILURE(errorCode)) { return nullptr; }

    int32_t numRanges = inclusions->getRangeCount();

    UChar32 start = 0;

    uint32_t value = nullValue;

    for (int32_t i = 0; i < numRanges; ++i) {

        UChar32 rangeEnd = inclusions->getRangeEnd(i);

        for (UChar32 c = inclusions->getRangeStart(i); c <= rangeEnd; ++c) {

            // TODO: Get a UCharacterProperty.IntProperty to avoid the property dispatch.

            uint32_t nextValue = u_getIntPropertyValue(c, property);

            if (value != nextValue) {

                if (value != nullValue) {

                    umutablecptrie_setRange(mutableTrie.getAlias(), start, c - 1, value, &errorCode);

                }

                start = c;

                value = nextValue;

            }

        }

    }

    if (value != 0) {

        umutablecptrie_setRange(mutableTrie.getAlias(), start, 0x10FFFF, value, &errorCode);

    }

    UCPTrieType type;

    if (property == UCHAR_BIDI_CLASS || property == UCHAR_GENERAL_CATEGORY) {

        type = UCPTRIE_TYPE_FAST;

    } else {

        type = UCPTRIE_TYPE_SMALL;

    }

    UCPTrieValueWidth valueWidth;

    // TODO: UCharacterProperty.IntProperty

    int32_t max = u_getIntPropertyMaxValue(property);

    if (max <= 0xff) {

        valueWidth = UCPTRIE_VALUE_BITS_8;

    } else if (max <= 0xffff) {

        valueWidth = UCPTRIE_VALUE_BITS_16;

    } else {

        valueWidth = UCPTRIE_VALUE_BITS_32;

    }

    return reinterpret_cast<UCPMap *>(

        umutablecptrie_buildImmutable(mutableTrie.getAlias(), type, valueWidth, &errorCode));

}

}  // namespace

U_NAMESPACE_USE

U_CAPI const USet * U_EXPORT2

u_getBinaryPropertySet(UProperty property, UErrorCode *pErrorCode) {

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

    if (property < 0 || UCHAR_BINARY_LIMIT <= property) {

        *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;

        return nullptr;

    }

    Mutex m(&cpMutex);

    UnicodeSet *set = sets[property];

    if (set == nullptr) {

        sets[property] = set = makeSet(property, *pErrorCode);

    }

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

    return set->toUSet();

}

U_CAPI const UCPMap * U_EXPORT2

u_getIntPropertyMap(UProperty property, UErrorCode *pErrorCode) {

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

    if (property < UCHAR_INT_START || UCHAR_INT_LIMIT <= property) {

        *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;

        return nullptr;

    }

    Mutex m(&cpMutex);

    UCPMap *map = maps[property - UCHAR_INT_START];

    if (map == nullptr) {

        maps[property - UCHAR_INT_START] = map = makeMap(property, *pErrorCode);

    }

    return map;

}