//##header
/*
 *******************************************************************************
 * Copyright (C) 2004-2006, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
*/
package com.ibm.icu.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

//#ifndef FOUNDATION
import java.util.regex.Matcher;
import java.util.regex.Pattern;
//#endif

import com.ibm.icu.impl.Utility;
import com.ibm.icu.impl.ZoneMeta;
import com.ibm.icu.text.Collator;
import com.ibm.icu.text.DateFormat;
import com.ibm.icu.text.DecimalFormat;
import com.ibm.icu.text.DecimalFormatSymbols;
import com.ibm.icu.text.NumberFormat;
import com.ibm.icu.text.SimpleDateFormat;

/**
 * This convenience class provides a mechanism for bundling together different
 * globalization preferences. It includes:
 * <ul>
 * <li>A list of locales/languages in preference order</li>
 * <li>A territory</li>
 * <li>A currency</li>
 * <li>A timezone</li>
 * <li>A calendar</li>
 * <li>A collator (for language-sensitive sorting, searching, and matching).</li>
 * <li>Explicit overrides for date/time formats, etc.</li>
 * </ul>
 * The class will heuristically compute implicit, heuristic values for the above
 * based on available data if explicit values are not supplied. These implicit
 * values can be presented to users for confirmation, or replacement if the
 * values are incorrect.
 * <p>
 * To reset any explicit field so that it will get heuristic values, pass in
 * null. For example, myPreferences.setLocale(null);
 * <p>
 * All of the heuristics can be customized by subclasses, by overriding
 * getTerritory(), guessCollator(), etc.
 * <p>
 * The class also supplies display names for languages, scripts, territories,
 * currencies, timezones, etc. These are computed according to the
 * locale/language preference list. Thus, if the preference is Breton; French;
 * English, then the display name for a language will be returned in Breton if
 * available, otherwise in French if available, otherwise in English.
 * <p>
 * The codes used to reference territory, currency, etc. are as defined elsewhere in ICU,
 * and are taken from CLDR (which reflects RFC 3066bis usage, ISO 4217, and the 
 * TZ Timezone database identifiers).
 * <p>
 * <b>This is at a prototype stage, and has not incorporated all the design
 * changes that we would like yet; further feedback is welcome.</b></p>
 * <p>
 * TODO:<ul>
 * <li>Separate out base class</li>
 * <li>Add BreakIterator</li>
 * <li>Add Holidays</li>
 * <li>Add convenience to get/take Locale as well as ULocale.</li>
 * <li>Add getResourceBundle(String baseName, ClassLoader loader);</li>
 * <li>Add getFallbackLocales();</li>
 * <li>Add Lenient datetime formatting when that is available.</li>
 * <li>Should this be serializable?</li>
 * <li>Other utilities?</li>
 * </ul>
 * Note:
 * <ul>
 * <li>to get the display name for the first day of the week, use the calendar +
 * display names.</li>
 * <li>to get the work days, ask the calendar (when that is available).</li>
 * <li>to get papersize / measurement system/bidi-orientation, ask the locale
 * (when that is available there)</li>
 * <li>to get the field order in a date, and whether a time is 24hour or not,
 * ask the DateFormat (when that is available there)</li>
 * <li>it will support HOST locale when it becomes available (it is a special
 * locale that will ask the services to use the host platform's values).</li>
 * </ul>
 *
 * @internal
 * @deprecated This API is ICU internal only.
 */
