/**
 *******************************************************************************
 * Copyright (C) 2001-2012, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */
package com.ibm.icu.util;

import java.io.Serializable;
import java.util.Locale;

import com.ibm.icu.util.ULocale.Category;

/**
 * A class encapsulating a currency, as defined by ISO 4217.  A
 * <tt>Currency</tt> object can be created given a <tt>Locale</tt> or
 * given an ISO 4217 code.  Once created, the <tt>Currency</tt> object
 * can return various data necessary to its proper display:
 *
 * <ul><li>A display symbol, for a specific locale
 * <li>The number of fraction digits to display
 * <li>A rounding increment
 * </ul>
 *
 * The <tt>DecimalFormat</tt> class uses these data to display
 * currencies.
 *
 * <p>Note: This class deliberately resembles
 * <tt>java.util.Currency</tt> but it has a completely independent
 * implementation, and adds features not present in the JDK.
 * @author Alan Liu
 * @stable ICU 2.2
 */
public class Currency implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * @internal
     */
    public final java.util.Currency currency;

    /**
     * @internal
     * @param delegate the NumberFormat to which to delegate
     */
    public Currency(java.util.Currency delegate) {
        this.currency = delegate;
    }

    /**
     * Selector for getName() indicating a symbolic name for a
     * currency, such as "$" for USD.
     * @stable ICU 2.6
     */
    public static final int SYMBOL_NAME = 0;

    /**
     * Selector for ucurr_getName indicating the long name for a
     * currency, such as "US Dollar" for USD.
     * @stable ICU 2.6
     */
    public static final int LONG_NAME = 1;
   
    /**
     * Selector for getName() indicating the plural long name for a 
     * currency, such as "US dollar" for USD in "1 US dollar", 
     * and "US dollars" for USD in "2 US dollars".
     * @stable ICU 4.2
     */
    public static final int PLURAL_LONG_NAME = 2;

    /**
     * Returns a currency object for the default currency in the given
     * locale.
     * @param locale the locale
     * @return the currency object for this locale
     * @stable ICU 2.2
     */
    public static Currency getInstance(Locale locale) {
        return new Currency(java.util.Currency.getInstance(locale));
    }

    /**
     * Returns a currency object for the default currency in the given
     * locale.
     * @stable ICU 3.2
     */
    public static Currency getInstance(ULocale locale) {
        return new Currency(java.util.Currency.getInstance(locale.toLocale()));
    }

//    /**
//     * Returns an array of Strings which contain the currency
//     * identifiers that are valid for the given locale on the 
//     * given date.  If there are no such identifiers, returns null.
//     * Returned identifiers are in preference order.
//     * @param loc the locale for which to retrieve currency codes.
//     * @param d the date for which to retrieve currency codes for the given locale.
//     * @return The array of ISO currency codes.
//     * @stable ICU 4.0
//     */
//    public static String[] getAvailableCurrencyCodes(ULocale loc, Date d) {
//        throw new UnsupportedOperationException("Method not supproted by com.ibm.icu.base");
//    }

//    /**
//     * Returns the set of available currencies. The returned set of currencies contains all of the
//     * available currencies, including obsolete ones. The result set can be modified without
//     * affecting the available currencies in the runtime.
//     * 
//     * @return The set of available currencies. The returned set could be empty if there is no
//     * currency data available.
//     * 
//     * @stable ICU 49
//     */
//    public static Set<Currency> getAvailableCurrencies() {
//        throw new UnsupportedOperationException("Method not supproted by com.ibm.icu.base");
//    }

    /**
     * Returns a currency object given an ISO 4217 3-letter code.
     * @param theISOCode the iso code
     * @return the currency for this iso code
     * @throws NullPointerException if <code>theISOCode</code> is null.
     * @throws IllegalArgumentException if <code>theISOCode</code> is not a
     *         3-letter alpha code.
     * @stable ICU 2.2
     */
    public static Currency getInstance(String theISOCode) {
        return new Currency(java.util.Currency.getInstance(theISOCode));
    }

