/*
 * Copyright (C) 2015 Andy VanWagoner (thetalecrafter@gmail.com)
 * Copyright (C) 2015 Sukolsak Sakshuwong (sukolsak@gmail.com)
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "IntlObject.h"

#if ENABLE(INTL)

#include "Error.h"
#include "FunctionPrototype.h"
#include "IntlCollator.h"
#include "IntlCollatorConstructor.h"
#include "IntlCollatorPrototype.h"
#include "IntlDateTimeFormat.h"
#include "IntlDateTimeFormatConstructor.h"
#include "IntlDateTimeFormatPrototype.h"
#include "IntlNumberFormat.h"
#include "IntlNumberFormatConstructor.h"
#include "IntlNumberFormatPrototype.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "Lookup.h"
#include "ObjectPrototype.h"
#include <unicode/uloc.h>
#include <wtf/Assertions.h>

namespace JSC {

STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(IntlObject);

}

namespace JSC {

struct MatcherResult {
    String locale;
    String extension;
    size_t extensionIndex;
};

const ClassInfo IntlObject::s_info = { "Object", &Base::s_info, 0, CREATE_METHOD_TABLE(IntlObject) };

IntlObject::IntlObject(VM& vm, Structure* structure)
    : JSNonFinalObject(vm, structure)
{
}

IntlObject* IntlObject::create(VM& vm, JSGlobalObject* globalObject, Structure* structure)
{
    IntlObject* object = new (NotNull, allocateCell<IntlObject>(vm.heap)) IntlObject(vm, structure);
    object->finishCreation(vm, globalObject);
    return object;
}

void IntlObject::finishCreation(VM& vm, JSGlobalObject* globalObject)
{
    Base::finishCreation(vm);
    ASSERT(inherits(info()));

    // Set up Collator.
    IntlCollatorPrototype* collatorPrototype = IntlCollatorPrototype::create(vm, globalObject, IntlCollatorPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
    Structure* collatorStructure = IntlCollator::createStructure(vm, globalObject, collatorPrototype);
    IntlCollatorConstructor* collatorConstructor = IntlCollatorConstructor::create(vm, IntlCollatorConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), collatorPrototype, collatorStructure);

    collatorPrototype->putDirectWithoutTransition(vm, vm.propertyNames->constructor, collatorConstructor, DontEnum);

    // Set up NumberFormat.
    IntlNumberFormatPrototype* numberFormatPrototype = IntlNumberFormatPrototype::create(vm, globalObject, IntlNumberFormatPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
    Structure* numberFormatStructure = IntlNumberFormat::createStructure(vm, globalObject, numberFormatPrototype);
    IntlNumberFormatConstructor* numberFormatConstructor = IntlNumberFormatConstructor::create(vm, IntlNumberFormatConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), numberFormatPrototype, numberFormatStructure);

    numberFormatPrototype->putDirectWithoutTransition(vm, vm.propertyNames->constructor, numberFormatConstructor, DontEnum);

    // Set up DateTimeFormat.
    IntlDateTimeFormatPrototype* dateTimeFormatPrototype = IntlDateTimeFormatPrototype::create(vm, globalObject, IntlDateTimeFormatPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
    Structure* dateTimeFormatStructure = IntlDateTimeFormat::createStructure(vm, globalObject, dateTimeFormatPrototype);
    IntlDateTimeFormatConstructor* dateTimeFormatConstructor = IntlDateTimeFormatConstructor::create(vm, IntlDateTimeFormatConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), dateTimeFormatPrototype, dateTimeFormatStructure);

    dateTimeFormatPrototype->putDirectWithoutTransition(vm, vm.propertyNames->constructor, dateTimeFormatConstructor, DontEnum);

    // 8.1 Properties of the Intl Object (ECMA-402 2.0)
    putDirectWithoutTransition(vm, vm.propertyNames->Collator, collatorConstructor, DontEnum);
    putDirectWithoutTransition(vm, vm.propertyNames->NumberFormat, numberFormatConstructor, DontEnum);
    putDirectWithoutTransition(vm, vm.propertyNames->DateTimeFormat, dateTimeFormatConstructor, DontEnum);
}

Structure* IntlObject::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
    return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
}

static String defaultLocale()
{
    // 6.2.4 DefaultLocale ()
    // FIXME: Implement this method.
    return ASCIILiteral("en");
}

bool intlBooleanOption(ExecState& state, JSValue options, PropertyName property, bool& usesFallback)
{
    // 9.2.9 GetOption (options, property, type, values, fallback)
    // For type="boolean". values is always undefined.

    // 1. Let opts be ToObject(options).
    JSObject* opts = options.toObject(&state);

    // 2. ReturnIfAbrupt(opts).
    if (state.hadException())
        return false;

    // 3. Let value be Get(opts, property).
    JSValue value = opts->get(&state, property);

    // 4. ReturnIfAbrupt(value).
    if (state.hadException())
        return false;

    // 5. If value is not undefined, then
    if (!value.isUndefined()) {
        // a. Assert: type is "boolean" or "string".
        // Function dedicated to "boolean".

        // b. If type is "boolean", then
        // i. Let value be ToBoolean(value).
        bool booleanValue = value.toBoolean(&state);

        // e. Return value.
        usesFallback = false;
        return booleanValue;
    }

    // 6. Else return fallback.
    // Because fallback can be undefined, we let the caller handle it instead.
    usesFallback = true;
    return false;
}

String intlStringOption(ExecState& state, JSValue options, PropertyName property, const HashSet<String>& values, const char* notFound, String fallback)
{
    // 9.2.9 GetOption (options, property, type, values, fallback)
    // For type="string".

    // 1. Let opts be ToObject(options).
    JSObject* opts = options.toObject(&state);

    // 2. ReturnIfAbrupt(opts).
    if (state.hadException())
        return String();

    // 3. Let value be Get(opts, property).
    JSValue value = opts->get(&state, property);

    // 4. ReturnIfAbrupt(value).
    if (state.hadException())
        return String();

    // 5. If value is not undefined, then
    if (!value.isUndefined()) {
        // a. Assert: type is "boolean" or "string".
        // Function dedicated to "string".

        // c. If type is "string", then
        // i. Let value be ToString(value).
        JSString* stringValue = value.toString(&state);

        // ii. ReturnIfAbrupt(value).
        if (state.hadException())
            return String();

        // d. If values is not undefined, then
        // i. If values does not contain an element equal to value, throw a RangeError exception.
        if (!values.isEmpty() && !values.contains(stringValue->value(&state))) {
            state.vm().throwException(&state, createRangeError(&state, String(notFound)));
            return String();
        }

        // e. Return value.
        return stringValue->value(&state);
    }

    // 6. Else return fallback.
    return fallback;
}

static String privateUseLangTag(const Vector<String>& parts, size_t startIndex)
{
    size_t numParts = parts.size();
    size_t currentIndex = startIndex;

    // Check for privateuse.
    // privateuse = "x" 1*("-" (2*8alphanum))
    StringBuilder privateuse;
    while (currentIndex < numParts) {
        const String& singleton = parts[currentIndex];
        unsigned singletonLength = singleton.length();
        bool isValid = (singletonLength == 1 && (singleton == "x" || singleton == "X"));
        if (!isValid)
            break;

        if (currentIndex != startIndex)
            privateuse.append('-');

        ++currentIndex;
        unsigned numExtParts = 0;
        privateuse.append('x');
        while (currentIndex < numParts) {
            const String& extPart = parts[currentIndex];
            unsigned extPartLength = extPart.length();

            bool isValid = (extPartLength >= 2 && extPartLength <= 8 && extPart.isAllSpecialCharacters<isASCIIAlphanumeric>());
            if (!isValid)
                break;

            ++currentIndex;
            ++numExtParts;
            privateuse.append('-');
            privateuse.append(extPart.convertToASCIILowercase());
        }

        // Requires at least one production.
        if (!numExtParts)
            return String();
    }

    // Leftovers makes it invalid.
    if (currentIndex < numParts)
        return String();

    return privateuse.toString();
}

static String canonicalLangTag(const Vector<String>& parts)
{
    ASSERT(!parts.isEmpty());

    // Follows the grammar at https://www.rfc-editor.org/rfc/bcp/bcp47.txt
    // langtag = language ["-" script] ["-" region] *("-" variant) *("-" extension) ["-" privateuse]

    size_t numParts = parts.size();
    // Check for language.
    // language = 2*3ALPHA ["-" extlang] / 4ALPHA / 5*8ALPHA
    size_t currentIndex = 0;
    const String& language = parts[currentIndex];
    unsigned languageLength = language.length();
    bool canHaveExtlang = languageLength >= 2 && languageLength <= 3;
    bool isValidLanguage = languageLength >= 2 && languageLength <= 8 && language.isAllSpecialCharacters<isASCIIAlpha>();
    if (!isValidLanguage)
        return String();

    ++currentIndex;
    StringBuilder canonical;
    canonical.append(language.convertToASCIILowercase());

    // Check for extlang.
    // extlang = 3ALPHA *2("-" 3ALPHA)
    if (canHaveExtlang) {
        for (unsigned times = 0; times < 3 && currentIndex < numParts; ++times) {
            const String& extlang = parts[currentIndex];
            unsigned extlangLength = extlang.length();
            if (extlangLength == 3 && extlang.isAllSpecialCharacters<isASCIIAlpha>()) {
                ++currentIndex;
                canonical.append('-');
                canonical.append(extlang.convertToASCIILowercase());
            } else
                break;
        }
    }

    // Check for script.
    // script = 4ALPHA
    if (currentIndex < numParts) {
        const String& script = parts[currentIndex];
        unsigned scriptLength = script.length();
        if (scriptLength == 4 && script.isAllSpecialCharacters<isASCIIAlpha>()) {
            ++currentIndex;
            canonical.append('-');
            canonical.append(toASCIIUpper(script[0]));
            canonical.append(script.substring(1, 3).convertToASCIILowercase());
        }
    }

    // Check for region.
    // region = 2ALPHA / 3DIGIT
    if (currentIndex < numParts) {
        const String& region = parts[currentIndex];
        unsigned regionLength = region.length();
        bool isValidRegion = (
            (regionLength == 2 && region.isAllSpecialCharacters<isASCIIAlpha>())
            || (regionLength == 3 && region.isAllSpecialCharacters<isASCIIDigit>())
        );
        if (isValidRegion) {
            ++currentIndex;
            canonical.append('-');
            canonical.append(region.upper());
        }
    }

    // Check for variant.
    // variant = 5*8alphanum / (DIGIT 3alphanum)
    HashSet<String> subtags;
    while (currentIndex < numParts) {
        const String& variant = parts[currentIndex];
        unsigned variantLength = variant.length();
        bool isValidVariant = (
            (variantLength >= 5 && variantLength <= 8 && variant.isAllSpecialCharacters<isASCIIAlphanumeric>())
            || (variantLength == 4 && isASCIIDigit(variant[0]) && variant.substring(1, 3).isAllSpecialCharacters<isASCIIAlphanumeric>())
        );
        if (!isValidVariant)
            break;

        // Cannot include duplicate subtags (case insensitive).
        String lowerVariant = variant.convertToASCIILowercase();
        if (!subtags.add(lowerVariant).isNewEntry)
            return String();

        ++currentIndex;

        // Reordering variant subtags is not required in the spec.
        canonical.append('-');
        canonical.append(lowerVariant);
    }

    // Check for extension.
    // extension = singleton 1*("-" (2*8alphanum))
    // singleton = alphanum except x or X
    subtags.clear();
    Vector<String> extensions;
    while (currentIndex < numParts) {
        const String& possibleSingleton = parts[currentIndex];
        unsigned singletonLength = possibleSingleton.length();
        bool isValidSingleton = (singletonLength == 1 && possibleSingleton != "x" && possibleSingleton != "X" && isASCIIAlphanumeric(possibleSingleton[0]));
        if (!isValidSingleton)
            break;

        // Cannot include duplicate singleton (case insensitive).
        String singleton = possibleSingleton.convertToASCIILowercase();
        if (!subtags.add(singleton).isNewEntry)
            return String();

        ++currentIndex;
        int numExtParts = 0;
        StringBuilder extension;
        extension.append(singleton);
        while (currentIndex < numParts) {
            const String& extPart = parts[currentIndex];
            unsigned extPartLength = extPart.length();

            bool isValid = (extPartLength >= 2 && extPartLength <= 8 && extPart.isAllSpecialCharacters<isASCIIAlphanumeric>());
            if (!isValid)
                break;

            ++currentIndex;
            ++numExtParts;
            extension.append('-');
            extension.append(extPart.convertToASCIILowercase());
        }

        // Requires at least one production.
        if (!numExtParts)
            return String();

        extensions.append(extension.toString());
    }

    // Add extensions to canonical sorted by singleton.
    std::sort(
        extensions.begin(),
        extensions.end(),
        [] (const String& a, const String& b) -> bool {
            return a[0] < b[0];
        }
    );
    size_t numExtenstions = extensions.size();
    for (size_t i = 0; i < numExtenstions; ++i) {
        canonical.append('-');
        canonical.append(extensions[i]);
    }

    // Check for privateuse.
    if (currentIndex < numParts) {
        String privateuse = privateUseLangTag(parts, currentIndex);
        if (privateuse.isNull())
            return String();
        canonical.append('-');
        canonical.append(privateuse);
    }

    // FIXME: Replace subtags with their preferred values.

    return canonical.toString();
}

static String grandfatheredLangTag(const String& locale)
{
    // grandfathered = irregular / regular
    // FIXME: convert to a compile time hash table if this is causing performance issues.
    HashMap<String, String> tagMap = {
        // Irregular.
        { ASCIILiteral("en-gb-oed"), ASCIILiteral("en-GB-oed") },
        { ASCIILiteral("i-ami"), ASCIILiteral("ami") },
        { ASCIILiteral("i-bnn"), ASCIILiteral("bnn") },
        { ASCIILiteral("i-default"), ASCIILiteral("i-default") },
        { ASCIILiteral("i-enochian"), ASCIILiteral("i-enochian") },
        { ASCIILiteral("i-hak"), ASCIILiteral("hak") },
        { ASCIILiteral("i-klingon"), ASCIILiteral("tlh") },
        { ASCIILiteral("i-lux"), ASCIILiteral("lb") },
        { ASCIILiteral("i-mingo"), ASCIILiteral("i-mingo") },
        { ASCIILiteral("i-navajo"), ASCIILiteral("nv") },
        { ASCIILiteral("i-pwn"), ASCIILiteral("pwn") },
        { ASCIILiteral("i-tao"), ASCIILiteral("tao") },
        { ASCIILiteral("i-tay"), ASCIILiteral("tay") },
        { ASCIILiteral("i-tsu"), ASCIILiteral("tsu") },
        { ASCIILiteral("sgn-be-fr"), ASCIILiteral("sfb") },
        { ASCIILiteral("sgn-be-nl"), ASCIILiteral("vgt") },
        { ASCIILiteral("sgn-ch-de"), ASCIILiteral("sgg") },
        // Regular.
        { ASCIILiteral("art-lojban"), ASCIILiteral("jbo") },
        { ASCIILiteral("cel-gaulish"), ASCIILiteral("cel-gaulish") },
        { ASCIILiteral("no-bok"), ASCIILiteral("nb") },
        { ASCIILiteral("no-nyn"), ASCIILiteral("nn") },
        { ASCIILiteral("zh-guoyu"), ASCIILiteral("cmn") },
        { ASCIILiteral("zh-hakka"), ASCIILiteral("hak") },
        { ASCIILiteral("zh-min"), ASCIILiteral("zh-min") },
        { ASCIILiteral("zh-min-nan"), ASCIILiteral("nan") },
        { ASCIILiteral("zh-xiang"), ASCIILiteral("hsn") }
    };

    return tagMap.get(locale.convertToASCIILowercase());
}

static String canonicalizeLanguageTag(const String& locale)
{
    // 6.2.2 IsStructurallyValidLanguageTag (locale)
    // 6.2.3 CanonicalizeLanguageTag (locale)
    // These are done one after another in CanonicalizeLocaleList, so they are combined here to reduce duplication.
    // https://www.rfc-editor.org/rfc/bcp/bcp47.txt

    // Language-Tag = langtag / privateuse / grandfathered
    String grandfather = grandfatheredLangTag(locale);
    if (!grandfather.isNull())
        return grandfather;

    // FIXME: Replace redundant tags [RFC4647].

    Vector<String> parts;
    locale.split('-', true, parts);
    if (!parts.isEmpty()) {
        String langtag = canonicalLangTag(parts);
        if (!langtag.isNull())
            return langtag;

        String privateuse = privateUseLangTag(parts, 0);
        if (!privateuse.isNull())
            return privateuse;
    }

    return String();
}

Vector<String> canonicalizeLocaleList(ExecState& state, JSValue locales)
{
    // 9.2.1 CanonicalizeLocaleList (locales)
    VM& vm = state.vm();
    JSGlobalObject* globalObject = state.callee()->globalObject();
    Vector<String> seen;

    // 1. If locales is undefined, then a. Return a new empty List.
    if (locales.isUndefined())
        return seen;

    // 2. Let seen be an empty List.
    // Done before to also return in step 1, if needed.

    // 3. If Type(locales) is String, then
    JSObject* localesObject;
    if (locales.isString()) {
        //  a. Let aLocales be CreateArrayFromList(«locales»).
        JSArray* localesArray = JSArray::tryCreateUninitialized(vm, globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous), 1);
        localesArray->initializeIndex(vm, 0, locales);
        // 4. Let O be ToObject(aLocales).
        localesObject = localesArray;
    } else {
        // 4. Let O be ToObject(aLocales).
        localesObject = locales.toObject(&state);
    }

    // 5. ReturnIfAbrupt(O).
    if (state.hadException())
        return Vector<String>();

    // 6. Let len be ToLength(Get(O, "length")).
    JSValue lengthProperty = localesObject->get(&state, vm.propertyNames->length);
    if (state.hadException())
        return Vector<String>();

    double length = lengthProperty.toLength(&state);
    if (state.hadException())
        return Vector<String>();

    // Keep track of locales that have been added to the list.
    HashSet<String> seenSet;

    // 7. Let k be 0.
    // 8. Repeat, while k < len
    for (double k = 0; k < length; ++k) {
        // a. Let Pk be ToString(k).
        // Not needed because hasProperty and get take an int for numeric key.

        // b. Let kPresent be HasProperty(O, Pk).
        bool kPresent = localesObject->hasProperty(&state, k);

        // c. ReturnIfAbrupt(kPresent).
        if (state.hadException())
            return Vector<String>();

        // d. If kPresent is true, then
        if (kPresent) {
            // i. Let kValue be Get(O, Pk).
            JSValue kValue = localesObject->get(&state, k);

            // ii. ReturnIfAbrupt(kValue).
            if (state.hadException())
                return Vector<String>();

            // iii. If Type(kValue) is not String or Object, throw a TypeError exception.
            if (!kValue.isString() && !kValue.isObject()) {
                throwTypeError(&state, ASCIILiteral("locale value must be a string or object"));
                return Vector<String>();
            }

            // iv. Let tag be ToString(kValue).
            JSString* tag = kValue.toString(&state);

            // v. ReturnIfAbrupt(tag).
            if (state.hadException())
                return Vector<String>();

            // vi. If IsStructurallyValidLanguageTag(tag) is false, throw a RangeError exception.
            // vii. Let canonicalizedTag be CanonicalizeLanguageTag(tag).
            String canonicalizedTag = canonicalizeLanguageTag(tag->value(&state));
            if (canonicalizedTag.isNull()) {
                state.vm().throwException(&state, createRangeError(&state, String::format("invalid language tag: %s", tag->value(&state).utf8().data())));
                return Vector<String>();
            }

            // viii. If canonicalizedTag is not an element of seen, append canonicalizedTag as the last element of seen.
            if (seenSet.add(canonicalizedTag).isNewEntry)
                seen.append(canonicalizedTag);
        }
        // e. Increase k by 1.
    }

    return seen;
}

static String bestAvailableLocale(const HashSet<String>& availableLocales, const String& locale)
{
    // 9.2.2 BestAvailableLocale (availableLocales, locale)
    // 1. Let candidate be locale.
    String candidate = locale;

    // 2. Repeat
    while (!candidate.isEmpty()) {
        // a. If availableLocales contains an element equal to candidate, then return candidate.
        if (availableLocales.contains(candidate))
            return candidate;

        // b. Let pos be the character index of the last occurrence of "-" (U+002D) within candidate. If that character does not occur, return undefined.
        size_t pos = candidate.reverseFind('-');
        if (pos == notFound)
            return String();

        // c. If pos ≥ 2 and the character "-" occurs at index pos-2 of candidate, then decrease pos by 2.
        if (pos >= 2 && candidate[pos - 2] == '-')
            pos -= 2;

        // d. Let candidate be the substring of candidate from position 0, inclusive, to position pos, exclusive.
        candidate = candidate.substring(0, pos);
    }

    return String();
}

static String removeUnicodeLocaleExtension(const String& locale)
{
    Vector<String> parts;
    locale.split('-', parts);
    StringBuilder builder;
    size_t partsSize = parts.size();
    if (partsSize > 0)
        builder.append(parts[0]);
    for (size_t p = 1; p < partsSize; ++p) {
        if (parts[p] == "u") {
            // Skip the u- and anything that follows until another singleton.
            // While the next part is part of the unicode extension, skip it.
            while (p + 1 < partsSize && parts[p + 1].length() > 1)
                ++p;
        } else {
            builder.append('-');
            builder.append(parts[p]);
        }
    }
    return builder.toString();
}

static MatcherResult lookupMatcher(const HashSet<String>& availableLocales, const Vector<String>& requestedLocales)
{
    // 9.2.3 LookupMatcher (availableLocales, requestedLocales) (ECMA-402 2.0)
    String locale;
    String noExtensionsLocale;
    String availableLocale;
    for (size_t i = 0; i < requestedLocales.size() && availableLocale.isNull(); ++i) {
        locale = requestedLocales[i];
        noExtensionsLocale = removeUnicodeLocaleExtension(locale);
        availableLocale = bestAvailableLocale(availableLocales, noExtensionsLocale);
    }

    MatcherResult result;
    if (!availableLocale.isNull()) {
        result.locale = availableLocale;
        if (locale != noExtensionsLocale) {
            // i. Let extension be the String value consisting of the first substring of locale that is a Unicode locale extension sequence.
            // ii. Let extensionIndex be the character position of the initial "-" extension sequence within locale.
            size_t extensionIndex = locale.find("-u-");
            RELEASE_ASSERT(extensionIndex != notFound);

            size_t extensionLength = locale.length() - extensionIndex;
            size_t end = extensionIndex + 3;
            while (end < locale.length()) {
                end = locale.find('-', end);
                if (end == notFound)
                    break;
                if (end + 2 < locale.length() && locale[end + 2] == '-') {
                    extensionLength = end - extensionIndex;
                    break;
                }
                end++;
            }
            result.extension = locale.substring(extensionIndex, extensionLength);
            result.extensionIndex = extensionIndex;
        }
    } else
        result.locale = defaultLocale();
    return result;
}

static MatcherResult bestFitMatcher(const HashSet<String>& availableLocales, const Vector<String>& requestedLocales)
{
    // 9.2.4 BestFitMatcher (availableLocales, requestedLocales) (ECMA-402 2.0)
    // FIXME: Implement something better than lookup.
    return lookupMatcher(availableLocales, requestedLocales);
}

HashMap<String, String> resolveLocale(const HashSet<String>& availableLocales, const Vector<String>& requestedLocales, const HashMap<String, String>& options, const Vector<String>& relevantExtensionKeys, Vector<String> (*localeData)(const String&, const String&))
{
    // 9.2.5 ResolveLocale (availableLocales, requestedLocales, options, relevantExtensionKeys, localeData) (ECMA-402 2.0)
    // 1. Let matcher be the value of options.[[localeMatcher]].
    const String& matcher = options.get(ASCIILiteral("localeMatcher"));

    // 2. If matcher is "lookup", then
    MatcherResult (*matcherOperation)(const HashSet<String>&, const Vector<String>&);
    if (matcher == "lookup") {
        // a. Let MatcherOperation be the abstract operation LookupMatcher.
        matcherOperation = lookupMatcher;
    } else { // 3. Else
        // a. Let MatcherOperation be the abstract operation BestFitMatcher.
        matcherOperation = bestFitMatcher;
    }

    // 4. Let r be MatcherOperation(availableLocales, requestedLocales).
    MatcherResult matcherResult = matcherOperation(availableLocales, requestedLocales);

    // 5. Let foundLocale be the value of r.[[locale]].
    String foundLocale = matcherResult.locale;

    // 6. If r has an [[extension]] field, then
    Vector<String> extensionSubtags;
    if (!matcherResult.extension.isNull()) {
        // a. Let extension be the value of r.[[extension]].
        // b. Let extensionIndex be the value of r.[[extensionIndex]].
        // c. Let extensionSubtags be Call(%StringProto_split%, extension, «"-"») .
        // d. Let extensionSubtagsLength be Get(CreateArrayFromList(extensionSubtags), "length").
        matcherResult.extension.split('-', extensionSubtags);
    }

    // 7. Let result be a new Record.
    HashMap<String, String> result;

    // 8. Set result.[[dataLocale]] to foundLocale.
    result.set(ASCIILiteral("dataLocale"), foundLocale);

    // 9. Let supportedExtension be "-u".
    String supportedExtension = ASCIILiteral("-u");

    // 10. Let k be 0.
    // 11. Let rExtensionKeys be ToObject(CreateArrayFromList(relevantExtensionKeys)).
    // 12. ReturnIfAbrupt(rExtensionKeys).
    // 13. Let len be ToLength(Get(rExtensionKeys, "length")).
    // 14. Repeat while k < len
    for (size_t k = 0; k < relevantExtensionKeys.size(); ++k) {
        // a. Let key be Get(rExtensionKeys, ToString(k)).
        // b. ReturnIfAbrupt(key).
        const String& key = relevantExtensionKeys[k];

        // c. Let foundLocaleData be Get(localeData, foundLocale).
        // d. ReturnIfAbrupt(foundLocaleData).
        // e. Let keyLocaleData be ToObject(Get(foundLocaleData, key)).
        // f. ReturnIfAbrupt(keyLocaleData).
        Vector<String> keyLocaleData = localeData(foundLocale, key);

        // g. Let value be ToString(Get(keyLocaleData, "0")).
        // h. ReturnIfAbrupt(value).
        ASSERT(!keyLocaleData.isEmpty());
        String value = keyLocaleData[0];

        // i. Let supportedExtensionAddition be "".
        String supportedExtensionAddition;

        // j. If extensionSubtags is not undefined, then
        if (!extensionSubtags.isEmpty()) {
            // i. Let keyPos be Call(%ArrayProto_indexOf%, extensionSubtags, «key») .
            size_t keyPos = extensionSubtags.find(key);
            // ii. If keyPos != -1, then
            if (keyPos != notFound) {
                // 1. If keyPos + 1 < extensionSubtagsLength and the length of the result of Get(extensionSubtags, ToString(keyPos +1)) is greater than 2, then
                if (keyPos + 1 < extensionSubtags.size() && extensionSubtags[keyPos + 1].length() > 2) {
                    const String& requestedValue = extensionSubtags[keyPos + 1];
                    if (keyLocaleData.contains(requestedValue)) {
                        value = requestedValue;
                        supportedExtensionAddition = "-" + key + '-' + value;
                    }
                } else if (keyLocaleData.contains(static_cast<String>(ASCIILiteral("true")))) {
                    // 2. Else, if the result of Call(%StringProto_includes%, keyLocaleData, «"true"») is true, then
                    value = ASCIILiteral("true");
                }
            }
        }

        // k. If options has a field [[<key>]], then
        HashMap<String, String>::const_iterator iterator = options.find(key);
        if (iterator != options.end()) {
            // i. Let optionsValue be the value of ToString(options.[[<key>]]).
            // ii. ReturnIfAbrupt(optionsValue).
            const String& optionsValue = iterator->value;
            // iii. If the result of Call(%StringProto_includes%, keyLocaleData, «optionsValue») is true, then
            if (!optionsValue.isNull() && keyLocaleData.contains(optionsValue)) {
                // 1. If optionsValue is not equal to value, then
                if (optionsValue != value) {
                    value = optionsValue;
                    supportedExtensionAddition = String();
                }
            }
        }

        // l. Set result.[[<key>]] to value.
        result.set(key, value);

        // m. Append supportedExtensionAddition to supportedExtension.
        supportedExtension.append(supportedExtensionAddition);

        // n. Increase k by 1.
    }

    // 15. If the number of elements in supportedExtension is greater than 2, then
    if (supportedExtension.length() > 2) {
        // a. Let preExtension be the substring of foundLocale from position 0, inclusive, to position extensionIndex, exclusive.
        // b. Let postExtension be the substring of foundLocale from position extensionIndex to the end of the string.
        // c. Let foundLocale be the concatenation of preExtension, supportedExtension, and postExtension.
        String preExtension = foundLocale.substring(0, matcherResult.extensionIndex);
        String postExtension = foundLocale.substring(matcherResult.extensionIndex);
        foundLocale = preExtension + supportedExtension + postExtension;
    }

    // 16. Set result.[[locale]] to foundLocale.
    result.set(ASCIILiteral("locale"), foundLocale);

    // 17. Return result.
    return result;
}

static JSArray* lookupSupportedLocales(ExecState& state, const HashSet<String>& availableLocales, const Vector<String>& requestedLocales)
{
    // 9.2.6 LookupSupportedLocales (availableLocales, requestedLocales)

    // 1. Let rLocales be CreateArrayFromList(requestedLocales).
    // Already an array.

    // 2. Let len be ToLength(Get(rLocales, "length")).
    size_t len = requestedLocales.size();

    // 3. Let subset be an empty List.
    VM& vm = state.vm();
    JSGlobalObject* globalObject = state.callee()->globalObject();
    JSArray* subset = JSArray::tryCreateUninitialized(vm, globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithUndecided), 0);
    if (!subset) {
        throwOutOfMemoryError(&state);
        return nullptr;
    }

    // 4. Let k be 0.
    // 5. Repeat while k < len
    for (size_t k = 0; k < len; ++k) {
        // a. Let Pk be ToString(k).
        // b. Let locale be Get(rLocales, Pk).
        // c. ReturnIfAbrupt(locale).
        const String& locale = requestedLocales[k];

        // d. Let noExtensionsLocale be the String value that is locale with all Unicode locale extension sequences removed.
        String noExtensionsLocale = removeUnicodeLocaleExtension(locale);

        // e. Let availableLocale be BestAvailableLocale(availableLocales, noExtensionsLocale).
        String availableLocale = bestAvailableLocale(availableLocales, noExtensionsLocale);

        // f. If availableLocale is not undefined, then append locale to the end of subset.
        if (!availableLocale.isNull())
            subset->push(&state, jsString(&state, locale));

        // g. Increment k by 1.
    }

    // 6. Return subset.
    return subset;
}

static JSArray* bestFitSupportedLocales(ExecState& state, const HashSet<String>& availableLocales, const Vector<String>& requestedLocales)
{
    // 9.2.7 BestFitSupportedLocales (availableLocales, requestedLocales)
    // FIXME: Implement something better than lookup.
    return lookupSupportedLocales(state, availableLocales, requestedLocales);
}

JSValue supportedLocales(ExecState& state, const HashSet<String>& availableLocales, const Vector<String>& requestedLocales, JSValue options)
{
    // 9.2.8 SupportedLocales (availableLocales, requestedLocales, options)
    VM& vm = state.vm();
    String matcher;

    // 1. If options is not undefined, then
    if (!options.isUndefined()) {
        // a. Let matcher be GetOption(options, "localeMatcher", "string", « "lookup", "best fit" », "best fit").
        const HashSet<String> matchers({ ASCIILiteral("lookup"), ASCIILiteral("best fit") });
        matcher = intlStringOption(state, options, vm.propertyNames->localeMatcher, matchers, "localeMatcher must be either \"lookup\" or \"best fit\"", ASCIILiteral("best fit"));
        // b. ReturnIfAbrupt(matcher).
        if (state.hadException())
            return jsUndefined();
    } else {
        // 2. Else, let matcher be "best fit".
        matcher = ASCIILiteral("best fit");
    }

    JSArray* supportedLocales;
    // 3. If matcher is "best fit",
    if (matcher == "best fit") {
        // a. Let MatcherOperation be the abstract operation BestFitSupportedLocales.
        // 5. Let supportedLocales be MatcherOperation(availableLocales, requestedLocales).
        supportedLocales = bestFitSupportedLocales(state, availableLocales, requestedLocales);
    } else {
        // 4. Else
        // a. Let MatcherOperation be the abstract operation LookupSupportedLocales.
        // 5. Let supportedLocales be MatcherOperation(availableLocales, requestedLocales).
        supportedLocales = lookupSupportedLocales(state, availableLocales, requestedLocales);
    }

    if (state.hadException())
        return jsUndefined();

    // 6. Let subset be CreateArrayFromList(supportedLocales).
    // Already an array.

    // 7. Let keys be subset.[[OwnPropertyKeys]]().
    PropertyNameArray keys(&state, PropertyNameMode::Strings);
    supportedLocales->getOwnPropertyNames(supportedLocales, &state, keys, EnumerationMode());

    PropertyDescriptor desc;
    desc.setConfigurable(false);
    desc.setWritable(false);

    // 8. Repeat for each element P of keys in List order,
    size_t len = keys.size();
    for (size_t i = 0; i < len; ++i) {
        // a. Let desc be PropertyDescriptor { [[Configurable]]: false, [[Writable]]: false }.
        // Created above for reuse.

        // b. Let status be DefinePropertyOrThrow(subset, P, desc).
        supportedLocales->defineOwnProperty(supportedLocales, &state, keys[i], desc, true);

        // c. Assert: status is not abrupt completion.
        if (state.hadException())
            return jsUndefined();
    }

    // 9. Return subset.
    return supportedLocales;
}

} // namespace JSC

#endif // ENABLE(INTL)