/*

* Copyright (c) 2007-2009 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 for plain text formatter for ES MR entries

*

*/

#include "emailtrace.h"

#include "cesmrmailplaitextformatter.h"

#include <esmrtasks.rsg>

#include <cmrmailboxutils.h>

#include <StringLoader.h>

#include <calentry.h>

#include <caluser.h>

#include <avkon.rsg>

#include <utf.h>

#include <data_caging_path_literals.hrh>

#include "cesmrcaluserutil.h"

#include "esmrhelper.h"

#include <bautils.h>

// Unnamed namespace for local definitions

namespace  {

// Resource file name definition

_LIT( KResourceFileName,"esmrtasks.rsc" );

// Definition for new line

_LIT( KNewLine,"\n" );

_LIT( KWhiteSpace, " " );

// Definition for first position

const TInt KFirstPos( 0 );

// Denition for amount of needed newlines

const TInt KNewLinesNeeded = 5;

// Definition for time string length (13:15)

const TInt KTimeStringLength = 20;

// Definition for date stinng length (31.12.2007)

const TInt KDateStringLength = 20;

}//namespace

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

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::CESMRMailPlainTextFormatter

// ---------------------------------------------------------------------------

//

inline CESMRMailPlainTextFormatter::CESMRMailPlainTextFormatter(

        CMRMailboxUtils& aMailboxUtils ) :

    iMailboxUtils(aMailboxUtils)

    {

    FUNC_LOG;

    //do nothing

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::~CESMRMailPlainTextFormatter

// ---------------------------------------------------------------------------

//

CESMRMailPlainTextFormatter::~CESMRMailPlainTextFormatter()

    {

    FUNC_LOG;

    if ( iResourceOffset )

        {

        CCoeEnv::Static()->DeleteResourceFile( iResourceOffset );

        }

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::NewL

// ---------------------------------------------------------------------------

//

CESMRMailPlainTextFormatter* CESMRMailPlainTextFormatter::NewL(

        CMRMailboxUtils& aMailboxUtils )

    {

    FUNC_LOG;

    CESMRMailPlainTextFormatter* self = NewLC( aMailboxUtils );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::NewLC

// ---------------------------------------------------------------------------

//

CESMRMailPlainTextFormatter* CESMRMailPlainTextFormatter::NewLC(

        CMRMailboxUtils& aMailboxUtils )

    {

    FUNC_LOG;

    CESMRMailPlainTextFormatter* self =

        new (ELeave) CESMRMailPlainTextFormatter(aMailboxUtils);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::ConstructL

// ---------------------------------------------------------------------------

//

void CESMRMailPlainTextFormatter::ConstructL()

    {

    FUNC_LOG;

    CCoeEnv* coeEnv = CCoeEnv::Static();// codescanner::eikonenvstatic

    TFileName resourceFile;

    ESMRHelper::LocateResourceFile(

            KResourceFileName,

            KDC_RESOURCE_FILES_DIR,

            resourceFile,

            &coeEnv->FsSession());

    // Find the resource file for the nearest language

    BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceFile );

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::Body16LC

// ---------------------------------------------------------------------------

//

HBufC* CESMRMailPlainTextFormatter::Body16LC(

        CCalEntry& aEntry )

    {

    FUNC_LOG;

    HBufC* dateFormatString = StringLoader::LoadLC( R_QTN_DATE_USUAL );

    HBufC* timeFormatString = StringLoader::LoadLC( R_QTN_TIME_USUAL );

    TTime mrStartTime = aEntry.StartTimeL().TimeLocalL();

    TTime mrEndTime   = aEntry.EndTimeL().TimeLocalL();

    TBuf<KTimeStringLength> startTimeStr, endTimeStr;

    TBuf<KDateStringLength> startDateStr, endDateStr;

    mrStartTime.FormatL( startTimeStr, *timeFormatString );

    mrStartTime.FormatL( startDateStr, *dateFormatString );

    mrEndTime.FormatL( endTimeStr, *timeFormatString );

    mrEndTime.FormatL( endDateStr, *dateFormatString );

    CleanupStack::PopAndDestroy( 2, dateFormatString );

    HBufC* subject =

        StringLoader::LoadLC(R_QTN_MEET_REQ_PLAIN_TEXT_SUBJECT);

    HBufC* location =

        StringLoader::LoadLC(R_QTN_MEET_REQ_PLAIN_TEXT_LOCATION);

    HBufC* startTime =

        StringLoader::LoadLC(R_QTN_MEET_REQ_PLAIN_TEXT_START_TIME);

    HBufC* endTime =

        StringLoader::LoadLC(R_QTN_MEET_REQ_PLAIN_TEXT_END_TIME);

    HBufC* description =

        StringLoader::LoadLC(R_QTN_MEET_REQ_PLAIN_TEXT_DESCRIPTION);

    HBufC* details =

        HBufC::NewLC( subject->Length() +

                      location->Length() +

                      startTime->Length() +

                      endTime->Length() +

                      description->Length() +

                      aEntry.SummaryL().Length() +

                      aEntry.LocationL().Length() +

                      aEntry.DescriptionL().Length() +

                      KNewLine().Length() * KNewLinesNeeded +

                      KTimeStringLength * 2 + // start and end time

                      KDateStringLength * 2 + // start and end date

                      KWhiteSpace().Length() * 2 ); // start and end date times

    TPtr detailsPtr( details->Des() );

    detailsPtr.Append( *subject );

    detailsPtr.Append( aEntry.SummaryL() );

    detailsPtr.Append( KNewLine );

    detailsPtr.Append( *location );

    detailsPtr.Append( aEntry.LocationL() );

    detailsPtr.Append( KNewLine );

    detailsPtr.Append( *startTime );

    detailsPtr.Append( startDateStr );

    detailsPtr.Append( KWhiteSpace );

    detailsPtr.Append( startTimeStr );

    detailsPtr.Append( KNewLine );

    detailsPtr.Append( *endTime );

    detailsPtr.Append( endDateStr );

    detailsPtr.Append( KWhiteSpace );

    detailsPtr.Append( endTimeStr );

    detailsPtr.Append( KNewLine );

    detailsPtr.Append( *description );

    detailsPtr.Append( aEntry.DescriptionL() );

    detailsPtr.Append( KNewLine );

    CleanupStack::Pop( details );

    // subject, location, startTime, endTime, description

    CleanupStack::PopAndDestroy( 5, subject );

    CleanupStack::PushL( details );

    return details;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::Body8LC

// ---------------------------------------------------------------------------

//

HBufC8* CESMRMailPlainTextFormatter::Body8LC(

        CCalEntry& aEntry )

    {

    FUNC_LOG;

    HBufC* buf16 = Body16LC( aEntry );

    HBufC8* buf8 = HBufC8::NewLC( buf16->Length() );

    TPtr8 ptr8( buf8->Des() );

    TInt err = CnvUtfConverter::ConvertFromUnicodeToUtf8( ptr8, *buf16 );

    User::LeaveIfError( err );

    CleanupStack::Pop( buf8 );

    CleanupStack::PopAndDestroy( buf16 );

    CleanupStack::PushL( buf8 );

    return buf8;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::Subject16LC

// ---------------------------------------------------------------------------

//

HBufC* CESMRMailPlainTextFormatter::Subject16LC(

            CCalEntry& aEntry,

            TBool aIsForwarded,

            TBool aIsUpdate )

    {

    FUNC_LOG;

    CESMRCalUserUtil* caluserUtil = CESMRCalUserUtil::NewLC( aEntry );

    TESMRRole role = caluserUtil->PhoneOwnerRoleL();

    CleanupStack::PopAndDestroy( caluserUtil );

    // create prefix for subject:

    HBufC* prefix = SubjectLinePrefix16LC(

                            aEntry,

                            aIsForwarded,

                            aIsUpdate ); //if returns NULL no need to CleanupStack::Pop later

    // user's email address is attached to subject if user is

    // responding to meeting request:

    HBufC* responseAddress = KNullDesC().AllocLC();

    if ( !aIsForwarded )

        {

        if ( EESMRRoleRequiredAttendee == role ||

             EESMRRoleOptionalAttendee == role ||

             EESMRRoleNonParticipant == role  )

             {

             CleanupStack::PopAndDestroy( responseAddress );

             responseAddress = NULL;

             CCalUser* phoneOwner = aEntry.PhoneOwnerL();

             responseAddress = phoneOwner->Address().AllocLC();

             }

        }

    // count the subject line buffer length

    TInt subjectLineLength( aEntry.SummaryL().Length() );

    if (prefix)

        {

        subjectLineLength += prefix->Length();

        }

    if (responseAddress)

        {

        subjectLineLength += responseAddress->Length();

        }

    // create and fill the subject buffer

    HBufC* subjectLine =

        HBufC::NewLC( subjectLineLength );

    TPtr ptrSubject( subjectLine->Des() );

     if (responseAddress)

        {

        ptrSubject.Append(*responseAddress);

        }

     if (prefix)

        {

        ptrSubject.Copy( *prefix );

        }

    ptrSubject.Append( aEntry.SummaryL() );

    CleanupStack::Pop( subjectLine );

    if (prefix)

        {

        CleanupStack::PopAndDestroy( 2, prefix ); // responseAddress

        }

    else

        {

        CleanupStack::PopAndDestroy( responseAddress );

        }

    CleanupStack::PushL( subjectLine );

    return subjectLine;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::Subject8LC

// ---------------------------------------------------------------------------

//

HBufC8* CESMRMailPlainTextFormatter::Subject8LC(

            CCalEntry& aEntry,

            TBool aIsForwarded,

            TBool aIsUpdate  )

    {

    FUNC_LOG;

    HBufC* buf16 = Subject16LC( aEntry, aIsForwarded, aIsUpdate );

    HBufC8* buf8 = HBufC8::NewLC( buf16->Length() );

    TPtr8 ptr8(buf8->Des() );

    TInt err = CnvUtfConverter::ConvertFromUnicodeToUtf8( ptr8, *buf16 );

    User::LeaveIfError( err );

    CleanupStack::Pop( buf8 );

    CleanupStack::PopAndDestroy( buf16 );

    CleanupStack::PushL( buf8 );

    return buf8;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::SubjectLinePrefix16LC

// ---------------------------------------------------------------------------

//

HBufC* CESMRMailPlainTextFormatter::SubjectLinePrefix16LC(

        CCalEntry& aEntry,

        TBool aIsForwarded,

        TBool aIsUpdate  )

    {

    FUNC_LOG;

    HBufC* prefix = NULL;

    CESMRCalUserUtil* caluserUtil = CESMRCalUserUtil::NewLC( aEntry );

    TESMRRole role = caluserUtil->PhoneOwnerRoleL();

    CleanupStack::PopAndDestroy( caluserUtil );

    caluserUtil = NULL;

    if ( EESMRRoleOrganizer == role )

        {

        CCalEntry::TMethod method = aEntry.MethodL();

        if ( CCalEntry::EMethodCancel == method )

            {

            prefix =

                StringLoader::LoadLC( R_QTN_MEET_REQ_PLAIN_TEXT_CANCELLED );

            }

        else if ( CCalEntry::EMethodRequest == method  &&

                  (aIsUpdate || aIsForwarded) )

            {

            prefix =

                StringLoader::LoadLC( R_QTN_MEET_REQ_PLAIN_TEXT_UPDATE );

            }

        else

            {

            prefix =

                KNullDesC().AllocLC();

            }

        }

    else if ( EESMRRoleRequiredAttendee == role ||

              EESMRRoleOptionalAttendee == role ||

              EESMRRoleNonParticipant == role )

        {

        CCalAttendee* attendee =

            iMailboxUtils.ThisAttendeeL( aEntry );

        if ( attendee )

            {

            switch( attendee->StatusL() )

                {

                case CCalAttendee::EAccepted:

                    prefix =

                            StringLoader::LoadLC(

                                R_QTN_MEET_REQ_PLAIN_TEXT_ACCEPTED );

                    break;

                case CCalAttendee::ETentative:

                    prefix =

                            StringLoader::LoadLC(

                                R_QTN_MEET_REQ_PLAIN_TEXT_TENTATIVE );

                    break;

                case CCalAttendee::EDeclined:

                    prefix =

                            StringLoader::LoadLC(

                                R_QTN_MEET_REQ_PLAIN_TEXT_DECLINED );

                    break;

                default:

                    prefix =

                        KNullDesC().AllocLC();

                    break;

                }

            }

        else

            {

            prefix =

                KNullDesC().AllocLC();

            }

        }

    return prefix;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::UpdatedStringLC

// ---------------------------------------------------------------------------

//

HBufC* CESMRMailPlainTextFormatter::UpdatedStringLC()

    {

    FUNC_LOG;

    HBufC* updatedString =

            StringLoader::LoadLC( R_QTN_MEET_REQ_PLAIN_TEXT_UPDATE );

    return updatedString;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::CanceledStringLC

// ---------------------------------------------------------------------------

//

HBufC* CESMRMailPlainTextFormatter::CanceledStringLC()

    {

    FUNC_LOG;

    HBufC* canceledString =

            StringLoader::LoadLC( R_QTN_MEET_REQ_PLAIN_TEXT_CANCELLED );

    return canceledString;

    }

// ---------------------------------------------------------------------------

// CESMRMailPlainTextFormatter::ReplyStringLC

// ---------------------------------------------------------------------------

//

HBufC* CESMRMailPlainTextFormatter::ReplyStringLC( CCalEntry& aEntry )

    {

    FUNC_LOG;

    HBufC* replyString = NULL;

    HBufC* replyStringPrefix =

            StringLoader::LoadLC( R_QTN_MEET_REQ_VIEWER_SUBJECT_PREFIX_REPL );

    TPtrC subject( aEntry.SummaryL() );

    TInt pos = subject.Find( *replyStringPrefix );

    if ( KErrNotFound == pos || KFirstPos != pos )

        {

        // There is no reply prefix already or reply prefix is not at the 

        // beginning --> We need to add it to description

        // No need to put into cleanupstack because calling only non leaving 

        // functions before exiting

        replyString = HBufC::NewL( 

                            replyStringPrefix->Length() + subject.Length() );

        TPtr ptrReply( replyString->Des() );

        ptrReply.Copy( *replyStringPrefix );

        ptrReply.Append( subject );

        }

    else

        {

        replyString = subject.AllocL();

        }

    CleanupStack::PopAndDestroy( replyStringPrefix );

    CleanupStack::PushL( replyString );

    return replyString;

    }

// EOF