//    /**
//     * Registers a new currency for the provided locale.  The returned object
//     * is a key that can be used to unregister this currency object.
//     * @param currency the currency to register
//     * @param locale the ulocale under which to register the currency
//     * @return a registry key that can be used to unregister this currency
//     * @see #unregister
//     * @stable ICU 3.2
//     */
//    public static Object registerInstance(Currency currency, ULocale locale) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Unregister the currency associated with this key (obtained from
//     * registerInstance).
//     * @param registryKey the registry key returned from registerInstance
//     * @see #registerInstance
//     * @stable ICU 2.6
//     */
//    public static boolean unregister(Object registryKey) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Return an array of the locales for which a currency
//     * is defined.
//     * @return an array of the available locales
//     * @stable ICU 2.2
//     */
//    public static Locale[] getAvailableLocales() {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Return an array of the ulocales for which a currency
//     * is defined.
//     * @return an array of the available ulocales
//     * @stable ICU 3.2
//     */
//    public static ULocale[] getAvailableULocales() {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Given a key and a locale, returns an array of values for the key for which data
//     * exists.  If commonlyUsed is true, these are the values that typically are used
//     * with this locale, otherwise these are all values for which data exists.  
//     * This is a common service API.
//     * <p>
//     * The only supported key is "currency", other values return an empty array.
//     * <p>
//     * Currency information is based on the region of the locale.  If the locale does not
//     * indicate a region, {@link ULocale#addLikelySubtags(ULocale)} is used to infer a region,
//     * except for the 'und' locale.
//     * <p>
//     * If commonlyUsed is true, only the currencies known to be in use as of the current date
//     * are returned.  When there are more than one, these are returned in preference order
//     * (typically, this occurs when a country is transitioning to a new currency, and the
//     * newer currency is preferred), see 
//     * <a href="http://unicode.org/reports/tr35/#Supplemental_Currency_Data">Unicode TR#35 Sec. C1</a>.  
//     * If commonlyUsed is false, all currencies ever used in any locale are returned, in no
//     * particular order.
//     * 
//     * @param key           key whose values to look up.  the only recognized key is "currency"
//     * @param locale        the locale
//     * @param commonlyUsed  if true, return only values that are currently used in the locale.
//     *                      Otherwise returns all values.
//     * @return an array of values for the given key and the locale.  If there is no data, the
//     *   array will be empty.
//     * @stable ICU 4.2
//     */
//    public static final String[] getKeywordValuesForLocale(String key, ULocale locale, 
//            boolean commonlyUsed) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

    /**
     * Return a hashcode for this currency.
     * @stable ICU 2.2
     */
    public int hashCode() {
        return currency.hashCode();
    }

    /**
     * Return true if rhs is a Currency instance,
     * is non-null, and has the same currency code.
     * @stable ICU 2.2
     */
    public boolean equals(Object rhs) {
        try {
            return currency.equals(((Currency)rhs).currency);
        }
        catch (Exception e) {
            return false;
        }
    }

    /**
     * Returns the ISO 4217 3-letter code for this currency object.
     * @stable ICU 2.2
     */
    public String getCurrencyCode() {
        return currency.getCurrencyCode();
    }

//    /**
//     * Returns the ISO 4217 numeric code for this currency object.
//     * <p>Note: If the ISO 4217 numeric code is not assigned for the currency or
//     * the currency is unknown, this method returns 0.</p>
//     * @return The ISO 4217 numeric code of this currency.
//     * @stable ICU 49
//     */
//    public int getNumericCode() {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

    /**
     * Convenience and compatibility override of getName that
     * requests the symbol name.
     * @see #getName
     * @stable ICU 3.4
     */
    public String getSymbol() {
        return currency.getSymbol(ULocale.getDefault(Category.DISPLAY).toLocale());
    }

    /**
     * Convenience and compatibility override of getName that
     * requests the symbol name.
     * @param loc the Locale for the symbol
     * @see #getName
     * @stable ICU 3.4
     */
    public String getSymbol(Locale loc) {
        return currency.getSymbol(loc);
    }

    /**
     * Convenience and compatibility override of getName that
     * requests the symbol name.
     * @param uloc the ULocale for the symbol
     * @see #getName
     * @stable ICU 3.4
     */
    public String getSymbol(ULocale uloc) {
        return currency.getSymbol(uloc.toLocale());
    }

