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

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

/*

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

* Copyright (c) 2002-2016, International Business Machines

* Corporation and others.  All Rights Reserved.

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

*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/ucurr.h"

#include "unicode/locid.h"

#include "unicode/ures.h"

#include "unicode/ustring.h"

#include "unicode/parsepos.h"

#include "unicode/uniset.h"

#include "unicode/usetiter.h"

#include "unicode/utf16.h"

#include "ustr_imp.h"

#include "charstr.h"

#include "cmemory.h"

#include "cstring.h"

#include "static_unicode_sets.h"

#include "uassert.h"

#include "umutex.h"

#include "ucln_cmn.h"

#include "uenumimp.h"

#include "uhash.h"

#include "hash.h"

#include "uinvchar.h"

#include "uresimp.h"

#include "ulist.h"

#include "uresimp.h"

#include "ureslocs.h"

#include "ulocimp.h"

using namespace icu;

//#define UCURR_DEBUG_EQUIV 1

#ifdef UCURR_DEBUG_EQUIV

#include "stdio.h"

#endif

//#define UCURR_DEBUG 1

#ifdef UCURR_DEBUG

#include "stdio.h"

#endif

typedef struct IsoCodeEntry {

    const char16_t *isoCode; /* const because it's a reference to a resource bundle string. */

    UDate from;

    UDate to;

} IsoCodeEntry;

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

// Constants

// Default currency meta data of last resort.  We try to use the

// defaults encoded in the meta data resource bundle.  If there is a

// configuration/build error and these are not available, we use these

// hard-coded defaults (which should be identical).

static const int32_t LAST_RESORT_DATA[] = { 2, 0, 2, 0 };

// POW10[i] = 10^i, i=0..MAX_POW10

static const int32_t POW10[] = { 1, 10, 100, 1000, 10000, 100000,

                                 1000000, 10000000, 100000000, 1000000000 };

static const int32_t MAX_POW10 = UPRV_LENGTHOF(POW10) - 1;

#define ISO_CURRENCY_CODE_LENGTH 3

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

// Resource tags

//

static const char CURRENCY_DATA[] = "supplementalData";

// Tag for meta-data, in root.

static const char CURRENCY_META[] = "CurrencyMeta";

// Tag for map from countries to currencies, in root.

static const char CURRENCY_MAP[] = "CurrencyMap";

// Tag for default meta-data, in CURRENCY_META

static const char DEFAULT_META[] = "DEFAULT";

// Variant delimiter

static const char VAR_DELIM = '_';

// Tag for localized display names (symbols) of currencies

static const char CURRENCIES[] = "Currencies";

static const char CURRENCIES_NARROW[] = "Currencies%narrow";

static const char CURRENCIES_FORMAL[] = "Currencies%formal";

static const char CURRENCIES_VARIANT[] = "Currencies%variant";

static const char CURRENCYPLURALS[] = "CurrencyPlurals";

// ISO codes mapping table

static const UHashtable* gIsoCodes = nullptr;

static icu::UInitOnce gIsoCodesInitOnce {};

// Currency symbol equivalances

static const icu::Hashtable* gCurrSymbolsEquiv = nullptr;

static icu::UInitOnce gCurrSymbolsEquivInitOnce {};

U_NAMESPACE_BEGIN

// EquivIterator iterates over all strings that are equivalent to a given

// string, s. Note that EquivIterator will never yield s itself.

class EquivIterator : public icu::UMemory {

public:

    // Constructor. hash stores the equivalence relationships; s is the string

    // for which we find equivalent strings.

    inline EquivIterator(const icu::Hashtable& hash, const icu::UnicodeString& s)

        : _hash(hash) { 

        _start = _current = &s;

    }

    inline ~EquivIterator() { }

    // next returns the next equivalent string or nullptr if there are no more.

    // If s has no equivalent strings, next returns nullptr on the first call.

    const icu::UnicodeString *next();

private:

    const icu::Hashtable& _hash;

    const icu::UnicodeString* _start;

    const icu::UnicodeString* _current;

};

const icu::UnicodeString *

