/*

 * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.

 * 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.Map;

import java.util.Set;

public final class InternalLocaleBuilder {

    private static final CaseInsensitiveChar PRIVATEUSE_KEY

        = new CaseInsensitiveChar(LanguageTag.PRIVATEUSE);

    private String language = "";

    private String script = "";

    private String region = "";

    private String variant = "";

    private Map<CaseInsensitiveChar, String> extensions;

    private Set<CaseInsensitiveString> uattributes;

    private Map<CaseInsensitiveString, String> ukeywords;

    public InternalLocaleBuilder() {

    }

    public InternalLocaleBuilder setLanguage(String language) throws LocaleSyntaxException {

        if (LocaleUtils.isEmpty(language)) {

            this.language = "";

        } else {

            if (!LanguageTag.isLanguage(language)) {

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

            }

            this.language = language;

        }

        return this;

    }

    public InternalLocaleBuilder setScript(String script) throws LocaleSyntaxException {

        if (LocaleUtils.isEmpty(script)) {

            this.script = "";

        } else {

            if (!LanguageTag.isScript(script)) {

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

            }

            this.script = script;

        }

        return this;

    }

    public InternalLocaleBuilder setRegion(String region) throws LocaleSyntaxException {

        if (LocaleUtils.isEmpty(region)) {

            this.region = "";

        } else {

            if (!LanguageTag.isRegion(region)) {

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

            }

            this.region = region;

        }

        return this;

    }

    public InternalLocaleBuilder setVariant(String variant) throws LocaleSyntaxException {

        if (LocaleUtils.isEmpty(variant)) {

            this.variant = "";

        } 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);

            }

            this.variant = var;

        }

        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

        if (uattributes == null) {

            uattributes = new HashSet<>(4);

        }

        uattributes.add(new CaseInsensitiveString(attribute));

        return this;

    }

    public InternalLocaleBuilder removeUnicodeLocaleAttribute(String attribute) throws LocaleSyntaxException {

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

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

        }

        if (uattributes != null) {

            uattributes.remove(new CaseInsensitiveString(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) {

            if (ukeywords != null) {

                // null type is used for remove the key

                ukeywords.remove(cikey);

            }

        } 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)) {

                        throw new LocaleSyntaxException("Ill-formed Unicode locale keyword type: "

                                                        + type,

                                                        itr.currentStart());

                    }

                    itr.next();

                }

            }

            if (ukeywords == null) {

                ukeywords = new HashMap<>(4);

            }

            ukeywords.put(cikey, type);

        }

        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);

        }

        boolean remove = LocaleUtils.isEmpty(value);

        CaseInsensitiveChar key = new CaseInsensitiveChar(singleton);

        if (remove) {

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

                // clear entire Unicode locale extension

                if (uattributes != null) {

                    uattributes.clear();

                }

                if (ukeywords != null) {

                    ukeywords.clear();

                }

            } else {

                if (extensions != null && extensions.containsKey(key)) {

                    extensions.remove(key);

                }

            }

        } 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) {

                    throw new LocaleSyntaxException("Ill-formed extension value: " + s,

                                                    itr.currentStart());

                }

                itr.next();

            }

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

                setUnicodeLocaleExtension(val);

            } else {

                if (extensions == null) {

                    extensions = new HashMap<>(4);

                }

                extensions.put(key, val);

            }

        }

        return this;

    }

    /*

     * Set extension/private subtags in a single string representation

     */

    public InternalLocaleBuilder setExtensions(String subtags) throws LocaleSyntaxException {

        if (LocaleUtils.isEmpty(subtags)) {

            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) {

                    throw new LocaleSyntaxException("Incomplete extension '" + singleton + "'",

                                                    start);

                }

                if (extensions == null) {

                    extensions = new ArrayList<>(4);

                }

                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) {

                    throw new LocaleSyntaxException("Incomplete privateuse:"

                                                    + subtags.substring(start),

                                                    start);

                } else {

                    privateuse = sb.toString();

                }

            }

        }

        if (!itr.isDone()) {

            throw new LocaleSyntaxException("Ill-formed extension subtags:"

                                            + subtags.substring(itr.currentStart()),

                                            itr.currentStart());

        }

        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();

        if (!LocaleUtils.isEmpty(bcpExtensions)) {

            Set<CaseInsensitiveChar> done = new HashSet<>(bcpExtensions.size());

            for (String bcpExt : bcpExtensions) {

                CaseInsensitiveChar key = new CaseInsensitiveChar(bcpExt);

                // ignore duplicates

                if (!done.contains(key)) {

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

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

                        setUnicodeLocaleExtension(bcpExt.substring(2));

                    } else {

                        if (extensions == null) {

                            extensions = new HashMap<>(4);

                        }

                        extensions.put(key, bcpExt.substring(2));

                    }

                }

                done.add(key);

            }

        }

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

            if (extensions == null) {

                extensions = new HashMap<>(1);

            }

            extensions.put(new CaseInsensitiveChar(privateuse), privateuse.substring(2));

        }

        return this;

    }

    /*

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

     */

    public InternalLocaleBuilder setLanguageTag(LanguageTag langtag) {

        clear();

        if (!langtag.getExtlangs().isEmpty()) {

            language = langtag.getExtlangs().get(0);

        } else {

            String lang = langtag.getLanguage();

            if (!lang.equals(LanguageTag.UNDETERMINED)) {

                language = lang;

            }

        }

        script = langtag.getScript();

        region = langtag.getRegion();

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

        if (!bcpVariants.isEmpty()) {

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

            int size = bcpVariants.size();

            for (int i = 1; i < size; i++) {

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

            }

            variant = var.toString();

        }

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

        return this;

    }

    public InternalLocaleBuilder setLocale(BaseLocale base, LocaleExtensions localeExtensions) throws LocaleSyntaxException {

        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"

            assert("japanese".equals(localeExtensions.getUnicodeLocaleType("ca")));

            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"

            assert("thai".equals(localeExtensions.getUnicodeLocaleType("nu")));

            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.

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

        }

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

        }

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

        }

            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.

        this.language = language;

        this.script = script;

        this.region = region;

        this.variant = variant;

        clearExtensions();

        Set<Character> extKeys = (localeExtensions == null) ? null : localeExtensions.getKeys();

        if (extKeys != null) {

            // map localeExtensions back to builder's internal format

            for (Character key : extKeys) {

                Extension e = localeExtensions.getExtension(key);

                if (e instanceof UnicodeLocaleExtension) {

                    UnicodeLocaleExtension ue = (UnicodeLocaleExtension)e;

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

                        if (uattributes == null) {

                            uattributes = new HashSet<>(4);

                        }

                        uattributes.add(new CaseInsensitiveString(uatr));

                    }

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

                        if (ukeywords == null) {

                            ukeywords = new HashMap<>(4);

                        }

                        ukeywords.put(new CaseInsensitiveString(ukey), ue.getUnicodeLocaleType(ukey));

                    }

                } else {

                    if (extensions == null) {

                        extensions = new HashMap<>(4);

                    }

                    extensions.put(new CaseInsensitiveChar(key), e.getValue());

                }

            }

        }

        return this;

    }

    public InternalLocaleBuilder clear() {

        language = "";

        script = "";

        region = "";

        variant = "";

        clearExtensions();

        return this;

    }

    public InternalLocaleBuilder clearExtensions() {

        if (extensions != null) {

            extensions.clear();

        }

        if (uattributes != null) {

            uattributes.clear();

        }

        if (ukeywords != null) {

            ukeywords.clear();

        }

        return this;

    }

    public BaseLocale getBaseLocale() {

        String language = this.language;

        String script = this.script;

        String region = this.region;

        String variant = this.variant;

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

        // interpreted as Java variant.

        if (extensions != null) {

            String privuse = extensions.get(PRIVATEUSE_KEY);

            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;

                    }

                    if (LocaleUtils.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) {

                        sawPrefix = true;

                    }

                    itr.next();

                }