/*

 * 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.awt.font;

import java.io.IOException;

import java.io.ObjectOutputStream;

import java.util.Arrays;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.Set;

import jdk.internal.access.SharedSecrets;

/**

 * The {@code NumericShaper} class is used to convert Latin-1 (European)

 * digits to other Unicode decimal digits.  Users of this class will

 * primarily be people who wish to present data using

 * national digit shapes, but find it more convenient to represent the

 * data internally using Latin-1 (European) digits.  This does not

 * interpret the deprecated numeric shape selector character (U+206E).

 * <p>

 * Instances of {@code NumericShaper} are typically applied

 * as attributes to text with the

 * {@link TextAttribute#NUMERIC_SHAPING NUMERIC_SHAPING} attribute

 * of the {@code TextAttribute} class.

 * For example, this code snippet causes a {@code TextLayout} to

 * shape European digits to Arabic in an Arabic context:<br>

 * <blockquote><pre>

 * Map map = new HashMap();

 * map.put(TextAttribute.NUMERIC_SHAPING,

 *     NumericShaper.getContextualShaper(NumericShaper.ARABIC));

 * FontRenderContext frc = ...;

 * TextLayout layout = new TextLayout(text, map, frc);

 * layout.draw(g2d, x, y);

 * </pre></blockquote>

 * <br>

 * It is also possible to perform numeric shaping explicitly using instances

 * of {@code NumericShaper}, as this code snippet demonstrates:<br>

 * <blockquote><pre>

 * char[] text = ...;

 * // shape all EUROPEAN digits (except zero) to ARABIC digits

 * NumericShaper shaper = NumericShaper.getShaper(NumericShaper.ARABIC);

 * shaper.shape(text, start, count);

 *

 * // shape European digits to ARABIC digits if preceding text is Arabic, or

 * // shape European digits to TAMIL digits if preceding text is Tamil, or

 * // leave European digits alone if there is no preceding text, or

 * // preceding text is neither Arabic nor Tamil

 * NumericShaper shaper =

 *     NumericShaper.getContextualShaper(NumericShaper.ARABIC |

 *                                         NumericShaper.TAMIL,

 *                                       NumericShaper.EUROPEAN);

 * shaper.shape(text, start, count);

 * </pre></blockquote>

 *

 * <p><b>Bit mask- and enum-based Unicode ranges</b></p>

 *

 * <p>This class supports two different programming interfaces to

 * represent Unicode ranges for script-specific digits: bit

 * mask-based ones, such as {@link #ARABIC NumericShaper.ARABIC}, and

 * enum-based ones, such as {@link NumericShaper.Range#ARABIC}.

 * Multiple ranges can be specified by ORing bit mask-based constants,

 * such as:

 * <blockquote><pre>

 * NumericShaper.ARABIC | NumericShaper.TAMIL

 * </pre></blockquote>

 * or creating a {@code Set} with the {@link NumericShaper.Range}

 * constants, such as:

 * <blockquote><pre>

 * EnumSet.of(NumericShaper.Range.ARABIC, NumericShaper.Range.TAMIL)

 * </pre></blockquote>

 * The enum-based ranges are a super set of the bit mask-based ones.

 *

 * <p>If the two interfaces are mixed (including serialization),

 * Unicode range values are mapped to their counterparts where such

 * mapping is possible, such as {@code NumericShaper.Range.ARABIC}

 * from/to {@code NumericShaper.ARABIC}.  If any unmappable range

 * values are specified, such as {@code NumericShaper.Range.BALINESE},

 * those ranges are ignored.

 *

 * <p><b>Decimal Digits Precedence</b></p>

 *

 * <p>A Unicode range may have more than one set of decimal digits. If

 * multiple decimal digits sets are specified for the same Unicode

 * range, one of the sets will take precedence as follows.

 *

 * <table class="plain">

 * <caption>NumericShaper constants precedence</caption>

 * <thead>

 *   <tr>

 *     <th scope="col">Unicode Range

 *     <th scope="col">{@code NumericShaper} Constants

 *     <th scope="col">Precedence

 * </thead>

 * <tbody>

 *   <tr>

 *     <td>{@link NumericShaper#ARABIC NumericShaper.ARABIC}

 *     <br>

 *     {@link NumericShaper#EASTERN_ARABIC NumericShaper.EASTERN_ARABIC}

 *     <td>{@link NumericShaper#EASTERN_ARABIC NumericShaper.EASTERN_ARABIC}

 *   </tr>

 *   <tr>

 *     <br>

 *     {@link NumericShaper.Range#EASTERN_ARABIC}

 *     <td>{@link NumericShaper.Range#EASTERN_ARABIC}

 *   <tr>

 *     <th scope="row">Tai Tham

 *     <td>{@link NumericShaper.Range#TAI_THAM_HORA}

 *     <br>

 *     {@link NumericShaper.Range#TAI_THAM_THAM}

 *     <td>{@link NumericShaper.Range#TAI_THAM_THAM}

 * </tbody>

 * </table>

 *

 * @since 1.4

 */