//    /**
//     * Returns the display name for the given currency in the
//     * given locale.  
//     * This is a convenient method for 
//     * getName(ULocale, int, boolean[]); 
//     * @stable ICU 3.2
//     */
//    public String getName(Locale locale,
//                          int nameStyle,
//                          boolean[] isChoiceFormat) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Returns the display name for the given currency in the
//     * given locale.  For example, the display name for the USD
//     * currency object in the en_US locale is "$".
//     * @param locale locale in which to display currency
//     * @param nameStyle selector for which kind of name to return.
//     *                  The nameStyle should be either SYMBOL_NAME or 
//     *                  LONG_NAME. Otherwise, throw IllegalArgumentException.
//     * @param isChoiceFormat fill-in; isChoiceFormat[0] is set to true
//     * if the returned value is a ChoiceFormat pattern; otherwise it
//     * is set to false
//     * @return display string for this currency.  If the resource data
//     * contains no entry for this currency, then the ISO 4217 code is
//     * returned.  If isChoiceFormat[0] is true, then the result is a
//     * ChoiceFormat pattern.  Otherwise it is a static string. <b>Note:</b>
//     * as of ICU 4.4, choice formats are not used, and the value returned
//     * in isChoiceFormat is always false.
//     * <p>
//     * @throws  IllegalArgumentException  if the nameStyle is not SYMBOL_NAME
//     *                                    or LONG_NAME.
//     * @see #getName(ULocale, int, String, boolean[])
//     * @stable ICU 3.2
//     */
//    public String getName(ULocale locale, int nameStyle, boolean[] isChoiceFormat) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Returns the display name for the given currency in the given locale.  
//     * This is a convenience overload of getName(ULocale, int, String, boolean[]);
//     * @stable ICU 4.2
//     */
//    public String getName(Locale locale, int nameStyle, String pluralCount,
//            boolean[] isChoiceFormat) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Returns the display name for this currency in the default locale.
//     * If the resource data for the default locale contains no entry for this currency,
//     * then the ISO 4217 code is returned.
//     * <p>
//     * Note: This method was added for JDK compatibility support and equivalent to
//     * <code>getName(Locale.getDefault(), LONG_NAME, null)</code>.
//     * 
//     * @return The display name of this currency
//     * @see #getDisplayName(Locale)
//     * @see #getName(Locale, int, boolean[])
//     * @stable ICU 49
//     */
//    public String getDisplayName() {
//        //return getName(Locale.getDefault(), LONG_NAME, null);
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Returns the display name for this currency in the given locale.
//     * If the resource data for the given locale contains no entry for this currency,
//     * then the ISO 4217 code is returned.
//     * <p>
//     * Note: This method was added for JDK compatibility support and equivalent to
//     * <code>getName(locale, LONG_NAME, null)</code>.
//     * 
//     * @param locale locale in which to display currency
//     * @return The display name of this currency for the specified locale
//     * @see #getDisplayName(Locale)
//     * @see #getName(Locale, int, boolean[])
//     * @stable ICU 49
//     */
//    public String getDisplayName(Locale locale) {
//        //return getName(locale, LONG_NAME, null);
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Returns the display name for the given currency in the
//     * given locale.  For example, the SYMBOL_NAME for the USD
//     * currency object in the en_US locale is "$".
//     * The PLURAL_LONG_NAME for the USD currency object when the currency 
//     * amount is plural is "US dollars", such as in "3.00 US dollars";
//     * while the PLURAL_LONG_NAME for the USD currency object when the currency
//     * amount is singular is "US dollar", such as in "1.00 US dollar".
//     * @param locale locale in which to display currency
//     * @param nameStyle selector for which kind of name to return
//     * @param pluralCount plural count string for this locale
//     * @param isChoiceFormat fill-in; isChoiceFormat[0] is set to true
//     * if the returned value is a ChoiceFormat pattern; otherwise it
//     * is set to false
//     * @return display string for this currency.  If the resource data
//     * contains no entry for this currency, then the ISO 4217 code is
//     * returned.  If isChoiceFormat[0] is true, then the result is a
//     * ChoiceFormat pattern.  Otherwise it is a static string. <b>Note:</b>
//     * as of ICU 4.4, choice formats are not used, and the value returned
//     * in isChoiceFormat is always false.
//     * @throws  IllegalArgumentException  if the nameStyle is not SYMBOL_NAME,
//     *                                    LONG_NAME, or PLURAL_LONG_NAME.
//     * @stable ICU 4.2
//     */
//    public String getName(ULocale locale, int nameStyle, String pluralCount,
//            boolean[] isChoiceFormat) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Attempt to parse the given string as a currency, either as a
//     * display name in the given locale, or as a 3-letter ISO 4217
//     * code.  If multiple display names match, then the longest one is
//     * selected.  If both a display name and a 3-letter ISO code
//     * match, then the display name is preferred, unless it's length
//     * is less than 3.
//     *
//     * @param locale the locale of the display names to match
//     * @param text the text to parse
//     * @param type parse against currency type: LONG_NAME only or not
//     * @param pos input-output position; on input, the position within
//     * text to match; must have 0 <= pos.getIndex() < text.length();
//     * on output, the position after the last matched character. If
//     * the parse fails, the position in unchanged upon output.
//     * @return the ISO 4217 code, as a string, of the best match, or
//     * null if there is no match
//     *
//     * @internal
//     * @deprecated This API is ICU internal only.
//     */
//    public static String parse(ULocale locale, String text, int type, ParsePosition pos) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

    /**
     * Returns the number of the number of fraction digits that should
     * be displayed for this currency.
     * @return a non-negative number of fraction digits to be
     * displayed
     * @stable ICU 2.2
     */
    public int getDefaultFractionDigits() {
        return currency.getDefaultFractionDigits();
    }

