/*
**********************************************************************
*   Copyright (C) 1997-2001, International Business Machines
*   Corporation and others.  All Rights Reserved.
**********************************************************************
*
* File USCRIPT.C
*
* Modification History:
*
*   Date        Name        Description
*   07/06/2001    Ram         Creation.
******************************************************************************
*/

#include "unicode/uscript.h"
#include "unicode/ures.h"
#include "uprops.h"
#include "cmemory.h"
#include "cstring.h"

#define ARRAY_SIZE(array) (sizeof array  / sizeof array[0])

struct ParenStackEntry
{
    int32_t pairIndex;
    UScriptCode scriptCode;
};

struct UScriptRun
{
    int32_t textLength;
    const UChar *textArray;

    int32_t scriptStart;
    int32_t scriptLimit;
    UScriptCode scriptCode;

    struct ParenStackEntry parenStack[128];
    int32_t parenSP;
};

static int8_t highBit(int32_t value);

static const char kLocaleScript[] = "LocaleScript";

/*
 * Use pairs of (name, code) instead of separate arrays to simplify maintenance
 * of these arrays.
 */
struct NameCodePair {
    const char *name;
    int32_t code;
};
typedef struct NameCodePair NameCodePair;

/* script names with codes, sorted by names */
static const NameCodePair
scriptNames[]={
   { "ARABIC",              USCRIPT_ARABIC      },
   { "ARMENIAN",            USCRIPT_ARMENIAN    },
   { "BENGALI",             USCRIPT_BENGALI     },
   { "BOPOMOFO",            USCRIPT_BOPOMOFO    },
   { "BUHID",               USCRIPT_BUHID       },
   { "CANADIAN_ABORIGINAL", USCRIPT_UCAS        },
   { "CHEROKEE",            USCRIPT_CHEROKEE    },
   { "COMMON",              USCRIPT_COMMON      },
   { "CYRILLIC",            USCRIPT_CYRILLIC    },
   { "DESERET",             USCRIPT_DESERET     },
   { "DEVANAGARI",          USCRIPT_DEVANAGARI  },
   { "ETHIOPIC",            USCRIPT_ETHIOPIC    },
   { "GEORGIAN",            USCRIPT_GEORGIAN    },
   { "GOTHIC",              USCRIPT_GOTHIC      },
   { "GREEK",               USCRIPT_GREEK       },
   { "GUJARATI",            USCRIPT_GUJARATI    },
   { "GURMUKHI",            USCRIPT_GURMUKHI    },
   { "HAN",                 USCRIPT_HAN         },
   { "HANGUL",              USCRIPT_HANGUL      },
   { "HANUNOO",             USCRIPT_HANUNOO     },
   { "HEBREW",              USCRIPT_HEBREW      },
   { "HIRAGANA",            USCRIPT_HIRAGANA    },
   { "INHERITED",           USCRIPT_INHERITED   },
   { "KANNADA",             USCRIPT_KANNADA     },
   { "KATAKANA",            USCRIPT_KATAKANA    },
   { "KHMER",               USCRIPT_KHMER       },
   { "LATIN",               USCRIPT_LATIN       },
   { "MALAYALAM",           USCRIPT_MALAYALAM   },
   { "MONGOLIAN",           USCRIPT_MONGOLIAN   },
   { "MYANMAR",             USCRIPT_MYANMAR     },
   { "OGHAM",               USCRIPT_OGHAM       },
   { "OLD_ITALIC",          USCRIPT_OLD_ITALIC  },
   { "ORIYA",               USCRIPT_ORIYA       },
   { "RUNIC",               USCRIPT_RUNIC       },
   { "SINHALA",             USCRIPT_SINHALA     },
   { "SYRIAC",              USCRIPT_SYRIAC      },
   { "TAGALOG",             USCRIPT_TAGALOG     },
   { "TAGBANWA",            USCRIPT_TAGBANWA    },
   { "TAMIL",               USCRIPT_TAMIL       },
   { "TELUGU",              USCRIPT_TELUGU      },
   { "THAANA",              USCRIPT_THAANA      },
   { "THAI",                USCRIPT_THAI        },
   { "TIBETAN",             USCRIPT_TIBETAN     },
   { "UCAS",                USCRIPT_UCAS        },
   { "YI",                  USCRIPT_YI          }
};

