/*

 * Copyright (c) 2018, 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 java.text;

import java.io.IOException;

import java.io.InvalidObjectException;

import java.io.ObjectInputStream;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.math.RoundingMode;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Locale;

import java.util.Objects;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

/**

 * <p>

 * {@code CompactNumberFormat} is a concrete subclass of {@code NumberFormat}

 * that formats a decimal number in its compact form.

 *

 * The compact number formatting is designed for the environment where the space

 * is limited, and the formatted string can be displayed in that limited space.

 * It is defined by LDML's specification for

 * <a href = "http://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats">

 * Compact Number Formats</a>. A compact number formatting refers

 * to the representation of a number in a shorter form, based on the patterns

 * provided for a given locale.

 *

 * <p>

 * For example:

 * <br>In the {@link java.util.Locale#US US locale}, {@code 1000} can be formatted

 * as {@code "1K"}, and {@code 1000000} as {@code "1M"}, depending upon the

 * <a href = "#compact_number_style" >style</a> used.

 * <br>In the {@code "hi_IN"} locale, {@code 1000} can be formatted as

 * "1 \u0939\u091C\u093C\u093E\u0930", and {@code 50000000} as "5 \u0915.",

 * depending upon the <a href = "#compact_number_style" >style</a> used.

 *

 * <p>

 * To obtain a {@code CompactNumberFormat} for a locale, use one

 * of the factory methods given by {@code NumberFormat} for compact number

 * formatting. For example,

 * {@link NumberFormat#getCompactNumberInstance(Locale, Style)}.

 *

 * <blockquote><pre>

 * NumberFormat fmt = NumberFormat.getCompactNumberInstance(

 *                             new Locale("hi", "IN"), NumberFormat.Style.SHORT);

 * String result = fmt.format(1000);

 * </pre></blockquote>

 *

 * <h2><a id="compact_number_style">Style</a></h2>

 * <p>

 * A number can be formatted in the compact forms with two different

 * styles, {@link NumberFormat.Style#SHORT SHORT}

 * and {@link NumberFormat.Style#LONG LONG}. Use

 * {@link NumberFormat#getCompactNumberInstance(Locale, Style)} for formatting and

 * parsing a number in {@link NumberFormat.Style#SHORT SHORT} or

 * {@link NumberFormat.Style#LONG LONG} compact form,

 * where the given {@code Style} parameter requests the desired

 * format. A {@link NumberFormat.Style#SHORT SHORT} style

 * compact number instance in the {@link java.util.Locale#US US locale} formats

 * {@code 10000} as {@code "10K"}. However, a

 * {@link NumberFormat.Style#LONG LONG} style instance in same locale

 * formats {@code 10000} as {@code "10 thousand"}.

 *

 * <h2><a id="compact_number_patterns">Compact Number Patterns</a></h2>

 * <p>

 * The compact number patterns are represented in a series of patterns where each

 * pattern is used to format a range of numbers. An example of

 * {@link NumberFormat.Style#SHORT SHORT} styled compact number patterns

 * for the {@link java.util.Locale#US US locale} is {@code {"", "", "", "0K",

 * "00K", "000K", "0M", "00M", "000M", "0B", "00B", "000B", "0T", "00T", "000T"}},

 * ranging from {@code 10}<sup>{@code 0}</sup> to {@code 10}<sup>{@code 14}</sup>.

 * There can be any number of patterns and they are

 * strictly index based starting from the range {@code 10}<sup>{@code 0}</sup>.

 * For example, in the above patterns, pattern at index 3

 * ({@code "0K"}) is used for formatting {@code number >= 1000 and number < 10000},

 * pattern at index 4 ({@code "00K"}) is used for formatting

 * {@code number >= 10000 and number < 100000} and so on. In most of the locales,

 * patterns with the range

 * {@code 10}<sup>{@code 0}</sup>-{@code 10}<sup>{@code 2}</sup> are empty

 * strings, which implicitly means a special pattern {@code "0"}.

 * A special pattern {@code "0"} is used for any range which does not contain

 * a compact pattern. This special pattern can appear explicitly for any specific

 * range, or considered as a default pattern for an empty string.

 * <p>

 * A compact pattern has the following syntax:

 * <blockquote><pre>

 * <i>Pattern:</i>

 *         <i>PositivePattern</i>

 *         <i>PositivePattern</i> <i>[; NegativePattern]<sub>optional</sub></i>

 * <i>PositivePattern:</i>

 *         <i>Prefix<sub>optional</sub></i> <i>MinimumInteger</i> <i>Suffix<sub>optional</sub></i>

 * <i>NegativePattern:</i>

 *        <i>Prefix<sub>optional</sub></i> <i>MinimumInteger</i> <i>Suffix<sub>optional</sub></i>

 * <i>Prefix:</i>

 *      Any Unicode characters except \uFFFE, \uFFFF, and

 *      <a href = "DecimalFormat.html#special_pattern_character">special characters</a>

 * <i>Suffix:</i>

 *      Any Unicode characters except \uFFFE, \uFFFF, and

 *      <a href = "DecimalFormat.html#special_pattern_character">special characters</a>

 * <i>MinimumInteger:</i>

 *      0

 *      0 <i>MinimumInteger</i>

 * </pre></blockquote>

 *

 * A compact pattern contains a positive and negative subpattern

 * separated by a subpattern boundary character {@code ';' (U+003B)},

 * for example, {@code "0K;-0K"}. Each subpattern has a prefix,

 * minimum integer digits, and suffix. The negative subpattern

 * is optional, if absent, then the positive subpattern prefixed with the

 * minus sign ({@code '-' U+002D HYPHEN-MINUS}) is used as the negative

 * subpattern. That is, {@code "0K"} alone is equivalent to {@code "0K;-0K"}.

 * If there is an explicit negative subpattern, it serves only to specify

 * the negative prefix and suffix. The number of minimum integer digits,

 * and other characteristics are all the same as the positive pattern.

 * That means that {@code "0K;-00K"} produces precisely the same behavior

 * as {@code "0K;-0K"}.

 *

 * <p>

 * Many characters in a compact pattern are taken literally, they are matched

 * during parsing and output unchanged during formatting.

 * <a href = "DecimalFormat.html#special_pattern_character">Special characters</a>,

 * on the other hand, stand for other characters, strings, or classes of

 * characters. They must be quoted, using single quote {@code ' (U+0027)}

 * unless noted otherwise, if they are to appear in the prefix or suffix

 * as literals. For example, 0\u0915'.'.

 *

 * <h2>Formatting</h2>

 * The default formatting behavior returns a formatted string with no fractional

 * digits, however users can use the {@link #setMinimumFractionDigits(int)}

 * method to include the fractional part.

 * The number {@code 1000.0} or {@code 1000} is formatted as {@code "1K"}

 * not {@code "1.00K"} (in the {@link java.util.Locale#US US locale}). For this

 * reason, the patterns provided for formatting contain only the minimum

 * integer digits, prefix and/or suffix, but no fractional part.

 * For example, patterns used are {@code {"", "", "", 0K, 00K, ...}}. If the pattern

 * selected for formatting a number is {@code "0"} (special pattern),

 * either explicit or defaulted, then the general number formatting provided by

 * {@link java.text.DecimalFormat DecimalFormat}

 * for the specified locale is used.

 *

 * <h2>Parsing</h2>

 * The default parsing behavior does not allow a grouping separator until

 * grouping used is set to {@code true} by using

 * {@link #setGroupingUsed(boolean)}. The parsing of the fractional part

 * depends on the {@link #isParseIntegerOnly()}. For example, if the

 * parse integer only is set to true, then the fractional part is skipped.

 *

 * <h2>Rounding</h2>

 * {@code CompactNumberFormat} provides rounding modes defined in

 * {@link java.math.RoundingMode} for formatting.  By default, it uses

 * {@link java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}.

 *

 * @see CompactNumberFormat.Style

 * @see NumberFormat

 * @see DecimalFormat

 * @since 12

 */

