/*

 *

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

 *

 */

#include "LETypes.h"

#include "OpenTypeTables.h"

#include "OpenTypeUtilities.h"

#include "IndicReordering.h"

#include "LEGlyphStorage.h"

#include "MPreFixups.h"

U_NAMESPACE_BEGIN

const LEUnicode KBearURA		= 0x0A73;

const LEUnicode KDepVowelU		= 0x0A41;

const LEUnicode KDepVowelUU		= 0x0A42;

const LEUnicode KDepVowelOO		= 0x0A4B;

const LEUnicode KVowelU	    	= 0x0A09;

const LEUnicode KVowelUU		= 0x0A0A;

const LEUnicode KVowelOO		= 0x0A13;

class ReorderingOutput : public UMemory {

private:

    le_int32 fOutIndex;

    LEUnicode *fOutChars;

    LEGlyphStorage &fGlyphStorage;

    LEUnicode fMpre;

    le_int32  fMpreIndex;

    LEUnicode fMbelow;

    le_int32  fMbelowIndex;

    LEUnicode fMabove;

    le_int32  fMaboveIndex;

    LEUnicode fMpost;

    le_int32  fMpostIndex;

    LEUnicode fLengthMark;

    le_int32  fLengthMarkIndex;

    const LETag *fMatraTags;

    le_int32 fMPreOutIndex;

    MPreFixups *fMPreFixups;

    LEUnicode fVMabove;

    LEUnicode fVMpost;

    le_int32  fVMIndex;

    const LETag *fVMTags;

    LEUnicode fSMabove;

    LEUnicode fSMbelow;

    le_int32  fSMIndex;

    const LETag *fSMTags;

    void saveMatra(LEUnicode matra, le_int32 matraIndex, IndicClassTable::CharClass matraClass)

    {

        // FIXME: check if already set, or if not a matra...

        if (IndicClassTable::isLengthMark(matraClass)) {

            fLengthMark = matra;

            fLengthMarkIndex = matraIndex;

        } else {

            switch (matraClass & CF_POS_MASK) {

            case CF_POS_BEFORE:

                fMpre = matra;

                fMpreIndex = matraIndex;

                break;

            case CF_POS_BELOW:

                fMbelow = matra;

                fMbelowIndex = matraIndex;

                break;

            case CF_POS_ABOVE:

                fMabove = matra;

                fMaboveIndex = matraIndex;

                break;

            case CF_POS_AFTER:

                fMpost = matra;

                fMpostIndex = matraIndex;

                break;

            default:

                // can't get here...

                break;

           }

        }

        // 1922 mlyl : only the right part of matra AU should be displayed -->

        if (fMpre == CC_DEPENDENT_VOWEL_SIGN_MLYL_E && fLengthMark != 0) 

        {

        	fMpre = 0;

        	fMpreIndex = -1;

        } 

        // <-- 1922 mlyl

    }

public:

    ReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage, MPreFixups *mpreFixups)

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

          fMpre(0), fMpreIndex(0), fMbelow(0), fMbelowIndex(0), fMabove(0), fMaboveIndex(0),

          fMpost(0), fMpostIndex(0), fLengthMark(0), fLengthMarkIndex(0), fMatraTags(NULL),

          fMPreOutIndex(-1), fMPreFixups(mpreFixups),

          fVMabove(0), fVMpost(0), fVMIndex(0), fVMTags(NULL),

          fSMabove(0), fSMbelow(0), fSMIndex(0), fSMTags(NULL)

    {

        // nothing else to do...

    }

    ~ReorderingOutput()

    {

        // nothing to do here...

    }

    void reset()

    {

        fMpre = fMbelow = fMabove = fMpost = fLengthMark = 0;

        fMPreOutIndex = -1;

        fVMabove = fVMpost  = 0;

        fSMabove = fSMbelow = 0;

    }

    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_bool noteMatra(const IndicClassTable *classTable, LEUnicode matra, le_uint32 matraIndex, const LETag *matraTags)

    {

        IndicClassTable::CharClass matraClass = classTable->getCharClass(matra);

        fMatraTags  = matraTags;

        if (IndicClassTable::isMatra(matraClass)) {

            if (IndicClassTable::isSplitMatra(matraClass)) {

                const SplitMatra *splitMatra = classTable->getSplitMatra(matraClass);

                int i;

                for (i = 0; i < 3 && (*splitMatra)[i] != 0; i += 1) {

                    LEUnicode piece = (*splitMatra)[i];

                    IndicClassTable::CharClass pieceClass = classTable->getCharClass(piece);

                    saveMatra(piece, matraIndex, pieceClass);

                }

            } else {

                saveMatra(matra, matraIndex, matraClass);

            }

            return TRUE;

        }

        return FALSE;

    }

    void noteVowelModifier(const IndicClassTable *classTable, LEUnicode vowelModifier, le_uint32 vowelModifierIndex, const LETag *vowelModifierTags)

    {

        IndicClassTable::CharClass vmClass = classTable->getCharClass(vowelModifier);

        fVMIndex = vowelModifierIndex;

        fVMTags  = vowelModifierTags;

        if (IndicClassTable::isVowelModifier(vmClass)) {

           switch (vmClass & CF_POS_MASK) {

           case CF_POS_ABOVE:

               fVMabove = vowelModifier;

               break;

           case CF_POS_AFTER:

               fVMpost = vowelModifier;

               break;

           default:

               // FIXME: this is an error...

               break;

           }

        }

    }

    void noteStressMark(const IndicClassTable *classTable, LEUnicode stressMark, le_uint32 stressMarkIndex, const LETag *stressMarkTags)

    {

       IndicClassTable::CharClass smClass = classTable->getCharClass(stressMark);

        fSMIndex = stressMarkIndex;

        fSMTags  = stressMarkTags;

        if (IndicClassTable::isStressMark(smClass)) {

            switch (smClass & CF_POS_MASK) {

            case CF_POS_ABOVE:

                fSMabove = stressMark;

                break;

            case CF_POS_BELOW:

                fSMbelow = stressMark;

                break;

            default:

                // FIXME: this is an error...

                break;

           }

        }

    }

    void noteBaseConsonant()

    {

        if (fMPreFixups != NULL && fMPreOutIndex >= 0) {

            fMPreFixups->add(fOutIndex, fMPreOutIndex);

        }

    }

    void writeMpre()

    {

        if (fMpre != 0) {

            fMPreOutIndex = fOutIndex;

            writeChar(fMpre, fMpreIndex, fMatraTags);

        }

    }

    void writeMbelow()

    {

        if (fMbelow != 0) {

            writeChar(fMbelow, fMbelowIndex, fMatraTags);

        }

    }

    void writeMabove()

    {

        if (fMabove != 0) {

            writeChar(fMabove, fMaboveIndex, fMatraTags);

        }

    }

    void writeMpost()

    {

        if (fMpost != 0) {

            writeChar(fMpost, fMpostIndex, fMatraTags);

        }

    }

    void writeLengthMark()

    {

        if (fLengthMark != 0) {

            writeChar(fLengthMark, fLengthMarkIndex, fMatraTags);

        }

    }

    void writeVMabove()

    {

        if (fVMabove != 0) {

            writeChar(fVMabove, fVMIndex, fVMTags);

        }

    }

    void writeVMpost()

    {

        if (fVMpost != 0) {

            writeChar(fVMpost, fVMIndex, fVMTags);

        }

    }

    void writeSMabove()

    {

        if (fSMabove != 0) {

            writeChar(fSMabove, fSMIndex, fSMTags);

        }

    }

    void writeSMbelow()

    {

        if (fSMbelow != 0) {

            writeChar(fSMbelow, fSMIndex, fSMTags);

        }

    }

    le_int32 getOutputIndex()

    {

        return fOutIndex;

    }

};

