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

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

/*

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

* Copyright (C) 2010-2016, International Business Machines Corporation and

* others. All Rights Reserved.

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

*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/locdspnm.h"

#include "unicode/simpleformatter.h"

#include "unicode/ucasemap.h"

#include "unicode/ures.h"

#include "unicode/udisplaycontext.h"

#include "unicode/brkiter.h"

#include "unicode/ucurr.h"

#include "cmemory.h"

#include "cstring.h"

#include "mutex.h"

#include "ulocimp.h"

#include "umutex.h"

#include "ureslocs.h"

#include "uresimp.h"

#include <stdarg.h>

/**

 * Concatenate a number of null-terminated strings to buffer, leaving a

 * null-terminated string.  The last argument should be the null pointer.

 * Return the length of the string in the buffer, not counting the trailing

 * null.  Return -1 if there is an error (buffer is null, or buflen < 1).

 */

static int32_t ncat(char *buffer, uint32_t buflen, ...) {

  va_list args;

  char *str;

  char *p = buffer;

  const char* e = buffer + buflen - 1;

  if (buffer == NULL || buflen < 1) {

    return -1;

  }

  va_start(args, buflen);

  while ((str = va_arg(args, char *)) != 0) {

    char c;

    while (p != e && (c = *str++) != 0) {

      *p++ = c;

    }

  }

  *p = 0;

  va_end(args);

  return static_cast<int32_t>(p - buffer);

}

U_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////

// Access resource data for locale components.

// Wrap code in uloc.c for now.

class ICUDataTable {

    const char* path;

    Locale locale;

public:

    ICUDataTable(const char* path, const Locale& locale);

    ~ICUDataTable();

    const Locale& getLocale();

    UnicodeString& get(const char* tableKey, const char* itemKey,

                        UnicodeString& result) const;

    UnicodeString& get(const char* tableKey, const char* subTableKey, const char* itemKey,

                        UnicodeString& result) const;

    UnicodeString& getNoFallback(const char* tableKey, const char* itemKey,

                                UnicodeString &result) const;

    UnicodeString& getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,

                                UnicodeString &result) const;

};

inline UnicodeString &

ICUDataTable::get(const char* tableKey, const char* itemKey, UnicodeString& result) const {

    return get(tableKey, NULL, itemKey, result);

}

inline UnicodeString &

ICUDataTable::getNoFallback(const char* tableKey, const char* itemKey, UnicodeString& result) const {

    return getNoFallback(tableKey, NULL, itemKey, result);

}

ICUDataTable::ICUDataTable(const char* path, const Locale& locale)

    : path(NULL), locale(Locale::getRoot())

{

  if (path) {

    int32_t len = static_cast<int32_t>(uprv_strlen(path));

    this->path = (const char*) uprv_malloc(len + 1);

    if (this->path) {

      uprv_strcpy((char *)this->path, path);

      this->locale = locale;

    }

  }

}

ICUDataTable::~ICUDataTable() {

  if (path) {

    uprv_free((void*) path);

    path = NULL;

  }

}

const Locale&

ICUDataTable::getLocale() {

  return locale;

}

UnicodeString &

ICUDataTable::get(const char* tableKey, const char* subTableKey, const char* itemKey,

                  UnicodeString &result) const {

  UErrorCode status = U_ZERO_ERROR;

  int32_t len = 0;

  const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),

                                                   tableKey, subTableKey, itemKey,

                                                   &len, &status);

  if (U_SUCCESS(status) && len > 0) {

    return result.setTo(s, len);

  }

  return result.setTo(UnicodeString(itemKey, -1, US_INV));

}

UnicodeString &

ICUDataTable::getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,

                            UnicodeString& result) const {

  UErrorCode status = U_ZERO_ERROR;

  int32_t len = 0;

  const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),

                                                   tableKey, subTableKey, itemKey,

                                                   &len, &status);

  if (U_SUCCESS(status)) {

    return result.setTo(s, len);

  }

  result.setToBogus();

  return result;

}

////////////////////////////////////////////////////////////////////////////////////////////////////