public final class NumericShaper implements java.io.Serializable {

    // For access from java.text.Bidi

    static {

        if (SharedSecrets.getJavaAWTFontAccess() == null) {

            SharedSecrets.setJavaAWTFontAccess(new JavaAWTFontAccessImpl());

        }

    }

    /**

     * A {@code NumericShaper.Range} represents a Unicode range of a

     * script having its own decimal digits. For example, the {@link

     * NumericShaper.Range#THAI} range has the Thai digits, THAI DIGIT

     * ZERO (U+0E50) to THAI DIGIT NINE (U+0E59).

     *

     * <p>The {@code Range} enum replaces the traditional bit

     * mask-based values (e.g., {@link NumericShaper#ARABIC}), and

     * supports more Unicode ranges than the bit mask-based ones. For

     * example, the following code using the bit mask:

     * <blockquote><pre>

     * NumericShaper.getContextualShaper(NumericShaper.ARABIC |

     *                                     NumericShaper.TAMIL,

     *                                   NumericShaper.EUROPEAN);

     * </pre></blockquote>

     * can be written using this enum as:

     * <blockquote><pre>

     * NumericShaper.getContextualShaper(EnumSet.of(

     *                                     NumericShaper.Range.ARABIC,

     *                                     NumericShaper.Range.TAMIL),

     *                                   NumericShaper.Range.EUROPEAN);

     * </pre></blockquote>

     *

     * @since 1.7

     */

    public static enum Range {

        // The order of EUROPEAN to MOGOLIAN must be consistent

        // with the bitmask-based constants.

        /**

         * The Latin (European) range with the Latin (ASCII) digits.

         */

        EUROPEAN        ('\u0030', '\u0000', '\u0300'),

        /**

         * The Arabic range with the Arabic-Indic digits.

         */

        ARABIC          ('\u0660', '\u0600', '\u0780'),

        /**

         * The Arabic range with the Eastern Arabic-Indic digits.

         */

        EASTERN_ARABIC  ('\u06f0', '\u0600', '\u0780'),

        /**

         * The Devanagari range with the Devanagari digits.

         */

        DEVANAGARI      ('\u0966', '\u0900', '\u0980'),

        /**

         * The Bengali range with the Bengali digits.

         */

        BENGALI         ('\u09e6', '\u0980', '\u0a00'),

        /**

         * The Gurmukhi range with the Gurmukhi digits.

         */

        GURMUKHI        ('\u0a66', '\u0a00', '\u0a80'),

        /**

         * The Gujarati range with the Gujarati digits.

         */

        GUJARATI        ('\u0ae6', '\u0b00', '\u0b80'),

        /**

         * The Oriya range with the Oriya digits.

         */

        ORIYA           ('\u0b66', '\u0b00', '\u0b80'),

        /**

         * The Tamil range with the Tamil digits.

         */

        TAMIL           ('\u0be6', '\u0b80', '\u0c00'),

        /**

         * The Telugu range with the Telugu digits.

         */

        TELUGU          ('\u0c66', '\u0c00', '\u0c80'),

        /**

         * The Kannada range with the Kannada digits.

         */

        KANNADA         ('\u0ce6', '\u0c80', '\u0d00'),

        /**

         * The Malayalam range with the Malayalam digits.

         */

        MALAYALAM       ('\u0d66', '\u0d00', '\u0d80'),

        /**

         * The Thai range with the Thai digits.

         */

        THAI            ('\u0e50', '\u0e00', '\u0e80'),

        /**

         * The Lao range with the Lao digits.

         */