/* script abbreviations with codes, sorted by abbreviations */
static const NameCodePair
scriptAbbr[]= {
    { "Arab",       USCRIPT_ARABIC      },
    { "Armn",       USCRIPT_ARMENIAN    },
    { "Beng",       USCRIPT_BENGALI     },
    { "Bopo",       USCRIPT_BOPOMOFO    },
    { "Buhd",       USCRIPT_BUHID       },
    { "Cans",       USCRIPT_UCAS        },
    { "Cher",       USCRIPT_CHEROKEE    },
    { "Cyrl",       USCRIPT_CYRILLIC    },
 /* { "Cyrs",       USCRIPT_CYRILLIC    }, */
    { "Deva",       USCRIPT_DEVANAGARI  },
    { "Dsrt",       USCRIPT_DESERET     },
    { "Ethi",       USCRIPT_ETHIOPIC    },
 /* { "Geoa",       USCRIPT_GEORGIAN    }, */
 /* { "Geon",       USCRIPT_GEORGIAN    }, */
    { "Geor",       USCRIPT_GEORGIAN    },
    { "Goth",       USCRIPT_GOTHIC      },
    { "Grek",       USCRIPT_GREEK       },
    { "Gujr",       USCRIPT_GUJARATI    },
    { "Guru",       USCRIPT_GURMUKHI    },
    { "Hang",       USCRIPT_HANGUL      },
    { "Hani",       USCRIPT_HAN         },
    { "Hano",       USCRIPT_HANUNOO     },
    { "Hebr",       USCRIPT_HEBREW      },
    { "Hira",       USCRIPT_HIRAGANA    },
    { "Ital",       USCRIPT_OLD_ITALIC  },
    { "Kana",       USCRIPT_KATAKANA    },
    { "Khmr",       USCRIPT_KHMER       },
    { "Knda",       USCRIPT_KANNADA     },
    { "Lao",        USCRIPT_LAO         },
 /* { "Laoo",       USCRIPT_LAO         }, */
 /* { "Latf",       USCRIPT_LATIN       }, */
 /* { "Latg",       USCRIPT_LATIN       }, */
    { "Latn",       USCRIPT_LATIN       },
    { "Mlym",       USCRIPT_MALAYALAM   },
    { "Mong",       USCRIPT_MONGOLIAN   },
    { "Mymr",       USCRIPT_MYANMAR     },
    { "Ogam",       USCRIPT_OGHAM       },
    { "Orya",       USCRIPT_ORIYA       },
    { "Qaac",       USCRIPT_COPTIC      },
    { "Qaai",       USCRIPT_INHERITED   },
    { "Runr",       USCRIPT_RUNIC       },
    { "Sinh",       USCRIPT_SINHALA     },
    { "Syrc",       USCRIPT_SYRIAC      },
 /* { "Syre",       USCRIPT_SYRIAC      }, */
 /* { "Syrj",       USCRIPT_SYRIAC      }, */
 /* { "Syrn",       USCRIPT_SYRIAC      }, */
    { "Tagb",       USCRIPT_TAGBANWA    },
    { "Taml",       USCRIPT_TAMIL       },
    { "Telu",       USCRIPT_TELUGU      },
    { "Tglg",       USCRIPT_TAGALOG     },
    { "Thaa",       USCRIPT_THAANA      },
    { "Thai",       USCRIPT_THAI        },
    { "Tibt",       USCRIPT_TIBETAN     },
    { "Yiii",       USCRIPT_YI          },
    { "Zyyy",       USCRIPT_COMMON      }
};

static const UChar32 pairedChars[] = {
    0x0028, 0x0029, /* ascii paired punctuation */
    0x003c, 0x003e,
    0x005b, 0x005d,
    0x007b, 0x007d,
    0x00ab, 0x00bb, /* guillemets */
    0x2018, 0x2019, /* general punctuation */
    0x201c, 0x201d,
    0x2039, 0x203a,
    0x3008, 0x3009, /* chinese paired punctuation */
    0x300a, 0x300b,
    0x300c, 0x300d,
    0x300e, 0x300f,
    0x3010, 0x3011,
    0x3014, 0x3015,
    0x3016, 0x3017,
    0x3018, 0x3019,
    0x301a, 0x301b
};