LocaleDisplayNames::~LocaleDisplayNames() {}

////////////////////////////////////////////////////////////////////////////////////////////////////

#if 0  // currently unused

class DefaultLocaleDisplayNames : public LocaleDisplayNames {

  UDialectHandling dialectHandling;

public:

  // constructor

  DefaultLocaleDisplayNames(UDialectHandling dialectHandling);

  virtual ~DefaultLocaleDisplayNames();

  virtual const Locale& getLocale() const;

  virtual UDialectHandling getDialectHandling() const;

  virtual UnicodeString& localeDisplayName(const Locale& locale,

                                           UnicodeString& result) const;

  virtual UnicodeString& localeDisplayName(const char* localeId,

                                           UnicodeString& result) const;

  virtual UnicodeString& languageDisplayName(const char* lang,

                                             UnicodeString& result) const;

  virtual UnicodeString& scriptDisplayName(const char* script,

                                           UnicodeString& result) const;

  virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,

                                           UnicodeString& result) const;

  virtual UnicodeString& regionDisplayName(const char* region,

                                           UnicodeString& result) const;

  virtual UnicodeString& variantDisplayName(const char* variant,

                                            UnicodeString& result) const;

  virtual UnicodeString& keyDisplayName(const char* key,

                                        UnicodeString& result) const;

  virtual UnicodeString& keyValueDisplayName(const char* key,

                                             const char* value,

                                             UnicodeString& result) const;

};

DefaultLocaleDisplayNames::DefaultLocaleDisplayNames(UDialectHandling dialectHandling)

    : dialectHandling(dialectHandling) {

}

DefaultLocaleDisplayNames::~DefaultLocaleDisplayNames() {

}

const Locale&

DefaultLocaleDisplayNames::getLocale() const {

  return Locale::getRoot();

}

UDialectHandling

DefaultLocaleDisplayNames::getDialectHandling() const {

  return dialectHandling;

}

UnicodeString&

DefaultLocaleDisplayNames::localeDisplayName(const Locale& locale,

                                             UnicodeString& result) const {

  return result = UnicodeString(locale.getName(), -1, US_INV);

}

UnicodeString&

DefaultLocaleDisplayNames::localeDisplayName(const char* localeId,

                                             UnicodeString& result) const {

  return result = UnicodeString(localeId, -1, US_INV);

}

UnicodeString&

DefaultLocaleDisplayNames::languageDisplayName(const char* lang,

                                               UnicodeString& result) const {

  return result = UnicodeString(lang, -1, US_INV);

}

UnicodeString&

DefaultLocaleDisplayNames::scriptDisplayName(const char* script,

                                             UnicodeString& result) const {

  return result = UnicodeString(script, -1, US_INV);

}

UnicodeString&

DefaultLocaleDisplayNames::scriptDisplayName(UScriptCode scriptCode,

                                             UnicodeString& result) const {

  const char* name = uscript_getName(scriptCode);

  if (name) {

    return result = UnicodeString(name, -1, US_INV);

  }

  return result.remove();

}

UnicodeString&

DefaultLocaleDisplayNames::regionDisplayName(const char* region,

                                             UnicodeString& result) const {

  return result = UnicodeString(region, -1, US_INV);

}

UnicodeString&

DefaultLocaleDisplayNames::variantDisplayName(const char* variant,

                                              UnicodeString& result) const {

  return result = UnicodeString(variant, -1, US_INV);

}

UnicodeString&

DefaultLocaleDisplayNames::keyDisplayName(const char* key,

                                          UnicodeString& result) const {

  return result = UnicodeString(key, -1, US_INV);

}

UnicodeString&

DefaultLocaleDisplayNames::keyValueDisplayName(const char* /* key */,

                                               const char* value,

                                               UnicodeString& result) const {

  return result = UnicodeString(value, -1, US_INV);

}

#endif  // currently unused class DefaultLocaleDisplayNames

////////////////////////////////////////////////////////////////////////////////////////////////////