EquivIterator::next() {

    const icu::UnicodeString* _next = (const icu::UnicodeString*) _hash.get(*_current);

    if (_next == nullptr) {

        U_ASSERT(_current == _start);

        return nullptr;

    }

    if (*_next == *_start) {

        return nullptr;

    }

    _current = _next;

    return _next;

}

U_NAMESPACE_END

// makeEquivalent makes lhs and rhs equivalent by updating the equivalence

// relations in hash accordingly.

static void makeEquivalent(

    const icu::UnicodeString &lhs,

    const icu::UnicodeString &rhs,

    icu::Hashtable* hash, UErrorCode &status) {

    if (U_FAILURE(status)) {

        return;

    }

    if (lhs == rhs) {

        // already equivalent

        return;

    }

    icu::EquivIterator leftIter(*hash, lhs);

    icu::EquivIterator rightIter(*hash, rhs);

    const icu::UnicodeString *firstLeft = leftIter.next();

    const icu::UnicodeString *firstRight = rightIter.next();

    const icu::UnicodeString *nextLeft = firstLeft;

    const icu::UnicodeString *nextRight = firstRight;

    while (nextLeft != nullptr && nextRight != nullptr) {

        if (*nextLeft == rhs || *nextRight == lhs) {

            // Already equivalent

            return;

        }

        nextLeft = leftIter.next();

        nextRight = rightIter.next();

    }

    // Not equivalent. Must join.

    icu::UnicodeString *newFirstLeft;

    icu::UnicodeString *newFirstRight;

    if (firstRight == nullptr && firstLeft == nullptr) {

        // Neither lhs or rhs belong to an equivalence circle, so we form

        // a new equivalnce circle of just lhs and rhs.

        newFirstLeft = new icu::UnicodeString(rhs);

        newFirstRight = new icu::UnicodeString(lhs);

    } else if (firstRight == nullptr) {

        // lhs belongs to an equivalence circle, but rhs does not, so we link

        // rhs into lhs' circle.

        newFirstLeft = new icu::UnicodeString(rhs);

        newFirstRight = new icu::UnicodeString(*firstLeft);

    } else if (firstLeft == nullptr) {

        // rhs belongs to an equivlance circle, but lhs does not, so we link

        // lhs into rhs' circle.

        newFirstLeft = new icu::UnicodeString(*firstRight);

        newFirstRight = new icu::UnicodeString(lhs);

    } else {

        // Both lhs and rhs belong to different equivalnce circles. We link

        // them together to form one single, larger equivalnce circle.

        newFirstLeft = new icu::UnicodeString(*firstRight);

        newFirstRight = new icu::UnicodeString(*firstLeft);

    }

    if (newFirstLeft == nullptr || newFirstRight == nullptr) {

        delete newFirstLeft;

        delete newFirstRight;

        status = U_MEMORY_ALLOCATION_ERROR;

        return;

    }

    hash->put(lhs, (void *) newFirstLeft, status);

    hash->put(rhs, (void *) newFirstRight, status);

}

// countEquivalent counts how many strings are equivalent to s.

// hash stores all the equivalnce relations.

// countEquivalent does not include s itself in the count.

static int32_t countEquivalent(const icu::Hashtable &hash, const icu::UnicodeString &s) {

    int32_t result = 0;

    icu::EquivIterator iter(hash, s);

    while (iter.next() != nullptr) {

        ++result;

    }

#ifdef UCURR_DEBUG_EQUIV

 {

   char tmp[200];

   s.extract(0,s.length(),tmp, "UTF-8");

   printf("CountEquivalent('%s') = %d\n", tmp, result);

 }

#endif

    return result;

}

static const icu::Hashtable* getCurrSymbolsEquiv();

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

// Code

/**

 * Cleanup callback func

 */

static UBool U_CALLCONV 

isoCodes_cleanup()

{

    if (gIsoCodes != nullptr) {

        uhash_close(const_cast<UHashtable *>(gIsoCodes));

        gIsoCodes = nullptr;

    }

    gIsoCodesInitOnce.reset();

    return true;

}

/**

 * Cleanup callback func

 */

static UBool U_CALLCONV 

currSymbolsEquiv_cleanup()

