/*
* Copyright (c) 2002-2004 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 : Class looking after alarm fields for forms.
*
*/

//debug
#include "calendarui_debug.h"
#include "CalenExtraRowFormatter.h"

#include <calenkoreanlunarplugindata.rsg>
#include <aknbiditextutils.h>
#include <badesca.h>
#include <eikenv.h>
#include <StringLoader.h>

// CONSTANTS
_LIT( KSeparatorFmt, "%0U" );
const TInt KExtraRowLength = 1000;

// ======== MEMBER FUNCTIONS ========


// ---------------------------------------------------------------------------
// CollapseDuplicatesL()
// ---------------------------------------------------------------------------
//
void CollapseDuplicatesL( TDes& aStr, TInt aPos, const TDesC& aSub )
    {
    TRACE_ENTRY_POINT;

    const TInt sublen = aSub.Length();
    if ( aStr.Length() == 0 || sublen == 0 )
        {
        return;
        }

    TPtrC remaining = aStr.Mid( aPos );
    TInt fstInRemaining = remaining.Find( aSub );

    if ( fstInRemaining >= 0 )
        {
        TInt restPos = fstInRemaining + sublen;
        TPtrC rest = remaining.Mid( restPos );
        TInt sndInRest = rest.Find( aSub );

        // 1) two substrings found in sequence
        if ( sndInRest == 0 )
            {
            // replace second substring with empty string
            TInt fst = aPos + fstInRemaining;
            TInt snd = aPos + restPos + sndInRest;
            aStr.Replace( snd, sublen, KNullDesC);
            // continue collapsing from first
            CollapseDuplicatesL( aStr, fst, aSub );
            }
        // 2) substring found later in string
        else if ( sndInRest > 0 )
            {
            // continue collapsing from this second substring
            TInt snd = aPos + restPos + sndInRest;
            CollapseDuplicatesL( aStr, snd, aSub );
            }
        // 3) No second substring found -> nothing to collapse
        else
            {
            TRACE_EXIT_POINT;
            return;
            }
        }
    // No substring found
    else
        {
        TRACE_EXIT_POINT;
        return;
        }
    }

