/*

  *

  * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved 

  *

  * This file is a modification of the ICU file IndicReordering.cpp

  * by Jens Herden and Javier Sola for Khmer language 

  *

  */

 #include "LETypes.h"

 #include "KhmerReordering.h"

 #include "LEGlyphStorage.h"

 U_NAMESPACE_BEGIN

 // Characters that get refered to by name...

 enum

 {

     C_SIGN_ZWNJ     = 0x200C,

     C_SIGN_ZWJ      = 0x200D,

     C_DOTTED_CIRCLE = 0x25CC,

     C_RO            = 0x179A,

     C_VOWEL_AA      = 0x17B6,

     C_SIGN_NIKAHIT  = 0x17C6,

     C_VOWEL_E       = 0x17C1,

     C_COENG         = 0x17D2

 };

 enum

 {

     // simple classes, they are used in the statetable (in this file) to control the length of a syllable

     // they are also used to know where a character should be placed (location in reference to the base character)

     // and also to know if a character, when independtly displayed, should be displayed with a dotted-circle to

     // indicate error in syllable construction 

     _xx = KhmerClassTable::CC_RESERVED,

     _sa = KhmerClassTable::CC_SIGN_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_POS_ABOVE,

     _sp = KhmerClassTable::CC_SIGN_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE| KhmerClassTable::CF_POS_AFTER,

     _c1 = KhmerClassTable::CC_CONSONANT | KhmerClassTable::CF_CONSONANT,

     _c2 = KhmerClassTable::CC_CONSONANT2 | KhmerClassTable::CF_CONSONANT,

     _c3 = KhmerClassTable::CC_CONSONANT3 | KhmerClassTable::CF_CONSONANT,

     _rb = KhmerClassTable::CC_ROBAT | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE,

     _cs = KhmerClassTable::CC_CONSONANT_SHIFTER | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_SHIFTER,

     _dl = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BEFORE | KhmerClassTable::CF_DOTTED_CIRCLE, 

     _db = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BELOW | KhmerClassTable::CF_DOTTED_CIRCLE,

     _da = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_ABOVE_VOWEL,

     _dr = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE,

     _co = KhmerClassTable::CC_COENG | KhmerClassTable::CF_COENG | KhmerClassTable::CF_DOTTED_CIRCLE,

     // split vowel

     _va = _da | KhmerClassTable::CF_SPLIT_VOWEL,

     _vr = _dr | KhmerClassTable::CF_SPLIT_VOWEL

 };

 // Character class tables 

 // _xx character does not combine into syllable, such as numbers, puntuation marks, non-Khmer signs... 

 // _sa Sign placed above the base

 // _sp Sign placed after the base

 // _c1 Consonant of type 1 or independent vowel (independent vowels behave as type 1 consonants)

 // _c2 Consonant of type 2 (only RO)

 // _c3 Consonant of type 3 

 // _rb Khmer sign robat u17CC. combining mark for subscript consonants

 // _cd Consonant-shifter

 // _dl Dependent vowel placed before the base (left of the base)

 // _db Dependent vowel placed below the base 

 // _da Dependent vowel placed above the base

 // _dr Dependent vowel placed behind the base (right of the base)    

 // _co Khmer combining mark COENG u17D2, combines with the consonant or independent vowel following 

 //     it to create a subscript consonant or independent vowel   

 // _va Khmer split vowel in wich the first part is before the base and the second one above the base

 // _vr Khmer split vowel in wich the first part is before the base and the second one behind (right of) the base

 static const KhmerClassTable::CharClass khmerCharClasses[] =

 {

     _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, // 1780 - 178F

     _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c2, _c1, _c1, _c1, _c3, _c3, // 1790 - 179F

     _c1, _c3, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, // 17A0 - 17AF

     _c1, _c1, _c1, _c1, _dr, _dr, _dr, _da, _da, _da, _da, _db, _db, _db, _va, _vr, // 17B0 - 17BF

     _vr, _dl, _dl, _dl, _vr, _vr, _sa, _sp, _sp, _cs, _cs, _sa, _rb, _sa, _sa, _sa, // 17C0 - 17CF

     _sa, _sa, _co, _sa, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _sa, _xx, _xx, // 17D0 - 17DF

 };                                                                                  

 //

 // Khmer Class Tables

 //                   

 //

 // The range of characters defined in the above table is defined here. FOr Khmer 1780 to 17DF

 // Even if the Khmer range is bigger, all other characters are not combinable, and therefore treated

 // as _xx

 static const KhmerClassTable khmerClassTable = {0x1780, 0x17df, khmerCharClasses};

 // Below we define how a character in the input string is either in the khmerCharClasses table

 // (in which case we get its type back), a ZWJ or ZWNJ (two characters that may appear 

 // within the syllable, but are not in the table) we also get their type back, or an unknown object

 // in which case we get _xx (CC_RESERVED) back

 KhmerClassTable::CharClass KhmerClassTable::getCharClass(LEUnicode ch) const

 {

     if (ch == C_SIGN_ZWJ) {

         return CC_ZERO_WIDTH_J_MARK;

     }

     if (ch == C_SIGN_ZWNJ) {

         return CC_ZERO_WIDTH_NJ_MARK;

     }

     if (ch < firstChar || ch > lastChar) {

         return CC_RESERVED;

     }

     return classTable[ch - firstChar];

 }

 const KhmerClassTable *KhmerClassTable::getKhmerClassTable()

 {

     return &khmerClassTable;

 }

 class ReorderingOutput : public UMemory {

 private:

     le_int32 fOutIndex;

     LEUnicode *fOutChars;

     LEGlyphStorage &fGlyphStorage;

 public:

     ReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage)

         : fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage)

     {

         // nothing else to do...

     }

     ~ReorderingOutput()

     {

         // nothing to do here...

     }

     void writeChar(LEUnicode ch, le_uint32 charIndex, const LETag *charTags)

     {

         LEErrorCode success = LE_NO_ERROR;

         fOutChars[fOutIndex] = ch;

         fGlyphStorage.setCharIndex(fOutIndex, charIndex, success);

         fGlyphStorage.setAuxData(fOutIndex, (void *) charTags, success);

         fOutIndex += 1;

     }

     le_int32 getOutputIndex()

     {

         return fOutIndex;

     }

 };

 static const LETag emptyTag       = 0x00000000; // ''

 //TODO remove unused flags

 //static const LETag nuktFeatureTag = LE_NUKT_FEATURE_TAG;

 //static const LETag akhnFeatureTag = LE_AKHN_FEATURE_TAG;

 //static const LETag rphfFeatureTag = LE_RPHF_FEATURE_TAG;

 static const LETag blwfFeatureTag = LE_BLWF_FEATURE_TAG;

 //static const LETag halfFeatureTag = LE_HALF_FEATURE_TAG;

 static const LETag pstfFeatureTag = LE_PSTF_FEATURE_TAG;

 //static const LETag vatuFeatureTag = LE_VATU_FEATURE_TAG;

 static const LETag presFeatureTag = LE_PRES_FEATURE_TAG;

 static const LETag blwsFeatureTag = LE_BLWS_FEATURE_TAG;

 static const LETag abvsFeatureTag = LE_ABVS_FEATURE_TAG;

 static const LETag pstsFeatureTag = LE_PSTS_FEATURE_TAG;

 //static const LETag halnFeatureTag = LE_HALN_FEATURE_TAG;

 static const LETag blwmFeatureTag = LE_BLWM_FEATURE_TAG;

 static const LETag abvmFeatureTag = LE_ABVM_FEATURE_TAG;

 static const LETag distFeatureTag = LE_DIST_FEATURE_TAG;

 static const LETag prefFeatureTag = LE_PREF_FEATURE_TAG;

 static const LETag abvfFeatureTag = LE_ABVF_FEATURE_TAG;

 static const LETag cligFeatureTag = LE_CLIG_FEATURE_TAG;

 static const LETag mkmkFeatureTag = LE_MKMK_FEATURE_TAG;

 // These are in the order in which the features need to be applied

 // for correct processing

 static const LETag featureOrder[] =

 {

     // Shaping features

     prefFeatureTag, blwfFeatureTag, abvfFeatureTag, pstfFeatureTag, 

     presFeatureTag, blwsFeatureTag, abvsFeatureTag, pstsFeatureTag,

     cligFeatureTag, 

     // Positioning features

     distFeatureTag, blwmFeatureTag, abvmFeatureTag, mkmkFeatureTag,

     emptyTag

 };

 static const LETag tagPref[] = 

 {

     prefFeatureTag, presFeatureTag, 

     cligFeatureTag, 

     // Positioning features

     distFeatureTag, 

     emptyTag

 };

 static const LETag tagAbvf[] = 

 {

     abvfFeatureTag, abvsFeatureTag, 

     cligFeatureTag, 

     // Positioning features

     distFeatureTag, abvmFeatureTag, mkmkFeatureTag,

     emptyTag

 };

 static const LETag tagPstf[] = 

 {

     blwfFeatureTag, blwsFeatureTag, 

     prefFeatureTag, presFeatureTag, 

     pstfFeatureTag, pstsFeatureTag, 

     cligFeatureTag, 

     // Positioning features

     distFeatureTag, blwmFeatureTag, 

     emptyTag

 };

 static const LETag tagBlwf[] = 

 {

     blwfFeatureTag, blwsFeatureTag, 

     cligFeatureTag, 

     // Positioning features

     distFeatureTag, blwmFeatureTag, mkmkFeatureTag,

     emptyTag

 };

 // TODO do we need all of them?

 static const LETag tagDefault[] = 

 {

     // Shaping feature

     prefFeatureTag, blwfFeatureTag, /*abvfFeatureTag,*/ /*pstfFeatureTag, */

     presFeatureTag, blwsFeatureTag, /*abvsFeatureTag,*/ /*pstsFeatureTag,*/

     cligFeatureTag, 

     // Positioning features

     distFeatureTag, abvmFeatureTag, blwmFeatureTag, mkmkFeatureTag,

     emptyTag

 };

 // The stateTable is used to calculate the end (the length) of a well

 // formed Khmer Syllable. 

 //

 // Each horizontal line is ordered exactly the same way as the values in KhmerClassTable

 // CharClassValues in KhmerReordering.h This coincidence of values allows the

 // follow up of the table.

 //

 // Each line corresponds to a state, which does not necessarily need to be a type

 // of component... for example, state 2 is a base, with is always a first character

 // in the syllable, but the state could be produced a consonant of any type when

 // it is the first character that is analysed (in ground state).

 //

 // Differentiating 3 types of consonants is necessary in order to 

 // forbid the use of certain combinations, such as having a second

 // coeng after a coeng RO, 

 // The inexistent possibility of having a type 3 after another type 3 is permitted,

 // eliminating it would very much complicate the table, and it does not create typing

 // problems, as the case above.

 //

 // The table is quite complex, in order to limit the number of coeng consonants

 // to 2 (by means of the table).

 //

 // There a peculiarity, as far as Unicode is concerned:

 // - The consonant-shifter is considered in two possible different 

 //   locations, the one considered in Unicode 3.0 and the one considered in

 //   Unicode 4.0. (there is a backwards compatibility problem in this standard).

 // xx    independent character, such as a number, punctuation sign or non-khmer char

 //

 // c1    Khmer consonant of type 1 or an independent vowel

 //       that is, a letter in which the subscript for is only under the

 //       base, not taking any space to the right or to the left

 //

 // c2    Khmer consonant of type 2, the coeng form takes space under

 //       and to the left of the base (only RO is of this type)

 //

 // c3    Khmer consonant of type 3. Its subscript form takes space under

 //       and to the right of the base. 

 //

 // cs    Khmer consonant shifter         

 //

 // rb    Khmer robat

 //

 // co    coeng character (u17D2)

 //

 // dv    dependent vowel (including split vowels, they are treated in the same way).

 //       even if dv is not defined above, the component that is really tested for is

 //       KhmerClassTable::CC_DEPENDENT_VOWEL, which is common to all dependent vowels

 //

 // zwj   Zero Width joiner

 //

 // zwnj  Zero width non joiner  

 //

 // sa    above sign

 //

 // sp    post sign    

 // 

 // there are lines with equal content but for an easier understanding 

 // (and maybe change in the future) we did not join them

 //

 static const le_int8 khmerStateTable[][KhmerClassTable::CC_COUNT] =

 {

 //   xx  c1  c2  c3 zwnj cs  rb  co  dv  sa  sp zwj  

     { 1,  2,  2,  2,  1,  1,  1,  6,  1,  1,  1,  2}, //  0 - ground state

     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  1 - exit state (or sign to the right of the syllable)

     {-1, -1, -1, -1,  3,  4,  5,  6, 16, 17,  1, -1}, //  2 - Base consonant    

     {-1, -1, -1, -1, -1,  4, -1, -1, 16, -1, -1, -1}, //  3 - First ZWNJ before a register shifter

                                                       //      It can only be followed by a shifter or a vowel

     {-1, -1, -1, -1, 15, -1, -1,  6, 16, 17,  1, 14}, //  4 - First register shifter             

     {-1, -1, -1, -1, -1, -1, -1, -1, 20, -1,  1, -1}, //  5 - Robat

     {-1,  7,  8,  9, -1, -1, -1, -1, -1, -1, -1, -1}, //  6 - First Coeng

     {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  7 - First consonant of type 1 after coeng 

     {-1, -1, -1, -1, 12, 13, -1, -1, 16, 17,  1, 14}, //  8 - First consonant of type 2 after coeng

     {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  9 - First consonant or type 3 after ceong

     {-1, 11, 11, 11, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - Second Coeng (no register shifter before)

     {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 11 - Second coeng consonant (or ind. vowel) no register shifter before 

     {-1, -1,  1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter

     {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 13 - Second register shifter 

     {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 14 - ZWJ before vowel    

     {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 15 - ZWNJ before vowel

     {-1, -1, -1, -1, -1, -1, -1, -1, -1, 17,  1, 18}, // 16 - dependent vowel 

     {-1, -1,  1, -1, -1, -1, -1, -1, -1, -1,  1, 18}, // 17 - sign above

     {-1, -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, -1}, // 18 - ZWJ after vowel    

     {-1,  1, -1,  1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - Third coeng 

     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1, -1}, // 20 - dependent vowel after a Robat

 };         

 const LETag *KhmerReordering::getFeatureOrder()

 {

     return featureOrder;

 }

 // Given an input string of characters and a location in which to start looking

 // calculate, using the state table, which one is the last character of the syllable

 // that starts in the starting position.

 le_int32 KhmerReordering::findSyllable(const KhmerClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount)

 {

     le_int32 cursor = prev;

     le_int8 state = 0;

     while (cursor < charCount) {

         KhmerClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) & KhmerClassTable::CF_CLASS_MASK);

         state = khmerStateTable[state][charClass];

         if (state < 0) {

             break;

         }

         cursor += 1;

     }

     return cursor;

 }

 // This is the real reordering function as applied to the Khmer language

 le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 /*scriptCode*/,

                                   LEUnicode *outChars, LEGlyphStorage &glyphStorage)

 {

     const KhmerClassTable *classTable = KhmerClassTable::getKhmerClassTable();

     ReorderingOutput output(outChars, glyphStorage);

     KhmerClassTable::CharClass charClass;

     le_int32 i, prev = 0, coengRo;

     // This loop only exits when we reach the end of a run, which may contain 

     // several syllables.

     while (prev < charCount) {

         le_int32 syllable = findSyllable(classTable, chars, prev, charCount);

         // write a pre vowel or the pre part of a split vowel first

         // and look out for coeng + ro. RO is the only vowel of type 2, and

         // therefore the only one that requires saving space before the base.

         coengRo = -1;  // There is no Coeng Ro, if found this value will change

         for (i = prev; i < syllable; i += 1) {

             charClass = classTable->getCharClass(chars[i]);

             // if a split vowel, write the pre part. In Khmer the pre part

             // is the same for all split vowels, same glyph as pre vowel C_VOWEL_E

             if (charClass & KhmerClassTable::CF_SPLIT_VOWEL) {

                 output.writeChar(C_VOWEL_E, i, &tagPref[0]);

                 break; // there can be only one vowel

             }

             // if a vowel with pos before write it out

             if (charClass & KhmerClassTable::CF_POS_BEFORE) {

                 output.writeChar(chars[i], i, &tagPref[0]);

                 break; // there can be only one vowel 

             }

             // look for coeng + ro and remember position

             // works because coeng + ro is always in front of a vowel (if there is a vowel) 

             // and because CC_CONSONANT2 is enough to identify it, as it is the only consonant

             // with this flag

             if ( (charClass & KhmerClassTable::CF_COENG) && (i + 1 < syllable) &&

                  ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == KhmerClassTable::CC_CONSONANT2) )

             {

                     coengRo = i;

             }

         }

         // write coeng + ro if found

         if (coengRo > -1) {

             output.writeChar(C_COENG, coengRo, &tagPref[0]);

             output.writeChar(C_RO, coengRo + 1, &tagPref[0]);

         }

         // shall we add a dotted circle?

         // If in the position in which the base should be (first char in the string) there is

         // a character that has the Dotted circle flag (a character that cannot be a base)

         // then write a dotted circle

         if (classTable->getCharClass(chars[prev]) & KhmerClassTable::CF_DOTTED_CIRCLE) {

             output.writeChar(C_DOTTED_CIRCLE, prev, &tagDefault[0]);        

         }        

         // copy what is left to the output, skipping before vowels and coeng Ro if they are present

         for (i = prev; i < syllable; i += 1) {

             charClass = classTable->getCharClass(chars[i]);

             // skip a before vowel, it was already processed

             if (charClass & KhmerClassTable::CF_POS_BEFORE) {

                 continue;

             }

             // skip coeng + ro, it was already processed

             if (i == coengRo) {

                 i += 1;

                 continue;

             }

             switch (charClass & KhmerClassTable::CF_POS_MASK) {

                 case KhmerClassTable::CF_POS_ABOVE :

                     output.writeChar(chars[i], i, &tagAbvf[0]);

                     break;

                 case KhmerClassTable::CF_POS_AFTER :

                     output.writeChar(chars[i], i, &tagPstf[0]);

                     break;

                 case KhmerClassTable::CF_POS_BELOW :

                     output.writeChar(chars[i], i, &tagBlwf[0]);

                     break;

                 default:

                     // assign the correct flags to a coeng consonant

                     // Consonants of type 3 are taged as Post forms and those type 1 as below forms

                     if ( (charClass & KhmerClassTable::CF_COENG) && i + 1 < syllable ) {

                         if ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) 

                               == KhmerClassTable::CC_CONSONANT3) {

                             output.writeChar(chars[i], i, &tagPstf[0]);

                             i += 1;

                             output.writeChar(chars[i], i, &tagPstf[0]);

                         }

                         else {

                             output.writeChar(chars[i], i, &tagBlwf[0]);

                             i += 1;

                             output.writeChar(chars[i], i, &tagBlwf[0]);

                         }

                         break;

                     }

                     // if a shifter is followed by an above vowel change the shifter to below form,

                     // an above vowel can have two possible positions i + 1 or i + 3 

                     // (position i+1 corresponds to unicode 3, position i+3 to Unicode 4)

                     // and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two

                     // different positions, right after the shifter or after a vowel (Unicode 4)

                     if ( (charClass & KhmerClassTable::CF_SHIFTER) && (i + 1 < syllable) ) {

                         if ((classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_ABOVE_VOWEL)

                             || (i + 2 < syllable

                                 && ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)

                                 && ( (classTable->getCharClass(chars[i + 2]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT))

                             || (i + 3 < syllable && (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_ABOVE_VOWEL))

                             || (i + 4 < syllable

                                 && ( (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)

                                 && ( (classTable->getCharClass(chars[i + 4]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) ) 

                         {

                             output.writeChar(chars[i], i, &tagBlwf[0]);

                             break;

                         }

                     }

                     // default - any other characters

                     output.writeChar(chars[i], i, &tagDefault[0]);

                     break;

             } // switch

         } // for

         prev = syllable; // move the pointer to the start of next syllable

     }

     return output.getOutputIndex();

 }

 U_NAMESPACE_END