/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id$ */

package org.apache.fop.util;

import java.util.ArrayList;
import java.util.List;

// CSOFF: LineLengthCheck
// CSOFF: InnerAssignmentCheck
// CSOFF: NoWhitespaceAfterCheck
// CSOFF: AvoidNestedBlocksCheck

/**
 * Implementation of Number to String Conversion algorithm specified by
 * XSL Transformations (XSLT) Version 2.0, W3C Recommendation, 23 January 2007.
 *
 * This algorithm differs from that specified in XSLT 1.0 in the following
 * ways:
 * <ul>
 * <li>input numbers are greater than or equal to zero rather than greater than zero;</li>
 * <li>introduces format tokens { w, W, Ww };</li>
 * <li>introduces ordinal parameter to generate ordinal numbers;</li>
 * </ul>
 *
 * Implementation Defaults and Limitations
 * <ul>
 * <li>If language parameter is unspecified (null or empty string), then the value
 * of DEFAULT_LANGUAGE is used, which is defined below as "eng" (English).</li>
 * <li>Only English, French, and Spanish word numerals are supported, and only if less than one trillion (1,000,000,000,000).</li>
 * <li>Ordinal word numerals are supported for French and Spanish only when less than or equal to ten (10).</li>
 * </ul>
 *
 * Implementation Notes
 * <ul>
 * <li>In order to handle format tokens outside the Unicode BMP, all processing is
 * done in Unicode Scalar Values represented with Integer and Integer[]
 * types. Without affecting behavior, this may be subsequently optimized to
 * use int and int[] types.</li>
 * <li>In order to communicate various sub-parameters, including ordinalization, a <em>features</em>
 * is employed, which consists of comma separated name and optional value tokens, where name and value
 * are separated by an equals '=' sign.</li>
 * <li>Ordinal numbers are selected by specifying a word based format token in combination with a  'ordinal' feature with no value, in which case
 * the features 'male' and 'female' may be used to specify gender for gender sensitive languages. For example, the feature string "ordinal,female"
 * selects female ordinals.</li>
 * </ul>
 *
 * @author Glenn Adams
 */
public class NumberConverter {

    /** alphabetical  */
    public static final int LETTER_VALUE_ALPHABETIC = 1;
    /** traditional  */
    public static final int LETTER_VALUE_TRADITIONAL = 2;

    /** no token type */
    private static final int TOKEN_NONE = 0;
    /** alhphanumeric token type */
    private static final int TOKEN_ALPHANUMERIC = 1;
    /** nonalphanumeric token type */
    private static final int TOKEN_NONALPHANUMERIC = 2;
    /** default token */
    private static final Integer[] DEFAULT_TOKEN = new Integer[] { (int) '1' };
    /** default separator */
    private static final Integer[] DEFAULT_SEPARATOR = new Integer[] { (int) '.' };
    /** default language */
    private static final String DEFAULT_LANGUAGE = "eng";

    /** prefix token */
    private Integer[] prefix;
    /** suffix token */
    private Integer[] suffix;
    /** sequence of tokens, as parsed from format */
    private Integer[][] tokens;
    /** sequence of separators, as parsed from format */
    private Integer[][] separators;
    /** grouping separator */
    private int groupingSeparator;
    /** grouping size */
    private int groupingSize;
    /** letter value */
    private int letterValue;
    /** letter value system */
    private String features;
    /** language */
    private String language;
    /** country */
    private String country;

    /**
     * Construct parameterized number converter.
     * @param format format for the page number (may be null or empty, which is treated as null)
     * @param groupingSeparator grouping separator (if zero, then no grouping separator applies)
     * @param groupingSize grouping size (if zero or negative, then no grouping size applies)
     * @param letterValue letter value (must be one of the above letter value enumeration values)
     * @param features features (feature sub-parameters)
     * @param language (may be null or empty, which is treated as null)
     * @param country (may be null or empty, which is treated as null)
     * @throws IllegalArgumentException if format is not a valid UTF-16 string (e.g., has unpaired surrogate)
     */
    public NumberConverter ( String format, int groupingSeparator, int groupingSize, int letterValue, String features, String language, String country )
        throws IllegalArgumentException {
        this.groupingSeparator = groupingSeparator;
        this.groupingSize = groupingSize;
        this.letterValue = letterValue;
        this.features = features;
        this.language = ( language != null ) ? language.toLowerCase() : null;
        this.country = ( country != null ) ? country.toLowerCase() : null;
        parseFormatTokens ( format );
    }

    /**
     * Convert a number to string according to conversion parameters.
     * @param number number to conver
     * @return string representing converted number
     */
    public String convert ( long number ) {
        List<Long> numbers = new ArrayList<Long>();
        numbers.add ( number );
        return convert ( numbers );
    }

    /**
     * Convert list of numbers to string according to conversion parameters.
     * @param numbers list of numbers to convert
     * @return string representing converted list of numbers
     */
    public String convert ( List<Long> numbers ) {
        List<Integer> scalars = new ArrayList<Integer>();
        if ( prefix != null ) {
            appendScalars ( scalars, prefix );
        }
        convertNumbers ( scalars, numbers );
        if ( suffix != null ) {
            appendScalars ( scalars, suffix );
        }
        return scalarsToString ( scalars );
    }

    private void parseFormatTokens ( String format ) throws IllegalArgumentException {
        List<Integer[]> tokens = new ArrayList<Integer[]>();
        List<Integer[]> separators = new ArrayList<Integer[]>();
        if ( ( format == null ) || ( format.length() == 0 ) ) {
            format = "1";
        }
        int tokenType = TOKEN_NONE;
        List<Integer> token = new ArrayList<Integer>();
        Integer[] ca = CharUtilities.toUTF32 ( format, 0, true );
        for ( int i = 0, n = ca.length; i < n; i++ ) {
            int c = ca[i];
            int tokenTypeNew = isAlphaNumeric ( c ) ? TOKEN_ALPHANUMERIC : TOKEN_NONALPHANUMERIC;
            if ( tokenTypeNew != tokenType ) {
                if ( token.size() > 0 ) {
                    if ( tokenType == TOKEN_ALPHANUMERIC ) {
                        tokens.add ( token.toArray ( new Integer [ token.size() ]  ) );
                    } else {
                        separators.add ( token.toArray ( new Integer [ token.size() ]  ) );
                    }
                    token.clear();
                }
                tokenType = tokenTypeNew;
            }
            token.add ( c );
        }
        if ( token.size() > 0 ) {
            if ( tokenType == TOKEN_ALPHANUMERIC ) {
                tokens.add ( token.toArray ( new Integer [ token.size() ]  ) );
            } else {
                separators.add ( token.toArray ( new Integer [ token.size() ]  ) );
            }
        }
        if ( ! separators.isEmpty() ) {
            this.prefix = separators.remove ( 0 );
        }
        if ( ! separators.isEmpty() ) {
            this.suffix = separators.remove ( separators.size() - 1 );
        }
        this.separators = separators.toArray ( new Integer [ separators.size() ] [] );
        this.tokens = tokens.toArray ( new Integer [ tokens.size() ] [] );
    }