{

    delete const_cast<icu::Hashtable *>(gCurrSymbolsEquiv);

    gCurrSymbolsEquiv = nullptr;

    gCurrSymbolsEquivInitOnce.reset();

    return true;

}

/**

 * Deleter for IsoCodeEntry

 */

static void U_CALLCONV

deleteIsoCodeEntry(void *obj) {

    IsoCodeEntry *entry = (IsoCodeEntry*)obj;

    uprv_free(entry);

}

/**

 * Deleter for gCurrSymbolsEquiv.

 */

static void U_CALLCONV

deleteUnicode(void *obj) {

    icu::UnicodeString *entry = (icu::UnicodeString*)obj;

    delete entry;

}

/**

 * Unfortunately, we have to convert the char16_t* currency code to char*

 * to use it as a resource key.

 */

static inline char*

myUCharsToChars(char* resultOfLen4, const char16_t* currency) {

    u_UCharsToChars(currency, resultOfLen4, ISO_CURRENCY_CODE_LENGTH);

    resultOfLen4[ISO_CURRENCY_CODE_LENGTH] = 0;

    return resultOfLen4;

}

/**

 * Internal function to look up currency data.  Result is an array of

 * four integers.  The first is the fraction digits.  The second is the

 * rounding increment, or 0 if none.  The rounding increment is in

 * units of 10^(-fraction_digits).  The third and fourth are the same

 * except that they are those used in cash transactions ( cashDigits

 * and cashRounding ).

 */

static const int32_t*

_findMetaData(const char16_t* currency, UErrorCode& ec) {

    if (currency == 0 || *currency == 0) {

        if (U_SUCCESS(ec)) {

            ec = U_ILLEGAL_ARGUMENT_ERROR;

        }

        return LAST_RESORT_DATA;

    }

    // Get CurrencyMeta resource out of root locale file.  [This may

    // move out of the root locale file later; if it does, update this

    // code.]

    UResourceBundle* currencyData = ures_openDirect(U_ICUDATA_CURR, CURRENCY_DATA, &ec);

    UResourceBundle* currencyMeta = ures_getByKey(currencyData, CURRENCY_META, currencyData, &ec);

    if (U_FAILURE(ec)) {

        ures_close(currencyMeta);

        // Config/build error; return hard-coded defaults

        return LAST_RESORT_DATA;

    }

    // Look up our currency, or if that's not available, then DEFAULT

    char buf[ISO_CURRENCY_CODE_LENGTH+1];

    UErrorCode ec2 = U_ZERO_ERROR; // local error code: soft failure

    UResourceBundle* rb = ures_getByKey(currencyMeta, myUCharsToChars(buf, currency), nullptr, &ec2);

      if (U_FAILURE(ec2)) {

        ures_close(rb);

        rb = ures_getByKey(currencyMeta,DEFAULT_META, nullptr, &ec);

        if (U_FAILURE(ec)) {

            ures_close(currencyMeta);

            ures_close(rb);

            // Config/build error; return hard-coded defaults

            return LAST_RESORT_DATA;

        }

    }

    int32_t len;

    const int32_t *data = ures_getIntVector(rb, &len, &ec);

    if (U_FAILURE(ec) || len != 4) {

        // Config/build error; return hard-coded defaults

        if (U_SUCCESS(ec)) {

            ec = U_INVALID_FORMAT_ERROR;

        }

        ures_close(currencyMeta);

        ures_close(rb);

        return LAST_RESORT_DATA;

    }

    ures_close(currencyMeta);

    ures_close(rb);

    return data;

}

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

static void

idForLocale(const char* locale, char* countryAndVariant, int capacity, UErrorCode* ec)

{

    ulocimp_getRegionForSupplementalData(locale, false, countryAndVariant, capacity, ec);

}

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

//

// Registration

//

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

// don't use ICUService since we don't need fallback

U_CDECL_BEGIN

static UBool U_CALLCONV currency_cleanup();

U_CDECL_END

#if !UCONFIG_NO_SERVICE

struct CReg;

static UMutex gCRegLock;

static CReg* gCRegHead = 0;

struct CReg : public icu::UMemory {

    CReg *next;