class LocaleDisplayNamesImpl : public LocaleDisplayNames {

    Locale locale;

    UDialectHandling dialectHandling;

    ICUDataTable langData;

    ICUDataTable regionData;

    SimpleFormatter separatorFormat;

    SimpleFormatter format;

    SimpleFormatter keyTypeFormat;

    UDisplayContext capitalizationContext;

#if !UCONFIG_NO_BREAK_ITERATION

    BreakIterator* capitalizationBrkIter;

#else

    UObject* capitalizationBrkIter;

#endif

    UnicodeString formatOpenParen;

    UnicodeString formatReplaceOpenParen;

    UnicodeString formatCloseParen;

    UnicodeString formatReplaceCloseParen;

    UDisplayContext nameLength;

    UDisplayContext substitute;

    // Constants for capitalization context usage types.

    enum CapContextUsage {

        kCapContextUsageLanguage,

        kCapContextUsageScript,

        kCapContextUsageTerritory,

        kCapContextUsageVariant,

        kCapContextUsageKey,

        kCapContextUsageKeyValue,

        kCapContextUsageCount

    };

    // Capitalization transforms. For each usage type, indicates whether to titlecase for

    // the context specified in capitalizationContext (which we know at construction time)

     UBool fCapitalization[kCapContextUsageCount];

public:

    // constructor

    LocaleDisplayNamesImpl(const Locale& locale, UDialectHandling dialectHandling);

    LocaleDisplayNamesImpl(const Locale& locale, UDisplayContext *contexts, int32_t length);

    virtual ~LocaleDisplayNamesImpl();

    virtual const Locale& getLocale() const;

    virtual UDialectHandling getDialectHandling() const;

    virtual UDisplayContext getContext(UDisplayContextType type) const;

    virtual UnicodeString& localeDisplayName(const Locale& locale,

                                                UnicodeString& result) const;

    virtual UnicodeString& localeDisplayName(const char* localeId,

                                                UnicodeString& result) const;

    virtual UnicodeString& languageDisplayName(const char* lang,

                                               UnicodeString& result) const;

    virtual UnicodeString& scriptDisplayName(const char* script,

                                                UnicodeString& result) const;

    virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,

                                                UnicodeString& result) const;

    virtual UnicodeString& regionDisplayName(const char* region,

                                                UnicodeString& result) const;

    virtual UnicodeString& variantDisplayName(const char* variant,

                                                UnicodeString& result) const;

    virtual UnicodeString& keyDisplayName(const char* key,

                                                UnicodeString& result) const;

    virtual UnicodeString& keyValueDisplayName(const char* key,

                                                const char* value,

                                                UnicodeString& result) const;

private:

    UnicodeString& localeIdName(const char* localeId,

                                UnicodeString& result, bool substitute) const;

    UnicodeString& appendWithSep(UnicodeString& buffer, const UnicodeString& src) const;

    UnicodeString& adjustForUsageAndContext(CapContextUsage usage, UnicodeString& result) const;

    UnicodeString& scriptDisplayName(const char* script, UnicodeString& result, UBool skipAdjust) const;

    UnicodeString& regionDisplayName(const char* region, UnicodeString& result, UBool skipAdjust) const;

    UnicodeString& variantDisplayName(const char* variant, UnicodeString& result, UBool skipAdjust) const;

    UnicodeString& keyDisplayName(const char* key, UnicodeString& result, UBool skipAdjust) const;

    UnicodeString& keyValueDisplayName(const char* key, const char* value,

                                        UnicodeString& result, UBool skipAdjust) const;

    void initialize(void);

    struct CapitalizationContextSink;

};

LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,

                                               UDialectHandling dialectHandling)

    : dialectHandling(dialectHandling)

    , langData(U_ICUDATA_LANG, locale)

    , regionData(U_ICUDATA_REGION, locale)

    , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)

    , capitalizationBrkIter(NULL)

    , nameLength(UDISPCTX_LENGTH_FULL)

    , substitute(UDISPCTX_SUBSTITUTE)

{

    initialize();

}

LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,

                                               UDisplayContext *contexts, int32_t length)

    : dialectHandling(ULDN_STANDARD_NAMES)

    , langData(U_ICUDATA_LANG, locale)

    , regionData(U_ICUDATA_REGION, locale)

    , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)

    , capitalizationBrkIter(NULL)

    , nameLength(UDISPCTX_LENGTH_FULL)

    , substitute(UDISPCTX_SUBSTITUTE)

{

    while (length-- > 0) {

        UDisplayContext value = *contexts++;

        UDisplayContextType selector = (UDisplayContextType)((uint32_t)value >> 8);

        switch (selector) {

            case UDISPCTX_TYPE_DIALECT_HANDLING:

                dialectHandling = (UDialectHandling)value;

                break;

            case UDISPCTX_TYPE_CAPITALIZATION:

                capitalizationContext = value;

                break;

            case UDISPCTX_TYPE_DISPLAY_LENGTH:

                nameLength = value;

                break;

            case UDISPCTX_TYPE_SUBSTITUTE_HANDLING:

                substitute = value;

                break;

            default:

                break;

        }

    }

    initialize();

}

struct LocaleDisplayNamesImpl::CapitalizationContextSink : public ResourceSink {

    UBool hasCapitalizationUsage;

    LocaleDisplayNamesImpl& parent;

    CapitalizationContextSink(LocaleDisplayNamesImpl& _parent)

      : hasCapitalizationUsage(FALSE), parent(_parent) {}

    virtual ~CapitalizationContextSink();

    virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,

            UErrorCode &errorCode) {

        ResourceTable contexts = value.getTable(errorCode);

        if (U_FAILURE(errorCode)) { return; }

        for (int i = 0; contexts.getKeyAndValue(i, key, value); ++i) {

            CapContextUsage usageEnum;

            if (uprv_strcmp(key, "key") == 0) {

                usageEnum = kCapContextUsageKey;

            } else if (uprv_strcmp(key, "keyValue") == 0) {

                usageEnum = kCapContextUsageKeyValue;

            } else if (uprv_strcmp(key, "languages") == 0) {

                usageEnum = kCapContextUsageLanguage;

            } else if (uprv_strcmp(key, "script") == 0) {

                usageEnum = kCapContextUsageScript;

            } else if (uprv_strcmp(key, "territory") == 0) {

                usageEnum = kCapContextUsageTerritory;

            } else if (uprv_strcmp(key, "variant") == 0) {

                usageEnum = kCapContextUsageVariant;

            } else {

                continue;

            }

            int32_t len = 0;

            const int32_t* intVector = value.getIntVector(len, errorCode);

            if (U_FAILURE(errorCode)) { return; }

            if (len < 2) { continue; }

            int32_t titlecaseInt = (parent.capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU) ? intVector[0] : intVector[1];

            if (titlecaseInt == 0) { continue; }

            parent.fCapitalization[usageEnum] = TRUE;

            hasCapitalizationUsage = TRUE;

        }

    }

};

// Virtual destructors must be defined out of line.

LocaleDisplayNamesImpl::CapitalizationContextSink::~CapitalizationContextSink() {}

void