    private static boolean isAlphaNumeric ( int c ) {
        switch ( Character.getType ( c ) ) {
        case Character.DECIMAL_DIGIT_NUMBER:    // Nd
        case Character.LETTER_NUMBER:           // Nl
        case Character.OTHER_NUMBER:            // No
        case Character.UPPERCASE_LETTER:        // Lu
        case Character.LOWERCASE_LETTER:        // Ll
        case Character.TITLECASE_LETTER:        // Lt
        case Character.MODIFIER_LETTER:         // Lm
        case Character.OTHER_LETTER:            // Lo
            return true;
        default:
            return false;
        }
    }

    private void convertNumbers ( List<Integer> scalars, List<Long> numbers ) {
        Integer[] tknLast = DEFAULT_TOKEN;
        int   tknIndex = 0;
        int   tknCount = tokens.length;
        int   sepIndex = 0;
        int   sepCount = separators.length;
        int   numIndex = 0;
        for ( Long number : numbers ) {
            Integer[] sep = null;
            Integer[] tkn;
            if ( tknIndex < tknCount ) {
                if ( numIndex > 0 ) {
                    if ( sepIndex < sepCount ) {
                        sep = separators [ sepIndex++ ];
                    } else {
                        sep = DEFAULT_SEPARATOR;
                    }
                }
                tkn = tokens [ tknIndex++ ];
            } else {
                tkn = tknLast;
            }
            appendScalars ( scalars, convertNumber ( number, sep, tkn ) );
            tknLast = tkn;
            numIndex++;
        }
    }

    private Integer[] convertNumber ( long number, Integer[] separator, Integer[] token ) {
        List<Integer> sl = new ArrayList<Integer>();
        if ( separator != null ) {
            appendScalars ( sl, separator );
        }
        if ( token != null ) {
            appendScalars ( sl, formatNumber ( number, token ) );
        }
        return sl.toArray ( new Integer [ sl.size() ] );
    }

    private Integer[] formatNumber ( long number, Integer[] token ) {
        Integer[] fn = null;
        assert token.length > 0;
        if ( number < 0 ) {
            throw new IllegalArgumentException ( "number must be non-negative" );
        } else if ( token.length == 1 ) {
            int s = token[0].intValue();
            switch ( s ) {
            case (int) '1':
                {
                    fn = formatNumberAsDecimal ( number, (int) '1', 1 );
                    break;
                }
            case (int) 'W':
            case (int) 'w':
                {
                    fn = formatNumberAsWord ( number, ( s == (int) 'W' ) ? Character.UPPERCASE_LETTER : Character.LOWERCASE_LETTER );
                    break;
                }
            case (int) 'A': // handled as numeric sequence
            case (int) 'a': // handled as numeric sequence
            case (int) 'I': // handled as numeric special
            case (int) 'i': // handled as numeric special
            default:
                {
                    if ( isStartOfDecimalSequence ( s ) ) {
                        fn = formatNumberAsDecimal ( number, s, 1 );
                    } else if ( isStartOfAlphabeticSequence ( s ) ) {
                        fn = formatNumberAsSequence ( number, s, getSequenceBase ( s ), null );
                    } else if ( isStartOfNumericSpecial ( s ) ) {
                        fn = formatNumberAsSpecial ( number, s );
                    } else {
                        fn = null;
                    }
                    break;
                }
            }
        } else if ( ( token.length == 2 ) && ( token[0] == (int) 'W' ) && ( token[1] == (int) 'w' ) ) {
            fn = formatNumberAsWord ( number, Character.TITLECASE_LETTER );
        } else if ( isPaddedOne ( token ) ) {
            int s = token [ token.length - 1 ].intValue();
            fn = formatNumberAsDecimal ( number, s, token.length );
        } else {
            throw new IllegalArgumentException ( "invalid format token: \"" + CharUtilities.fromUTF32 ( token ) + "\"" );
        }
        if ( fn == null ) {
            fn = formatNumber ( number, DEFAULT_TOKEN );
        }
        assert fn != null;
        return fn;
    }

    /**
     * Format NUMBER as decimal using characters denoting digits that start at ONE,
     * adding one or more (zero) padding characters as needed to fill out field WIDTH.
     * @param number to be formatted
     * @param one unicode scalar value denoting numeric value 1
     * @param width non-negative integer denoting field width of number, possible including padding
     * @return formatted number as array of unicode scalars
     */
    private Integer[] formatNumberAsDecimal ( long number, int one, int width ) {
        assert Character.getNumericValue ( one ) == 1;
        assert Character.getNumericValue ( one - 1 ) == 0;
        assert Character.getNumericValue ( one + 8 ) == 9;
        List<Integer> sl = new ArrayList<Integer>();
        int zero = one - 1;
        while ( number > 0 ) {
            long digit = number % 10;
            sl.add ( 0, zero + (int) digit );
            number = number / 10;
        }
        while ( width > sl.size() ) {
            sl.add ( 0, zero );
        }
        if ( ( groupingSize != 0 ) && ( groupingSeparator != 0 ) ) {
            sl = performGrouping ( sl, groupingSize, groupingSeparator );
        }
        return sl.toArray ( new Integer [ sl.size() ] );
    }

    private static List<Integer> performGrouping ( List<Integer> sl, int groupingSize, int groupingSeparator ) {
        assert groupingSize > 0;
        assert groupingSeparator != 0;
        if ( sl.size() > groupingSize ) {
            List<Integer> gl = new ArrayList<Integer>();
            for ( int i = 0, n = sl.size(), g = 0; i < n; i++ ) {
                int k = n - i - 1;
                if ( g == groupingSize ) {
                    gl.add ( 0, groupingSeparator );
                    g = 1;
                } else {
                    g++;
                }
                gl.add ( 0, sl.get ( k ) );
            }
            return gl;
        } else {
            return sl;
        }
    }


    /**
     * Format NUMBER as using sequence of characters that start at ONE, and
     * having BASE radix.
     * @param number to be formatted
     * @param one unicode scalar value denoting start of sequence (numeric value 1)
     * @param base number of elements in sequence
     * @param map if non-null, then maps sequences indices to unicode scalars
     * @return formatted number as array of unicode scalars
     */
    private Integer[] formatNumberAsSequence ( long number, int one, int base, int[] map ) {
        assert base > 1;
        assert ( map == null ) || ( map.length >= base );
        List<Integer> sl = new ArrayList<Integer>();
        if ( number == 0 ) {
            return null;
        } else {
            long n = number;
            while ( n > 0 ) {
                int d = (int) ( ( n - 1 ) % (long) base );
                int s = ( map != null ) ? map [ d ] : ( one + d );
                sl.add ( 0, s );
                n = ( n - 1 ) / base;
            }
            return sl.toArray ( new Integer [ sl.size() ] );
        }
    }