#if 0
static const int32_t pairedCharCount = ARRAY_SIZE(pairedChars);
static const int32_t pairedCharPower = 1 << highBit(pairedCharCount);
static const int32_t pairedCharExtra = pairedCharCount - pairedCharPower;
#endif

/* binary search the string array */
U_INLINE static int 
findStringIndex(const NameCodePair sortedArr[], const char *target, int32_t size) {
    int32_t left, middle, right, rc;

    left =0;
    right= size-1;
    
    while(left <= right){
        middle = (left+right)/2;
        rc=uprv_comparePropertyNames(sortedArr[middle].name, target);
        if(rc<0){
            left = middle+1;
        }else if(rc >0){
            right = middle -1;
        }else{
            return middle;
        }
    }
    return -1;
}

/* linearly search the array and return the index */
U_INLINE static int
findCodeIndex(const NameCodePair unsorted[], const UScriptCode target, int size){
    int i=0;
    while(i<size){
        if(target == unsorted[i].code){
            return i;
        }
        i++;
    }
    return -1;
}

static int8_t
highBit(int32_t value)
{
    int8_t bit = 0;

    if (value <= 0) {
        return -32;
    }

    if (value >= 1 << 16) {
        value >>= 16;
        bit += 16;
    }

    if (value >= 1 << 8) {
        value >>= 8;
        bit += 8;
    }

    if (value >= 1 << 4) {
        value >>= 4;
        bit += 4;
    }

    if (value >= 1 << 2) {
        value >>= 2;
        bit += 2;
    }

    if (value >= 1 << 1) {
        value >>= 1;
        bit += 1;
    }

    return bit;
}

static int32_t
getPairIndex(UChar32 ch)
{
    int32_t pairedCharCount = ARRAY_SIZE(pairedChars);
    int32_t pairedCharPower = 1 << highBit(pairedCharCount);
    int32_t pairedCharExtra = pairedCharCount - pairedCharPower;

    int32_t probe = pairedCharPower;
    int32_t index = 0;

    if (ch >= pairedChars[pairedCharExtra]) {
        index = pairedCharExtra;
    }

    while (probe > (1 << 0)) {
        probe >>= 1;

        if (ch >= pairedChars[index + probe]) {
            index += probe;
        }
    }

    if (pairedChars[index] != ch) {
        index = -1;
    }

    return index;
}

static UBool
sameScript(UScriptCode scriptOne, UScriptCode scriptTwo)
{
    return scriptOne <= USCRIPT_INHERITED || scriptTwo <= USCRIPT_INHERITED || scriptOne == scriptTwo;
}