public final class CompactNumberFormat extends NumberFormat {

    private static final long serialVersionUID = 7128367218649234678L;

    /**

     * The patterns for compact form of numbers for this

     * {@code CompactNumberFormat}. A possible example is

     * {@code {"", "", "", "0K", "00K", "000K", "0M", "00M", "000M", "0B",

     * "00B", "000B", "0T", "00T", "000T"}} ranging from

     * {@code 10}<sup>{@code 0}</sup>-{@code 10}<sup>{@code 14}</sup>,

     * where each pattern is used to format a range of numbers.

     * For example, {@code "0K"} is used for formatting

     * {@code number >= 1000 and number < 10000}, {@code "00K"} is used for

     * formatting {@code number >= 10000 and number < 100000} and so on.

     * This field must not be {@code null}.

     *

     * @serial

     */

    private String[] compactPatterns;

    /**

     * List of positive prefix patterns of this formatter's

     * compact number patterns.

     */

    private transient List<String> positivePrefixPatterns;

    /**

     * List of negative prefix patterns of this formatter's

     * compact number patterns.

     */

    private transient List<String> negativePrefixPatterns;

    /**

     * List of positive suffix patterns of this formatter's

     * compact number patterns.

     */

    private transient List<String> positiveSuffixPatterns;

    /**

     * List of negative suffix patterns of this formatter's

     * compact number patterns.

     */