    /**
     * Format NUMBER as using special system that starts at ONE.
     * @param number to be formatted
     * @param one unicode scalar value denoting start of system (numeric value 1)
     * @return formatted number as array of unicode scalars
     */
    private Integer[] formatNumberAsSpecial ( long number, int one ) {
        SpecialNumberFormatter f = getSpecialFormatter ( one, letterValue, features, language, country );
        if ( f != null ) {
            return f.format ( number, one, letterValue, features, language, country );
        } else {
            return null;
        }
    }

    /**
     * Format NUMBER as word according to TYPE, which must be either
     * Character.UPPERCASE_LETTER, Character.LOWERCASE_LETTER, or 
     * Character.TITLECASE_LETTER. Makes use of this.language to
     * determine language of word.
     * @param number to be formatted
     * @param caseType unicode character type for case conversion
     * @return formatted number as array of unicode scalars
     */
    private Integer[] formatNumberAsWord ( long number, int caseType ) {
        SpecialNumberFormatter f = null;
        if ( isLanguage ( "eng" ) ) {
            f = new EnglishNumberAsWordFormatter ( caseType );
        } else if ( isLanguage ( "spa" ) ) {
            f = new SpanishNumberAsWordFormatter ( caseType );
        } else if ( isLanguage ( "fra" ) ) {
            f = new FrenchNumberAsWordFormatter ( caseType );
        } else {
            f = new EnglishNumberAsWordFormatter ( caseType );
        }
        return f.format ( number, 0, letterValue, features, language, country );
    }

    private boolean isLanguage ( String iso3Code ) {
        if ( language == null ) {
            return false;
        } else if ( language.equals ( iso3Code ) ) {
            return true;
        } else {
            return isSameLanguage ( iso3Code, language );
        }
    }

    private static String[][] equivalentLanguages = {
        { "eng", "en" },
        { "fra", "fre", "fr" },
        { "spa", "es" },
    };

    private static boolean isSameLanguage ( String i3c, String lc ) {
        for ( String[] el : equivalentLanguages ) {
            assert el.length >= 2;
            if ( el[0].equals ( i3c ) ) {
                for ( int i = 0, n = el.length; i < n; i++ ) {
                    if ( el[i].equals ( lc ) ) {
                        return true;
                    }
                }
                return false;
            }
        }
        return false;
    }

    private static boolean hasFeature ( String features, String feature ) {
        if ( features != null ) {
            assert feature != null;
            assert feature.length() != 0;
            String[] fa = features.split(",");
            for ( String f : fa ) {
                String[] fp = f.split("=");
                assert fp.length > 0;
                String   fn = fp[0];
                String   fv = ( fp.length > 1 ) ? fp[1] : "";
                if ( fn.equals ( feature ) ) {
                    return true;
                }
            }
        }
        return false;
    }

    /* not yet used
    private static String getFeatureValue ( String features, String feature ) {
        if ( features != null ) {
            assert feature != null;
            assert feature.length() != 0;
            String[] fa = features.split(",");
            for ( String f : fa ) {
                String[] fp = f.split("=");
                assert fp.length > 0;
                String   fn = fp[0];
                String   fv = ( fp.length > 1 ) ? fp[1] : "";
                if ( fn.equals ( feature ) ) {
                    return fv;
                }
            }
        }
        return "";
    }
    */

    private static void appendScalars ( List<Integer> scalars, Integer[] sa ) {
        for ( Integer s : sa ) {
            scalars.add ( s );
        }
    }

    private static String scalarsToString ( List<Integer> scalars ) {
        Integer[] sa = scalars.toArray ( new Integer [ scalars.size() ] );
        return CharUtilities.fromUTF32 ( sa );
    }

    private static boolean isPaddedOne ( Integer[] token ) {
        if ( getDecimalValue ( token [ token.length - 1 ] ) != 1 ) {
            return false;
        } else {
            for ( int i = 0, n = token.length - 1; i < n; i++ ) {
                if ( getDecimalValue ( token [ i ] ) != 0 ) {
                    return false;
                }
            }
            return true;
        }
    }

    private static int getDecimalValue ( Integer scalar ) {
        int s = scalar.intValue();
        if ( Character.getType ( s ) == Character.DECIMAL_DIGIT_NUMBER ) {
            return Character.getNumericValue ( s );
        } else {
            return -1;
        }
    }

    private static boolean isStartOfDecimalSequence ( int s ) {
        return ( Character.getNumericValue ( s ) == 1 )
            && ( Character.getNumericValue ( s - 1 ) == 0 )
            && ( Character.getNumericValue ( s + 8 ) == 9 );
    }

    private static int[][] supportedAlphabeticSequences = {
        { 'A', 26 },            // A...Z
        { 'a', 26 },            // a...z
    };

    private static boolean isStartOfAlphabeticSequence ( int s ) {
        for ( int[] ss : supportedAlphabeticSequences ) {
            assert ss.length >= 2;
            if ( ss[0] == s ) {
                return true;
            }
        }
        return false;
    }

    private static int getSequenceBase ( int s ) {
        for ( int[] ss : supportedAlphabeticSequences ) {
            assert ss.length >= 2;
            if ( ss[0] == s ) {
                return ss[1];
            }
        }
        return 0;
    }

    private static int[][] supportedSpecials = {
        { 'I' },                // latin - uppercase roman numerals
        { 'i' },                // latin - lowercase roman numerals
        { '\u0391' },           // greek - uppercase isopsephry numerals
        { '\u03B1' },           // greek - lowercase isopsephry numerals
        { '\u05D0' },           // hebrew - gematria numerals
        { '\u0623' },           // arabic - abjadi numberals
        { '\u0627' },           // arabic - either abjadi or hijai alphabetic sequence
        { '\u0E01' },           // thai - default alphabetic sequence
        { '\u3042' },           // kana - hiragana (gojuon) - default alphabetic sequence
        { '\u3044' },           // kana - hiragana (iroha)
        { '\u30A2' },           // kana - katakana (gojuon) - default alphabetic sequence
        { '\u30A4' },           // kana - katakana (iroha)
    };

    private static boolean isStartOfNumericSpecial ( int s ) {
        for ( int[] ss : supportedSpecials ) {
            assert ss.length >= 1;
            if ( ss[0] == s ) {
                return true;
            }
        }
        return false;
    }

    private SpecialNumberFormatter getSpecialFormatter ( int one, int letterValue, String features, String language, String country ) {
        if ( one == (int) 'I' ) {
            return new RomanNumeralsFormatter();
        } else if ( one == (int) 'i' ) {
            return new RomanNumeralsFormatter();
        } else if ( one == (int) '\u0391' ) {
            return new IsopsephryNumeralsFormatter();
        } else if ( one == (int) '\u03B1' ) {
            return new IsopsephryNumeralsFormatter();
        } else if ( one == (int) '\u05D0' ) {
            return new GematriaNumeralsFormatter();
        } else if ( one == (int) '\u0623' ) {
            return new ArabicNumeralsFormatter();
        } else if ( one == (int) '\u0627' ) {
            return new ArabicNumeralsFormatter();
        } else if ( one == (int) '\u0E01' ) {
            return new ThaiNumeralsFormatter();
        } else if ( one == (int) '\u3042' ) {
            return new KanaNumeralsFormatter();
        } else if ( one == (int) '\u3044' ) {
            return new KanaNumeralsFormatter();
        } else if ( one == (int) '\u30A2' ) {
            return new KanaNumeralsFormatter();
        } else if ( one == (int) '\u30A4' ) {
            return new KanaNumeralsFormatter();
        } else {
            return null;
        }
    }

