/*

 * Copyright (c) 2012, 2019, 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.

 */

package sun.util.locale.provider;

import java.lang.ref.SoftReference;

import java.text.DateFormat;

import java.text.DateFormatSymbols;

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

import java.text.NumberFormat;

import java.text.SimpleDateFormat;

import java.text.spi.DateFormatProvider;

import java.text.spi.DateFormatSymbolsProvider;

import java.text.spi.DecimalFormatSymbolsProvider;

import java.text.spi.NumberFormatProvider;

import java.util.Calendar;

import java.util.Collections;

import java.util.Currency;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Locale;

import java.util.Map;

import java.util.ResourceBundle.Control;

import java.util.Set;

import java.util.TimeZone;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import java.util.concurrent.atomic.AtomicReferenceArray;

import java.util.spi.CalendarDataProvider;

import java.util.spi.CalendarNameProvider;

import java.util.spi.CurrencyNameProvider;

import java.util.spi.LocaleNameProvider;

import sun.text.spi.JavaTimeDateTimePatternProvider;

import sun.util.spi.CalendarProvider;

/**

 * LocaleProviderdapter implementation for the Windows locale data.

 *

 * @author Naoto Sato

 */

public class HostLocaleProviderAdapterImpl {

    // locale categories

    private static final int CAT_DISPLAY = 0;

    private static final int CAT_FORMAT  = 1;

    // NumberFormat styles

    private static final int NF_NUMBER   = 0;

    private static final int NF_CURRENCY = 1;

    private static final int NF_PERCENT  = 2;

    private static final int NF_INTEGER  = 3;

    private static final int NF_MAX = NF_INTEGER;

    // CalendarData value types

    private static final int CD_FIRSTDAYOFWEEK = 0;

    private static final int CD_MINIMALDAYSINFIRSTWEEK = 1;

    // Currency/Locale display name types

    private static final int DN_CURRENCY_NAME   = 0;

    private static final int DN_CURRENCY_SYMBOL = 1;

    private static final int DN_LOCALE_LANGUAGE = 2;

    private static final int DN_LOCALE_SCRIPT   = 3;

    private static final int DN_LOCALE_REGION   = 4;

    private static final int DN_LOCALE_VARIANT  = 5;

    // Windows Calendar IDs

    private static final int CAL_JAPAN  = 3;

    // Native Calendar ID to LDML calendar type map

    private static final String[] calIDToLDML = {

        "",

        "gregory",

        "gregory_en-US",

        "japanese",

        "roc",

        "",          // No appropriate type for CAL_KOREA

        "islamic",

        "buddhist",

        "hebrew",

        "gregory_fr",

        "gregory_ar",

        "gregory_en",

        "gregory_fr", "", "", "", "", "", "", "", "", "", "",

        "islamic-umalqura",

    };

    // Caches

    private static final ConcurrentMap<Locale, SoftReference<AtomicReferenceArray<String>>> dateFormatCache = new ConcurrentHashMap<>();

    private static final ConcurrentMap<Locale, SoftReference<DateFormatSymbols>> dateFormatSymbolsCache = new ConcurrentHashMap<>();

    private static final ConcurrentMap<Locale, SoftReference<AtomicReferenceArray<String>>> numberFormatCache = new ConcurrentHashMap<>();

    private static final ConcurrentMap<Locale, SoftReference<DecimalFormatSymbols>> decimalFormatSymbolsCache = new ConcurrentHashMap<>();

    private static final Set<Locale> supportedLocaleSet;

    private static final String nativeDisplayLanguage;

    static {

        Set<Locale> tmpSet = new HashSet<>();

        if (initialize()) {

            // Assuming the default locales do not include any extensions, so

            // no stripping is needed here.

            Control c = Control.getNoFallbackControl(Control.FORMAT_DEFAULT);

            String displayLocale = getDefaultLocale(CAT_DISPLAY);

            Locale l = Locale.forLanguageTag(displayLocale.replace('_', '-'));

            tmpSet.addAll(c.getCandidateLocales("", l));

            nativeDisplayLanguage = l.getLanguage();

            String formatLocale = getDefaultLocale(CAT_FORMAT);

            if (!formatLocale.equals(displayLocale)) {

                l = Locale.forLanguageTag(formatLocale.replace('_', '-'));

                tmpSet.addAll(c.getCandidateLocales("", l));

            }

        } else {

            nativeDisplayLanguage = "";

        }

        supportedLocaleSet = Collections.unmodifiableSet(tmpSet);

    }