enum

{

    C_DOTTED_CIRCLE = 0x25CC

};

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

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 loclFeatureTag = LE_LOCL_FEATURE_TAG;

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

// for correct processing

static const LETag featureOrder[] =

{

    loclFeatureTag,

    nuktFeatureTag, akhnFeatureTag, rphfFeatureTag, blwfFeatureTag, halfFeatureTag, pstfFeatureTag,

    vatuFeatureTag, presFeatureTag, blwsFeatureTag, abvsFeatureTag, pstsFeatureTag, halnFeatureTag,

    blwmFeatureTag, abvmFeatureTag, distFeatureTag, emptyTag

};

// The order of these is determined so that the tag array of each glyph can start

// at an offset into this array 

// FIXME: do we want a seperate tag array for each kind of character??

// FIXME: are there cases where this ordering causes glyphs to get tags

// that they shouldn't?

static const LETag tagArray[] =

{

    rphfFeatureTag, blwfFeatureTag, halfFeatureTag, pstfFeatureTag, nuktFeatureTag, akhnFeatureTag,

    vatuFeatureTag, presFeatureTag, blwsFeatureTag, abvsFeatureTag, pstsFeatureTag, halnFeatureTag,

    blwmFeatureTag, abvmFeatureTag, distFeatureTag, loclFeatureTag, emptyTag

};

// Nokia: New state responses ia and de, and new states for Devanagari Independent Vowel A 

// added by Nokia to allow the special Devanagari CANDRA A formation using A + CANDRA E, and

// a new zero width joiner state specially for ZWJ's that come after the Independent Vowel A

// Also, changed the consonant response to ZWJ by allowing it to have a ZWJ straight after it.

// This allows Kannada RA to take a ZWJ after it and not make it a REPHA

// Nokia: New states for Gurmukhi bearers to support decompositions of the independent vowels 

// into a sequence of a vowel bearer and a depending vowel sign.

static const le_int8 stateTable[][CC_COUNT] =