    private static Integer[] toUpperCase ( Integer[] sa ) {
        assert sa != null;
        for ( int i = 0, n = sa.length; i < n; i++ ) {
            Integer s = sa [ i ];
            sa [ i ] = Character.toUpperCase ( s );
        }
        return sa;
    }

    private static Integer[] toLowerCase ( Integer[] sa ) {
        assert sa != null;
        for ( int i = 0, n = sa.length; i < n; i++ ) {
            Integer s = sa [ i ];
            sa [ i ] = Character.toLowerCase ( s );
        }
        return sa;
    }

    /* not yet used
    private static Integer[] toTitleCase ( Integer[] sa ) {
        assert sa != null;
        if ( sa.length > 0 ) {
            sa [ 0 ] = Character.toTitleCase ( sa [ 0 ] );
        }
        return sa;
    }
    */

    private static List<String> convertWordCase ( List<String> words, int caseType ) {
        List<String> wl = new ArrayList<String>();
        for ( String w : words ) {
            wl.add ( convertWordCase ( w, caseType ) );
        }
        return wl;
    }

    private static String convertWordCase ( String word, int caseType ) {
        if ( caseType == Character.UPPERCASE_LETTER ) {
            return word.toUpperCase();
        } else if ( caseType == Character.LOWERCASE_LETTER ) {
            return word.toLowerCase();
        } else if ( caseType == Character.TITLECASE_LETTER ) {
            StringBuffer sb = new StringBuffer();
            for ( int i = 0, n = word.length(); i < n; i++ ) {
                String s = word.substring ( i, i + 1 );
                if ( i == 0 ) {
                    sb.append ( s.toUpperCase() );
                } else {
                    sb.append ( s.toLowerCase() );
                }
            }
            return sb.toString();
        } else {
            return word;
        }
    }

    private static String joinWords ( List<String> words, String separator ) {
        StringBuffer sb = new StringBuffer();
        for ( String w : words ) {
            if ( sb.length() > 0 ) {
                sb.append ( separator );
            }
            sb.append ( w );
        }
        return sb.toString();
    }

    /**
     * Special number formatter.
     */
    interface SpecialNumberFormatter {
        /**
         * Format number with special numeral system.
         * @param number to be formatted
         * @param one unicode scalar value denoting numeric value 1
         * @param letterValue letter value (must be one of the above letter value enumeration values)
         * @param features features (feature sub-parameters)
         * @param language denotes applicable language
         * @param country denotes applicable country
         * @return formatted number as array of unicode scalars
         */
        Integer[] format ( long number, int one, int letterValue, String features, String language, String country );
    }