public class GlobalizationPreferences implements Freezable {
    /**
     * Number Format types
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public static final int CURRENCY = 0, NUMBER = 1, INTEGER = 2, SCIENTIFIC = 3, 
        PERCENT = 4, NUMBER_LIMIT = 5;

    /**
     * Supplement to DateFormat.FULL, LONG, MEDIUM, SHORT. Indicates
     * that no value for one of date or time is to be used.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public static final int NONE = 4;

    /**
     * For selecting a choice of display names
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public static final int
        LOCALEID = 0, LANGUAGEID = 1, SCRIPTID = 2, TERRITORYID = 3, VARIANTID = 4, 
        KEYWORDID = 5, KEYWORD_VALUEID = 6,
        CURRENCYID = 7, CURRENCY_SYMBOLID = 8, TIMEZONEID = 9, DISPLAYID_LIMIT = 10;
	
    /**
     * Sets the language/locale priority list. If other information is
     * not (yet) available, this is used to to produce a default value
     * for the appropriate territory, currency, timezone, etc.  The
     * user should be given the opportunity to correct those defaults
     * in case they are incorrect.
     * @param locales list of locales in priority order, eg {"be", "fr"} 
     *     for Breton first, then French if that fails.
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setLocales(List locales) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        if (locales.size() == 0) {
            this.locales = locales.get(0);
        } else {
            this.locales = new ArrayList(locales); // clone for safety
        }
        return this;
    }

    /**
     * Get a copy of the language/locale priority list
     * @return a copy of the language/locale priority list.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public List getLocales() {
        List result = new ArrayList(); // clone for safety
        if (locales == null) {
            result = guessLocales();
        } else if (locales instanceof ULocale) {
            result.add(locales);
        } else {
            result.addAll((List)locales);
        }
        return result;
    }

    /**
     * Convenience function for getting the locales in priority order
     * @param index The index (0..n) of the desired item.
     * @return desired item.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public ULocale getLocale(int index) {
        if (locales == null) {
            return (ULocale)guessLocales().get(index);
        } else if (locales instanceof ULocale) {
            if (index != 0) throw new IllegalArgumentException("Out of bounds: " + index);
            return (ULocale)locales;
        } else {
            return (ULocale)((List)locales).get(index);
        }
    }

    /**
     * Convenience routine for setting the language/locale priority
     * list from an array.
     * @see #setLocales(List locales)
     * @param uLocales list of locales in an array
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setLocales(ULocale[] uLocales) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        return setLocales(Arrays.asList(uLocales));
    }
    /**
     * Convenience routine for setting the language/locale priority
     * list from a single locale/language.
     * @see #setLocales(List locales)
     * @param uLocale single locale
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setLocale(ULocale uLocale) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        return setLocales(new ULocale[]{uLocale});
    }

//#ifndef FOUNDATION
    /**
     * Convenience routine for setting the locale priority list from
     * an Accept-Language string.
     * @see #setLocales(List locales)
     * @param acceptLanguageString Accept-Language list, as defined by 
     *     Section 14.4 of the RFC 2616 (HTTP 1.1)
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setLocales(String acceptLanguageString) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        /*
          Accept-Language = "Accept-Language" ":" 1#( language-range [ ";" "q" "=" qvalue ] )
          x matches x-...
        */
        // reorders in quality order
        // don't care that it is not very efficient right now
        Matcher acceptMatcher = Pattern.compile("\\s*([-_a-zA-Z]+)(;q=([.0-9]+))?\\s*").matcher("");
        Map reorder = new TreeMap();
        String[] pieces = acceptLanguageString.split(",");
		
        for (int i = 0; i < pieces.length; ++i) {
            Double qValue = new Double(1);
            try {
                if (!acceptMatcher.reset(pieces[i]).matches()) {
                    throw new IllegalArgumentException();
                }
                String qValueString = acceptMatcher.group(3);
                if (qValueString != null) qValue = new Double(Double.parseDouble(qValueString));
            } catch (Exception e) {
                throw new IllegalArgumentException("element '" + pieces[i] + 
                    "' is not of the form '<locale>{;q=<number>}");
            }
            List items = (List)reorder.get(qValue);
            if (items == null) reorder.put(qValue, items = new LinkedList());
            items.add(0, acceptMatcher.group(1)); // reverse order, will reverse again
        }
        // now read out in reverse order
        List result = new ArrayList();
        for (Iterator it = reorder.keySet().iterator(); it.hasNext();) {
            Object key = it.next();
            List items = (List)reorder.get(key);
            for (Iterator it2 = items.iterator(); it2.hasNext();) {
                result.add(0, new ULocale((String)it2.next()));
            }
        }
        return setLocales(result);
    }