    private transient List<String> negativeSuffixPatterns;

    /**

     * List of divisors of this formatter's compact number patterns.

     * Divisor can be either Long or BigInteger (if the divisor value goes

     * beyond long boundary)

     */

    private transient List<Number> divisors;

    /**

     * The {@code DecimalFormatSymbols} object used by this format.

     * It contains the symbols used to format numbers. For example,

     * the grouping separator, decimal separator, and so on.

     * This field must not be {@code null}.

     *

     * @serial

     * @see DecimalFormatSymbols

     */

    private DecimalFormatSymbols symbols;

    /**

     * The decimal pattern which is used for formatting the numbers

     * matching special pattern "0". This field must not be {@code null}.

     *

     * @serial

     * @see DecimalFormat

     */

    private final String decimalPattern;

    /**

     * A {@code DecimalFormat} used by this format for getting corresponding

     * general number formatting behavior for compact numbers.

     *

     */

    private transient DecimalFormat decimalFormat;

    /**

     * A {@code DecimalFormat} used by this format for getting general number

     * formatting behavior for the numbers which can't be represented as compact

     * numbers. For example, number matching the special pattern "0" are

     * formatted through general number format pattern provided by

     * {@link java.text.DecimalFormat DecimalFormat}

     * for the specified locale.

     *

     */

    private transient DecimalFormat defaultDecimalFormat;

    /**

     * The number of digits between grouping separators in the integer portion

     * of a compact number. For the grouping to work while formatting, this

     * field needs to be greater than 0 with grouping used set as true.

     * This field must not be negative.

     *

     * @serial

     */

    private byte groupingSize = 0;

    /**

     * Returns whether the {@link #parse(String, ParsePosition)}

     * method returns {@code BigDecimal}.

     *

     * @serial

     */

    private boolean parseBigDecimal = false;

    /**

     * The {@code RoundingMode} used in this compact number format.

     * This field must not be {@code null}.

     *

     * @serial

     */

    private RoundingMode roundingMode = RoundingMode.HALF_EVEN;

    /**

     * Special pattern used for compact numbers

     */

    private static final String SPECIAL_PATTERN = "0";

    /**

     * Multiplier for compact pattern range. In

     * the list compact patterns each compact pattern

     * specify the range with the multiplication factor of 10

     * of its previous compact pattern range.

     * For example, 10^0, 10^1, 10^2, 10^3, 10^4...

     *

     */

    private static final int RANGE_MULTIPLIER = 10;

    /**

     * Creates a {@code CompactNumberFormat} using the given decimal pattern,

     * decimal format symbols and compact patterns.

     * To obtain the instance of {@code CompactNumberFormat} with the standard

     * compact patterns for a {@code Locale} and {@code Style},

     * it is recommended to use the factory methods given by

     * {@code NumberFormat} for compact number formatting. For example,

     * {@link NumberFormat#getCompactNumberInstance(Locale, Style)}.

     *

     * @param decimalPattern a decimal pattern for general number formatting

     * @param symbols the set of symbols to be used

     * @param compactPatterns an array of

     *        <a href = "CompactNumberFormat.html#compact_number_patterns">

     *        compact number patterns</a>

     * @throws NullPointerException if any of the given arguments is

     *                                 {@code null}

     * @throws IllegalArgumentException if the given {@code decimalPattern} or the

     *                     {@code compactPatterns} array contains an invalid pattern

     *                     or if a {@code null} appears in the array of compact

     *                     patterns

     * @see DecimalFormat#DecimalFormat(java.lang.String, DecimalFormatSymbols)

     * @see DecimalFormatSymbols

     */