// ---------------------------------------------------------------------------
// RemoveLeadingAndTrailingL()
// ---------------------------------------------------------------------------
//
void RemoveLeadingAndTrailingL( TDes& aStr, const TDesC& aSub )
    {
    TRACE_ENTRY_POINT;

    // Trailing
    const TInt sublen = aSub.Length();
    if ( aStr.Right( sublen ).Find( aSub ) == 0 )
        {
        aStr.Replace( aStr.Length() - sublen, sublen, KNullDesC );
        }

    // Leading
    if ( aStr.Left( sublen ).Find( aSub ) == 0 )
        {
        aStr.Replace( 0, sublen, KNullDesC );
        }

    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// CCalenExtraRowFormatter::NewL()
// ---------------------------------------------------------------------------
//
CCalenExtraRowFormatter* CCalenExtraRowFormatter::NewL()
    {
    TRACE_ENTRY_POINT;

    CCalenExtraRowFormatter* self = new (ELeave) CCalenExtraRowFormatter;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;
    return self;
    }

// ---------------------------------------------------------------------------
// CCalenExtraRowFormatter::~CCalenExtraRowFormatter()
// ---------------------------------------------------------------------------
//
CCalenExtraRowFormatter::~CCalenExtraRowFormatter()
    {
    TRACE_ENTRY_POINT;
    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// CCalenExtraRowFormatter::CCalenExtraRowFormatter()
// ---------------------------------------------------------------------------
//
CCalenExtraRowFormatter::CCalenExtraRowFormatter()
    {
    TRACE_ENTRY_POINT;
    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// CCalenExtraRowFormatter::ConstructL()
// ---------------------------------------------------------------------------
//
void CCalenExtraRowFormatter::ConstructL()
    {
    TRACE_ENTRY_POINT;
    TRACE_EXIT_POINT;
    }

// ---------------------------------------------------------------------------
// CCalenExtraRowFormatter::FormatExtraRowInformationL()
// ---------------------------------------------------------------------------
//
TPtrC CCalenExtraRowFormatter::FormatExtraRowInformationL(
    CCalenLunarLocalizedInfo& aLocInfo,
    RArray<CCalenLunarLocalizedInfo::TField>& aPrioritizedFields,
    TInt aMaxWidth,
    const CFont& aFont
#ifdef RD_CALENDAR_PREVIEW
    ,TBool aTwoLines
#endif // RD_CALENDAR_PREVIEW
    )
    {
    TRACE_ENTRY_POINT;

    if ( aPrioritizedFields.Count() == 0)
        {
        iText = KNullDesC;

        TRACE_EXIT_POINT;
        return iText;
        }

    // Initialize substring labels
    RArray<CCalenLunarLocalizedInfo::TField> subLabels;
    CleanupClosePushL( subLabels );
    subLabels.AppendL( CCalenLunarLocalizedInfo::ELunarMonthAndDay );
    subLabels.AppendL( CCalenLunarLocalizedInfo::ELunarFestival );
    subLabels.AppendL( CCalenLunarLocalizedInfo::ESolarFestival );
    subLabels.AppendL( CCalenLunarLocalizedInfo::ESolarTerm );

    // ASSERT that all prioritized fields can be found from subLabels
    for ( TInt i=0; i < aPrioritizedFields.Count(); i++)
        {
        ASSERT( subLabels.Find( aPrioritizedFields[i] ) >= 0 );
        }

    TBool fits = EFalse;

    do
        {
        // Initialize substring array
        CPtrCArray* subs = new (ELeave) CPtrCArray(10);
        CleanupStack::PushL( subs );
        for ( TInt i = 0; i < subLabels.Count(); i++)
            {
            subs->AppendL( TPtrC( KNullDesC ) );
            }

        // Set wanted fields to substring array
        for ( TInt i = 0; i < aPrioritizedFields.Count(); i++)
            {
            CCalenLunarLocalizedInfo::TField field = aPrioritizedFields[i];
            TInt subIx = subLabels.Find( field );
            // Replace
            subs->Delete(subIx);
            RDebug::Print( _L("A sub count  %d"), subs->Count() );
            subs->InsertL(subIx, TPtrC( aLocInfo.GetField( field ) ) );
            RDebug::Print( _L("B sub count %d"), subs->Count() );
            RDebug::Print( _L("B field %S"), &(subs->At(subIx)) );
            }

        // Format all fields to extra row
        HBufC* extraRowFmt = StringLoader::LoadLC( R_KOR_CALE_EXTRA_ROW_LUNAR ); 

        RDebug::RawPrint( *extraRowFmt );

        TBuf<KExtraRowLength> fmt = *extraRowFmt;
        for ( TInt i=0; i < subLabels.Count(); i++ )
            {
            RDebug::Print( _L("Before Format") );
            RDebug::RawPrint( fmt );
            StringLoader::Format( iText,
                                  fmt,
                                  i + 1, // %0U is a separator
                                  subs->At( i ) );
            fmt = iText;
            RDebug::Print( _L("After Format") );
            RDebug::RawPrint( fmt );
            }

        // Now we have something like "Year of Dog%0U%0U6/11%0U%0U"
        // First We need to remove multiple occurences of %0U
        CollapseDuplicatesL( iText, 0, KSeparatorFmt );
        RDebug::Print( _L("After collapse") );
        RDebug::RawPrint( iText );

        // Remove leading and trailing %0U
        // By now, we are sure that there is max 1 %0U in the beginning
        // and in the end of string.
        RemoveLeadingAndTrailingL( iText, KSeparatorFmt );
        RDebug::Print( _L("After leading and trailing removal") );
        RDebug::RawPrint( iText );

        // If there are now separators anymore, then do not fill them
        TBool hasSeparators = iText.Find( KSeparatorFmt ) >= 0;

        if ( hasSeparators )
            {
            // fill in separators
            HBufC* separator = StringLoader::LoadLC( R_CALE_LUNAR_SEPARATOR );
            fmt = iText;
            StringLoader::Format( iText,
                                  fmt,
                                  0, // %0U is a separator
                                  *separator );

            RDebug::Print( _L("After separator insert") );
            RDebug::RawPrint( iText );
            CleanupStack::PopAndDestroy( separator );
            }

        CleanupStack::PopAndDestroy( extraRowFmt );
        CleanupStack::PopAndDestroy( subs );

        do{
        
        fits = TryToFitL( iText, aMaxWidth, aFont
#ifdef RD_CALENDAR_PREVIEW
                          , aTwoLines
#endif // RD_CALENDAR_PREVIEW
                          );
        
        if( !fits )
        	{
        	iText.SetLength( iText.Length()-1 );
        	}
        }while( !fits );
        if ( ! fits )
            {
            iText = KNullDesC;
            TInt last = aPrioritizedFields.Count() - 1;
            if ( last >= 0 )
                {
                aPrioritizedFields.Remove( last );
                }
            }

        } while ( ! fits && aPrioritizedFields.Count() );

    CleanupStack::PopAndDestroy( &subLabels );

    TRACE_EXIT_POINT;
    return iText;
    }

// ---------------------------------------------------------------------------
// CCalenExtraRowFormatter::TryToFitL()
// ---------------------------------------------------------------------------
//
TBool CCalenExtraRowFormatter::TryToFitL( const TDesC& aStr, TInt aMaxWidth, const CFont& aFont
#ifdef RD_CALENDAR_PREVIEW
                                          , TBool aTwoLines
#endif // RD_CALENDAR_PREVIEW
                                          )
    {
    TRACE_ENTRY_POINT;
#ifdef RD_CALENDAR_PREVIEW
    TBool result(EFalse);
    if(aTwoLines)
        {
        CArrayFixFlat<TPtrC>* textLines = new(ELeave)CArrayFixFlat<TPtrC>( 3 );
        CleanupStack::PushL( textLines );

        CArrayFixFlat<TInt>* lineWidths = new( ELeave )CArrayFixFlat<TInt>( 1 );
        CleanupStack::PushL( lineWidths );

        lineWidths->AppendL( aMaxWidth );

        HBufC* visualText = AknBidiTextUtils::ConvertToVisualAndWrapToArrayWholeTextL(
            aStr,
            *lineWidths,
            aFont,
            *textLines);

        result = (textLines->Count() <= 2);

        CleanupStack::PopAndDestroy( lineWidths );
        CleanupStack::PopAndDestroy( textLines );
        delete visualText;
        }
    else
        {
        CFont::TMeasureTextInput::TFlags logicalOrder = static_cast<CFont::TMeasureTextInput::TFlags>(0);
        TInt textW = AknBidiTextUtils::MeasureTextBoundsWidth( aFont, aStr, logicalOrder );
        result = (textW <= aMaxWidth);
        }
    TRACE_EXIT_POINT;
    return result;
#else
    CFont::TMeasureTextInput::TFlags logicalOrder = static_cast<CFont::TMeasureTextInput::TFlags>(0);
    TInt textW = AknBidiTextUtils::MeasureTextBoundsWidth( aFont, aStr, logicalOrder );
    TRACE_EXIT_POINT;
    return ( textW <= aMaxWidth );
#endif
    }

// End of file