        LAO             ('\u0ed0', '\u0e80', '\u0f00'),

        /**

         * The Tibetan range with the Tibetan digits.

         */

        TIBETAN         ('\u0f20', '\u0f00', '\u1000'),

        /**

         * The Myanmar range with the Myanmar digits.

         */

        MYANMAR         ('\u1040', '\u1000', '\u1080'),

        /**

         * The Ethiopic range with the Ethiopic digits. Ethiopic

         * does not have a decimal digit 0 so Latin (European) 0 is

         * used.

         */

        ETHIOPIC        ('\u1369', '\u1200', '\u1380') {

            @Override

            char getNumericBase() { return 1; }

        },

        /**

         * The Khmer range with the Khmer digits.

         */

        KHMER           ('\u17e0', '\u1780', '\u1800'),

        /**

         * The Mongolian range with the Mongolian digits.

         */

        MONGOLIAN       ('\u1810', '\u1800', '\u1900'),

        // The order of EUROPEAN to MOGOLIAN must be consistent

        // with the bitmask-based constants.

        /**

         * The N'Ko range with the N'Ko digits.

         */

        NKO             ('\u07c0', '\u07c0', '\u0800'),

        /**

         * The Myanmar range with the Myanmar Shan digits.

         */

        MYANMAR_SHAN    ('\u1090', '\u1000', '\u10a0'),

        /**

         * The Limbu range with the Limbu digits.

         */

        LIMBU           ('\u1946', '\u1900', '\u1950'),

        /**

         * The New Tai Lue range with the New Tai Lue digits.

         */

        NEW_TAI_LUE     ('\u19d0', '\u1980', '\u19e0'),

        /**

         * The Balinese range with the Balinese digits.

         */

        BALINESE        ('\u1b50', '\u1b00', '\u1b80'),

        /**

         * The Sundanese range with the Sundanese digits.

         */

        SUNDANESE       ('\u1bb0', '\u1b80', '\u1bc0'),

        /**

         * The Lepcha range with the Lepcha digits.

         */

        LEPCHA          ('\u1c40', '\u1c00', '\u1c50'),

        /**

         * The Ol Chiki range with the Ol Chiki digits.

         */

        OL_CHIKI        ('\u1c50', '\u1c50', '\u1c80'),

        /**

         * The Vai range with the Vai digits.

         */

        VAI             ('\ua620', '\ua500', '\ua640'),

        /**

         * The Saurashtra range with the Saurashtra digits.

         */

        SAURASHTRA      ('\ua8d0', '\ua880', '\ua8e0'),

        /**

         * The Kayah Li range with the Kayah Li digits.

         */

        KAYAH_LI        ('\ua900', '\ua900', '\ua930'),

        /**

         * The Cham range with the Cham digits.

         */

        CHAM            ('\uaa50', '\uaa00', '\uaa60'),

        /**

         * The Tai Tham Hora range with the Tai Tham Hora digits.

         */

        TAI_THAM_HORA   ('\u1a80', '\u1a20', '\u1ab0'),

        /**

         * The Tai Tham Tham range with the Tai Tham Tham digits.

         */

        TAI_THAM_THAM   ('\u1a90', '\u1a20', '\u1ab0'),

        /**

         * The Javanese range with the Javanese digits.

         */

        JAVANESE        ('\ua9d0', '\ua980', '\ua9e0'),

        /**

         * The Meetei Mayek range with the Meetei Mayek digits.

         */

        MEETEI_MAYEK    ('\uabf0', '\uabc0', '\uac00'),

        /**

         * The Sinhala range with the Sinhala digits.

         * @since 9

         */

        SINHALA         ('\u0de6', '\u0d80', '\u0e00'),

        /**

         * The Myanmar Extended-B range with the Myanmar Tai Laing digits.

         * @since 9

         */

        MYANMAR_TAI_LAING ('\ua9f0', '\ua9e0', '\uaa00');

        private static int toRangeIndex(Range script) {

            int index = script.ordinal();

            return index < NUM_KEYS ? index : -1;

        }

        private static Range indexToRange(int index) {

            return index < NUM_KEYS ? Range.values()[index] : null;

        }

        private static int toRangeMask(Set<Range> ranges) {

            int m = 0;

            for (Range range : ranges) {

                int index = range.ordinal();

                if (index < NUM_KEYS) {

                    m |= 1 << index;

                }

            }

            return m;

        }