LocaleDisplayNamesImpl::initialize(void) {

    LocaleDisplayNamesImpl *nonConstThis = (LocaleDisplayNamesImpl *)this;

    nonConstThis->locale = langData.getLocale() == Locale::getRoot()

        ? regionData.getLocale()

        : langData.getLocale();

    UnicodeString sep;

    langData.getNoFallback("localeDisplayPattern", "separator", sep);

    if (sep.isBogus()) {

        sep = UnicodeString("{0}, {1}", -1, US_INV);

    }

    UErrorCode status = U_ZERO_ERROR;

    separatorFormat.applyPatternMinMaxArguments(sep, 2, 2, status);

    UnicodeString pattern;

    langData.getNoFallback("localeDisplayPattern", "pattern", pattern);

    if (pattern.isBogus()) {

        pattern = UnicodeString("{0} ({1})", -1, US_INV);

    }

    format.applyPatternMinMaxArguments(pattern, 2, 2, status);

    if (pattern.indexOf((UChar)0xFF08) >= 0) {

        formatOpenParen.setTo((UChar)0xFF08);         // fullwidth (

        formatReplaceOpenParen.setTo((UChar)0xFF3B);  // fullwidth [

        formatCloseParen.setTo((UChar)0xFF09);        // fullwidth )

        formatReplaceCloseParen.setTo((UChar)0xFF3D); // fullwidth ]

    } else {

        formatOpenParen.setTo((UChar)0x0028);         // (

        formatReplaceOpenParen.setTo((UChar)0x005B);  // [

        formatCloseParen.setTo((UChar)0x0029);        // )

        formatReplaceCloseParen.setTo((UChar)0x005D); // ]

    }

    UnicodeString ktPattern;

    langData.get("localeDisplayPattern", "keyTypePattern", ktPattern);

    if (ktPattern.isBogus()) {

        ktPattern = UnicodeString("{0}={1}", -1, US_INV);

    }

    keyTypeFormat.applyPatternMinMaxArguments(ktPattern, 2, 2, status);

    uprv_memset(fCapitalization, 0, sizeof(fCapitalization));

#if !UCONFIG_NO_BREAK_ITERATION

    // Only get the context data if we need it! This is a const object so we know now...

    // Also check whether we will need a break iterator (depends on the data)

    UBool needBrkIter = FALSE;

    if (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU || capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_STANDALONE) {

        LocalUResourceBundlePointer resource(ures_open(NULL, locale.getName(), &status));

        if (U_FAILURE(status)) { return; }

        CapitalizationContextSink sink(*this);

        ures_getAllItemsWithFallback(resource.getAlias(), "contextTransforms", sink, status);

        if (status == U_MISSING_RESOURCE_ERROR) {

            // Silently ignore.  Not every locale has contextTransforms.

            status = U_ZERO_ERROR;

        } else if (U_FAILURE(status)) {

            return;

        }

        needBrkIter = sink.hasCapitalizationUsage;

    }

    // Get a sentence break iterator if we will need it

    if (needBrkIter || capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE) {

        status = U_ZERO_ERROR;

        capitalizationBrkIter = BreakIterator::createSentenceInstance(locale, status);

        if (U_FAILURE(status)) {

            delete capitalizationBrkIter;

            capitalizationBrkIter = NULL;

        }

    }

#endif

}

LocaleDisplayNamesImpl::~LocaleDisplayNamesImpl() {

#if !UCONFIG_NO_BREAK_ITERATION

    delete capitalizationBrkIter;

#endif

}

const Locale&

LocaleDisplayNamesImpl::getLocale() const {

    return locale;

}

UDialectHandling

LocaleDisplayNamesImpl::getDialectHandling() const {

    return dialectHandling;

}

UDisplayContext

LocaleDisplayNamesImpl::getContext(UDisplayContextType type) const {

    switch (type) {

        case UDISPCTX_TYPE_DIALECT_HANDLING:

            return (UDisplayContext)dialectHandling;

        case UDISPCTX_TYPE_CAPITALIZATION:

            return capitalizationContext;

        case UDISPCTX_TYPE_DISPLAY_LENGTH:

            return nameLength;

        case UDISPCTX_TYPE_SUBSTITUTE_HANDLING:

            return substitute;

        default:

            break;

    }

    return (UDisplayContext)0;

}

UnicodeString&

LocaleDisplayNamesImpl::adjustForUsageAndContext(CapContextUsage usage,

                                                UnicodeString& result) const {

#if !UCONFIG_NO_BREAK_ITERATION

    // check to see whether we need to titlecase result

    if ( result.length() > 0 && u_islower(result.char32At(0)) && capitalizationBrkIter!= NULL &&

          ( capitalizationContext==UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE || fCapitalization[usage] ) ) {

        // note fCapitalization[usage] won't be set unless capitalizationContext is UI_LIST_OR_MENU or STANDALONE

        static UMutex capitalizationBrkIterLock;

        Mutex lock(&capitalizationBrkIterLock);

        result.toTitle(capitalizationBrkIter, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);

    }

#endif

    return result;

}