    private static final Locale[] supportedLocale = supportedLocaleSet.toArray(new Locale[0]);

    public static DateFormatProvider getDateFormatProvider() {

        return new DateFormatProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return getSupportedCalendarLocales();

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return isSupportedCalendarLocale(locale);

            }

            @Override

            public DateFormat getDateInstance(int style, Locale locale) {

                AtomicReferenceArray<String> patterns = getDateTimePatterns(locale);

                return new SimpleDateFormat(patterns.get(style/2),

                                            getCalendarLocale(locale));

            }

            @Override

            public DateFormat getTimeInstance(int style, Locale locale) {

                AtomicReferenceArray<String> patterns = getDateTimePatterns(locale);

                return new SimpleDateFormat(patterns.get(style/2+2),

                                            getCalendarLocale(locale));

            }

            @Override

            public DateFormat getDateTimeInstance(int dateStyle,

                    int timeStyle, Locale locale) {

                AtomicReferenceArray<String> patterns = getDateTimePatterns(locale);

                String pattern = new StringBuilder(patterns.get(dateStyle/2))

                                       .append(" ")

                                       .append(patterns.get(timeStyle/2+2))

                                       .toString();

                return new SimpleDateFormat(pattern, getCalendarLocale(locale));

            }

            private AtomicReferenceArray<String> getDateTimePatterns(Locale locale) {

                AtomicReferenceArray<String> patterns;

                SoftReference<AtomicReferenceArray<String>> ref = dateFormatCache.get(locale);

                if (ref == null || (patterns = ref.get()) == null) {

                    String langtag = removeExtensions(locale).toLanguageTag();

                    patterns = new AtomicReferenceArray<>(4);

                    patterns.compareAndSet(0, null, convertDateTimePattern(

                        getDateTimePattern(DateFormat.LONG, -1, langtag)));

                    patterns.compareAndSet(1, null, convertDateTimePattern(

                        getDateTimePattern(DateFormat.SHORT, -1, langtag)));

                    patterns.compareAndSet(2, null, convertDateTimePattern(

                        getDateTimePattern(-1, DateFormat.LONG, langtag)));

                    patterns.compareAndSet(3, null, convertDateTimePattern(

                        getDateTimePattern(-1, DateFormat.SHORT, langtag)));

                    ref = new SoftReference<>(patterns);

                    dateFormatCache.put(locale, ref);

                }

                return patterns;

            }

        };

    }

    public static DateFormatSymbolsProvider getDateFormatSymbolsProvider() {

        return new DateFormatSymbolsProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return getSupportedCalendarLocales();

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return isSupportedCalendarLocale(locale);

            }

            @Override

            public DateFormatSymbols getInstance(Locale locale) {

                DateFormatSymbols dfs;

                SoftReference<DateFormatSymbols> ref =

                    dateFormatSymbolsCache.get(locale);

                if (ref == null || (dfs = ref.get()) == null) {

                    dfs = new DateFormatSymbols(locale);

                    String langTag = removeExtensions(locale).toLanguageTag();

                    dfs.setAmPmStrings(getAmPmStrings(langTag, dfs.getAmPmStrings()));

                    dfs.setEras(getEras(langTag, dfs.getEras()));

                    dfs.setMonths(getMonths(langTag, dfs.getMonths()));

                    dfs.setShortMonths(getShortMonths(langTag, dfs.getShortMonths()));

                    dfs.setWeekdays(getWeekdays(langTag, dfs.getWeekdays()));

                    dfs.setShortWeekdays(getShortWeekdays(langTag, dfs.getShortWeekdays()));

                    ref = new SoftReference<>(dfs);

                    dateFormatSymbolsCache.put(locale, ref);

                }

                return (DateFormatSymbols)dfs.clone();

            }

        };

    }

    public static NumberFormatProvider getNumberFormatProvider() {

        return new NumberFormatProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return getSupportedNativeDigitLocales();

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return isSupportedNativeDigitLocale(locale);

            }

            @Override

            public NumberFormat getCurrencyInstance(Locale locale) {

                AtomicReferenceArray<String> patterns = getNumberPatterns(locale);

                return new DecimalFormat(patterns.get(NF_CURRENCY),

                    DecimalFormatSymbols.getInstance(locale));

            }

            @Override

            public NumberFormat getIntegerInstance(Locale locale) {

                AtomicReferenceArray<String> patterns = getNumberPatterns(locale);

                    DecimalFormatSymbols.getInstance(locale));

            }

            @Override

            public NumberFormat getNumberInstance(Locale locale) {

                AtomicReferenceArray<String> patterns = getNumberPatterns(locale);

                return new DecimalFormat(patterns.get(NF_NUMBER),

                    DecimalFormatSymbols.getInstance(locale));

            }

            @Override

            public NumberFormat getPercentInstance(Locale locale) {

                AtomicReferenceArray<String> patterns = getNumberPatterns(locale);

                return new DecimalFormat(patterns.get(NF_PERCENT),

                    DecimalFormatSymbols.getInstance(locale));

            }

            private AtomicReferenceArray<String> getNumberPatterns(Locale locale) {

                AtomicReferenceArray<String> patterns;

                SoftReference<AtomicReferenceArray<String>> ref = numberFormatCache.get(locale);

                if (ref == null || (patterns = ref.get()) == null) {

                    String langtag = locale.toLanguageTag();

                    patterns = new AtomicReferenceArray<>(NF_MAX+1);

                    for (int i = 0; i <= NF_MAX; i++) {

                        patterns.compareAndSet(i, null, getNumberPattern(i, langtag));

                    }

                    ref = new SoftReference<>(patterns);

                    numberFormatCache.put(locale, ref);

                }

                return patterns;

            }

        };

    }

    public static DecimalFormatSymbolsProvider getDecimalFormatSymbolsProvider() {

        return new DecimalFormatSymbolsProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return getSupportedNativeDigitLocales();

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return isSupportedNativeDigitLocale(locale);

            }

            @Override

            public DecimalFormatSymbols getInstance(Locale locale) {

                DecimalFormatSymbols dfs;

                SoftReference<DecimalFormatSymbols> ref =

                    decimalFormatSymbolsCache.get(locale);

                if (ref == null || (dfs = ref.get()) == null) {

                    dfs = new DecimalFormatSymbols(getNumberLocale(locale));

                    String langTag = removeExtensions(locale).toLanguageTag();

                    // DecimalFormatSymbols.setInternationalCurrencySymbol() has

                    // a side effect of setting the currency symbol as well. So

                    // the calling order is relevant here.

                    dfs.setInternationalCurrencySymbol(getInternationalCurrencySymbol(langTag, dfs.getInternationalCurrencySymbol()));

                    dfs.setCurrencySymbol(getCurrencySymbol(langTag, dfs.getCurrencySymbol()));

                    dfs.setDecimalSeparator(getDecimalSeparator(langTag, dfs.getDecimalSeparator()));

                    dfs.setGroupingSeparator(getGroupingSeparator(langTag, dfs.getGroupingSeparator()));

                    dfs.setInfinity(getInfinity(langTag, dfs.getInfinity()));

                    dfs.setMinusSign(getMinusSign(langTag, dfs.getMinusSign()));

                    dfs.setMonetaryDecimalSeparator(getMonetaryDecimalSeparator(langTag, dfs.getMonetaryDecimalSeparator()));

                    dfs.setNaN(getNaN(langTag, dfs.getNaN()));

                    dfs.setPercent(getPercent(langTag, dfs.getPercent()));

                    dfs.setPerMill(getPerMill(langTag, dfs.getPerMill()));

                    dfs.setZeroDigit(getZeroDigit(langTag, dfs.getZeroDigit()));

                    ref = new SoftReference<>(dfs);

                    decimalFormatSymbolsCache.put(locale, ref);

                }

                return (DecimalFormatSymbols)dfs.clone();

            }

        };

    }

    public static CalendarDataProvider getCalendarDataProvider() {

        return new CalendarDataProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return getSupportedCalendarLocales();

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return isSupportedCalendarLocale(locale);

            }

            @Override

            public int getFirstDayOfWeek(Locale locale) {

                int first = getCalendarDataValue(

                                 removeExtensions(locale).toLanguageTag(),

                                 CD_FIRSTDAYOFWEEK);

                if (first != -1) {

                    return (first + 1) % 7 + 1;

                } else {

                    return 0;

                }

            }

            @Override

            public int getMinimalDaysInFirstWeek(Locale locale) {

                return 0;

            }

        };

    }

    public static CalendarNameProvider getCalendarNameProvider() {

        return new CalendarNameProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return getSupportedCalendarLocales();

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return isSupportedCalendarLocale(locale);

            }

            @Override

            public String getDisplayName(String calendarType, int field,

                int value, int style, Locale locale) {

                String[] names = getCalendarDisplayStrings(removeExtensions(locale).toLanguageTag(),

                            getCalendarIDFromLDMLType(calendarType), field, style);

                if (names != null && value >= 0 && value < names.length) {

                    return names[value];

                } else {

                    return null;

                }

            }

            @Override

            public Map<String, Integer> getDisplayNames(String calendarType,

                int field, int style, Locale locale) {

                Map<String, Integer> map = null;

                String[] names = getCalendarDisplayStrings(removeExtensions(locale).toLanguageTag(),

                            getCalendarIDFromLDMLType(calendarType), field, style);

                if (names != null) {

                    map = new HashMap<>();

                    for (int value = 0; value < names.length; value++) {

                        if (names[value] != null) {

                            map.put(names[value], value);

                        }

                    }

                    map = map.isEmpty() ? null : map;

                }

                return map;

            }

        };

    }

    public static CalendarProvider getCalendarProvider() {

        return new CalendarProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return getSupportedCalendarLocales();

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return isSupportedCalendarLocale(locale);

            }

            @Override

            public Calendar getInstance(TimeZone zone, Locale locale) {

                return new Calendar.Builder()

                             .setLocale(getCalendarLocale(locale))

                             .setTimeZone(zone)

                             .setInstant(System.currentTimeMillis())

                             .build();

            }

        };

    }

    public static CurrencyNameProvider getCurrencyNameProvider() {

        return new CurrencyNameProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return supportedLocale;

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                // Ignore the extensions for now

                return supportedLocaleSet.contains(locale.stripExtensions()) &&

                       locale.getLanguage().equals(nativeDisplayLanguage);

            }

            @Override

            public String getSymbol(String currencyCode, Locale locale) {

                // Retrieves the currency symbol by calling

                // GetLocaleInfoEx(LOCALE_SCURRENCY).

                // It only works with the "locale"'s currency in its native

                // language.

                try {

                    if (Currency.getInstance(locale).getCurrencyCode()

                        .equals(currencyCode)) {

                        return getDisplayString(locale.toLanguageTag(),

                                DN_CURRENCY_SYMBOL, currencyCode);

                    }

                } catch (IllegalArgumentException iae) {}

                return null;

            }

            @Override

            public String getDisplayName(String currencyCode, Locale locale) {

                // Retrieves the display name by calling

                // GetLocaleInfoEx(LOCALE_SNATIVECURRNAME).

                // It only works with the "locale"'s currency in its native

                // language.

                try {

                    if (Currency.getInstance(locale).getCurrencyCode()

                        .equals(currencyCode)) {

                        return getDisplayString(locale.toLanguageTag(),

                                DN_CURRENCY_NAME, currencyCode);

                    }

                } catch (IllegalArgumentException iae) {}

                return null;

            }

        };

    }

    public static LocaleNameProvider getLocaleNameProvider() {

        return new LocaleNameProvider() {

            @Override

            public Locale[] getAvailableLocales() {

                return supportedLocale;

            }

            @Override

            public boolean isSupportedLocale(Locale locale) {

                return supportedLocaleSet.contains(locale.stripExtensions()) &&

                       locale.getLanguage().equals(nativeDisplayLanguage);

            }

            @Override

            public String getDisplayLanguage(String languageCode, Locale locale) {

                // Retrieves the display language name by calling

                // GetLocaleInfoEx(LOCALE_SLOCALIZEDLANGUAGENAME).

                return getDisplayString(locale.toLanguageTag(),

                            DN_LOCALE_LANGUAGE, languageCode);

            }

            @Override

            public String getDisplayCountry(String countryCode, Locale locale) {

                // Retrieves the display country name by calling