//#endif

    /**
     * Sets the territory, which is a valid territory according to for
     * RFC 3066 (or successor).  If not otherwise set, default
     * currency and timezone values will be set from this.  The user
     * should be given the opportunity to correct those defaults in
     * case they are incorrect.
     * @param territory code
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setTerritory(String territory) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        this.territory = territory;
        return this;
    }

    /**
     * Gets the territory setting. If it wasn't explicitly set, it is
     * computed from the general locale setting.
     * @return territory code, explicit or implicit.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public String getTerritory() {
        if (territory == null) return guessTerritory();
        return territory; // immutable, so don't need to clone
    }

    /**
     * Sets the currency code. If this has not been set, uses default for territory.
     * @param currency Valid ISO 4217 currency code.
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setCurrency(Currency currency) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        this.currency = currency;
        return this;
    }

    /**
     * Get a copy of the currency computed according to the settings. 
     * @return currency code, explicit or implicit.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public Currency getCurrency() {
        if (currency == null) return guessCurrency();
        return currency; // immutable, so don't have to clone
    }

    /**
     * Sets the calendar. If this has not been set, uses default for territory.
     * @param calendar arbitrary calendar
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setCalendar(Calendar calendar) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        this.calendar = calendar;
        return this;
    }

    /**
     * Get a copy of the calendar according to the settings. 
     * @return calendar explicit or implicit.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public Calendar getCalendar() {
        if (calendar == null) return guessCalendar();
        Calendar temp = (Calendar) calendar.clone(); // clone for safety
        temp.setTimeZone(getTimeZone());
        return temp;
    }

    /**
     * Sets the timezone ID.  If this has not been set, uses default for territory.
     * @param timezone a valid TZID (see UTS#35).
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setTimeZone(TimeZone timezone) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        this.timezone = timezone;
        return this;
    }

    /**
     * Get the timezone. It was either explicitly set, or is
     * heuristically computed from other settings.
     * @return timezone, either implicitly or explicitly set
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public TimeZone getTimeZone() {
        if (timezone == null) return guessTimeZone();
        return (TimeZone) timezone.clone(); // clone for safety
    }
	
    /**
     * Get a copy of the collator according to the settings. 
     * @return collator explicit or implicit.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public Collator getCollator() {
        if (collator == null) return guessCollator();
        try {
            return (Collator) collator.clone();  // clone for safety
        } catch (CloneNotSupportedException e) {
            throw new InternalError("Error in cloning collator");
        }
    }

    /**
     * Explicitly set the collator for this object.
     * @param collator
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setCollator(Collator collator) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        this.collator = collator;
        return this;
    }

    /**
     * Set the date locale. 
     * @param dateLocale If not null, overrides the locale priority list for all the date formats.
     * @return this, for chaining
     */
    public GlobalizationPreferences setDateLocale(ULocale dateLocale) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        this.dateLocale = dateLocale;
        return this;
    }

    /**
     * Gets the date locale, to be used in computing date formats. Overrides the general locale setting.
     * @return date locale. Null if none was set explicitly.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public ULocale getDateLocale() {
        return dateLocale != null ? dateLocale : getLocale(0);
    }
	
    /**
     * Set the number locale. 
     * @param numberLocale If not null, overrides the locale priority list for all the date formats.
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setNumberLocale(ULocale numberLocale) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        this.numberLocale = numberLocale;
        return this;
    }

    /**
     * Get the current number locale setting used for getNumberFormat.
     * @return number locale. Null if none was set explicitly.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public ULocale getNumberLocale() {
        return numberLocale != null ? numberLocale : getLocale(0);
    }
	
    /**
     * Get the display name for an ID: language, script, territory, currency, timezone...
     * Uses the language priority list to do so.
     * @param id language code, script code, ...
     * @param type specifies the type of the ID: LANGUAGE, etc.
     * @return the display name
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public String getDisplayName(String id, int type) {
        String result = id;
        for (Iterator it = getLocales().iterator(); it.hasNext();) {
            ULocale locale = (ULocale) it.next();
            switch (type) {
            case LOCALEID: 
                result = ULocale.getDisplayName(id, locale); 
                break;
            case LANGUAGEID: 
                result = ULocale.getDisplayLanguage(id, locale); 
                break;
            case SCRIPTID: 
                result = ULocale.getDisplayScript("und-" + id, locale); 
                break;
            case TERRITORYID: 
                result = ULocale.getDisplayCountry("und-" + id, locale); 
                break;
            case VARIANTID: 
                // TODO fix variant parsing
                result = ULocale.getDisplayVariant("und-QQ-" + id, locale); 
                break;
            case KEYWORDID: 
                result = ULocale.getDisplayKeyword(id, locale); 
                break;
            case KEYWORD_VALUEID:
                String[] parts = new String[2];
                Utility.split(id,'=',parts);
                result = ULocale.getDisplayKeywordValue("und@"+id, parts[0], locale);
                // TODO fix to tell when successful
                if (result.equals(parts[1])) continue;
                break;
            case CURRENCY_SYMBOLID:
            case CURRENCYID:
                Currency temp = new Currency(id);
                result =temp.getName(locale, type==CURRENCYID 
                                     ? Currency.LONG_NAME 
                                     : Currency.SYMBOL_NAME, new boolean[1]);
                // TODO: have method that doesn't take parameter. Add
                // function to determine whether string is choice
                // format.  
                // TODO: have method that doesn't require us
                // to create a currency
                break;
            case TIMEZONEID:
                SimpleDateFormat dtf = new SimpleDateFormat("vvvv",locale);
                dtf.setTimeZone(TimeZone.getTimeZone(id));
                result = dtf.format(new Date());
                // TODO, have method that doesn't require us to create a timezone
                // fix other hacks
                // hack for couldn't match
                // note, compiling with FOUNDATION omits this check for now
//#ifndef FOUNDATION
                if (badTimeZone.reset(result).matches()) continue;
//#endif
                break;
            default:
                throw new IllegalArgumentException("Unknown type: " + type);
            }
            if (!id.equals(result)) return result;
            // TODO need better way of seeing if we fell back to root!!
            // This will not work at all for lots of stuff
        }
        return result;
    }
//#ifndef FOUNDATION
    // TODO remove need for this
    private static final Matcher badTimeZone = Pattern.compile("[A-Z]{2}|.*\\s\\([A-Z]{2}\\)").matcher("");
//#endif


    /**
     * Set an explicit date format. Overrides both the date locale,
     * and the locale priority list for a particular combination of
     * dateStyle and timeStyle. NONE should be used if for the style,
     * where only the date or time format individually is being set.
     * @param dateStyle NONE, or DateFormat.FULL, LONG, MEDIUM, SHORT
     * @param timeStyle NONE, or DateFormat.FULL, LONG, MEDIUM, SHORT
     * @param format
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setDateFormat(int dateStyle, int timeStyle, DateFormat format) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        if (dateFormats == null) dateFormats = new Object[NONE+1][NONE+1];
        dateFormats[dateStyle][timeStyle] = (DateFormat) format.clone(); // for safety
        return this;
    }
	
    /**
     * Set an explicit date format. Overrides both the date locale,
     * and the locale priority list for a particular combination of
     * dateStyle and timeStyle. NONE should be used if for the style,
     * where only the date or time format individually is being set.
     * @param dateStyle NONE, or DateFormat.FULL, LONG, MEDIUM, SHORT
     * @param timeStyle NONE, or DateFormat.FULL, LONG, MEDIUM, SHORT
     * @param formatPattern date pattern, eg "yyyy-MMM-dd"
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setDateFormat(int dateStyle, int timeStyle, String formatPattern) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        if (dateFormats == null) dateFormats = new Object[NONE+1][NONE+1];
        // test the format to make sure it won't throw an error later
        new SimpleDateFormat(formatPattern, getDateLocale());
        dateFormats[dateStyle][timeStyle] = formatPattern; // for safety
        return this;
    }

    /**
     * Gets a date format according to the current settings. If there
     * is an explicit (non-null) date/time format set, a copy of that
     * is returned. Otherwise, if there is a non-null date locale,
     * that is used.  Otherwise, the language priority list is
     * used. NONE should be used for the style, where only the date or
     * time format individually is being gotten.
     * @param dateStyle NONE, or DateFormat.FULL, LONG, MEDIUM, SHORT
     * @param timeStyle NONE, or DateFormat.FULL, LONG, MEDIUM, SHORT
     * @return a DateFormat, according to the above description
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public DateFormat getDateFormat(int dateStyle, int timeStyle) {
        try {
            DateFormat result = null;
            if (dateFormats != null) { // and override can either be a string or a pattern
                Object temp = dateFormats[dateStyle][timeStyle];
                if (temp instanceof DateFormat) {
                    result = (DateFormat) temp;
                } else {
                    result = new SimpleDateFormat((String)temp, getDateLocale());
                }	
            }
            if (result != null) {
                result = (DateFormat) result.clone(); // clone for safety
                result.setCalendar(getCalendar());
            } else {
                // In the case of date formats, we don't have to look at more than one
                // locale. May be different for other cases
                // TODO Make this one function.
                if (timeStyle == NONE) {
                    result = DateFormat.getDateInstance(getCalendar(), dateStyle, getDateLocale());
                } else if (dateStyle == NONE) {
                    result = DateFormat.getTimeInstance(getCalendar(), timeStyle, getDateLocale());
                } else {
                    result = DateFormat.getDateTimeInstance(getCalendar(), dateStyle, timeStyle, getDateLocale());
                }
            }
            return result;
        } catch (RuntimeException e) {
            IllegalArgumentException ex = new IllegalArgumentException("Cannot create DateFormat");
//#ifndef FOUNDATION
            ex.initCause(e);
//#endif
            throw ex;
        }
    }
	
    /**
     * Gets a number format according to the current settings.  If
     * there is an explicit (non-null) number format set, a copy of
     * that is returned. Otherwise, if there is a non-null number
     * locale, that is used.  Otherwise, the language priority list is
     * used. NONE should be used for the style, where only the date or
     * time format individually is being gotten.
     * @param style CURRENCY, NUMBER, INTEGER, SCIENTIFIC, PERCENT
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public NumberFormat getNumberFormat(int style) {
        try {
            NumberFormat result = null;
            if (numberFormats != null) {
                Object temp = numberFormats[style];
                if (temp instanceof NumberFormat) {
                    result = (NumberFormat) temp;
                } else {
                    result = new DecimalFormat((String)temp, new DecimalFormatSymbols(getDateLocale()));
                }	
            }
            if (result != null) {
                result = (NumberFormat) result.clone(); // clone for safety (later optimize)
                if (style == CURRENCY) {
                    result.setCurrency(getCurrency());
                }
                return result; 
            }
            // In the case of date formats, we don't have to look at more than one
            // locale. May be different for other cases
            switch (style) {
            case NUMBER: return NumberFormat.getInstance(getNumberLocale());
            case SCIENTIFIC: return NumberFormat.getScientificInstance(getNumberLocale());
            case INTEGER: return NumberFormat.getIntegerInstance(getNumberLocale());
            case PERCENT: return NumberFormat.getPercentInstance(getNumberLocale());
            case CURRENCY: result = NumberFormat.getCurrencyInstance(getNumberLocale());
                result.setCurrency(getCurrency());
                return result;
            }
        } catch (RuntimeException e) {}
        throw new IllegalArgumentException(); // fix later
    }
	
    /**
     * Sets a number format explicitly. Overrides the number locale
     * and the general locale settings.
     * @param style CURRENCY, NUMBER, INTEGER, SCIENTIFIC, PERCENT
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setNumberFormat(int style, DateFormat format) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        if (numberFormats == null) numberFormats = new Object[NUMBER_LIMIT];
        numberFormats[style] = (NumberFormat) format.clone(); // for safety
        return this;
    }
	
    /**
     * Sets a number format explicitly. Overrides the number locale
     * and the general locale settings.
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences setNumberFormat(int style, String formatPattern) {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        if (numberFormats == null) numberFormats = new Object[NUMBER_LIMIT];
        // check to make sure it compiles
        new DecimalFormat((String)formatPattern, new DecimalFormatSymbols(getDateLocale()));
        numberFormats[style] = formatPattern; // for safety
        return this;
    }

    /**
     * Restore the object to the initial state.
     * @return this, for chaining
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public GlobalizationPreferences reset() {
        if (isFrozen()) {
            throw new UnsupportedOperationException("Attempt to modify immutable object");
        }
        territory = null;
        calendar = null;
        collator = null;
        timezone = null;
        currency = null;
        dateFormats = null;
        numberFormats = null;
        dateLocale = null;
        numberLocale = null;
        locales = null;
        return this;
    }
	
    /**
     * This function can be overridden by subclasses to use different heuristics.
     * @internal
     * @deprecated This API is ICU internal only.
     */
    protected String guessTerritory() {
        String result;
        // pass through locales to see if there is a territory.
        for (Iterator it = getLocales().iterator(); it.hasNext();) {
            ULocale locale = (ULocale)it.next();
            result = locale.getCountry();
            if (result.length() != 0) {
                return result;
            }
        }
        // if not, guess from the first language tag, or maybe from
        // intersection of languages, eg nl + fr => BE
        // TODO: fix using real data
        // for now, just use fixed values
        ULocale firstLocale = getLocale(0);
        String language = firstLocale.getLanguage();
        String script = firstLocale.getScript();
        result = null;
        if (script.length() != 0) {
            result = (String) language_territory_hack_map.get(language + "_" + script);
        }
        if (result == null) result = (String) language_territory_hack_map.get(language);
        if (result == null) result = "US"; // need *some* default
        return result;
    }

    /**
     * This function can be overridden by subclasses to use different heuristics
     * @internal
     * @deprecated This API is ICU internal only.
     */
    protected Currency guessCurrency() {
        return Currency.getInstance(new ULocale("und-" + getTerritory()));
    }

    /**
     * This function can be overridden by subclasses to use different heuristics
     * <b>It MUST return a 'safe' value,
     * one whose modification will not affect this object.</b>
     * @internal
     * @deprecated This API is ICU internal only.
     */
    protected List guessLocales() {
        List result = new ArrayList(0);
        result.add(ULocale.getDefault());
        return result;
    }

    /**
     * This function can be overridden by subclasses to use different heuristics.
     * <b>It MUST return a 'safe' value,
     * one whose modification will not affect this object.</b>
     * @internal
     * @deprecated This API is ICU internal only.
     */
    protected Collator guessCollator() {
        return Collator.getInstance(getLocale(0));
    }

    /**
     * This function can be overridden by subclasses to use different heuristics.
     * <b>It MUST return a 'safe' value,
     * one whose modification will not affect this object.</b>
     * @internal
     * @deprecated This API is ICU internal only.
     */
    protected TimeZone guessTimeZone() {
        // TODO fix using real data
        // for single-zone countries, pick that zone
        // for others, pick the most populous zone
        // for now, just use fixed value
        // NOTE: in a few cases can do better by looking at language. 
        // Eg haw+US should go to Pacific/Honolulu
        // fr+CA should go to America/Montreal
        String timezoneString = (String) territory_tzid_hack_map.get(getTerritory());
        if (timezoneString == null) {
            String[] attempt = ZoneMeta.getAvailableIDs(getTerritory());
            if (attempt.length == 0) {
                timezoneString = "Etc/GMT"; // gotta do something
            } else {
                int i;
                // this all needs to be fixed to use real data. But for now, do slightly better by skipping cruft
                for (i = 0; i < attempt.length; ++i) {
                    if (attempt[i].indexOf("/") >= 0) break;
                }
                if (i > attempt.length) i = 0;
                timezoneString = attempt[i];
            }
        }
        return TimeZone.getTimeZone(timezoneString);
    }

    /**
     * This function can be overridden by subclasses to use different heuristics.
     * <b>It MUST return a 'safe' value,
     * one whose modification will not affect this object.</b>
     * @internal
     * @deprecated This API is ICU internal only.
     */
    protected Calendar guessCalendar() {
        // TODO add better API
        return Calendar.getInstance(new ULocale("und-" + getTerritory()));
    }
	
    // PRIVATES
	
    private Object locales;
    private String territory;
    private Currency currency;
    private TimeZone timezone;
    private Calendar calendar;
    private Collator collator;
	
    private ULocale dateLocale;
    private Object[][] dateFormats;
    private ULocale numberLocale;
    private Object[] numberFormats;
	
    {
        reset();
    }
	
    /** WARNING: All of this data is temporary, until we start importing from CLDR!!!
     * 
     */
    private static final Map language_territory_hack_map = new HashMap();
    private static final String[][] language_territory_hack = {
        {"af", "ZA"},
        {"am", "ET"},
        {"ar", "SA"},
        {"as", "IN"},
        {"ay", "PE"},
        {"az", "AZ"},
        {"bal", "PK"},
        {"be", "BY"},
        {"bg", "BG"},
        {"bn", "IN"},
        {"bs", "BA"},
        {"ca", "ES"},
        {"ch", "MP"},
        {"cpe", "SL"},
        {"cs", "CZ"},
        {"cy", "GB"},
        {"da", "DK"},
        {"de", "DE"},
        {"dv", "MV"},
        {"dz", "BT"},
        {"el", "GR"},
        {"en", "US"},
        {"es", "ES"},
        {"et", "EE"},
        {"eu", "ES"},
        {"fa", "IR"},
        {"fi", "FI"},
        {"fil", "PH"},
        {"fj", "FJ"},
        {"fo", "FO"},
        {"fr", "FR"},
        {"ga", "IE"},
        {"gd", "GB"},
        {"gl", "ES"},
        {"gn", "PY"},
        {"gu", "IN"},
        {"gv", "GB"},
        {"ha", "NG"},
        {"he", "IL"},
        {"hi", "IN"},
        {"ho", "PG"},
        {"hr", "HR"},
        {"ht", "HT"},
        {"hu", "HU"},
        {"hy", "AM"},
        {"id", "ID"},
        {"is", "IS"},
        {"it", "IT"},
        {"ja", "JP"},
        {"ka", "GE"},
        {"kk", "KZ"},
        {"kl", "GL"},
        {"km", "KH"},
        {"kn", "IN"},
        {"ko", "KR"},
        {"kok", "IN"},
        {"ks", "IN"},
        {"ku", "TR"},
        {"ky", "KG"},
        {"la", "VA"},
        {"lb", "LU"},
        {"ln", "CG"},
        {"lo", "LA"},
        {"lt", "LT"},
        {"lv", "LV"},
        {"mai", "IN"},
        {"men", "GN"},
        {"mg", "MG"},
        {"mh", "MH"},
        {"mk", "MK"},
        {"ml", "IN"},
        {"mn", "MN"},
        {"mni", "IN"},
        {"mo", "MD"},
        {"mr", "IN"},
        {"ms", "MY"},
        {"mt", "MT"},
        {"my", "MM"},
        {"na", "NR"},
        {"nb", "NO"},
        {"nd", "ZA"},
        {"ne", "NP"},
        {"niu", "NU"},
        {"nl", "NL"},
        {"nn", "NO"},
        {"no", "NO"},
        {"nr", "ZA"},
        {"nso", "ZA"},
        {"ny", "MW"},
        {"om", "KE"},
        {"or", "IN"},
        {"pa", "IN"},
        {"pau", "PW"},
        {"pl", "PL"},
        {"ps", "PK"},
        {"pt", "BR"},
        {"qu", "PE"},
        {"rn", "BI"},
        {"ro", "RO"},
        {"ru", "RU"},
        {"rw", "RW"},
        {"sd", "IN"},
        {"sg", "CF"},
        {"si", "LK"},
        {"sk", "SK"},
        {"sl", "SI"},
        {"sm", "WS"},
        {"so", "DJ"},
        {"sq", "CS"},
        {"sr", "CS"},
        {"ss", "ZA"},
        {"st", "ZA"},
        {"sv", "SE"},
        {"sw", "KE"},
        {"ta", "IN"},
        {"te", "IN"},
        {"tem", "SL"},
        {"tet", "TL"},
        {"th", "TH"},
        {"ti", "ET"},
        {"tg", "TJ"},
        {"tk", "TM"},
        {"tkl", "TK"},
        {"tvl", "TV"},
        {"tl", "PH"},
        {"tn", "ZA"},
        {"to", "TO"},
        {"tpi", "PG"},
        {"tr", "TR"},
        {"ts", "ZA"},
        {"uk", "UA"},
        {"ur", "IN"},
        {"uz", "UZ"},
        {"ve", "ZA"},
        {"vi", "VN"},
        {"wo", "SN"},
        {"xh", "ZA"},
        {"zh", "CN"},
        {"zh_Hant", "TW"},
        {"zu", "ZA"},
        {"aa", "ET"},
        {"byn", "ER"},
        {"eo", "DE"},
        {"gez", "ET"},
        {"haw", "US"},
        {"iu", "CA"},
        {"kw", "GB"},
        {"sa", "IN"},
        {"sh", "HR"},
        {"sid", "ET"},
        {"syr", "SY"},
        {"tig", "ER"},
        {"tt", "RU"},
        {"wal", "ET"},	};
    static {
        for (int i = 0; i < language_territory_hack.length; ++i) {
            language_territory_hack_map.put(language_territory_hack[i][0],language_territory_hack[i][1]);
        }
    }
	
    static final Map territory_tzid_hack_map = new HashMap();
    static final String[][] territory_tzid_hack = {
        {"AQ", "Antarctica/McMurdo"},
        {"AR", "America/Buenos_Aires"},
        {"AU", "Australia/Sydney"},
        {"BR", "America/Sao_Paulo"},
        {"CA", "America/Toronto"},
        {"CD", "Africa/Kinshasa"},
        {"CL", "America/Santiago"},
        {"CN", "Asia/Shanghai"},
        {"EC", "America/Guayaquil"},
        {"ES", "Europe/Madrid"},
        {"GB", "Europe/London"},
        {"GL", "America/Godthab"},
        {"ID", "Asia/Jakarta"},
        {"ML", "Africa/Bamako"},
        {"MX", "America/Mexico_City"},
        {"MY", "Asia/Kuala_Lumpur"},
        {"NZ", "Pacific/Auckland"},
        {"PT", "Europe/Lisbon"},
        {"RU", "Europe/Moscow"},
        {"UA", "Europe/Kiev"},
        {"US", "America/New_York"},
        {"UZ", "Asia/Tashkent"},
        {"PF", "Pacific/Tahiti"},
        {"FM", "Pacific/Kosrae"},
        {"KI", "Pacific/Tarawa"},
        {"KZ", "Asia/Almaty"},
        {"MH", "Pacific/Majuro"},
        {"MN", "Asia/Ulaanbaatar"},
        {"SJ", "Arctic/Longyearbyen"},
        {"UM", "Pacific/Midway"},	
    };
    static {
        for (int i = 0; i < territory_tzid_hack.length; ++i) {
            territory_tzid_hack_map.put(territory_tzid_hack[i][0],territory_tzid_hack[i][1]);
        }
    }

    private boolean frozen;

    /**
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public boolean isFrozen() {
        return frozen;
    }

    /**
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public Object freeze() {
        frozen = true;
        return this;
    }

    /**
     * @internal
     * @deprecated This API is ICU internal only.
     */
    public Object cloneAsThawed() {
        try {
            GlobalizationPreferences result = (GlobalizationPreferences) clone();
            result.frozen = false;
            return result;
        } catch (CloneNotSupportedException e) {
            // will always work
            return null;
        }
    }
}