/*

* Copyright (c) 2005-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:  Static helper methods

*

*/

// INCLUDE FILES

#include "esmrhelper.h"

#include "esmrentryhelper.h"

#include "esmrconfig.hrh"

#include <f32file.h>

#include <caluser.h>

#include <miuthdr.h>

#include <msvapi.h>

#include <msvuids.h>

#include <miutpars.h>

#include <bautils.h>

#include <coemain.h>

#include <msvids.h>

#include <calalarm.h>

#include <calrrule.h>

#include <calattachment.h>

#include <centralrepository.h>

#include <cmrmailboxutils.h>

#include <ct/rcpointerarray.h>

#include <utf.h>

#include <aknlists.h>

#include <data_caging_path_literals.hrh>

//<cmail> hardcoded paths removal

#include <pathinfo.h>

//</cmail>

#include "emailtrace.h"

// CONSTANTS

/// Unnamed namespace for local definitions

namespace { // codescanner::namespace

_LIT( KMailtoMatchPattern, "mailto:*" ); // these are never localized

const TInt KMailtoLength = 7; // "mailto:" length

// Resource file format

_LIT( KResourceFileLocFormat1, "r%02d");

_LIT( KResourceFileLocFormat2, "r%d");

const TInt KMinTwoDigitLanguageCode = 10;

_LIT (KResourceFormat, "rsc" );

// Definition for max hours, minutes, seconds in day for Memo

const TInt KMaxHoursForMemo( 23 );

const TInt KMaxMinutesForMemo( 59 );

const TInt KMaxSecondsForMemo( 59 );

// Definition for max hours, minutes, seconds in day for To-Do

const TInt KMaxHoursForTodo( 23 );

const TInt KMaxMinutesForTodo( 59 );

const TInt KMaxSecondsForTodo( 00 );

const TInt KDefaultAnniversaryAlarmHours( 12 );

const TInt KDefaultTodoAlarmHours( 12 );

// Definition for default alarm time for meeting

const TInt KDefaultMeetingAlarmMinutes( 15 );

// Constant for default meeeting start hour

const TInt KDefaultMeetingStartHour( 8 );

// Constant for default meeeting end hour

const TInt KDefaultMeetingEndHour( 9 );

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicNullMsvId = 1,

    EIllegalMsvEntryType,

    EPanicNoOrganizer,

    EInvalidEntryType,

    EInvalidSwitchType

    };

// Panic message definition