{

//   xx  vm  sm  iv  i2  ct  cn  nu  dv  s1  s2  s3  vr  zw  ia  de  cr  to  ba  bi  bu  ga  gi  gu 

    { 1,  1,  1,  5,  8,  3,  2,  1,  1,  9,  5,  1,  1,  1, 20,  1, 25, 26, 27, 28, 29,  1,  1,  1}, //  0 - ground state

    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  1 - exit state

    {-1,  6,  1, -1, -1, -1, -1, -1,  5,  9,  5,  5,  4, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, //  2 - consonant with nukta

    {-1,  6,  1, -1, -1, -1, -1,  2,  5,  9,  5,  5,  4, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, //  3 - consonant

    {-1, -1, -1, -1, -1, 12, 11, -1, -1, -1, -1, -1, -1, 22, -1, -1, 12, -1, -1, -1, -1, -1, -1, -1}, //  4 - ct vr

    {-1,  6,  1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  5 - dependent vowels

    {-1, -1,  1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  6 - vowel mark

    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  7 - ZWJ, ZWNJ seen after a consonant: Modified by Nokia

    {-1,  6,  1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  8 - independent vowels that can take a virama

    {-1,  6,  1, -1, -1, -1, -1, -1, -1, -1, 10,  5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  9 - first part of split vowel

    {-1,  6,  1, -1, -1, -1, -1, -1, -1, -1, -1,  5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - second part of split vowel

    {-1,  6,  1, -1, -1, -1, -1, -1,  5,  9,  5,  5, 13, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, // 11 - ct vr ct nu

    {-1,  6,  1, -1, -1, -1, -1, 11,  5,  9,  5,  5, 13, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, // 12 - ct vr ct

    {-1, -1, -1, -1, -1, 15, 14, -1, -1, -1, -1, -1, -1, 23, -1, -1, 15, -1, -1, -1, -1, -1, -1, -1}, // 13 - ct vr ct vr

    {-1,  6,  1, -1, -1, -1, -1, -1,  5,  9,  5,  5, 16, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, // 14 - ct vr ct vr ct nu

    {-1,  6,  1, -1, -1, -1, -1, 14,  5,  9,  5,  5, 16, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, // 15 - ct vr ct vr ct

    {-1, -1, -1, -1, -1, 18, 17, -1, -1, -1, -1, -1, -1, 24, -1, -1, 18, -1, -1, -1, -1, -1, -1, -1}, // 16 - ct vr ct vr ct vr

    {-1,  6,  1, -1, -1, -1, -1, -1,  5,  9,  5,  5, 19, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, // 17 - ct vr ct vr ct vr ct nu

    {-1,  6,  1, -1, -1, -1, -1, 17,  5,  9,  5,  5, 19, -1, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, // 18 - ct vr ct vr ct vr ct

    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - ct vr ct vr ct vr ct vr

    {-1,  6,  1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 21, -1,  5, -1, -1, -1, -1, -1, -1, -1, -1}, // 20 - devanagari independent vowel A that can take a modifier - CANDRA E: Added by Nokia

    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  5, -1, -1, -1, -1, -1, -1, -1, -1}, // 21 - ZWJ after independent vowel A: Added by Nokia  

    {-1,  6, -1, -1, -1, 12, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, 12, -1, -1, -1, -1, -1, -1, -1}, // 22 - ZWJ after a virama: Added by Nokia  

    {-1,  6, -1, -1, -1, 15, 14, -1, -1, -1, -1, -1, -1, -1, -1, -1, 15, -1, -1, -1, -1, -1, -1, -1}, // 23 - ZWJ after a ct vr ct vr: Added by Nokia  

    {-1,  6, -1, -1, -1, 18, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, 18, -1, -1, -1, -1, -1, -1, -1}, // 24 - ZWJ after a ct vr ct vr ct vr: Added by Nokia  

    {-1,  6,  1, -1, -1, -1, -1,  2,  5,  9,  5,  5,  4,  7, -1,  5, -1, 26, -1, -1, -1,  5,  5,  5}, // 25 - Kannada consonant Ra: Added by Nokia

    {-1,  6,  1, -1, -1, -1, -1, -1, -1, -1, 10,  5,  4, 21, -1,  5, -1, -1, -1, -1, -1, -1, -1, -1}, // 26 - devanagari independent vowel A that can take a modifier - CANDRA E: Added by Nokia

    {-1,  6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  5, -1, -1}, // 27 - Gurmukhi bearer ARA and independent A

    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  5, -1}, // 28 - Gurmukhi bearer IRI

    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  5}, // 29 - Gurmukhi bearer URA

};

const LETag *IndicReordering::getFeatureOrder()

{

    return featureOrder;

}

le_int32 IndicReordering::findSyllable(const IndicClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount)

{

    le_int32 cursor = prev;

    le_int8 state = 0;

    while (cursor < charCount) {

        IndicClassTable::CharClass charClass = classTable->getCharClass(chars[cursor]);

        state = stateTable[state][charClass & CF_CLASS_MASK];

        if (state < 0) {

            break;

        }

        cursor += 1;

    }

    return cursor;

}

le_int32 IndicReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 scriptCode,

                                  LEUnicode *outChars, LEGlyphStorage &glyphStorage,

                                  MPreFixups **outMPreFixups, LEErrorCode& success)

{

    MPreFixups *mpreFixups = NULL;

    const IndicClassTable *classTable = IndicClassTable::getScriptClassTable(scriptCode);

    if (classTable->scriptFlags & SF_MPRE_FIXUP) {

        mpreFixups = new MPreFixups(charCount);

        if (!mpreFixups) {

            success = LE_MEMORY_ALLOCATION_ERROR;

            return 0;

        }

    }

    ReorderingOutput output(outChars, glyphStorage, mpreFixups);

    le_int32 i, prev = 0;

    while (prev < charCount) {

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

        le_int32 matra, markStart = syllable;

        output.reset();

        if (classTable->isStressMark(chars[markStart - 1])) {

            markStart -= 1;

            output.noteStressMark(classTable, chars[markStart], markStart, &tagArray[1]);

        }

        if (prev != markStart && classTable->isVowelModifier(chars[markStart - 1])) {

            markStart -= 1;

            output.noteVowelModifier(classTable, chars[markStart], markStart, &tagArray[1]);

        }

        matra = markStart - 1;

        // Added by Nokia. Workaround ligature substitution: Bearer URA + Dependent Vowel -> Independent Vowel

        // For these sequences, no need to write matra since it will be replaced.

        if (!(chars[prev] == KBearURA && (prev + 1 < syllable) && 

        		(chars[prev+1] == KDepVowelU || chars[prev+1] == KDepVowelUU || chars[prev+1] == KDepVowelOO ))) {

        	while (prev <= matra && output.noteMatra(classTable, chars[matra], matra, &tagArray[1])) {

            	matra -= 1;

        	}

        }

        switch (classTable->getCharClass(chars[prev]) & CF_CLASS_MASK) {

        case CC_RESERVED:

        case CC_INDEPENDENT_VOWEL:

        case CC_ZERO_WIDTH_MARK:

        case CC_INDEPENDENT_VOWEL_A:	// Added by Nokia

        case CC_INDEPENDENT_VOWEL_TAMIL_O:	// Added by Nokia

        case CC_GUR_BEARER_U:	//Added by Nokia

        	// Added by Nokia. Workaround ligature substitution: Bearer URA + Dependent Vowel -> Independent Vowel

        	if (chars[prev] == KBearURA && (prev + 1 < markStart)){

        		if (chars[prev+1] == KDepVowelU){

        	   		output.writeChar(KVowelU, prev, &tagArray[1]);

        	   		prev = prev+2;

        		}

        		else if (chars[prev+1] == KDepVowelUU){

        			output.writeChar(KVowelUU, prev, &tagArray[1]);

        			prev = prev+2;

        		}

        		else if (chars[prev+1] == KDepVowelOO){

        			output.writeChar(KVowelOO, prev, &tagArray[1]);

        			prev = prev+2;

        		}

        	}

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

                output.writeChar(chars[i], i, &tagArray[1]);

            }

            break;

        case CC_NUKTA:

        case CC_VIRAMA:

            output.writeChar(C_DOTTED_CIRCLE, prev, &tagArray[1]);

            output.writeChar(chars[prev], prev, &tagArray[1]);

            break;

        case CC_DEPENDENT_VOWEL:

        case CC_DEPENDENT_VOWEL_CANDRA_E:	// Added by Nokia

        case CC_SPLIT_VOWEL_PIECE_1:

        case CC_SPLIT_VOWEL_PIECE_2:

        case CC_SPLIT_VOWEL_PIECE_3:

        case CC_VOWEL_MODIFIER:

        case CC_STRESS_MARK:

        case CC_GUR_DEPENDENT_VOWEL_A:

        case CC_GUR_DEPENDENT_VOWEL_I:

        case CC_GUR_DEPENDENT_VOWEL_U:

            output.writeMpre();

            output.writeChar(C_DOTTED_CIRCLE, prev, &tagArray[1]);

            output.writeMbelow();

            output.writeSMbelow();

            output.writeMabove();

            if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) != 0) {

                output.writeMpost();

            }

            if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) != 0) {

                output.writeVMabove();

                output.writeSMabove(); // FIXME: there are no SM's in these scripts...

            }

            if ((classTable->scriptFlags & SF_MATRAS_AFTER_BASE) == 0) {

                output.writeMpost();

            }

            output.writeLengthMark();

            if ((classTable->scriptFlags & SF_REPH_AFTER_BELOW) == 0) {

                output.writeVMabove();

                output.writeSMabove();