/*
* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0""
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:            Implementation of the vkb data manager
 *
*/












// system includes


// user includes
#include "AknFepZhuyinAnalyser.h"
#include "AknFepZhuyinAnalyserDb.h"

class TSpellBand
    {
public:
    int iStart;
    int iCount;
    };

class TSpellAnalysis : public TPriQueLink
    {
public:
    RArray<TInt> iSeparators;
    TSpellAnalysis( )
        {
        iPriority = -0x10000;
        }
    ~TSpellAnalysis( )
        {
        iSeparators.Close( );
        }

    TSpellAnalysis( const TSpellAnalysis& aSource )
        {
        iPriority = aSource.iPriority;
        for (TInt i = 0; i < aSource.iSeparators.Count( ); ++i )
            {
            iSeparators.Append( aSource.iSeparators[i] );
            }
        }
    void Calculate( )
        {
        iPriority = (iSeparators.Count() + 1) << 16;
        TInt multi = 12;
        for (TInt i = 0; i < iSeparators.Count(); ++i )
            {
            iPriority += ( 6 - iSeparators[i]) << multi;
            if ( multi >= 3 )
                {
                multi -= 3;
                }
            }
        iPriority = -iPriority;
        }
    TInt GetStartPos( )
        {
        if ( iSeparators.Count() == 0 )
            {
            return 0;
            }
        else
            {
            return iSeparators[ iSeparators.Count() - 1 ];
            }
        }
    void AddSeparator( TInt aPos )
        {
        iSeparators.Append( aPos );
        Calculate( );
        }
    };

// -----------------------------------------------------------------------------
// CAknFepVkbPinyinAnalyser::CAknFepVkbPinyinAnalyser
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CAknFepZhuyinAnalyser::CAknFepZhuyinAnalyser( )
    {
    iAnalysisFlag = EFalse;
    }