_LIT( KPanicMsg, "ESMRHelper" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

#endif // _DEBUG

CCalEntry::TType MapType( TESMRCalendarEventType aEntryType )

    {

    CCalEntry::TType type( CCalEntry::EAppt );

    switch ( aEntryType )

        {

        case EESMREventTypeAppt:

        case EESMREventTypeMeetingRequest:

            {

            type = CCalEntry::EAppt;

            break;

            }

        case EESMREventTypeETodo:

            {

            type = CCalEntry::ETodo;

            break;

            }

        case EESMREventTypeEEvent:

            {

            type = CCalEntry::EEvent;

            break;

            }

        case EESMREventTypeEReminder:

            {

            type = CCalEntry::EReminder;

            break;

            }

        case EESMREventTypeEAnniv:

            {

            type = CCalEntry::EAnniv;

            break;

            }

        default:

            {

            __ASSERT_DEBUG( EFalse, Panic( EInvalidEntryType ) );

            }

        }

    return type;

    }

/**

 * Fetches the supported mailboxes.

 * @param aMBUtils utils class

 * @param aMailBoxes to test

 */

void SupportedMailboxesL(

        CMRMailboxUtils& aMBUtils,

        RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

    {

    FUNC_LOG;

    aMBUtils.ListMailBoxesL( aMailBoxes );

    RCPointerArray<CImplementationInformation> implArray;

    CleanupClosePushL( implArray );

    //Get all MRViewers Implementation

    const TUid mrViewersIface = TUid::Uid(KMRViewersInterfaceUID);

    REComSession::ListImplementationsL(mrViewersIface, implArray );

    TInt mrviewerCount( implArray.Count() );

    TInt index(0);

    TInt mailboxCount( aMailBoxes.Count() );

    while ( index < mailboxCount )

         {

         TBool supported( EFalse );

         for ( TInt i(0); (i < mrviewerCount) && !supported; ++ i )

             {

             TBuf16<KMaxUidName> mbName;

             CnvUtfConverter::ConvertToUnicodeFromUtf8(

                     mbName,

                     implArray[i]->DataType() );

             if( aMailBoxes[index].iMtmUid.Name().CompareF(mbName) == 0)

                  {

                  supported = ETrue;

                 }

             }

         if ( supported )

             {

             index++;

             }

         else

             {

             aMailBoxes.Remove( index );

             mailboxCount = aMailBoxes.Count();

             }

         }

    CleanupStack::PopAndDestroy( &implArray );

    }

/**

 * Prompts user to select default mailbox.

 * @param aMailBoxes Reference to mailbox list

 */

TInt PromptForDefaultMailboxL(

        RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

    {

    FUNC_LOG;

    TInt selected( KErrCancel );

    TInt mbCount = aMailBoxes.Count();

    if( mbCount > 0)

        {

        CAknSinglePopupMenuStyleListBox* list =

            new (ELeave) CAknSinglePopupMenuStyleListBox;

        CleanupStack::PushL(list);

        CAknPopupList* popupList = CAknPopupList::NewL(

                                            list,

                                            R_AVKON_SOFTKEYS_OK_CANCEL);

        CleanupStack::PushL(popupList);

        list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);

        list->CreateScrollBarFrameL(ETrue);

        list->ScrollBarFrame()->SetScrollBarVisibilityL(

            CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

        CEikonEnv* eikEnv = CEikonEnv::Static();// codescanner::eikonenvstatic

        CDesCArrayFlat* items = new (ELeave)CDesCArrayFlat(mbCount);

        CleanupStack::PushL(items);

        for(TInt i=0; i<mbCount; ++i)

            {

            items->AppendL( aMailBoxes[i].iName );

            }

        CleanupStack::Pop(items);

        CTextListBoxModel* model = list->Model();

        //Pass ownersip of items to model

        model->SetItemTextArray(items);

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

        popupList->SetTitleL(*title);

        CleanupStack::PopAndDestroy(title);

        TBool accepted = popupList->ExecuteLD();

        CleanupStack::Pop( popupList );

        if(accepted)

            {

            selected = list->CurrentItemIndex();

            }

        else

            {

            selected = KErrCancel;

            }

        CleanupStack::PopAndDestroy( list );

        }

    else

        {

        //No mailboxes defined.  Could prompt user to define one here.

        selected = KErrCancel;

        }

    return selected;

    }

/**

 * Converts to-do specific priority to normal priority

 * @param Calendar entry, which priority is converted

 */

void ConvertTodoPriorityToNormalL( CCalEntry& entry )

    {

    FUNC_LOG;

    TInt priority( 0 );

    if( entry.PriorityL() == EFSCalenTodoPriorityHigh )

        {

        priority = EFSCalenMRPriorityHigh;

        }

    else if( entry.PriorityL() == EFSCalenTodoPriorityNormal )

        {

        priority = EFSCalenMRPriorityNormal;

        }

    else if( entry.PriorityL() == EFSCalenTodoPriorityLow )

        {

        priority = EFSCalenMRPriorityLow;

        }

    else

        {

        // Priority unknown, let's set it to normal then

        priority = EFSCalenMRPriorityNormal;

        }

    entry.SetPriorityL( priority );

    }

}  // namespace

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

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

// ESMRHelper::CopyAttendeeL

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

//

EXPORT_C CCalAttendee* ESMRHelper::CopyAttendeeL( CCalAttendee& aSource )

    {

    FUNC_LOG;

    CCalAttendee* copy = CopyAttendeeLC( aSource );

    CleanupStack::Pop( copy );

    return copy;

    }

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

// ESMRHelper::CopyAttendeeLC

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

//

EXPORT_C CCalAttendee* ESMRHelper::CopyAttendeeLC( CCalAttendee& aSource )

    {

    FUNC_LOG;

    CCalAttendee* copy = CCalAttendee::NewL( aSource.Address(),

                                             aSource.SentBy() );

    CleanupStack::PushL( copy );

    copy->SetCommonNameL( aSource.CommonName() );

    copy->SetRoleL( aSource.RoleL() );

    copy->SetStatusL( aSource.StatusL() );

    copy->SetResponseRequested( aSource.ResponseRequested() );

    return copy;

    }

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

// ESMRHelper::CopyUserL

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

//

EXPORT_C CCalUser* ESMRHelper::CopyUserL( CCalUser& aSource )

    {

    FUNC_LOG;

    CCalUser* copy = CopyUserLC( aSource );

    CleanupStack::Pop( copy );

    return copy;

    }

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

// ESMRHelper::CopyUserLC

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

//

EXPORT_C CCalUser* ESMRHelper::CopyUserLC( CCalUser& aSource )

    {

    FUNC_LOG;

    CCalUser* copy = CCalUser::NewL( aSource.Address(),

                                     aSource.SentBy() );

    CleanupStack::PushL( copy );

    copy->SetCommonNameL( aSource.CommonName() );

    return copy;

    }

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

// ESMRHelper::CopyEntryL

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

//

EXPORT_C CCalEntry* ESMRHelper::CopyEntryL(

    const CCalEntry& aEntry,

    CCalEntry::TMethod aMethod,

    TCopyFields aCopyType,

    TESMRCalendarEventType aEntryType )

    {

    FUNC_LOG;

    CCalEntry* copy = CopyEntryLC( aEntry, aMethod, aCopyType, aEntryType );

    CleanupStack::Pop( copy );

    return copy;

    }

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

// ESMRHelper::CopyEntryLC

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

//

EXPORT_C CCalEntry* ESMRHelper::CopyEntryLC(

    const CCalEntry& aEntry,

    CCalEntry::TMethod aMethod,

    TCopyFields aCopyType,

    TESMRCalendarEventType aEntryType )

    {

    FUNC_LOG;

    CCalEntry* copy = NULL;

    TESMRCalendarEventType type = ESMREntryHelper::EventTypeL( aEntry );

    if( aEntryType == EESMREventTypeNone ||

            type == aEntryType )

        {

        HBufC8* uid = aEntry.UidL().AllocLC();

        CCalEntry::TType entryType = aEntry.EntryTypeL();

        if ( aEntryType != EESMREventTypeNone )

            {

            entryType = MapType( aEntryType );

            }

        if ( ESMREntryHelper::IsModifyingEntryL( aEntry ) )

            {

            copy = CCalEntry::NewL( entryType,

                                    uid,

                                    aMethod,

                                    aEntry.SequenceNumberL(),

                                    aEntry.RecurrenceIdL(),

                                    aEntry.RecurrenceRangeL() );

            }

        else

            {

            copy = CCalEntry::NewL( entryType,

                                    uid,

                                    aMethod,

                                    aEntry.SequenceNumberL() );

            }

        CleanupStack::Pop( uid ); // ownership transferred to the copy entry

        CleanupStack::PushL( copy );

        CopyFieldsL( aEntry, *copy, aCopyType );

        copy->SetLastModifiedDateL();

        }

    else

        {

        copy = CopyEntryAndSwitchTypeL( aEntry, aEntryType );

        CleanupStack::PushL( copy );

        }

    return copy;

    }

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

// ESMRHelper::CopyFieldsL

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

//

EXPORT_C void ESMRHelper::CopyFieldsL(

    const CCalEntry& aSource,

    CCalEntry& aTarget,

    TCopyFields aCopyType )

    {

    FUNC_LOG;

    if ( aCopyType == ECopyFull )

        {

        CCalEntry::TMethod tmpMethod( aTarget.MethodL() );

        aTarget.CopyFromL( aSource );

        // We must re-set the method to the original value

        aTarget.SetMethodL( tmpMethod );

        if ( Time::NullTTime() == aTarget.DTStampL().TimeUtcL() )

            {

            TCalTime dtStamp( aSource.DTStampL() );

            if ( Time::NullTTime() == dtStamp.TimeUtcL() )

                {

                TTime now; now.UniversalTime();

                dtStamp.SetTimeUtcL( now );

                }

            aTarget.SetDTStampL( dtStamp );

            }

        }

    else

        {

        if ( aCopyType == ECopyOrganizer )

            {

            __ASSERT_DEBUG( aSource.OrganizerL(), Panic( EPanicNoOrganizer ) );

            CCalUser* organizer = CopyUserLC( *( aSource.OrganizerL() ) );

            aTarget.SetOrganizerL( organizer );

            CleanupStack::Pop( organizer ); // ownership transferred

            }

        // these are required for entries (start and end time actually not

        // for cancels and responses, but won't do any harm either):

        aTarget.SetStartAndEndTimeL( aSource.StartTimeL(), aSource.EndTimeL() );

        aTarget.SetDTStampL( aSource.DTStampL() );

        }

    }

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

// ESMRHelper::AddressWithoutMailtoPrefix

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

//

EXPORT_C TPtrC ESMRHelper::AddressWithoutMailtoPrefix( const TDesC& aAddress )

    {

    FUNC_LOG;

    TPtrC addrWithoutPrefix( aAddress );

    TInt pos = KErrNotFound;

    do

        {

        pos = addrWithoutPrefix.MatchF( KMailtoMatchPattern );

        if ( pos != KErrNotFound )

        {

            addrWithoutPrefix.Set( addrWithoutPrefix.Mid( KMailtoLength ) );

            }

        }

    while ( pos != KErrNotFound );

    return addrWithoutPrefix;

    }

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