    /**
     * English Word Numerals
     */
    private static String[] englishWordOnes = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
    private static String[] englishWordTeens = { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
    private static String[] englishWordTens = { "", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
    private static String[] englishWordOthers = { "hundred", "thousand", "million", "billion" };
    private static String[] englishWordOnesOrd = { "none", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth" };
    private static String[] englishWordTeensOrd = { "tenth", "eleventh", "twelfth", "thirteenth", "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteenth", "nineteenth" };
    private static String[] englishWordTensOrd = { "", "tenth", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", "seventieth", "eightieth", "ninetith" };
    private static String[] englishWordOthersOrd = { "hundredth", "thousandth", "millionth", "billionth" };
    private static class EnglishNumberAsWordFormatter implements SpecialNumberFormatter {
        private int caseType = Character.UPPERCASE_LETTER;
        EnglishNumberAsWordFormatter ( int caseType ) {
            this.caseType = caseType;
        }
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            List<String> wl = new ArrayList<String>();
            if ( number >= 1000000000000L ) {
                return null;
            } else {
                boolean ordinal = hasFeature ( features, "ordinal" );
                if ( number == 0 ) {
                    wl.add ( englishWordOnes [ 0 ] );
                } else if ( ordinal && ( number < 10 ) ) {
                    wl.add ( englishWordOnesOrd [ (int) number ] );
                } else {
                    int ones = (int) ( number % 1000 );
                    int thousands = (int) ( ( number / 1000 ) % 1000 );
                    int millions = (int) ( ( number / 1000000 ) % 1000 );
                    int billions = (int) ( ( number / 1000000000 ) % 1000 );
                    if ( billions > 0 ) {
                        wl = formatOnesInThousand ( wl, billions );
                        if ( ordinal && ( ( number % 1000000000 ) == 0 ) ) {
                            wl.add ( englishWordOthersOrd[3] );
                        } else {
                            wl.add ( englishWordOthers[3] );
                        }
                    }
                    if ( millions > 0 ) {
                        wl = formatOnesInThousand ( wl, millions );
                        if ( ordinal && ( ( number % 1000000 ) == 0 ) ) {
                            wl.add ( englishWordOthersOrd[2] );
                        } else {
                            wl.add ( englishWordOthers[2] );
                        }
                    }
                    if ( thousands > 0 ) {
                        wl = formatOnesInThousand ( wl, thousands );
                        if ( ordinal && ( ( number % 1000 ) == 0 ) ) {
                            wl.add ( englishWordOthersOrd[1] );
                        } else {
                            wl.add ( englishWordOthers[1] );
                        }
                    }
                    if ( ones > 0 ) {
                        wl = formatOnesInThousand ( wl, ones, ordinal );
                    }
                }
                wl = convertWordCase ( wl, caseType );
                return CharUtilities.toUTF32 ( joinWords ( wl, " " ), 0, true );
            }
        }
        private List<String> formatOnesInThousand ( List<String> wl, int number ) {
            return formatOnesInThousand ( wl, number, false );
        }
        private List<String> formatOnesInThousand ( List<String> wl, int number, boolean ordinal ) {
            assert number < 1000;
            int ones = number % 10;
            int tens = ( number / 10 ) % 10;
            int hundreds = ( number / 100 ) % 10;
            if ( hundreds > 0 ) {
                wl.add ( englishWordOnes [ hundreds ] );
                if ( ordinal && ( ( number % 100 ) == 0 ) ) {
                    wl.add ( englishWordOthersOrd[0] );
                } else {
                    wl.add ( englishWordOthers[0] );
                }
            }
            if ( tens > 0 ) {
                if ( tens == 1 ) {
                    if ( ordinal ) {
                        wl.add ( englishWordTeensOrd [ ones ] );
                    } else {
                        wl.add ( englishWordTeens [ ones ] );
                    }
                } else {
                    if ( ordinal && ( ones == 0 ) ) {
                        wl.add ( englishWordTensOrd [ tens ] );
                    } else {
                        wl.add ( englishWordTens [ tens ] );
                    }
                    if ( ones > 0 ) {
                        if ( ordinal ) {
                            wl.add ( englishWordOnesOrd [ ones ] );
                        } else {
                            wl.add ( englishWordOnes [ ones ] );
                        }
                    }
                }
            } else if ( ones > 0 ) {
                if ( ordinal ) {
                    wl.add ( englishWordOnesOrd [ ones ] );
                } else {
                    wl.add ( englishWordOnes [ ones ] );
                }
            }
            return wl;
        }
    }

    /**
     * French Word Numerals
     */
    private static String[] frenchWordOnes = { "z\u00e9ro", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf" };
    private static String[] frenchWordTeens = { "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf" };
    private static String[] frenchWordTens = { "", "dix", "vingt", "trente", "quarante", "cinquante", "soixante", "soixante-dix", "quatre-vingt", "quatre-vingt-dix" };
    private static String[] frenchWordOthers = { "cent", "cents", "mille", "million", "millions", "milliard", "milliards" };
    private static String[] frenchWordOnesOrdMale = { "premier", "deuxi\u00e8me", "troisi\u00e8me", "quatri\u00e8me", "cinqui\u00e8me", "sixi\u00e8me", "septi\u00e8me", "huiti\u00e8me", "neuvi\u00e8me", "dixi\u00e8me" };
    private static String[] frenchWordOnesOrdFemale = { "premi\u00e8re", "deuxi\u00e8me", "troisi\u00e8me", "quatri\u00e8me", "cinqui\u00e8me", "sixi\u00e8me", "septi\u00e8me", "huiti\u00e8me", "neuvi\u00e8me", "dixi\u00e8me" };
    private static class FrenchNumberAsWordFormatter implements SpecialNumberFormatter {
        private int caseType = Character.UPPERCASE_LETTER;
        FrenchNumberAsWordFormatter ( int caseType ) {
            this.caseType = caseType;
        }
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            List<String> wl = new ArrayList<String>();
            if ( number >= 1000000000000L ) {
                return null;
            } else {
                boolean ordinal = hasFeature ( features, "ordinal" );
                if ( number == 0 ) {
                    wl.add ( frenchWordOnes [ 0 ] );
                } else if ( ordinal && ( number <= 10 ) ) {
                    boolean female = hasFeature ( features, "female" );
                    if ( female ) {
                        wl.add ( frenchWordOnesOrdFemale [ (int) number ] );
                    } else {
                        wl.add ( frenchWordOnesOrdMale [ (int) number ] );
                    }
                } else {
                    int ones = (int) ( number % 1000 );
                    int thousands = (int) ( ( number / 1000 ) % 1000 );
                    int millions = (int) ( ( number / 1000000 ) % 1000 );
                    int billions = (int) ( ( number / 1000000000 ) % 1000 );
                    if ( billions > 0 ) {
                        wl = formatOnesInThousand ( wl, billions );
                        if ( billions == 1 ) {
                            wl.add ( frenchWordOthers[5] );
                        } else {
                            wl.add ( frenchWordOthers[6] );
                        }
                    }
                    if ( millions > 0 ) {
                        wl = formatOnesInThousand ( wl, millions );
                        if ( millions == 1 ) {
                            wl.add ( frenchWordOthers[3] );
                        } else {
                            wl.add ( frenchWordOthers[4] );
                        }
                    }
                    if ( thousands > 0 ) {
                        if ( thousands > 1 ) {
                            wl = formatOnesInThousand ( wl, thousands );
                        }
                        wl.add ( frenchWordOthers[2] );
                    }
                    if ( ones > 0 ) {
                        wl = formatOnesInThousand ( wl, ones );
                    }
                }
                wl = convertWordCase ( wl, caseType );
                return CharUtilities.toUTF32 ( joinWords ( wl, " " ), 0, true );
            }
        }
        private List<String> formatOnesInThousand ( List<String> wl, int number ) {
            assert number < 1000;
            int ones = number % 10;
            int tens = ( number / 10 ) % 10;
            int hundreds = ( number / 100 ) % 10;
            if ( hundreds > 0 ) {
                if ( hundreds > 1 ) {
                    wl.add ( frenchWordOnes [ hundreds ] );
                }
                if ( ( hundreds > 1 ) && ( tens == 0 ) && ( ones == 0 ) ) {
                    wl.add ( frenchWordOthers[1] );
                } else {
                    wl.add ( frenchWordOthers[0] );
                }
            }
            if ( tens > 0 ) {
                if ( tens == 1 ) {
                    wl.add ( frenchWordTeens [ ones ] );
                } else if ( tens < 7 ) {
                    if ( ones == 1 ) {
                        wl.add ( frenchWordTens [ tens ] );
                        wl.add ( "et" );
                        wl.add ( frenchWordOnes [ ones ] );
                    } else {
                        StringBuffer sb = new StringBuffer();
                        sb.append ( frenchWordTens [ tens ] );
                        if ( ones > 0 ) {
                            sb.append ( '-' );
                            sb.append ( frenchWordOnes [ ones ] );
                        }
                        wl.add ( sb.toString() );
                    }
                } else if ( tens == 7 ) {
                    if ( ones == 1 ) {
                        wl.add ( frenchWordTens [ 6 ] );
                        wl.add ( "et" );
                        wl.add ( frenchWordTeens [ ones ] );
                    } else {
                        StringBuffer sb = new StringBuffer();
                        sb.append ( frenchWordTens [ 6 ] );
                        sb.append ( '-' );
                        sb.append ( frenchWordTeens [ ones ] );
                        wl.add ( sb.toString() );
                    }
                } else if ( tens == 8 ) {
                    StringBuffer sb = new StringBuffer();
                    sb.append ( frenchWordTens [ tens ] );
                    if ( ones > 0 ) {
                        sb.append ( '-' );
                        sb.append ( frenchWordOnes [ ones ] );
                    } else {
                        sb.append ( 's' );
                    }
                    wl.add ( sb.toString() );
                } else if ( tens == 9 ) {
                    StringBuffer sb = new StringBuffer();
                    sb.append ( frenchWordTens [ 8 ] );
                    sb.append ( '-' );
                    sb.append ( frenchWordTeens [ ones ] );
                    wl.add ( sb.toString() );
                }
            } else if ( ones > 0 ) {
                wl.add ( frenchWordOnes [ ones ] );
            }
            return wl;
        }
    }

    /**
     * Spanish Word Numerals
     */
    private static String[] spanishWordOnes = { "cero", "uno", "dos", "tres", "cuatro", "cinco", "seise", "siete", "ocho", "nueve" };
    private static String[] spanishWordTeens = { "diez", "once", "doce", "trece", "catorce", "quince", "diecis\u00e9is", "diecisiete", "dieciocho", "diecinueve" };
    private static String[] spanishWordTweens = { "veinte", "veintiuno", "veintid\u00f3s", "veintitr\u00e9s", "veinticuatro", "veinticinco", "veintis\u00e9is", "veintisiete", "veintiocho", "veintinueve" };
    private static String[] spanishWordTens = { "", "diez", "veinte", "treinta", "cuarenta", "cincuenta", "sesenta", "setenta", "ochenta", "noventa" };
    private static String[] spanishWordHundreds = { "", "ciento", "doscientos", "trescientos", "cuatrocientos", "quinientos", "seiscientos", "setecientos", "ochocientos", "novecientos" };
    private static String[] spanishWordOthers = { "un", "cien", "mil", "mill\u00f3n", "millones" };
    private static String[] spanishWordOnesOrdMale = { "ninguno", "primero", "segundo", "tercero", "cuarto", "quinto", "sexto", "s\u00e9ptimo", "octavo", "novento", "d\u00e9cimo" };
    private static String[] spanishWordOnesOrdFemale = { "ninguna", "primera", "segunda", "tercera", "cuarta", "quinta", "sexta", "s\u00e9ptima", "octava", "noventa", "d\u00e9cima" };
    private static class SpanishNumberAsWordFormatter implements SpecialNumberFormatter {
        private int caseType = Character.UPPERCASE_LETTER;
        SpanishNumberAsWordFormatter ( int caseType ) {
            this.caseType = caseType;
        }
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            List<String> wl = new ArrayList<String>();
            if ( number >= 1000000000000L ) {
                return null;
            } else {
                boolean ordinal = hasFeature ( features, "ordinal" );
                if ( number == 0 ) {
                    wl.add ( spanishWordOnes [ 0 ] );
                } else if ( ordinal && ( number <= 10 ) ) {
                    boolean female = hasFeature ( features, "female" );
                    if ( female ) {
                        wl.add ( spanishWordOnesOrdFemale [ (int) number ] );
                    } else {
                        wl.add ( spanishWordOnesOrdMale [ (int) number ] );
                    }
                } else {
                    int ones = (int) ( number % 1000 );
                    int thousands = (int) ( ( number / 1000 ) % 1000 );
                    int millions = (int) ( ( number / 1000000 ) % 1000 );
                    int billions = (int) ( ( number / 1000000000 ) % 1000 );
                    if ( billions > 0 ) {
                        if ( billions > 1 ) {
                            wl = formatOnesInThousand ( wl, billions );
                        }
                        wl.add ( spanishWordOthers[2] );
                        wl.add ( spanishWordOthers[4] );
                    }
                    if ( millions > 0 ) {
                        if ( millions == 1 ) {
                            wl.add ( spanishWordOthers[0] );
                        } else {
                            wl = formatOnesInThousand ( wl, millions );
                        }
                        if ( millions > 1 ) {
                            wl.add ( spanishWordOthers[4] );
                        } else {
                            wl.add ( spanishWordOthers[3] );
                        }
                    }
                    if ( thousands > 0 ) {
                        if ( thousands > 1 ) {
                            wl = formatOnesInThousand ( wl, thousands );
                        }
                        wl.add ( spanishWordOthers[2] );
                    }
                    if ( ones > 0 ) {
                        wl = formatOnesInThousand ( wl, ones );
                    }
                }
                wl = convertWordCase ( wl, caseType );
                return CharUtilities.toUTF32 ( joinWords ( wl, " " ), 0, true );
            }
        }
        private List<String> formatOnesInThousand ( List<String> wl, int number ) {
            assert number < 1000;
            int ones = number % 10;
            int tens = ( number / 10 ) % 10;
            int hundreds = ( number / 100 ) % 10;
            if ( hundreds > 0 ) {
                if ( ( hundreds == 1 ) && ( tens == 0 ) && ( ones == 0 ) ) {
                    wl.add ( spanishWordOthers[1] );
                } else {
                    wl.add ( spanishWordHundreds [ hundreds ] );
                }
            }
            if ( tens > 0 ) {
                if ( tens == 1 ) {
                    wl.add ( spanishWordTeens [ ones ] );
                } else if ( tens == 2 ) {
                    wl.add ( spanishWordTweens [ ones ] );
                } else {
                    wl.add ( spanishWordTens [ tens ] );
                    if ( ones > 0 ) {
                        wl.add ( "y" );
                        wl.add ( spanishWordOnes [ ones ] );
                    }
                }
            } else if ( ones > 0 ) {
                wl.add ( spanishWordOnes [ ones ] );
            }
            return wl;
        }
    }

    /**
     * Roman (Latin) Numerals
     */
    private static int[] romanMapping = {
        100000,
        90000,
        50000,
        40000,
        10000,
        9000,
        5000,
        4000,
        1000,
        900,
        500,
        400,
        100,
        90,
        50,
        40,
        10,
        9,
        8,
        7,
        6,
        5,
        4,
        3,
        2,
        1
    };
    private static String[] romanStandardForms = {
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        "m",
        "cm",
        "d",
        "cd",
        "c",
        "xc",
        "l",
        "xl",
        "x",
        "ix",
        null,
        null,
        null,
        "v",
        "iv",
        null,
        null,
        "i"
    };
    private static String[] romanLargeForms = {
        "\u2188",
        "\u2182\u2188",
        "\u2187",
        "\u2182\u2187",
        "\u2182",
        "\u2180\u2182",
        "\u2181",
        "\u2180\u2181",
        "m",
        "cm",
        "d",
        "cd",
        "c",
        "xc",
        "l",
        "xl",
        "x",
        "ix",
        null,
        null,
        null,
        "v",
        "iv",
        null,
        null,
        "i"
    };
    private static String[] romanNumberForms = {
        "\u2188",
        "\u2182\u2188",
        "\u2187",
        "\u2182\u2187",
        "\u2182",
        "\u2180\u2182",
        "\u2181",
        "\u2180\u2181",
        "\u216F",
        "\u216D\u216F",
        "\u216E",
        "\u216D\u216E",
        "\u216D",
        "\u2169\u216D",
        "\u216C",
        "\u2169\u216C",
        "\u2169",
        "\u2168",
        "\u2167",
        "\u2166",
        "\u2165",
        "\u2164",
        "\u2163",
        "\u2162",
        "\u2161",
        "\u2160"
    };
    private static class RomanNumeralsFormatter implements SpecialNumberFormatter {
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            List<Integer> sl = new ArrayList<Integer>();
            if ( number == 0 ) {
                return null;
            } else {
                String[] forms;
                int maxNumber;
                if ( hasFeature ( features, "unicode-number-forms" ) ) {
                    forms = romanNumberForms;
                    maxNumber = 199999;
                } else if ( hasFeature ( features, "large" ) ) {
                    forms = romanLargeForms;
                    maxNumber = 199999;
                } else {
                    forms = romanStandardForms;
                    maxNumber = 4999;
                }
                if ( number > maxNumber ) {
                    return null;
                } else {
                    while ( number > 0 ) {
                        for ( int i = 0, n = romanMapping.length; i < n; i++ ) {
                            int d = romanMapping [ i ];
                            if ( ( number >= d ) && ( forms [ i ] != null ) ) {
                                appendScalars ( sl, CharUtilities.toUTF32 ( forms [ i ], 0, true ) );
                                number = number - d;
                                break;
                            }
                        }
                    }
                    if ( one == (int) 'I' ) {
                        return toUpperCase ( sl.toArray ( new Integer [ sl.size() ] ) );
                    } else if ( one == (int) 'i' ) {
                        return toLowerCase ( sl.toArray ( new Integer [ sl.size() ] ) );
                    } else {
                        return null;
                    }
                }
            }
        }
    }

    /**
     * Isopsephry (Greek) Numerals
     */
    private static class IsopsephryNumeralsFormatter implements SpecialNumberFormatter {
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            return null;
        }
    }

