/*
 * Copyright (C) 2006 The Android Open Source Project
 *
 * Licensed 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.
 */

//

#ifndef ANDROID_UNICODE_H
#define ANDROID_UNICODE_H

#include <stdint.h>
#include <sys/types.h>

#define REPLACEMENT_CHAR (0xFFFD)

// this part of code is copied from umachine.h under ICU
/**
 * Define UChar32 as a type for single Unicode code points.
 * UChar32 is a signed 32-bit integer (same as int32_t).
 *
 * The Unicode code point range is 0..0x10ffff.
 * All other values (negative or >=0x110000) are illegal as Unicode code points.
 * They may be used as sentinel values to indicate "done", "error"
 * or similar non-code point conditions.
 *
 * @stable ICU 2.4
 */
typedef int32_t UChar32;

namespace android {

    class Encoding;
    /**
     * \class Unicode
     *
     * Helper class for getting properties of Unicode characters. Characters
     * can have one of the types listed in CharType and each character can have the
     * directionality of Direction.
     */
    class Unicode
    {
    public:
        /**
         * Directions specified in the Unicode standard. These directions map directly
         * to java.lang.Character.
         */
        enum Direction {
            DIRECTIONALITY_UNDEFINED = -1,
            DIRECTIONALITY_LEFT_TO_RIGHT,
            DIRECTIONALITY_RIGHT_TO_LEFT,
            DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC,
            DIRECTIONALITY_EUROPEAN_NUMBER,
            DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR,
            DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR,
            DIRECTIONALITY_ARABIC_NUMBER,
            DIRECTIONALITY_COMMON_NUMBER_SEPARATOR,
            DIRECTIONALITY_NONSPACING_MARK,
            DIRECTIONALITY_BOUNDARY_NEUTRAL,
            DIRECTIONALITY_PARAGRAPH_SEPARATOR,
            DIRECTIONALITY_SEGMENT_SEPARATOR,
            DIRECTIONALITY_WHITESPACE,
            DIRECTIONALITY_OTHER_NEUTRALS,
            DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING,
            DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE,
            DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING,
            DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE,
            DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
        };

        /**
         * Character types as specified in the Unicode standard. These map directly to
         * java.lang.Character.
         */
        enum CharType {
            CHARTYPE_UNASSIGNED = 0,
            CHARTYPE_UPPERCASE_LETTER,
            CHARTYPE_LOWERCASE_LETTER,
            CHARTYPE_TITLECASE_LETTER,
            CHARTYPE_MODIFIER_LETTER,
            CHARTYPE_OTHER_LETTER,
            CHARTYPE_NON_SPACING_MARK,
            CHARTYPE_ENCLOSING_MARK,
            CHARTYPE_COMBINING_SPACING_MARK,
            CHARTYPE_DECIMAL_DIGIT_NUMBER,
            CHARTYPE_LETTER_NUMBER,
            CHARTYPE_OTHER_NUMBER,
            CHARTYPE_SPACE_SEPARATOR,
            CHARTYPE_LINE_SEPARATOR,
            CHARTYPE_PARAGRAPH_SEPARATOR,
            CHARTYPE_CONTROL,
            CHARTYPE_FORMAT,
            CHARTYPE_MISSING_VALUE_FOR_JAVA,    /* This is the mysterious missing 17 value from the java constants */
            CHARTYPE_PRIVATE_USE,
            CHARTYPE_SURROGATE,
            CHARTYPE_DASH_PUNCTUATION,
            CHARTYPE_START_PUNCTUATION,
            CHARTYPE_END_PUNCTUATION,
            CHARTYPE_CONNECTOR_PUNCTUATION,
            CHARTYPE_OTHER_PUNCTUATION,
            CHARTYPE_MATH_SYMBOL,
            CHARTYPE_CURRENCY_SYMBOL,
            CHARTYPE_MODIFIER_SYMBOL,
            CHARTYPE_OTHER_SYMBOL,
            CHARTYPE_INITIAL_QUOTE_PUNCTUATION,
            CHARTYPE_FINAL_QUOTE_PUNCTUATION
        };