    public CompactNumberFormat(String decimalPattern,

            DecimalFormatSymbols symbols, String[] compactPatterns) {

        Objects.requireNonNull(decimalPattern, "decimalPattern");

        Objects.requireNonNull(symbols, "symbols");

        Objects.requireNonNull(compactPatterns, "compactPatterns");

        this.symbols = symbols;

        // Instantiating the DecimalFormat with "0" pattern; this acts just as a

        // basic pattern; the properties (For example, prefix/suffix)

        // are later computed based on the compact number formatting process.

        decimalFormat = new DecimalFormat(SPECIAL_PATTERN, this.symbols);

        // Initializing the super class state with the decimalFormat values

        // to represent this CompactNumberFormat.

        // For setting the digits counts, use overridden setXXX methods of this

        // CompactNumberFormat, as it performs check with the max range allowed

        // for compact number formatting

        setMaximumIntegerDigits(decimalFormat.getMaximumIntegerDigits());

        setMinimumIntegerDigits(decimalFormat.getMinimumIntegerDigits());

        setMaximumFractionDigits(decimalFormat.getMaximumFractionDigits());

        setMinimumFractionDigits(decimalFormat.getMinimumFractionDigits());

        super.setGroupingUsed(decimalFormat.isGroupingUsed());

        super.setParseIntegerOnly(decimalFormat.isParseIntegerOnly());

        this.compactPatterns = compactPatterns;

        // DecimalFormat used for formatting numbers with special pattern "0".

        // Formatting is delegated to the DecimalFormat's number formatting

        // with no fraction digits

        this.decimalPattern = decimalPattern;

        defaultDecimalFormat = new DecimalFormat(this.decimalPattern,

                this.symbols);

        defaultDecimalFormat.setMaximumFractionDigits(0);

        // Process compact patterns to extract the prefixes, suffixes and

        // divisors

        processCompactPatterns();

    }

    /**

     * Formats a number to produce a string representing its compact form.

     * The number can be of any subclass of {@link java.lang.Number}.

     * @param number     the number to format

     * @param toAppendTo the {@code StringBuffer} to which the formatted

     *                   text is to be appended

     * @param fieldPosition    keeps track on the position of the field within

     *                         the returned string. For example, for formatting

     *                         a number {@code 123456789} in the

     *                         {@link java.util.Locale#US US locale},

     *                         if the given {@code fieldPosition} is

     *                         {@link NumberFormat#INTEGER_FIELD}, the begin

     *                         index and end index of {@code fieldPosition}

     *                         will be set to 0 and 3, respectively for the

     *                         output string {@code 123M}. Similarly, positions

     *                         of the prefix and the suffix fields can be

     *                         obtained using {@link NumberFormat.Field#PREFIX}

     *                         and {@link NumberFormat.Field#SUFFIX} respectively.

     * @return           the {@code StringBuffer} passed in as {@code toAppendTo}

     * @throws           IllegalArgumentException if {@code number} is

     *                   {@code null} or not an instance of {@code Number}

     * @throws           NullPointerException if {@code toAppendTo} or

     *                   {@code fieldPosition} is {@code null}

     * @throws           ArithmeticException if rounding is needed with rounding

     *                   mode being set to {@code RoundingMode.UNNECESSARY}

     * @see              FieldPosition

     */

    @Override

    public final StringBuffer format(Object number,

            StringBuffer toAppendTo,

            FieldPosition fieldPosition) {

        if (number == null) {

            throw new IllegalArgumentException("Cannot format null as a number");

        }

        if (number instanceof Long || number instanceof Integer

                || number instanceof Short || number instanceof Byte

                || number instanceof AtomicInteger

                || number instanceof AtomicLong

                || (number instanceof BigInteger

                && ((BigInteger) number).bitLength() < 64)) {

            return format(((Number) number).longValue(), toAppendTo,

                    fieldPosition);

        } else if (number instanceof BigDecimal) {

            return format((BigDecimal) number, toAppendTo, fieldPosition);

        } else if (number instanceof BigInteger) {

            return format((BigInteger) number, toAppendTo, fieldPosition);

        } else if (number instanceof Number) {

            return format(((Number) number).doubleValue(), toAppendTo, fieldPosition);

        } else {

            throw new IllegalArgumentException("Cannot format "

                    + number.getClass().getName() + " as a number");

        }

    }