    /**
     * Gematria (Hebrew) Numerals
     */
    private static int[] hebrewGematriaAlphabeticMap = {
        // ones
        0x05D0, // ALEF
        0x05D1, // BET
        0x05D2, // GIMEL
        0x05D3, // DALET
        0x05D4, // HE
        0x05D5, // VAV
        0x05D6, // ZAYIN
        0x05D7, // HET
        0x05D8, // TET
        // tens
        0x05D9, // YOD
        0x05DB, // KAF
        0x05DC, // LAMED
        0x05DE, // MEM
        0x05E0, // NUN
        0x05E1, // SAMEKH
        0x05E2, // AYIN
        0x05E4, // PE
        0x05E6, // TSADHI
        // hundreds
        0x05E7, // QOF
        0x05E8, // RESH
        0x05E9, // SHIN
        0x05EA, // TAV
        0x05DA, // FINAL KAF
        0x05DD, // FINAL MEM
        0x05DF, // FINAL NUN
        0x05E3, // FINAL PE
        0x05E5, // FINAL TSADHI
    };
    private class GematriaNumeralsFormatter implements SpecialNumberFormatter {
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            if ( one == 0x05D0 ) {
                if ( letterValue == LETTER_VALUE_ALPHABETIC ) {
                    return formatNumberAsSequence ( number, one, hebrewGematriaAlphabeticMap.length, hebrewGematriaAlphabeticMap );
                } else if ( letterValue == LETTER_VALUE_TRADITIONAL ) {
                    if ( ( number == 0 ) || ( number > 1999 ) ) {
                        return null;
                    } else {
                        return formatAsGematriaNumber ( number, features, language, country );
                    }
                } else {
                    return null;
                }
            } else {
                return null;
            }
        }
        private Integer[] formatAsGematriaNumber ( long number, String features, String language, String country ) {
            List<Integer> sl = new ArrayList<Integer>();
            assert hebrewGematriaAlphabeticMap.length == 27;
            assert hebrewGematriaAlphabeticMap[0] == 0x05D0;  // ALEF
            assert hebrewGematriaAlphabeticMap[21] == 0x05EA; // TAV
            assert number != 0;
            assert number < 2000;
            int[] map = hebrewGematriaAlphabeticMap;
            int thousands = (int) ( ( number / 1000 ) % 10 );
            int hundreds = (int) ( ( number / 100 ) % 10 );
            int tens = (int) ( ( number / 10 ) % 10 );
            int ones = (int) ( ( number / 1 ) % 10 );
            if ( thousands > 0 ) {
                sl.add ( map [ 0 + ( thousands - 1 ) ] );
                sl.add ( 0x05F3 );
            }
            if ( hundreds > 0 ) {
                assert hundreds < 10;
                if ( hundreds < 5 ) {
                    sl.add ( map [ 18 + ( hundreds - 1 ) ] );
                } else if ( hundreds < 9 ) {
                    sl.add ( map [ 18 + ( 4 - 1 ) ] );
                    sl.add ( 0x05F4 );
                    sl.add ( map [ 18 + ( hundreds - 5 ) ] );
                } else if ( hundreds == 9 ) {
                    sl.add ( map [ 18 + ( 4 - 1 ) ] );
                    sl.add ( map [ 18 + ( 4 - 1 ) ] );
                    sl.add ( 0x05F4 );
                    sl.add ( map [ 18 + ( hundreds - 9 ) ] );
                }
            }
            if ( number == 15 ) {
                sl.add ( map [ 9 - 1] );
                sl.add ( 0x05F4 );
                sl.add ( map [ 6 - 1] );
            } else if ( number == 16 ) {
                sl.add ( map [ 9 - 1 ] );
                sl.add ( 0x05F4 );
                sl.add ( map [ 7 - 1 ] );
            } else {
                if ( tens > 0 ) {
                    assert tens < 10;
                    sl.add ( map [ 9 + ( tens - 1 ) ] );
                }
                if ( ones > 0 ) {
                    assert ones < 10;
                    sl.add ( map [ 0 + ( ones - 1 ) ] );
                }
            }
            return sl.toArray ( new Integer [ sl.size() ] );
        }
    }

    /**
     * Arabic Numerals
     */
    private static int[] arabicAbjadiAlphabeticMap = {
        // ones
        0x0623, // ALEF WITH HAMZA ABOVE
        0x0628, // BEH
        0x062C, // JEEM
        0x062F, // DAL
        0x0647, // HEH
        0x0648, // WAW
        0x0632, // ZAIN
        0x062D, // HAH
        0x0637, // TAH
        // tens
        0x0649, // ALEF MAQSURA
        0x0643, // KAF
        0x0644, // LAM
        0x0645, // MEEM
        0x0646, // NOON
        0x0633, // SEEN
        0x0639, // AIN
        0x0641, // FEH
        0x0635, // SAD
        // hundreds
        0x0642, // QAF
        0x0631, // REH
        0x0634, // SHEEN
        0x062A, // TEH
        0x062B, // THEH
        0x062E, // KHAH
        0x0630, // THAL
        0x0636, // DAD
        0x0638, // ZAH
        // thousands
        0x063A, // GHAIN
    };
    private static int[] arabicHijaiAlphabeticMap = {
        0x0623, // ALEF WITH HAMZA ABOVE
        0x0628, // BEH
        0x062A, // TEH
        0x062B, // THEH
        0x062C, // JEEM
        0x062D, // HAH
        0x062E, // KHAH
        0x062F, // DAL
        0x0630, // THAL
        0x0631, // REH
        0x0632, // ZAIN
        0x0633, // SEEN
        0x0634, // SHEEN
        0x0635, // SAD
        0x0636, // DAD
        0x0637, // TAH
        0x0638, // ZAH
        0x0639, // AIN
        0x063A, // GHAIN
        0x0641, // FEH
        0x0642, // QAF
        0x0643, // KAF
        0x0644, // LAM
        0x0645, // MEEM
        0x0646, // NOON
        0x0647, // HEH
        0x0648, // WAW
        0x0649, // ALEF MAQSURA
    };
    private class ArabicNumeralsFormatter implements SpecialNumberFormatter {
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            if ( one == 0x0627 ) {
                int[] map;
                if ( letterValue == LETTER_VALUE_TRADITIONAL ) {
                    map = arabicAbjadiAlphabeticMap;
                } else if ( letterValue == LETTER_VALUE_ALPHABETIC ) {
                    map = arabicHijaiAlphabeticMap;
                } else {
                    map = arabicAbjadiAlphabeticMap;
                }
                return formatNumberAsSequence ( number, one, map.length, map );
            } else if ( one == 0x0623 ) {
                if ( ( number == 0 ) || ( number > 1999 ) ) {
                    return null;
                } else {
                    return formatAsAbjadiNumber ( number, features, language, country );
                }
            } else {
                return null;
            }
        }
        private Integer[] formatAsAbjadiNumber ( long number, String features, String language, String country ) {
            List<Integer> sl = new ArrayList<Integer>();
            assert arabicAbjadiAlphabeticMap.length == 28;
            assert arabicAbjadiAlphabeticMap[0] == 0x0623;  // ALEF WITH HAMZA ABOVE
            assert arabicAbjadiAlphabeticMap[27] == 0x063A; // GHAIN
            assert number != 0;
            assert number < 2000;
            int[] map = arabicAbjadiAlphabeticMap;
            int thousands = (int) ( ( number / 1000 ) % 10 );
            int hundreds = (int) ( ( number / 100 ) % 10 );
            int tens = (int) ( ( number / 10 ) % 10 );
            int ones = (int) ( ( number / 1 ) % 10 );
            if ( thousands > 0 ) {
                assert thousands < 2;
                sl.add ( map [ 27 + ( thousands - 1 ) ] );
            }
            if ( hundreds > 0 ) {
                assert thousands < 10;
                sl.add ( map [ 18 + ( hundreds - 1 ) ] );
            }
            if ( tens > 0 ) {
                assert tens < 10;
                sl.add ( map [ 9 + ( tens - 1 ) ] );
            }
            if ( ones > 0 ) {
                assert ones < 10;
                sl.add ( map [ 0 + ( ones - 1 ) ] );
            }
            return sl.toArray ( new Integer [ sl.size() ] );
        }
    }

    /**
     * Kana (Japanese) Numerals
     */
    private static int[] hiraganaGojuonAlphabeticMap = {
        0x3042, // A
        0x3044, // I
        0x3046, // U
        0x3048, // E
        0x304A, // O
        0x304B, // KA
        0x304D, // KI
        0x304F, // KU
        0x3051, // KE
        0x3053, // KO
        0x3055, // SA
        0x3057, // SI
        0x3059, // SU
        0x305B, // SE
        0x305D, // SO
        0x305F, // TA
        0x3061, // TI
        0x3064, // TU
        0x3066, // TE
        0x3068, // TO
        0x306A, // NA
        0x306B, // NI
        0x306C, // NU
        0x306D, // NE
        0x306E, // NO
        0x306F, // HA
        0x3072, // HI
        0x3075, // HU
        0x3078, // HE
        0x307B, // HO
        0x307E, // MA
        0x307F, // MI
        0x3080, // MU
        0x3081, // ME
        0x3082, // MO
        0x3084, // YA
        0x3086, // YU
        0x3088, // YO
        0x3089, // RA
        0x308A, // RI
        0x308B, // RU
        0x308C, // RE
        0x308D, // RO
        0x308F, // WA
        0x3090, // WI
        0x3091, // WE
        0x3092, // WO
        0x3093, // N
    };
    private static int[] katakanaGojuonAlphabeticMap = {
        0x30A2, // A
        0x30A4, // I
        0x30A6, // U
        0x30A8, // E
        0x30AA, // O
        0x30AB, // KA
        0x30AD, // KI
        0x30AF, // KU
        0x30B1, // KE
        0x30B3, // KO
        0x30B5, // SA
        0x30B7, // SI
        0x30B9, // SU
        0x30BB, // SE
        0x30BD, // SO
        0x30BF, // TA
        0x30C1, // TI
        0x30C4, // TU
        0x30C6, // TE
        0x30C8, // TO
        0x30CA, // NA
        0x30CB, // NI
        0x30CC, // NU
        0x30CD, // NE
        0x30CE, // NO
        0x30CF, // HA
        0x30D2, // HI
        0x30D5, // HU
        0x30D8, // HE
        0x30DB, // HO
        0x30DE, // MA
        0x30DF, // MI
        0x30E0, // MU
        0x30E1, // ME
        0x30E2, // MO
        0x30E4, // YA
        0x30E6, // YU
        0x30E8, // YO
        0x30E9, // RA
        0x30EA, // RI
        0x30EB, // RU
        0x30EC, // RE
        0x30ED, // RO
        0x30EF, // WA
        0x30F0, // WI
        0x30F1, // WE
        0x30F2, // WO
        0x30F3, // N
    };
    private class KanaNumeralsFormatter implements SpecialNumberFormatter {
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            if ( ( one == 0x3042 ) && ( letterValue == LETTER_VALUE_ALPHABETIC ) ) {
                return formatNumberAsSequence ( number, one, hiraganaGojuonAlphabeticMap.length, hiraganaGojuonAlphabeticMap );
            } else if ( ( one == 0x30A2 ) && ( letterValue == LETTER_VALUE_ALPHABETIC ) ) {
                return formatNumberAsSequence ( number, one, katakanaGojuonAlphabeticMap.length, katakanaGojuonAlphabeticMap );
            } else {
                return null;
            }
        }
    }

    /**
     * Thai Numerals
     */
    private static int[] thaiAlphabeticMap = {
        0x0E01,
        0x0E02,
        0x0E03,
        0x0E04,
        0x0E05,
        0x0E06,
        0x0E07,
        0x0E08,
        0x0E09,
        0x0E0A,
        0x0E0B,
        0x0E0C,
        0x0E0D,
        0x0E0E,
        0x0E0F,
        0x0E10,
        0x0E11,
        0x0E12,
        0x0E13,
        0x0E14,
        0x0E15,
        0x0E16,
        0x0E17,
        0x0E18,
        0x0E19,
        0x0E1A,
        0x0E1B,
        0x0E1C,
        0x0E1D,
        0x0E1E,
        0x0E1F,
        0x0E20,
        0x0E21,
        0x0E22,
        0x0E23,
        // 0x0E24, // RU - not used in modern sequence
        0x0E25,
        // 0x0E26, // LU - not used in modern sequence
        0x0E27,
        0x0E28,
        0x0E29,
        0x0E2A,
        0x0E2B,
        0x0E2C,
        0x0E2D,
        0x0E2E,
    };
    private class ThaiNumeralsFormatter implements SpecialNumberFormatter {
        @Override
        public Integer[] format ( long number, int one, int letterValue, String features, String language, String country ) {
            if ( ( one == 0x0E01 ) && ( letterValue == LETTER_VALUE_ALPHABETIC ) ) {
                return formatNumberAsSequence ( number, one, thaiAlphabeticMap.length, thaiAlphabeticMap );
            } else {
                return null;
            }
        }
    }

}