//    /**
//     * Returns the rounding increment for this currency, or 0.0 if no
//     * rounding is done by this currency.
//     * @return the non-negative rounding increment, or 0.0 if none
//     * @stable ICU 2.2
//     */
//    public double getRoundingIncrement() {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

    /**
     * Returns the ISO 4217 code for this currency.
     * @stable ICU 2.2
     */
    public String toString() {
        return currency.toString();
    }

//    /**
//     * Return the locale that was used to create this object, or null.
//     * This may may differ from the locale requested at the time of
//     * this object's creation.  For example, if an object is created
//     * for locale <tt>en_US_CALIFORNIA</tt>, the actual data may be
//     * drawn from <tt>en</tt> (the <i>actual</i> locale), and
//     * <tt>en_US</tt> may be the most specific locale that exists (the
//     * <i>valid</i> locale).
//     *
//     * <p>Note: This method will be obsoleted.  The implementation is
//     * no longer locale-specific and so there is no longer a valid or
//     * actual locale associated with the Currency object.  Until
//     * it is removed, this method will return the root locale.
//     * @param type type of information requested, either {@link
//     * com.ibm.icu.util.ULocale#VALID_LOCALE} or {@link
//     * com.ibm.icu.util.ULocale#ACTUAL_LOCALE}.
//     * @return the information specified by <i>type</i>, or null if
//     * this object was not constructed from locale data.
//     * @see com.ibm.icu.util.ULocale
//     * @see com.ibm.icu.util.ULocale#VALID_LOCALE
//     * @see com.ibm.icu.util.ULocale#ACTUAL_LOCALE
//     * @obsolete ICU 3.2 to be removed
//     * @deprecated This API is obsolete.
//     */
//    public final ULocale getLocale(ULocale.Type type) {
//        throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

//    /**
//     * Queries if the given ISO 4217 3-letter code is available on the specified date range.
//     * <p>
//     * Note: For checking availability of a currency on a specific date, specify the date on both <code>from</code> and
//     * <code>to</code>. When both <code>from</code> and <code>to</code> are null, this method checks if the specified
//     * currency is available all time.
//     * 
//     * @param code
//     *            The ISO 4217 3-letter code.
//     * @param from
//     *            The lower bound of the date range, inclusive. When <code>from</code> is null, check the availability
//     *            of the currency any date before <code>to</code>
//     * @param to
//     *            The upper bound of the date range, inclusive. When <code>to</code> is null, check the availability of
//     *            the currency any date after <code>from</code>
//     * @return true if the given ISO 4217 3-letter code is supported on the specified date range.
//     * @throws IllegalArgumentException when <code>to</code> is before <code>from</code>.
//     * 
//     * @draft ICU 4.6
//     * @provisional This API might change or be removed in a future release.
//     */
//    public static boolean isAvailable(String code, Date from, Date to) {
//    	throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
//    }

}

//eof