/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

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

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

 * others. All Rights Reserved.                                                *

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

 */

package sun.util.locale;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

public final class InternalLocaleBuilder {

    public InternalLocaleBuilder() {

    }

    public InternalLocaleBuilder setLanguage(String language) throws LocaleSyntaxException {

        } else {

            if (!LanguageTag.isLanguage(language)) {

                throw new LocaleSyntaxException("Ill-formed language: " + language, 0);

            }

        }

        return this;

    }

    public InternalLocaleBuilder setScript(String script) throws LocaleSyntaxException {

        } else {

            if (!LanguageTag.isScript(script)) {

                throw new LocaleSyntaxException("Ill-formed script: " + script, 0);

            }

        }

        return this;

    }

    public InternalLocaleBuilder setRegion(String region) throws LocaleSyntaxException {

        } else {

            if (!LanguageTag.isRegion(region)) {

                throw new LocaleSyntaxException("Ill-formed region: " + region, 0);

            }

        }

        return this;

    }

    public InternalLocaleBuilder setVariant(String variant) throws LocaleSyntaxException {

        } else {

            // normalize separators to "_"

            String var = variant.replaceAll(LanguageTag.SEP, BaseLocale.SEP);

            int errIdx = checkVariants(var, BaseLocale.SEP);

            if (errIdx != -1) {

                throw new LocaleSyntaxException("Ill-formed variant: " + variant, errIdx);

            }

        }

        return this;

    }

    public InternalLocaleBuilder addUnicodeLocaleAttribute(String attribute) throws LocaleSyntaxException {

        if (!UnicodeLocaleExtension.isAttribute(attribute)) {

            throw new LocaleSyntaxException("Ill-formed Unicode locale attribute: " + attribute);

        }

        // Use case insensitive string to prevent duplication

        }

        return this;

    }

    public InternalLocaleBuilder removeUnicodeLocaleAttribute(String attribute) throws LocaleSyntaxException {

        if (attribute == null || !UnicodeLocaleExtension.isAttribute(attribute)) {

            throw new LocaleSyntaxException("Ill-formed Unicode locale attribute: " + attribute);

        }

        }

        return this;

    }

    public InternalLocaleBuilder setUnicodeLocaleKeyword(String key, String type) throws LocaleSyntaxException {

        if (!UnicodeLocaleExtension.isKey(key)) {

            throw new LocaleSyntaxException("Ill-formed Unicode locale keyword key: " + key);

        }

        CaseInsensitiveString cikey = new CaseInsensitiveString(key);

        if (type == null) {

                // null type is used for remove the key

            }

        } else {

            if (type.length() != 0) {

                // normalize separator to "-"

                String tp = type.replaceAll(BaseLocale.SEP, LanguageTag.SEP);

                // validate

                StringTokenIterator itr = new StringTokenIterator(tp, LanguageTag.SEP);

                while (!itr.isDone()) {

                    String s = itr.current();

                    if (!UnicodeLocaleExtension.isTypeSubtag(s)) {

                    }

                    itr.next();

                }

            }

            }

        }

        return this;

    }

    public InternalLocaleBuilder setExtension(char singleton, String value) throws LocaleSyntaxException {

        // validate key

        boolean isBcpPrivateuse = LanguageTag.isPrivateusePrefixChar(singleton);

        if (!isBcpPrivateuse && !LanguageTag.isExtensionSingletonChar(singleton)) {

            throw new LocaleSyntaxException("Ill-formed extension key: " + singleton);

        }

        CaseInsensitiveChar key = new CaseInsensitiveChar(singleton);

        if (remove) {

            if (UnicodeLocaleExtension.isSingletonChar(key.value())) {

                // clear entire Unicode locale extension

                }

                }

            } else {

                }

            }

        } else {

            // validate value

            String val = value.replaceAll(BaseLocale.SEP, LanguageTag.SEP);

            StringTokenIterator itr = new StringTokenIterator(val, LanguageTag.SEP);

            while (!itr.isDone()) {

                String s = itr.current();

                boolean validSubtag;

                if (isBcpPrivateuse) {

                    validSubtag = LanguageTag.isPrivateuseSubtag(s);

                } else {

                    validSubtag = LanguageTag.isExtensionSubtag(s);

                }

                if (!validSubtag) {

                }

                itr.next();

            }

            if (UnicodeLocaleExtension.isSingletonChar(key.value())) {

                setUnicodeLocaleExtension(val);

            } else {

                }

            }

        }

        return this;

    }

    /*

     * Set extension/private subtags in a single string representation

     */

    public InternalLocaleBuilder setExtensions(String subtags) throws LocaleSyntaxException {

            clearExtensions();

            return this;

        }

        subtags = subtags.replaceAll(BaseLocale.SEP, LanguageTag.SEP);

        StringTokenIterator itr = new StringTokenIterator(subtags, LanguageTag.SEP);

        List<String> extensions = null;

        String privateuse = null;

        int parsed = 0;

        int start;

        // Make a list of extension subtags

        while (!itr.isDone()) {

            String s = itr.current();

            if (LanguageTag.isExtensionSingleton(s)) {

                start = itr.currentStart();

                String singleton = s;

                StringBuilder sb = new StringBuilder(singleton);

                itr.next();

                while (!itr.isDone()) {

                    s = itr.current();

                    if (LanguageTag.isExtensionSubtag(s)) {

                        sb.append(LanguageTag.SEP).append(s);

                        parsed = itr.currentEnd();

                    } else {

                        break;

                    }

                    itr.next();

                }

                if (parsed < start) {

                }

                if (extensions == null) {

                }

                extensions.add(sb.toString());

            } else {

                break;

            }

        }

        if (!itr.isDone()) {

            String s = itr.current();

            if (LanguageTag.isPrivateusePrefix(s)) {

                start = itr.currentStart();

                StringBuilder sb = new StringBuilder(s);

                itr.next();

                while (!itr.isDone()) {

                    s = itr.current();

                    if (!LanguageTag.isPrivateuseSubtag(s)) {

                        break;

                    }

                    sb.append(LanguageTag.SEP).append(s);

                    parsed = itr.currentEnd();

                    itr.next();

                }

                if (parsed <= start) {

                } else {

                    privateuse = sb.toString();

                }

            }

        }

        if (!itr.isDone()) {

        }

        return setExtensions(extensions, privateuse);

    }

    /*

     * Set a list of BCP47 extensions and private use subtags

     * BCP47 extensions are already validated and well-formed, but may contain duplicates

     */

    private InternalLocaleBuilder setExtensions(List<String> bcpExtensions, String privateuse) {

        clearExtensions();

            for (String bcpExt : bcpExtensions) {

                // ignore duplicates

                    // each extension string contains singleton, e.g. "a-abc-def"

                    if (UnicodeLocaleExtension.isSingletonChar(key.value())) {

                        setUnicodeLocaleExtension(bcpExt.substring(2));

                    } else {

                        }

                    }

                }

            }

        }

        if (privateuse != null && privateuse.length() > 0) {

            // privateuse string contains prefix, e.g. "x-abc-def"

            }

        }

        return this;

    }

    /*

     * Reset Builder's internal state with the given language tag

     */

    public InternalLocaleBuilder setLanguageTag(LanguageTag langtag) {

        clear();

        } else {

            }

        }

        List<String> bcpVariants = langtag.getVariants();

            StringBuilder var = new StringBuilder(bcpVariants.get(0));

                var.append(BaseLocale.SEP).append(bcpVariants.get(i));

            }

        }

        setExtensions(langtag.getExtensions(), langtag.getPrivateuse());

        return this;

    }

        String language = base.getLanguage();

        String script = base.getScript();

        String region = base.getRegion();

        String variant = base.getVariant();

        // Special backward compatibility support

        // Exception 1 - ja_JP_JP

        if (language.equals("ja") && region.equals("JP") && variant.equals("JP")) {

            // When locale ja_JP_JP is created, ca-japanese is always there.

            // The builder ignores the variant "JP"

            variant = "";

        }

        // Exception 2 - th_TH_TH

        else if (language.equals("th") && region.equals("TH") && variant.equals("TH")) {

            // When locale th_TH_TH is created, nu-thai is always there.

            // The builder ignores the variant "TH"

            variant = "";

        }

        // Exception 3 - no_NO_NY

        else if (language.equals("no") && region.equals("NO") && variant.equals("NY")) {

            // no_NO_NY is a valid locale and used by Java 6 or older versions.

            // The build ignores the variant "NY" and change the language to "nn".

            language = "nn";

            variant = "";

        }

        // Validate base locale fields before updating internal state.

        // LocaleExtensions always store validated/canonicalized values,

        // so no checks are necessary.

        if (language.length() > 0 && !LanguageTag.isLanguage(language)) {

            throw new LocaleSyntaxException("Ill-formed language: " + language);

        }

        if (script.length() > 0 && !LanguageTag.isScript(script)) {

            throw new LocaleSyntaxException("Ill-formed script: " + script);

        }

        if (region.length() > 0 && !LanguageTag.isRegion(region)) {

            throw new LocaleSyntaxException("Ill-formed region: " + region);

        }

        if (variant.length() > 0) {

            int errIdx = checkVariants(variant, BaseLocale.SEP);

            if (errIdx != -1) {

                throw new LocaleSyntaxException("Ill-formed variant: " + variant, errIdx);

            }

        }

        // The input locale is validated at this point.

        // Now, updating builder's internal fields.

        clearExtensions();

        if (extKeys != null) {

            for (Character key : extKeys) {

                if (e instanceof UnicodeLocaleExtension) {

                    UnicodeLocaleExtension ue = (UnicodeLocaleExtension)e;

                    for (String uatr : ue.getUnicodeLocaleAttributes()) {

                        }

                    }

                    for (String ukey : ue.getUnicodeLocaleKeys()) {

                        }

                    }

                } else {

                    }

                }

            }

        }

        return this;

    }

    public InternalLocaleBuilder clear() {

        clearExtensions();

        return this;

    }

    public InternalLocaleBuilder clearExtensions() {

        }

        }

        }

        return this;

    }

    public BaseLocale getBaseLocale() {

        // Special private use subtag sequence identified by "lvariant" will be

        // interpreted as Java variant.

            if (privuse != null) {

                StringTokenIterator itr = new StringTokenIterator(privuse, LanguageTag.SEP);

                boolean sawPrefix = false;

                int privVarStart = -1;

                while (!itr.isDone()) {

                    if (sawPrefix) {

                        privVarStart = itr.currentStart();

                        break;

                    }

                        sawPrefix = true;

                    }

                    itr.next();

                }

                if (privVarStart != -1) {