    char16_t iso[ISO_CURRENCY_CODE_LENGTH+1];

    char  id[ULOC_FULLNAME_CAPACITY];

    CReg(const char16_t* _iso, const char* _id)

        : next(0)

    {

        int32_t len = (int32_t)uprv_strlen(_id);

        if (len > (int32_t)(sizeof(id)-1)) {

            len = (sizeof(id)-1);

        }

        uprv_strncpy(id, _id, len);

        id[len] = 0;

        u_memcpy(iso, _iso, ISO_CURRENCY_CODE_LENGTH);

        iso[ISO_CURRENCY_CODE_LENGTH] = 0;

    }

    static UCurrRegistryKey reg(const char16_t* _iso, const char* _id, UErrorCode* status)

    {

        if (status && U_SUCCESS(*status) && _iso && _id) {

            CReg* n = new CReg(_iso, _id);

            if (n) {

                umtx_lock(&gCRegLock);

                if (!gCRegHead) {

                    /* register for the first time */

                    ucln_common_registerCleanup(UCLN_COMMON_CURRENCY, currency_cleanup);

                }

                n->next = gCRegHead;

                gCRegHead = n;

                umtx_unlock(&gCRegLock);

                return n;

            }

            *status = U_MEMORY_ALLOCATION_ERROR;

        }

        return 0;

    }

    static UBool unreg(UCurrRegistryKey key) {

        UBool found = false;

        umtx_lock(&gCRegLock);

        CReg** p = &gCRegHead;

        while (*p) {

            if (*p == key) {

                *p = ((CReg*)key)->next;

                delete (CReg*)key;

                found = true;

                break;

            }

            p = &((*p)->next);

        }

        umtx_unlock(&gCRegLock);

        return found;

    }

    static const char16_t* get(const char* id) {

        const char16_t* result = nullptr;

        umtx_lock(&gCRegLock);

        CReg* p = gCRegHead;

        /* register cleanup of the mutex */

        ucln_common_registerCleanup(UCLN_COMMON_CURRENCY, currency_cleanup);

        while (p) {

            if (uprv_strcmp(id, p->id) == 0) {

                result = p->iso;

                break;

            }

            p = p->next;

        }

        umtx_unlock(&gCRegLock);

        return result;

    }

    /* This doesn't need to be thread safe. It's for u_cleanup only. */

    static void cleanup() {

        while (gCRegHead) {

            CReg* n = gCRegHead;

            gCRegHead = gCRegHead->next;

            delete n;

        }

    }

};

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

U_CAPI UCurrRegistryKey U_EXPORT2

ucurr_register(const char16_t* isoCode, const char* locale, UErrorCode *status)

{

    if (status && U_SUCCESS(*status)) {

        char id[ULOC_FULLNAME_CAPACITY];

        idForLocale(locale, id, sizeof(id), status);

        return CReg::reg(isoCode, id, status);

    }

    return nullptr;

}

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

U_CAPI UBool U_EXPORT2

ucurr_unregister(UCurrRegistryKey key, UErrorCode* status)

{

    if (status && U_SUCCESS(*status)) {

        return CReg::unreg(key);

    }

    return false;

}

#endif /* UCONFIG_NO_SERVICE */

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

/**

 * Release all static memory held by currency.

 */

/*The declaration here is needed so currency_cleanup()

 * can call this function.

 */

static UBool U_CALLCONV

currency_cache_cleanup();

U_CDECL_BEGIN

static UBool U_CALLCONV currency_cleanup() {

#if !UCONFIG_NO_SERVICE

    CReg::cleanup();

#endif

    /*

     * There might be some cached currency data or isoCodes data.

     */

    currency_cache_cleanup();

    isoCodes_cleanup();

    currSymbolsEquiv_cleanup();

    return true;

}

U_CDECL_END

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

U_CAPI int32_t U_EXPORT2