UnicodeString&

LocaleDisplayNamesImpl::localeDisplayName(const Locale& loc,

                                          UnicodeString& result) const {

  if (loc.isBogus()) {

    result.setToBogus();

    return result;

  }

  UnicodeString resultName;

  const char* lang = loc.getLanguage();

  if (uprv_strlen(lang) == 0) {

    lang = "root";

  }

  const char* script = loc.getScript();

  const char* country = loc.getCountry();

  const char* variant = loc.getVariant();

  UBool hasScript = uprv_strlen(script) > 0;

  UBool hasCountry = uprv_strlen(country) > 0;

  UBool hasVariant = uprv_strlen(variant) > 0;

  if (dialectHandling == ULDN_DIALECT_NAMES) {

    char buffer[ULOC_FULLNAME_CAPACITY];

    do { // loop construct is so we can break early out of search

      if (hasScript && hasCountry) {

        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, "_", country, (char *)0);

        localeIdName(buffer, resultName, false);

        if (!resultName.isBogus()) {

          hasScript = FALSE;

          hasCountry = FALSE;

          break;

        }

      }

      if (hasScript) {

        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, (char *)0);

        localeIdName(buffer, resultName, false);

        if (!resultName.isBogus()) {

          hasScript = FALSE;

          break;

        }

      }

      if (hasCountry) {

        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", country, (char*)0);

        localeIdName(buffer, resultName, false);

        if (!resultName.isBogus()) {

          hasCountry = FALSE;

          break;

        }

      }

    } while (FALSE);

  }

  if (resultName.isBogus() || resultName.isEmpty()) {

    localeIdName(lang, resultName, substitute == UDISPCTX_SUBSTITUTE);

    if (resultName.isBogus()) {

      result.setToBogus();

      return result;

    }

  }

  UnicodeString resultRemainder;

  UnicodeString temp;

  UErrorCode status = U_ZERO_ERROR;

  if (hasScript) {

    UnicodeString script_str = scriptDisplayName(script, temp, TRUE);

    if (script_str.isBogus()) {

      result.setToBogus();

      return result;

    }

    resultRemainder.append(script_str);

  }

  if (hasCountry) {

    UnicodeString region_str = regionDisplayName(country, temp, TRUE);

    if (region_str.isBogus()) {

      result.setToBogus();

      return result;

    }

    appendWithSep(resultRemainder, region_str);

  }

  if (hasVariant) {

    UnicodeString variant_str = variantDisplayName(variant, temp, TRUE);

    if (variant_str.isBogus()) {

      result.setToBogus();

      return result;

    }

    appendWithSep(resultRemainder, variant_str);

  }

  resultRemainder.findAndReplace(formatOpenParen, formatReplaceOpenParen);

  resultRemainder.findAndReplace(formatCloseParen, formatReplaceCloseParen);

  LocalPointer<StringEnumeration> e(loc.createKeywords(status));

  if (e.isValid() && U_SUCCESS(status)) {

    UnicodeString temp2;

    char value[ULOC_KEYWORD_AND_VALUES_CAPACITY]; // sigh, no ULOC_VALUE_CAPACITY

    const char* key;

    while ((key = e->next((int32_t *)0, status)) != NULL) {

      value[0] = 0;

      loc.getKeywordValue(key, value, ULOC_KEYWORD_AND_VALUES_CAPACITY, status);

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

        return result;

      }

      keyDisplayName(key, temp, TRUE);

      temp.findAndReplace(formatOpenParen, formatReplaceOpenParen);

      temp.findAndReplace(formatCloseParen, formatReplaceCloseParen);

      keyValueDisplayName(key, value, temp2, TRUE);

      temp2.findAndReplace(formatOpenParen, formatReplaceOpenParen);

      temp2.findAndReplace(formatCloseParen, formatReplaceCloseParen);

      if (temp2 != UnicodeString(value, -1, US_INV)) {

        appendWithSep(resultRemainder, temp2);

      } else if (temp != UnicodeString(key, -1, US_INV)) {

        UnicodeString temp3;

        keyTypeFormat.format(temp, temp2, temp3, status);

        appendWithSep(resultRemainder, temp3);

      } else {

        appendWithSep(resultRemainder, temp)

          .append((UChar)0x3d /* = */)

          .append(temp2);

      }

    }

  }

  if (!resultRemainder.isEmpty()) {

    format.format(resultName, resultRemainder, result.remove(), status);

    return adjustForUsageAndContext(kCapContextUsageLanguage, result);

  }

  result = resultName;

  return adjustForUsageAndContext(kCapContextUsageLanguage, result);

}