// -----------------------------------------------------------------------------
// CAknFepVkbPinyinAnalyser::NewL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CAknFepZhuyinAnalyser* CAknFepZhuyinAnalyser::NewL( CZhuyinAnalyserDbFeed* aDb )
    {
    CAknFepZhuyinAnalyser* self = new ( ELeave ) CAknFepZhuyinAnalyser();
    CleanupStack::PushL( self );
    self->ConstructL( aDb );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CAknFepVkbPinyinAnalyser::~CAknFepVkbPinyinAnalyser
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CAknFepZhuyinAnalyser::~CAknFepZhuyinAnalyser( )
    {
    delete []iParagraph;
    delete []iSpellLibrary;
    delete iLastResult;
    delete iDb;
    }

void CAknFepZhuyinAnalyser::ConstructL( CZhuyinAnalyserDbFeed* aDb )
    {
    ASSERT( aDb != NULL );
    iDb = aDb;

    TInt length = iDb->GetSpellCount( );

    iSpellLibrary = new(ELeave) TPtrC[length];
    for (TInt i = 0; i < length; ++i )
        {
        iSpellLibrary[i].Set( aDb->GetSpellByIndex( i ) );
        }

    TInt current = 0;
    TInt pinyinElementCount = iDb->GetSpellElementCount( );
    iParagraph = new(ELeave) TSpellBand[pinyinElementCount];
    iParagraph[current].iStart = 0;
    for (TInt i = 0; i < length; ++i )
        {
        if ( iSpellLibrary[i][0] != iDb->GetSpellElementByIndex( current ) )
            {
            iParagraph[current].iCount = i - iParagraph[current].iStart;
            current++;
            iParagraph[current].iStart = i;
            while (iSpellLibrary[i][0]
                != iDb->GetSpellElementByIndex( current ) )
                {
                iParagraph[current].iCount = 0;
                current ++;
                iParagraph[current].iStart = i;
                }
            }
        }

    iParagraph[current].iCount = length - iParagraph[current].iStart;

    }

HBufC* CAknFepZhuyinAnalyser::LastAnalysisResult( )
    {
    return iLastResult;
    }

TBool CAknFepZhuyinAnalyser::AnalyzeL( const TDesC& aInputString )
    {
    delete iLastResult;
    iLastResult = NULL;

    iLastResult = HBufC::NewL( aInputString.Length( ) * 2 );

    if ( aInputString.Length( ) < 1 )
        {
        return ETrue;
        }

    if ( aInputString.Length( ) == 1 )
        {
        iLastResult->Des().Append( aInputString[0] );
        if ( iDb->IsFirstElement( aInputString[0] ) )
            {
            return ETrue;
            }
        else
            {
            return EFalse;
            }
        }

    if ( !iDb->IsFirstElement( aInputString[0] ) )
        {
        iLastResult->Des().Append( aInputString );
        return EFalse;
        }

    int first = 0, second = 1;
    TBool seriateTonemark = EFalse;
    for (; second < aInputString.Length( ); first++, second++ )
        {
        if ( iDb->IsToneMark( aInputString[first], aInputString[second] ) )
            {
            iLastResult->Des().Append( aInputString );
            seriateTonemark = ETrue;
            break;
            }
        }

    first = 0;
    second = 1;
    int previous = 0;
    iAnalysisFlag = ETrue;
    //rough spilit
    for (; second < aInputString.Length( ) && !seriateTonemark; first++, second++ )
        {
        if ( !iDb->IsNormalElement( aInputString[first] ) )
            {
            //go to detail analysis
            if ( first > previous )
                {
                TPtrC toanalysis = aInputString.Mid( previous, first
                    - previous );
                DetailAnalyseL( toanalysis );
                }

            iLastResult->Des().Append( aInputString[first] );
            previous = first + 1;
            }
        else if ( !iDb->IsNormalElement( aInputString[second] ) )
            {
            //go to detail analysis
            if ( second > previous )
                {
                TPtrC toanalysis = aInputString.Mid( previous, second
                    - previous );
                DetailAnalyseL( toanalysis );
                }

            iLastResult->Des().Append( aInputString[second] );
            previous = second + 1;
            first ++;
            second ++;
            }
        else if ( iDb->GetSpellElementType( aInputString[first] )
            == ESpellVowel || iDb->GetSpellElementType( aInputString[second] )
            == ESpellVowel )
            {
            continue;
            }
        else if ( iDb->GetSpellElementType( aInputString[first] )
            == ESpellConsonant
            || iDb->GetSpellElementType( aInputString[second] )
                == ESpellConsonant )
            {
            //go to detail analysis
            TPtrC toanalysis = aInputString.Mid( previous, second - previous );
            DetailAnalyseL( toanalysis );
            iLastResult->Des().Append( KProgramSeparator );
            previous = second;
            }
        else
            {
            if ( (aInputString[second] == L'h'&& ( aInputString[first] == L'z' || aInputString[first] == L'c' || aInputString[first] == L's')) || //ch, sh, zh
            (aInputString[second] == L'g' && aInputString[first] == L'n') || //ng
            (aInputString[second] == L'n' && aInputString[first] == L'h') //hn 
            )
                {
                }
            else
                {
                //go to detail analysis
                TPtrC toanalysis = aInputString.Mid(previous, second - previous);
                DetailAnalyseL(toanalysis);
                iLastResult->Des().Append(KProgramSeparator);
                previous = second;
                }
            }
        }

    if( aInputString.Length() <= previous 
    		|| second> aInputString.Length() 
    		|| seriateTonemark )
        {
        return TRUE;
        }

    TPtrC toanalysis = aInputString.Mid(previous, second - previous);
    DetailAnalyseL(toanalysis);
    return iAnalysisFlag;
    }

TBool CAknFepZhuyinAnalyser::DetailAnalyseL( const TDesC& aInputString )
    {
    TPriQue<TSpellAnalysis> open;
    TSpellAnalysis* p = new(ELeave) TSpellAnalysis();

    open.Add( *p );

    int sameLength;
    int startPos;
    TBool findRes;
    TSpellAnalysis* pNext= NULL;

    while ( !open.IsEmpty( ) )
        {
        pNext = open.First( );
        pNext->Deque( );

        startPos = pNext->GetStartPos( );
        findRes = FindSpell( aInputString.Mid( startPos ), sameLength );

        if ( findRes || sameLength + startPos == aInputString.Length( ) )
            {
            //got it!
            int start = 0;
            for (TInt j = 0; j < pNext->iSeparators.Count( ); ++j )
                {
                iLastResult->Des().Append( aInputString.Mid( start, pNext->iSeparators[j]
                    - start ) );
                start = pNext->iSeparators[j];
                iLastResult->Des().Append( KProgramSeparator );
                }

            iLastResult->Des().Append( aInputString.Mid( start, aInputString.Length( )
                - start ) );
            break;
            }
        else if ( sameLength == 0 )
            {
            delete pNext;
            pNext = NULL;
            }
        else
            {
            int partLength = sameLength - 1;
            while (partLength > 0 )
                {
                int templen;
                if ( FindSpell( aInputString.Mid( startPos, partLength ),
                    templen ) )
                    {
                    TSpellAnalysis* q = new TSpellAnalysis(*pNext);
                    q->AddSeparator( startPos + partLength );
                    open.Add( *q );
                    }
                partLength --;
                }
            pNext->AddSeparator( startPos + sameLength );
            open.Add( *pNext );
            }
        }
    if ( pNext )
        {
        delete pNext;
        pNext = NULL;
        while ( !open.IsEmpty( ) )
            {
            TSpellAnalysis* p = open.First( );
            p->Deque( );
            delete p;
            }
        return true;
        }
    else
        {
        //not found
        /*
         FindSpell(aInputString, sameLength);
         int offset = 0;
         TBool rtn = sameLength > 0;
         while( sameLength > 0 )
         {
         iLastResult->Des().Append(aInputString.Mid(offset, sameLength));
         iLastResult->Des().Append(KProgramSeparator);
         offset += sameLength;
         FindSpell(aInputString.Mid(offset), sameLength);
         }
         */
        //FindSpell(aInputString, sameLength);
        int offset = 0;

        while (offset < aInputString.Length( ) )
            {
            FindSpell( aInputString.Mid( offset ), sameLength );

            if ( sameLength )
                {
                iLastResult->Des().Append( aInputString.Mid( offset, sameLength ) );
                iLastResult->Des().Append( KProgramSeparator );
                offset += sameLength;
                }
            else
                {
                iLastResult->Des().Append( aInputString.Mid( offset, 1 ) );

                iLastResult->Des().Append( KProgramSeparator );

                offset += 1;
                }
            }
        if ( iLastResult->Des()[ iLastResult->Length() - 1 ] == KProgramSeparator )
            {
            iLastResult->Des().SetLength( iLastResult->Length( ) - 1 );
            }
        iAnalysisFlag = EFalse;
        return EFalse;
        }
    }

TBool CAknFepZhuyinAnalyser::FindSpell( const TDesC& aSpell, TInt& aSameLength )
    {
    int index = aSpell[0] - iDb->GetSpellElementByIndex( 0 );

    int start = iParagraph[index].iStart;
    int end = iParagraph[index].iCount + iParagraph[index].iStart - 1;
    int mid = (start + end ) >> 1;
    int result = 0;
    aSameLength = 0;
    while (mid > start && mid < end )
        {
        result = Compare( iSpellLibrary[mid], aSpell, aSameLength );
        if ( result == 0 )
            {
            return true;
            }
        else if ( result < 0 )
            {
            start = mid;
            mid = (start + end ) >> 1;
            }
        else
            {
            end = mid;
            mid = (start + end) >> 1;
            }
        }
    int newLength;
    if ( result > 0 )
        {
        result = Compare( iSpellLibrary[start], aSpell, newLength );
        }
    else
        {
        result = Compare( iSpellLibrary[end], aSpell, newLength );
        }
    newLength > aSameLength ? aSameLength = newLength : aSameLength;

    return result == 0;
    }

TInt CAknFepZhuyinAnalyser::Compare( const TDesC& aFirst,
    const TDesC& aSecond, TInt& aSameLength )
    {
    aSameLength = 0;

    TInt length = aFirst.Length( ) > aSecond.Length( ) ? aSecond.Length( )
        : aFirst.Length( );

    for (TInt i = 0; i < length; ++i )
        {
        if ( aFirst[i] != aSecond[i] )
            {
            return aFirst[i] - aSecond[i];
            }

        aSameLength ++;
        }

    return aFirst.Length( ) - aSecond.Length( );
    }