ucurr_forLocale(const char* locale,

                char16_t* buff,

                int32_t buffCapacity,

                UErrorCode* ec) {

    if (U_FAILURE(*ec)) { return 0; }

    if (buffCapacity < 0 || (buff == nullptr && buffCapacity > 0)) {

        *ec = U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    char currency[4];  // ISO currency codes are alpha3 codes.

    UErrorCode localStatus = U_ZERO_ERROR;

    int32_t resLen = uloc_getKeywordValue(locale, "currency",

                                          currency, UPRV_LENGTHOF(currency), &localStatus);

    if (U_SUCCESS(localStatus) && resLen == 3 && uprv_isInvariantString(currency, resLen)) {

        if (resLen < buffCapacity) {

            T_CString_toUpperCase(currency);

            u_charsToUChars(currency, buff, resLen);

        }

        return u_terminateUChars(buff, buffCapacity, resLen, ec);

    }

    // get country or country_variant in `id'

    char id[ULOC_FULLNAME_CAPACITY];

    idForLocale(locale, id, UPRV_LENGTHOF(id), ec);

    if (U_FAILURE(*ec)) {

        return 0;

    }

#if !UCONFIG_NO_SERVICE

    const char16_t* result = CReg::get(id);

    if (result) {

        if(buffCapacity > u_strlen(result)) {

            u_strcpy(buff, result);

        }

        resLen = u_strlen(result);

        return u_terminateUChars(buff, buffCapacity, resLen, ec);

    }

#endif

    // Remove variants, which is only needed for registration.

    char *idDelim = uprv_strchr(id, VAR_DELIM);

    if (idDelim) {

        idDelim[0] = 0;

    }

    const char16_t* s = nullptr;  // Currency code from data file.

    if (id[0] == 0) {

        // No point looking in the data for an empty string.

        // This is what we would get.

        localStatus = U_MISSING_RESOURCE_ERROR;

    } else {

        // Look up the CurrencyMap element in the root bundle.

        localStatus = U_ZERO_ERROR;

        UResourceBundle *rb = ures_openDirect(U_ICUDATA_CURR, CURRENCY_DATA, &localStatus);

        UResourceBundle *cm = ures_getByKey(rb, CURRENCY_MAP, rb, &localStatus);

        UResourceBundle *countryArray = ures_getByKey(rb, id, cm, &localStatus);

        // https://unicode-org.atlassian.net/browse/ICU-21997

        // Prefer to use currencies that are legal tender.

        if (U_SUCCESS(localStatus)) {

            int32_t arrayLength = ures_getSize(countryArray);

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

                LocalUResourceBundlePointer currencyReq(

                    ures_getByIndex(countryArray, i, nullptr, &localStatus));

                // The currency is legal tender if it is *not* marked with tender{"false"}.

                UErrorCode tenderStatus = localStatus;

                const char16_t *tender =

                    ures_getStringByKey(currencyReq.getAlias(), "tender", nullptr, &tenderStatus);

                bool isTender = U_FAILURE(tenderStatus) || u_strcmp(tender, u"false") != 0;

                if (!isTender && s != nullptr) {

                    // We already have a non-tender currency. Ignore all following non-tender ones.

                    continue;

                }

                // Fetch the currency code.

                s = ures_getStringByKey(currencyReq.getAlias(), "id", &resLen, &localStatus);

                if (isTender) {

                    break;

                }

            }

            if (U_SUCCESS(localStatus) && s == nullptr) {

                localStatus = U_MISSING_RESOURCE_ERROR;

            }

        }

        ures_close(countryArray);

    }

    if ((U_FAILURE(localStatus)) && strchr(id, '_') != 0) {

        // We don't know about it.  Check to see if we support the variant.

        uloc_getParent(locale, id, UPRV_LENGTHOF(id), ec);

        *ec = U_USING_FALLBACK_WARNING;

        // TODO: Loop over the shortened id rather than recursing and

        // looking again for a currency keyword.

        return ucurr_forLocale(id, buff, buffCapacity, ec);

    }

    if (*ec == U_ZERO_ERROR || localStatus != U_ZERO_ERROR) {

        // There is nothing to fallback to. Report the failure/warning if possible.

        *ec = localStatus;

    }

    if (U_SUCCESS(*ec)) {

        if(buffCapacity > resLen) {

            u_strcpy(buff, s);

        }

    }

    return u_terminateUChars(buff, buffCapacity, resLen, ec);

}

// end registration

