/*

 * 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

 * particular file as subject to the "Classpath" exception as provided

 *

 * 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.

 *

 */

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;

/**

 * The <code>NumericShaper</code> 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</code> are typically applied

 * as attributes to text with the

 * {@link TextAttribute#NUMERIC_SHAPING NUMERIC_SHAPING} attribute

 * of the <code>TextAttribute</code> class.

 * For example, this code snippet causes a <code>TextLayout</code> 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</code>, 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.Scirpt.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.

 *

 * @since 1.4

 */

public final class NumericShaper implements java.io.Serializable {

    /**

     * 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</code> 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');

        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 then 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 EmunSet.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;

    private static final int ARABIC_KEY = 1;

    private static final int EASTERN_ARABIC_KEY = 2;

    private static final int DEVANAGARI_KEY = 3;

    private static final int BENGALI_KEY = 4;

    private static final int GURMUKHI_KEY = 5;

    private static final int GUJARATI_KEY = 6;

    private static final int ORIYA_KEY = 7;

    private static final int TAMIL_KEY = 8;

    private static final int TELUGU_KEY = 9;

    private static final int KANNADA_KEY = 10;

    private static final int MALAYALAM_KEY = 11;

    private static final int THAI_KEY = 12;

    private static final int LAO_KEY = 13;

    private static final int TIBETAN_KEY = 14;

    private static final int MYANMAR_KEY = 15;

    private static final int ETHIOPIC_KEY = 16;

    private static final int KHMER_KEY = 17;

    private static final int MONGOLIAN_KEY = 18;

    private static final int NUM_KEYS = MONGOLIAN_KEY + 1; // fixed

    private static final int CONTEXTUAL_MASK = 1<<31;

    private static final char[] bases = {

        '\u0030' - '\u0030', // EUROPEAN

        '\u0660' - '\u0030', // ARABIC-INDIC

        '\u06f0' - '\u0030', // EXTENDED ARABIC-INDIC (EASTERN_ARABIC)

        '\u0966' - '\u0030', // DEVANAGARI

        '\u09e6' - '\u0030', // BENGALI

        '\u0a66' - '\u0030', // GURMUKHI

        '\u0ae6' - '\u0030', // GUJARATI

        '\u0b66' - '\u0030', // ORIYA

        '\u0be6' - '\u0030', // TAMIL - zero was added in Unicode 4.1

        '\u0c66' - '\u0030', // TELUGU

        '\u0ce6' - '\u0030', // KANNADA

        '\u0d66' - '\u0030', // MALAYALAM

        '\u0e50' - '\u0030', // THAI

        '\u0ed0' - '\u0030', // LAO

        '\u0f20' - '\u0030', // TIBETAN

        '\u1040' - '\u0030', // MYANMAR

        '\u1369' - '\u0031', // ETHIOPIC - no zero

        '\u17e0' - '\u0030', // KHMER

        '\u1810' - '\u0030', // MONGOLIAN

    };

    // some ranges adjoin or overlap, rethink if we want to do a binary search on this

    private static final char[] contexts = {

        '\u0000', '\u0300', // 'EUROPEAN' (really latin-1 and extended)

        '\u0600', '\u0780', // ARABIC

        '\u0600', '\u0780', // EASTERN_ARABIC -- note overlap with arabic

        '\u0900', '\u0980', // DEVANAGARI

        '\u0980', '\u0a00', // BENGALI

        '\u0a00', '\u0a80', // GURMUKHI

        '\u0a80', '\u0b00', // GUJARATI

        '\u0b00', '\u0b80', // ORIYA

        '\u0b80', '\u0c00', // TAMIL

        '\u0c00', '\u0c80', // TELUGU

        '\u0c80', '\u0d00', // KANNADA

        '\u0d00', '\u0d80', // MALAYALAM

        '\u0e00', '\u0e80', // THAI

        '\u0e80', '\u0f00', // LAO

        '\u0f00', '\u1000', // TIBETAN

        '\u1000', '\u1080', // MYANMAR

        '\u1200', '\u1380', // ETHIOPIC - note missing zero

        '\u1780', '\u1800', // KHMER

        '\u1800', '\u1900', // MONGOLIAN

        '\uffff',

    };

    // assume most characters are near each other so probing the cache is infrequent,

    // and a linear probe is ok.

    private static int ctCache = 0;

    private static int ctCacheLimit = contexts.length - 2;

    // warning, synchronize access to this as it modifies state

    private static int getContextKey(char c) {

        if (c < contexts[ctCache]) {