    /**

     * Formats a double to produce a string representing its compact form.

     * @param number    the double number to format

     * @param result    where the text is to be appended

     * @param fieldPosition    keeps track on the position of the field within

     *                         the returned string. For example, to format

     *                         a number {@code 1234567.89} in the

     *                         {@link java.util.Locale#US US locale}

     *                         if the given {@code fieldPosition} is

     *                         {@link NumberFormat#INTEGER_FIELD}, the begin

     *                         index and end index of {@code fieldPosition}

     *                         will be set to 0 and 1, respectively for the

     *                         output string {@code 1M}. Similarly, positions

     *                         of the prefix and the suffix fields can be

     *                         obtained using {@link NumberFormat.Field#PREFIX}

     *                         and {@link NumberFormat.Field#SUFFIX} respectively.

     * @return    the {@code StringBuffer} passed in as {@code result}

     * @throws NullPointerException if {@code result} or

     *            {@code fieldPosition} is {@code null}

     * @throws ArithmeticException if rounding is needed with rounding

     *            mode being set to {@code RoundingMode.UNNECESSARY}

     * @see FieldPosition

     */

    @Override

    public StringBuffer format(double number, StringBuffer result,

            FieldPosition fieldPosition) {

        fieldPosition.setBeginIndex(0);

        fieldPosition.setEndIndex(0);

        return format(number, result, fieldPosition.getFieldDelegate());

    }

    private StringBuffer format(double number, StringBuffer result,

            FieldDelegate delegate) {

        boolean nanOrInfinity = decimalFormat.handleNaN(number, result, delegate);

        if (nanOrInfinity) {

            return result;

        }

        boolean isNegative = ((number < 0.0)

                || (number == 0.0 && 1 / number < 0.0));

        nanOrInfinity = decimalFormat.handleInfinity(number, result, delegate, isNegative);

        if (nanOrInfinity) {

            return result;

        }

        // Round the double value with min fraction digits, the integer

        // part of the rounded value is used for matching the compact

        // number pattern

        // For example, if roundingMode is HALF_UP with min fraction

        // digits = 0, the number 999.6 should round up

        // to 1000 and outputs 1K/thousand in "en_US" locale

        DigitList dList = new DigitList();

        dList.setRoundingMode(getRoundingMode());

        number = isNegative ? -number : number;

        dList.set(isNegative, number, getMinimumFractionDigits());

        double roundedNumber = dList.getDouble();

        int compactDataIndex = selectCompactPattern((long) roundedNumber);

        if (compactDataIndex != -1) {

            String prefix = isNegative ? negativePrefixPatterns.get(compactDataIndex)

                    : positivePrefixPatterns.get(compactDataIndex);

            String suffix = isNegative ? negativeSuffixPatterns.get(compactDataIndex)

                    : positiveSuffixPatterns.get(compactDataIndex);

            if (!prefix.isEmpty() || !suffix.isEmpty()) {

                appendPrefix(result, prefix, delegate);

                long divisor = (Long) divisors.get(compactDataIndex);

                roundedNumber = roundedNumber / divisor;

                decimalFormat.setDigitList(roundedNumber, isNegative, getMaximumFractionDigits());

                decimalFormat.subformatNumber(result, delegate, isNegative,

                        false, getMaximumIntegerDigits(), getMinimumIntegerDigits(),

                        getMaximumFractionDigits(), getMinimumFractionDigits());

                appendSuffix(result, suffix, delegate);

            } else {

                defaultDecimalFormat.doubleSubformat(number, result, delegate, isNegative);

            }

        } else {

            defaultDecimalFormat.doubleSubformat(number, result, delegate, isNegative);

        }

        return result;

    }

    /**

     * Formats a long to produce a string representing its compact form.

     * @param number    the long number to format

     * @param result    where the text is to be appended

     * @param fieldPosition    keeps track on the position of the field within

     *                         the returned string. For example, to format

     *                         a number {@code 123456789} in the

     *                         {@link java.util.Locale#US US locale},