U_CAPI int32_t  U_EXPORT2
uscript_getCode(const char* nameOrAbbrOrLocale,
                UScriptCode* fillIn,
                int32_t capacity,
                UErrorCode* err){

    UScriptCode code = USCRIPT_INVALID_CODE;
    int strIndex=0;
    int32_t numFilled=0;
    int32_t len=0;
    /* check arguments */
    if(err==NULL ||U_FAILURE(*err)){
        return numFilled;
    }
    if(nameOrAbbrOrLocale==NULL || fillIn == NULL || capacity<0){
        *err = U_ILLEGAL_ARGUMENT_ERROR;
        return numFilled;
    }
    /* try the Names array first */
    strIndex = findStringIndex(scriptNames, nameOrAbbrOrLocale, ARRAY_SIZE(scriptNames));
    
    if(strIndex>=0){ 
        code = (UScriptCode) scriptNames[strIndex].code;
        len = 1;
    }
    /* we did not find in names array so try abbr array*/
    if(code ==USCRIPT_INVALID_CODE){
        strIndex = findStringIndex(scriptAbbr, nameOrAbbrOrLocale, ARRAY_SIZE(scriptAbbr));
        if(strIndex>=0){ 
            code = (UScriptCode) scriptAbbr[strIndex].code;
            len = 1;
        }
    }

    /* we still haven't found it try locale */
    if(code==USCRIPT_INVALID_CODE){
        UResourceBundle* resB = ures_open(u_getDataDirectory(),nameOrAbbrOrLocale,err);
        if(U_SUCCESS(*err)&& *err != U_USING_DEFAULT_ERROR){
            UResourceBundle* resD = ures_getByKey(resB,kLocaleScript,NULL,err);
            int index =0;
            if(U_SUCCESS(*err) ){
                len =0;
                while(ures_hasNext(resD)){
                    const UChar* name = ures_getNextString(resD,&len,NULL,err);
                    if(U_SUCCESS(*err)){
                        char cName[50] = {'\0'};
                        u_UCharsToChars(name,cName,len);
                        index = findStringIndex(scriptAbbr, cName, ARRAY_SIZE(scriptAbbr));
                        code = (UScriptCode) scriptAbbr[index].code;
                        /* got the script code now fill in the buffer */
                        if(numFilled<=capacity){ 
                            *(fillIn)++=code;
                            numFilled++;
                        }else{
                            ures_close(resD);
                            ures_close(resB);
                            *err=U_BUFFER_OVERFLOW_ERROR;
                            return len;
                        }
                    }
                }
            }
            ures_close(resD);
        
        }
        ures_close(resB);
    }else{
        /* we found it */
        if(numFilled<=capacity){ 
            *(fillIn)++=code;
            numFilled++;
        }else{
            *err=U_BUFFER_OVERFLOW_ERROR;
            return len;
        }
    }
    return numFilled;
}

U_CAPI const char*  U_EXPORT2
uscript_getName(UScriptCode scriptCode){
    int index = -1;
    if(scriptCode > USCRIPT_CODE_LIMIT){
        return "";
    }
    index = findCodeIndex(scriptNames, scriptCode, ARRAY_SIZE(scriptNames));
    if(index >=0){
        return scriptNames[index].name;
    }else{
       return "";
    }

}
U_CAPI const char*  U_EXPORT2
uscript_getShortName(UScriptCode scriptCode){
    int index = -1;
    if(scriptCode > USCRIPT_CODE_LIMIT){
        return "";
    }
    index = findCodeIndex(scriptAbbr, scriptCode, ARRAY_SIZE(scriptAbbr));
    if(index >=0){
        return scriptAbbr[index].name;
    }else{
       return "";
    }
}

U_CAPI UScriptRun * U_EXPORT2
uscript_openRun(const UChar *src, int32_t length, UErrorCode *pErrorCode)
{
    UScriptRun *result = NULL;

    if (pErrorCode == NULL || U_FAILURE(*pErrorCode)) {
        return NULL;
    }

    result = uprv_malloc(sizeof (UScriptRun));

    if (result == NULL) {
        *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
        return NULL;
    }

    uscript_setRunText(result, src, length, pErrorCode);

    /* Release the UScriptRun if uscript_setRunText() returns an error */
    if (U_FAILURE(*pErrorCode)) {
        uprv_free(result);
        result = NULL;
    }

    return result;
}

U_CAPI void U_EXPORT2
uscript_closeRun(UScriptRun *scriptRun)
{
    if (scriptRun != NULL) {
        uprv_free(scriptRun);
    }
}

U_CAPI void U_EXPORT2
uscript_resetRun(UScriptRun *scriptRun)
{
    if (scriptRun != NULL) {
        scriptRun->scriptStart = 0;
        scriptRun->scriptLimit = 0;
        scriptRun->scriptCode  = USCRIPT_INVALID_CODE;
        scriptRun->parenSP     = -1;
    }
}

U_CAPI void U_EXPORT2
uscript_setRunText(UScriptRun *scriptRun, const UChar *src, int32_t length, UErrorCode *pErrorCode)
{
    if (pErrorCode == NULL || U_FAILURE(*pErrorCode)) {
        return;
    }

    if (scriptRun == NULL || length < 0 || ((src == NULL) != (length == 0))) {
        *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }

    scriptRun->textArray  = src;
    scriptRun->textLength = length;

    uscript_resetRun(scriptRun);
}