UnicodeString&

LocaleDisplayNamesImpl::appendWithSep(UnicodeString& buffer, const UnicodeString& src) const {

    if (buffer.isEmpty()) {

        buffer.setTo(src);

    } else {

        const UnicodeString *values[2] = { &buffer, &src };

        UErrorCode status = U_ZERO_ERROR;

        separatorFormat.formatAndReplace(values, 2, buffer, NULL, 0, status);

    }

    return buffer;

}

UnicodeString&

LocaleDisplayNamesImpl::localeDisplayName(const char* localeId,

                                          UnicodeString& result) const {

    return localeDisplayName(Locale(localeId), result);

}

// private

UnicodeString&

LocaleDisplayNamesImpl::localeIdName(const char* localeId,

                                     UnicodeString& result, bool substitute) const {

    if (nameLength == UDISPCTX_LENGTH_SHORT) {

        langData.getNoFallback("Languages%short", localeId, result);

        if (!result.isBogus()) {

            return result;

        }

    }

    if (substitute) {

        return langData.get("Languages", localeId, result);

    } else {

        return langData.getNoFallback("Languages", localeId, result);

    }

}

UnicodeString&

LocaleDisplayNamesImpl::languageDisplayName(const char* lang,

                                            UnicodeString& result) const {

    if (uprv_strcmp("root", lang) == 0 || uprv_strchr(lang, '_') != NULL) {

        return result = UnicodeString(lang, -1, US_INV);

    }

    if (nameLength == UDISPCTX_LENGTH_SHORT) {

        langData.getNoFallback("Languages%short", lang, result);

        if (!result.isBogus()) {

            return adjustForUsageAndContext(kCapContextUsageLanguage, result);

        }

    }

    if (substitute == UDISPCTX_SUBSTITUTE) {

        langData.get("Languages", lang, result);

    } else {

        langData.getNoFallback("Languages", lang, result);

    }

    return adjustForUsageAndContext(kCapContextUsageLanguage, result);

}

UnicodeString&

LocaleDisplayNamesImpl::scriptDisplayName(const char* script,

                                          UnicodeString& result,

                                          UBool skipAdjust) const {

    if (nameLength == UDISPCTX_LENGTH_SHORT) {

        langData.getNoFallback("Scripts%short", script, result);

        if (!result.isBogus()) {

            return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageScript, result);

        }

    }

    if (substitute == UDISPCTX_SUBSTITUTE) {

        langData.get("Scripts", script, result);

    } else {

        langData.getNoFallback("Scripts", script, result);

    }

    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageScript, result);

}

UnicodeString&

LocaleDisplayNamesImpl::scriptDisplayName(const char* script,

                                          UnicodeString& result) const {

    return scriptDisplayName(script, result, FALSE);

}

UnicodeString&

LocaleDisplayNamesImpl::scriptDisplayName(UScriptCode scriptCode,

                                          UnicodeString& result) const {

    return scriptDisplayName(uscript_getName(scriptCode), result, FALSE);

}

UnicodeString&