        /**
         * Decomposition types as described by the unicode standard. These values map to
         * the same values in uchar.h in ICU.
         */
        enum DecompositionType {
            DECOMPOSITION_NONE = 0,
            DECOMPOSITION_CANONICAL,
            DECOMPOSITION_COMPAT,
            DECOMPOSITION_CIRCLE,
            DECOMPOSITION_FINAL,
            DECOMPOSITION_FONT,
            DECOMPOSITION_FRACTION,
            DECOMPOSITION_INITIAL,
            DECOMPOSITION_ISOLATED,
            DECOMPOSITION_MEDIAL,
            DECOMPOSITION_NARROW,
            DECOMPOSITION_NOBREAK,
            DECOMPOSITION_SMALL,
            DECOMPOSITION_SQUARE,
            DECOMPOSITION_SUB,
            DECOMPOSITION_SUPER,
            DECOMPOSITION_VERTICAL,
            DECOMPOSITION_WIDE
        };

        /**
         * Returns the packed data for java calls
         * @param c The unicode character.
         * @return The packed data for the character.
         *
         * Copied from java.lang.Character implementation:
         * 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
         * F E D C B A 9 8 7 6 5 4 3 2 1 0 F E D C B A 9 8 7 6 5 4 3 2 1 0
         * 
         *                              31 types                 ---------
         *                   18 directionalities       ---------
         *                   2 mirroreds             -
         *                               -----------      56  toupper diffs
         *                   -----------                  48  tolower diffs
         *               ---                              4 totitlecase diffs
         * -------------                                 84 numeric values
         *     ---------                                 24 mirror char diffs
         */
        static uint32_t getPackedData(UChar32 c);
        
        /**
         * Get the Character type.
         * @param c The unicode character.
         * @return The character's type or CHARTYPE_UNASSIGNED if the character is invalid
         *         or has an unassigned class.
         */
        static CharType getType(UChar32 c);    

        /**
         * Get the Character's decomposition type.
         * @param c The unicode character.
         * @return The character's decomposition type or DECOMPOSITION_NONE is there 
         *         is no decomposition.
         */
        static DecompositionType getDecompositionType(UChar32 c);
        
        /**
         * Returns the digit value of a character or -1 if the character
         * is not within the specified radix.
         *
         * The digit value is computed for integer characters and letters
         * within the given radix. This function does not handle Roman Numerals,
         * fractions, or any other characters that may represent numbers.
         * 
         * @param c The unicode character
         * @param radix The intended radix.
         * @return The digit value or -1 if there is no digit value or if the value is outside the radix.
         */
        static int getDigitValue(UChar32 c, int radix = 10);

        /**
         * Return the numeric value of a character
         *
         * @param c The unicode character.
         * @return The numeric value of the character. -1 if the character has no numeric value, 
         *         -2 if the character has a numeric value that is not representable by an integer.
         */
        static int getNumericValue(UChar32 c);

        /**
         * Convert the character to lowercase
         * @param c The unicode character.
         * @return The lowercase character equivalent of c. If c does not have a lowercase equivalent,
         *         the original character is returned.
         */
        static UChar32 toLower(UChar32 c);
            
        /**
         * Convert the character to uppercase
         * @param c The unicode character.
         * @return The uppercase character equivalent of c. If c does not have an uppercase equivalent,
         *         the original character is returned.
         */
        static UChar32 toUpper(UChar32 c);
    
        /**
         * Get the directionality of the character.
         * @param c The unicode character.
         * @return The direction of the character or DIRECTIONALITY_UNDEFINED.
         */
        static Direction getDirectionality(UChar32 c);
            
        /**
         * Check if the character is a mirrored character. This means that the character
         * has an equivalent character that is the mirror image of itself.
         * @param c The unicode character.
         * @return True iff c has a mirror equivalent.
         */
        static bool isMirrored(UChar32 c);
         
        /**
         * Return the mirror of the given character.
         * @param c The unicode character.
         * @return The mirror equivalent of c. If c does not have a mirror equivalent,
         *         the original character is returned.
         * @see isMirrored
         */
        static UChar32 toMirror(UChar32 c);
        
        /**
         * Convert the character to title case.
         * @param c The unicode character.
         * @return The titlecase equivalent of c. If c does not have a titlecase equivalent,
         *         the original character is returned.
         */
        static UChar32 toTitle(UChar32 c);

   };

}

#endif