/**

 * Modify the given locale name by removing the rightmost _-delimited

 * element.  If there is none, empty the string ("" == root).

 * NOTE: The string "root" is not recognized; do not use it.

 * @return true if the fallback happened; false if locale is already

 * root ("").

 */

static UBool fallback(char *loc) {

    if (!*loc) {

        return false;

    }

    UErrorCode status = U_ZERO_ERROR;

    if (uprv_strcmp(loc, "en_GB") == 0) {

        // HACK: See #13368.  We need "en_GB" to fall back to "en_001" instead of "en"

        // in order to consume the correct data strings.  This hack will be removed

        // when proper data sink loading is implemented here.

        // NOTE: "001" adds 1 char over "GB".  However, both call sites allocate

        // arrays with length ULOC_FULLNAME_CAPACITY (plenty of room for en_001).

        uprv_strcpy(loc + 3, "001");

    } else {

        uloc_getParent(loc, loc, (int32_t)uprv_strlen(loc), &status);

    }

 /*

    char *i = uprv_strrchr(loc, '_');

    if (i == nullptr) {

        i = loc;

    }

    *i = 0;

 */

    return true;

}

U_CAPI const char16_t* U_EXPORT2

ucurr_getName(const char16_t* currency,

              const char* locale,

              UCurrNameStyle nameStyle,

              UBool* isChoiceFormat, // fillin

              int32_t* len, // fillin

              UErrorCode* ec) {

    // Look up the Currencies resource for the given locale.  The

    // Currencies locale data looks like this:

    //|en {

    //|  Currencies {

    //|    USD { "US$", "US Dollar" }

    //|    CHF { "Sw F", "Swiss Franc" }

    //|    INR { "=0#Rs|1#Re|1<Rs", "=0#Rupees|1#Rupee|1<Rupees" }

    //|    //...

    //|  }

    //|}

    if (U_FAILURE(*ec)) {

        return 0;

    }

    int32_t choice = (int32_t) nameStyle;

    if (choice < 0 || choice > 4) {

        *ec = U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    // In the future, resource bundles may implement multi-level

    // fallback.  That is, if a currency is not found in the en_US

    // Currencies data, then the en Currencies data will be searched.

    // Currently, if a Currencies datum exists in en_US and en, the

    // en_US entry hides that in en.

    // We want multi-level fallback for this resource, so we implement

    // it manually.

    // Use a separate UErrorCode here that does not propagate out of

    // this function.

    UErrorCode ec2 = U_ZERO_ERROR;

    char loc[ULOC_FULLNAME_CAPACITY];

    uloc_getName(locale, loc, sizeof(loc), &ec2);

    if (U_FAILURE(ec2) || ec2 == U_STRING_NOT_TERMINATED_WARNING) {

        *ec = U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    char buf[ISO_CURRENCY_CODE_LENGTH+1];

    myUCharsToChars(buf, currency);

    /* Normalize the keyword value to uppercase */

    T_CString_toUpperCase(buf);

    const char16_t* s = nullptr;

    ec2 = U_ZERO_ERROR;

    LocalUResourceBundlePointer rb(ures_open(U_ICUDATA_CURR, loc, &ec2));

    if (nameStyle == UCURR_NARROW_SYMBOL_NAME || nameStyle == UCURR_FORMAL_SYMBOL_NAME || nameStyle == UCURR_VARIANT_SYMBOL_NAME) {

        CharString key;

        switch (nameStyle) {

        case UCURR_NARROW_SYMBOL_NAME:

            key.append(CURRENCIES_NARROW, ec2);

            break;

        case UCURR_FORMAL_SYMBOL_NAME:

            key.append(CURRENCIES_FORMAL, ec2);

            break;

        case UCURR_VARIANT_SYMBOL_NAME:

            key.append(CURRENCIES_VARIANT, ec2);

            break;

        default:

            *ec = U_UNSUPPORTED_ERROR;

            return 0;

        }

        key.append("/", ec2);

        key.append(buf, ec2);

        s = ures_getStringByKeyWithFallback(rb.getAlias(), key.data(), len, &ec2);

        if (ec2 == U_MISSING_RESOURCE_ERROR) {

            *ec = U_USING_FALLBACK_WARNING;

            ec2 = U_ZERO_ERROR;

            choice = UCURR_SYMBOL_NAME;

        }

    }

    if (s == nullptr) {

        ures_getByKey(rb.getAlias(), CURRENCIES, rb.getAlias(), &ec2);

        ures_getByKeyWithFallback(rb.getAlias(), buf, rb.getAlias(), &ec2);

        s = ures_getStringByIndex(rb.getAlias(), choice, len, &ec2);

    }

    // If we've succeeded we're done.  Otherwise, try to fallback.

    // If that fails (because we are already at root) then exit.

    if (U_SUCCESS(ec2)) {

        if (ec2 == U_USING_DEFAULT_WARNING

            || (ec2 == U_USING_FALLBACK_WARNING && *ec != U_USING_DEFAULT_WARNING)) {

            *ec = ec2;

        }

    }

    // We no longer support choice format data in names.  Data should not contain

    // choice patterns.

    if (isChoiceFormat != nullptr) {

        *isChoiceFormat = false;

    }

    if (U_SUCCESS(ec2)) {

        U_ASSERT(s != nullptr);

        return s;

    }

    // If we fail to find a match, use the ISO 4217 code

    *len = u_strlen(currency); // Should == ISO_CURRENCY_CODE_LENGTH, but maybe not...?

    *ec = U_USING_DEFAULT_WARNING;

    return currency;

}

U_CAPI const char16_t* U_EXPORT2

ucurr_getPluralName(const char16_t* currency,

                    const char* locale,

                    UBool* isChoiceFormat,

                    const char* pluralCount,

                    int32_t* len, // fillin

                    UErrorCode* ec) {

    // Look up the Currencies resource for the given locale.  The

    // Currencies locale data looks like this:

    //|en {

    //|  CurrencyPlurals {

    //|    USD{

    //|      one{"US dollar"}

    //|      other{"US dollars"}

    //|    }

    //|  }

    //|}

    if (U_FAILURE(*ec)) {

        return 0;

    }

    // Use a separate UErrorCode here that does not propagate out of

    // this function.

    UErrorCode ec2 = U_ZERO_ERROR;

    char loc[ULOC_FULLNAME_CAPACITY];

    uloc_getName(locale, loc, sizeof(loc), &ec2);

    if (U_FAILURE(ec2) || ec2 == U_STRING_NOT_TERMINATED_WARNING) {

        *ec = U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    char buf[ISO_CURRENCY_CODE_LENGTH+1];

    myUCharsToChars(buf, currency);

    const char16_t* s = nullptr;

    ec2 = U_ZERO_ERROR;

    UResourceBundle* rb = ures_open(U_ICUDATA_CURR, loc, &ec2);

    rb = ures_getByKey(rb, CURRENCYPLURALS, rb, &ec2);

    // Fetch resource with multi-level resource inheritance fallback

    rb = ures_getByKeyWithFallback(rb, buf, rb, &ec2);

    s = ures_getStringByKeyWithFallback(rb, pluralCount, len, &ec2);

    if (U_FAILURE(ec2)) {

        //  fall back to "other"

        ec2 = U_ZERO_ERROR;

        s = ures_getStringByKeyWithFallback(rb, "other", len, &ec2);     

        if (U_FAILURE(ec2)) {

            ures_close(rb);

            // fall back to long name in Currencies

            return ucurr_getName(currency, locale, UCURR_LONG_NAME, 

                                 isChoiceFormat, len, ec);

        }

    }

    ures_close(rb);

    // If we've succeeded we're done.  Otherwise, try to fallback.

    // If that fails (because we are already at root) then exit.

    if (U_SUCCESS(ec2)) {

        if (ec2 == U_USING_DEFAULT_WARNING

            || (ec2 == U_USING_FALLBACK_WARNING && *ec != U_USING_DEFAULT_WARNING)) {

            *ec = ec2;

        }

        U_ASSERT(s != nullptr);

        return s;

    }

    // If we fail to find a match, use the ISO 4217 code

    *len = u_strlen(currency); // Should == ISO_CURRENCY_CODE_LENGTH, but maybe not...?

    *ec = U_USING_DEFAULT_WARNING;

    return currency;

}

//========================================================================

// Following are structure and function for parsing currency names

#define NEED_TO_BE_DELETED 0x1

// TODO: a better way to define this?

#define MAX_CURRENCY_NAME_LEN 100

typedef struct {

    const char* IsoCode;  // key

    char16_t* currencyName;  // value

    int32_t currencyNameLen;  // value length

    int32_t flag;  // flags

} CurrencyNameStruct;

#ifndef MIN

#define MIN(a,b) (((a)<(b)) ? (a) : (b))

#endif

#ifndef MAX

#define MAX(a,b) (((a)<(b)) ? (b) : (a))

#endif

// Comparison function used in quick sort.

static int U_CALLCONV currencyNameComparator(const void* a, const void* b) {

    const CurrencyNameStruct* currName_1 = (const CurrencyNameStruct*)a;

    const CurrencyNameStruct* currName_2 = (const CurrencyNameStruct*)b;

    for (int32_t i = 0; 

         i < MIN(currName_1->currencyNameLen, currName_2->currencyNameLen);

         ++i) {

        if (currName_1->currencyName[i] < currName_2->currencyName[i]) {

            return -1;

        }

        if (currName_1->currencyName[i] > currName_2->currencyName[i]) {

            return 1;

        }

    }

    if (currName_1->currencyNameLen < currName_2->currencyNameLen) {

        return -1;

    } else if (currName_1->currencyNameLen > currName_2->currencyNameLen) {

        return 1;

    }

    return 0;

}

// Give a locale, return the maximum number of currency names associated with

// this locale.

// It gets currency names from resource bundles using fallback.

// It is the maximum number because in the fallback chain, some of the 

// currency names are duplicated.

// For example, given locale as "en_US", the currency names get from resource

// bundle in "en_US" and "en" are duplicated. The fallback mechanism will count

// all currency names in "en_US" and "en".

static void

getCurrencyNameCount(const char* loc, int32_t* total_currency_name_count, int32_t* total_currency_symbol_count) {

    U_NAMESPACE_USE

    *total_currency_name_count = 0;

    *total_currency_symbol_count = 0;

    const char16_t* s = nullptr;

    char locale[ULOC_FULLNAME_CAPACITY] = "";

    uprv_strcpy(locale, loc);

    const icu::Hashtable *currencySymbolsEquiv = getCurrSymbolsEquiv();

    for (;;) {

        UErrorCode ec2 = U_ZERO_ERROR;

        // TODO: ures_openDirect?

        UResourceBundle* rb = ures_open(U_ICUDATA_CURR, locale, &ec2);

        UResourceBundle* curr = ures_getByKey(rb, CURRENCIES, nullptr, &ec2);

        int32_t n = ures_getSize(curr);

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

            UResourceBundle* names = ures_getByIndex(curr, i, nullptr, &ec2);

            int32_t len;

            s = ures_getStringByIndex(names, UCURR_SYMBOL_NAME, &len, &ec2);

            ++(*total_currency_symbol_count);  // currency symbol

            if (currencySymbolsEquiv != nullptr) {

                *total_currency_symbol_count += countEquivalent(*currencySymbolsEquiv, UnicodeString(true, s, len));

            }

            ++(*total_currency_symbol_count); // iso code

            ++(*total_currency_name_count); // long name

            ures_close(names);

        }

        // currency plurals

        UErrorCode ec3 = U_ZERO_ERROR;

        UResourceBundle* curr_p = ures_getByKey(rb, CURRENCYPLURALS, nullptr, &ec3);

        n = ures_getSize(curr_p);

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

            UResourceBundle* names = ures_getByIndex(curr_p, i, nullptr, &ec3);

            *total_currency_name_count += ures_getSize(names);

            ures_close(names);

        }

        ures_close(curr_p);

        ures_close(curr);

        ures_close(rb);

        if (!fallback(locale)) {

            break;

        }

    }

}

static char16_t*

toUpperCase(const char16_t* source, int32_t len, const char* locale) {

    char16_t* dest = nullptr;

    UErrorCode ec = U_ZERO_ERROR;