LocaleDisplayNamesImpl::regionDisplayName(const char* region,

                                          UnicodeString& result,

                                          UBool skipAdjust) const {

    if (nameLength == UDISPCTX_LENGTH_SHORT) {

         regionData.getNoFallback("Countries%short", region, result);

        if (!result.isBogus()) {

            return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageTerritory, result);

        }

    }

    if (substitute == UDISPCTX_SUBSTITUTE) {

        regionData.get("Countries", region, result);

    } else {

        regionData.getNoFallback("Countries", region, result);

    }

    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageTerritory, result);

}

UnicodeString&

LocaleDisplayNamesImpl::regionDisplayName(const char* region,

                                          UnicodeString& result) const {

    return regionDisplayName(region, result, FALSE);

}

UnicodeString&

LocaleDisplayNamesImpl::variantDisplayName(const char* variant,

                                           UnicodeString& result,

                                           UBool skipAdjust) const {

    // don't have a resource for short variant names

    if (substitute == UDISPCTX_SUBSTITUTE) {

        langData.get("Variants", variant, result);

    } else {

        langData.getNoFallback("Variants", variant, result);

    }

    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageVariant, result);

}

UnicodeString&

LocaleDisplayNamesImpl::variantDisplayName(const char* variant,

                                           UnicodeString& result) const {

    return variantDisplayName(variant, result, FALSE);

}

UnicodeString&

LocaleDisplayNamesImpl::keyDisplayName(const char* key,

                                       UnicodeString& result,

                                       UBool skipAdjust) const {

    // don't have a resource for short key names

    if (substitute == UDISPCTX_SUBSTITUTE) {

        langData.get("Keys", key, result);

    } else {

        langData.getNoFallback("Keys", key, result);

    }

    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKey, result);

}

UnicodeString&

LocaleDisplayNamesImpl::keyDisplayName(const char* key,

                                       UnicodeString& result) const {

    return keyDisplayName(key, result, FALSE);

}

UnicodeString&

LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,

                                            const char* value,

                                            UnicodeString& result,

                                            UBool skipAdjust) const {

    if (uprv_strcmp(key, "currency") == 0) {

        // ICU4C does not have ICU4J CurrencyDisplayInfo equivalent for now.

        UErrorCode sts = U_ZERO_ERROR;

        UnicodeString ustrValue(value, -1, US_INV);

        int32_t len;

        const UChar *currencyName = ucurr_getName(ustrValue.getTerminatedBuffer(),

            locale.getBaseName(), UCURR_LONG_NAME, nullptr /* isChoiceFormat */, &len, &sts);

        if (U_FAILURE(sts)) {

            // Return the value as is on failure

            result = ustrValue;

            return result;

        }

        result.setTo(currencyName, len);

        return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);

    }

    if (nameLength == UDISPCTX_LENGTH_SHORT) {

        langData.getNoFallback("Types%short", key, value, result);

        if (!result.isBogus()) {

            return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);

        }

    }

    if (substitute == UDISPCTX_SUBSTITUTE) {

        langData.get("Types", key, value, result);

    } else {

        langData.getNoFallback("Types", key, value, result);

    }

    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);

}

UnicodeString&

LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,

                                            const char* value,

                                            UnicodeString& result) const {

    return keyValueDisplayName(key, value, result, FALSE);

}

////////////////////////////////////////////////////////////////////////////////////////////////////

LocaleDisplayNames*

LocaleDisplayNames::createInstance(const Locale& locale,

                                   UDialectHandling dialectHandling) {

    return new LocaleDisplayNamesImpl(locale, dialectHandling);

}

LocaleDisplayNames*

LocaleDisplayNames::createInstance(const Locale& locale,

                                   UDisplayContext *contexts, int32_t length) {

    if (contexts == NULL) {

        length = 0;

    }

    return new LocaleDisplayNamesImpl(locale, contexts, length);

}

U_NAMESPACE_END

////////////////////////////////////////////////////////////////////////////////////////////////////

U_NAMESPACE_USE

U_CAPI ULocaleDisplayNames * U_EXPORT2

uldn_open(const char * locale,

          UDialectHandling dialectHandling,

          UErrorCode *pErrorCode) {

  if (U_FAILURE(*pErrorCode)) {

    return 0;

  }