U_CAPI UBool U_EXPORT2
uscript_nextRun(UScriptRun *scriptRun, int32_t *pRunStart, int32_t *pRunLimit, UScriptCode *pRunScript)
{
    int32_t startSP  = -1;  /* used to find the first new open character */
    UErrorCode error = U_ZERO_ERROR;

    /* if we've fallen off the end of the text, we're done */
    if (scriptRun == NULL || scriptRun->scriptLimit >= scriptRun->textLength) {
        return FALSE;
    }
    
    startSP = scriptRun->parenSP;
    scriptRun->scriptCode = USCRIPT_COMMON;

    for (scriptRun->scriptStart = scriptRun->scriptLimit; scriptRun->scriptLimit < scriptRun->textLength; scriptRun->scriptLimit += 1) {
        UChar   high = scriptRun->textArray[scriptRun->scriptLimit];
        UChar32 ch   = high;
        UScriptCode sc;
        int32_t pairIndex;

        /*
         * if the character is a high surrogate and it's not the last one
         * in the text, see if it's followed by a low surrogate
         */
        if (high >= 0xD800 && high <= 0xDBFF && scriptRun->scriptLimit < scriptRun->textLength - 1)
        {
            UChar low = scriptRun->textArray[scriptRun->scriptLimit + 1];

            /*
             * if it is followed by a low surrogate,
             * consume it and form the full character
             */
            if (low >= 0xDC00 && low <= 0xDFFF) {
                ch = (high - 0xD800) * 0x0400 + low - 0xDC00 + 0x10000;
                scriptRun->scriptLimit += 1;
            }
        }

        sc = uscript_getScript(ch, &error);
        pairIndex = getPairIndex(ch);

        /*
         * Paired character handling:
         *
         * if it's an open character, push it onto the stack.
         * if it's a close character, find the matching open on the
         * stack, and use that script code. Any non-matching open
         * characters above it on the stack will be poped.
         */
        if (pairIndex >= 0) {
            if ((pairIndex & 1) == 0) {
                scriptRun->parenStack[++scriptRun->parenSP].pairIndex = pairIndex;
                scriptRun->parenStack[scriptRun->parenSP].scriptCode  = scriptRun->scriptCode;
            } else if (scriptRun->parenSP >= 0) {
                int32_t pi = pairIndex & ~1;

                while (scriptRun->parenSP >= 0 && scriptRun->parenStack[scriptRun->parenSP].pairIndex != pi) {
                    scriptRun->parenSP -= 1;
                }

                if (scriptRun->parenSP < startSP) {
                    startSP = scriptRun->parenSP;
                }

                if (scriptRun->parenSP >= 0) {
                    sc = scriptRun->parenStack[scriptRun->parenSP].scriptCode;
                }
            }
        }

        if (sameScript(scriptRun->scriptCode, sc)) {
            if (scriptRun->scriptCode <= USCRIPT_INHERITED && sc > USCRIPT_INHERITED) {
                scriptRun->scriptCode = sc;

                /*
                 * now that we have a final script code, fix any open
                 * characters we pushed before we knew the script code.
                 */
                while (startSP < scriptRun->parenSP) {
                    scriptRun->parenStack[++startSP].scriptCode = scriptRun->scriptCode;
                }
            }

            /*
             * if this character is a close paired character,
             * pop it from the stack
             */
            if (pairIndex >= 0 && (pairIndex & 1) != 0 && scriptRun->parenSP >= 0) {
                scriptRun->parenSP -= 1;
                startSP -= 1;
            }
        } else {
            /*
             * if the run broke on a surrogate pair,
             * end it before the high surrogate
             */
            if (ch >= 0x10000) {
                scriptRun->scriptLimit -= 1;
            }

            break;
        }
    }


    if (pRunStart != NULL) {
        *pRunStart = scriptRun->scriptStart;
    }

    if (pRunLimit != NULL) {
        *pRunLimit = scriptRun->scriptLimit;
    }

    if (pRunScript != NULL) {
        *pRunScript = scriptRun->scriptCode;
    }

    return TRUE;
}