        private static Set<Range> maskToRangeSet(int mask) {

            Set<Range> set = EnumSet.noneOf(Range.class);

            Range[] a = Range.values();

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

                if ((mask & (1 << i)) != 0) {

                    set.add(a[i]);

                }

            }

            return set;

        }

        // base character of range digits

        private final int base;

        // Unicode range

        private final int start, // inclusive

                          end;   // exclusive

        private Range(int base, int start, int end) {

            this.base = base - ('0' + getNumericBase());

            this.start = start;

            this.end = end;

        }

        private int getDigitBase() {

            return base;

        }

        char getNumericBase() {

            return 0;

        }

        private boolean inRange(int c) {

            return start <= c && c < end;

        }

    }

    /** index of context for contextual shaping - values range from 0 to 18 */

    private int key;

    /** flag indicating whether to shape contextually (high bit) and which

     *  digit ranges to shape (bits 0-18)

     */

    private int mask;

    /**

     * The context {@code Range} for contextual shaping or the {@code

     * Range} for non-contextual shaping. {@code null} for the bit

     * mask-based API.

     *

     * @since 1.7

     */

    private Range shapingRange;

    /**

     * {@code Set<Range>} indicating which Unicode ranges to

     * shape. {@code null} for the bit mask-based API.

     */

    private transient Set<Range> rangeSet;

    /**

     * rangeSet.toArray() value. Sorted by Range.base when the number

     * of elements is greater than BSEARCH_THRESHOLD.

     */

    private transient Range[] rangeArray;

    /**

     * If more than BSEARCH_THRESHOLD ranges are specified, binary search is used.

     */

    private static final int BSEARCH_THRESHOLD = 3;

    private static final long serialVersionUID = -8022764705923730308L;

    /** Identifies the Latin-1 (European) and extended range, and

     *  Latin-1 (European) decimal base.

     */

    public static final int EUROPEAN = 1<<0;

    /** Identifies the ARABIC range and decimal base. */

    public static final int ARABIC = 1<<1;

    /** Identifies the ARABIC range and ARABIC_EXTENDED decimal base. */

    public static final int EASTERN_ARABIC = 1<<2;

    /** Identifies the DEVANAGARI range and decimal base. */

    public static final int DEVANAGARI = 1<<3;

    /** Identifies the BENGALI range and decimal base. */

    public static final int BENGALI = 1<<4;

    /** Identifies the GURMUKHI range and decimal base. */

    public static final int GURMUKHI = 1<<5;

    /** Identifies the GUJARATI range and decimal base. */

    public static final int GUJARATI = 1<<6;

    /** Identifies the ORIYA range and decimal base. */

    public static final int ORIYA = 1<<7;

    /** Identifies the TAMIL range and decimal base. */

    // TAMIL DIGIT ZERO was added in Unicode 4.1

    public static final int TAMIL = 1<<8;

    /** Identifies the TELUGU range and decimal base. */

    public static final int TELUGU = 1<<9;

    /** Identifies the KANNADA range and decimal base. */

    public static final int KANNADA = 1<<10;

    /** Identifies the MALAYALAM range and decimal base. */

    public static final int MALAYALAM = 1<<11;

    /** Identifies the THAI range and decimal base. */

    public static final int THAI = 1<<12;

    /** Identifies the LAO range and decimal base. */

    public static final int LAO = 1<<13;

    /** Identifies the TIBETAN range and decimal base. */

    public static final int TIBETAN = 1<<14;

    /** Identifies the MYANMAR range and decimal base. */

    public static final int MYANMAR = 1<<15;

    /** Identifies the ETHIOPIC range and decimal base. */

    public static final int ETHIOPIC = 1<<16;

    /** Identifies the KHMER range and decimal base. */

    public static final int KHMER = 1<<17;

    /** Identifies the MONGOLIAN range and decimal base. */

    public static final int MONGOLIAN = 1<<18;

    /** Identifies all ranges, for full contextual shaping.

     *

     * <p>This constant specifies all of the bit mask-based

     * ranges. Use {@code EnumSet.allOf(NumericShaper.Range.class)} to

     * specify all of the enum-based ranges.

     */

    public static final int ALL_RANGES = 0x0007ffff;

    private static final int EUROPEAN_KEY = 0;