/*

* 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 "emailtrace.h"

#include "esmrhelper.h"

#include "esmrentryhelper.h"

#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 <SendUiConsts.h>

#include <data_caging_path_literals.hrh>

//<cmail> hardcoded paths removal

#include <pathinfo.h>

//</cmail>

// 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" );

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicNullMsvId = 1,

    EIllegalMsvEntryType,

    EPanicNoOrganizer

    };

// Panic message definition

_LIT( KPanicMsg, "ESMRHelper" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

#endif // _DEBUG

}  // 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 )

    {

    FUNC_LOG;

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

    CleanupStack::Pop( copy );

    return copy;

    }

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

// ESMRHelper::CopyEntryLC

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

//

EXPORT_C CCalEntry* ESMRHelper::CopyEntryLC(

    const CCalEntry& aEntry,

    CCalEntry::TMethod aMethod,

    TCopyFields aCopyType )

    {

    FUNC_LOG;

    CCalEntry* copy = NULL;

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

    if ( ESMREntryHelper::IsModifyingEntryL( aEntry ) )

        {

        copy = CCalEntry::NewL( aEntry.EntryTypeL(),

                                uid,

                                aMethod,

                                aEntry.SequenceNumberL(),

                                aEntry.RecurrenceIdL(),

                                aEntry.RecurrenceRangeL() );

        }

    else

        {

        copy = CCalEntry::NewL( aEntry.EntryTypeL(),

                                uid,

                                aMethod,

                                aEntry.SequenceNumberL() );

        }

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

    CleanupStack::PushL( copy );

    CopyFieldsL( aEntry, *copy, aCopyType );

    copy->SetLastModifiedDateL();

    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;

    }

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

// ESMRHelper::GetCorrectDllDriveL

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

//

EXPORT_C void ESMRHelper::GetCorrectDllDriveL( TFileName& aDriveName )

    {

    FUNC_LOG;

    TParse parse;

    Dll::FileName( aDriveName );

    User::LeaveIfError( parse.Set( aDriveName, NULL, NULL ) );

    aDriveName = parse.Drive(); // contains drive, e.g. "c:"

    }

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

// ESMRHelper::LoadResourceL

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

//

EXPORT_C TInt ESMRHelper::LoadResourceL( // codescanner::intleaves

    const TDesC& aResourceFile,

    const TDesC& aResourcePath )

    {

    FUNC_LOG;

    TFileName pathAndFile;

    // contains drive, e.g. "c:"

    ESMRHelper::GetCorrectDllDriveL( pathAndFile );

    // e.g. "c:MyResource.rsc"

    pathAndFile.Append( aResourceFile );

    TParse parse;

    parse.Set( pathAndFile, &aResourcePath, NULL );

    pathAndFile = parse.FullName(); // now we have full (unlocalized) file name

    // Find the resource file for the nearest language

    BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(),

                                    pathAndFile );

    TInt offset = CCoeEnv::Static()->AddResourceFileL( pathAndFile );

    return offset;

    }

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

// ESMRHelper::CorrespondingSmtpServiceL

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

//

EXPORT_C TMsvId ESMRHelper::CorrespondingSmtpServiceL(

            TMsvId aRelatedService,

            CMsvSession& aMsvSession )

    {

    FUNC_LOG;

    TMsvEntry entry;

    TMsvId    dummyService;

    User::LeaveIfError( aMsvSession.GetEntry( aRelatedService,

                                              dummyService,

                                              entry ) );

    TMsvId smtpId( KMsvNullIndexEntryId );

    switch ( entry.iMtm.iUid )

        {

        case KSenduiMtmImap4UidValue: // flow through

        case KSenduiMtmPop3UidValue:

            {

            // In these cases smtp entry is available in iRelatedId:

            smtpId = entry.iRelatedId;

            break;

            }

        case KSenduiMtmSmtpUidValue:

        case KSenduiMtmSyncMLEmailUidValue:

            {

            // In these cases we already know the msvid for the smtp settings

            // (for syncml there is also smtp settings):

            smtpId = aRelatedService;

            break;

            }

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    return smtpId;

    }

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

// ESMRHelper::PopulateChildFromParentL

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

//

EXPORT_C void ESMRHelper::PopulateChildFromParentL (

        CCalEntry &aChild,

        const CCalEntry &aParent)

    {

    FUNC_LOG;

    if ( aChild.DescriptionL() == KNullDesC )

        {

        aChild.SetDescriptionL( aParent.DescriptionL() );

        }

    if ( aChild.LocationL() == KNullDesC )

        {

        aChild.SetLocationL( aParent.LocationL() );

        }

    if ( aChild.PriorityL() == 0 )

        {

        // zero is undefined priority according to iCal spec.

        aChild.SetPriorityL( aParent.PriorityL() );

        }

    if ( aChild.SummaryL() == KNullDesC )

        {

        aChild.SetSummaryL( aParent.SummaryL() );

        }

    if ( aChild.StatusL() == CCalEntry::ENullStatus )

        {

        aChild.SetStatusL( aParent.StatusL() );

        }

    if (aChild.ReplicationStatusL() != aParent.ReplicationStatusL())

        {

        aChild.SetReplicationStatusL(aParent.ReplicationStatusL());

        }

    if (aChild.MethodL() == CCalEntry::EMethodNone)

        {

        aChild.SetMethodL(aParent.MethodL());

        }

    CCalAlarm* childAlarm = aChild.AlarmL();

    CleanupStack::PushL( childAlarm );

    CCalAlarm* parentAlarm = aChild.AlarmL();

    CleanupStack::PushL( parentAlarm );

    if( !childAlarm && parentAlarm )

        {

        aChild.SetAlarmL( parentAlarm );

        }

    CleanupStack::PopAndDestroy( parentAlarm );

    CleanupStack::PopAndDestroy( childAlarm );

    // Organizer

    if ( !aChild.OrganizerL() && aParent.OrganizerL() )

        {

        CCalUser* owner =

                ESMRHelper::CopyUserLC( *( aParent.OrganizerL() ) );

        aChild.SetOrganizerL( owner );

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

        }

    // Attendees

    RPointerArray<CCalAttendee>& childAtt = aChild.AttendeesL();

    RPointerArray<CCalAttendee>& parentAtt = aParent.AttendeesL();

    CCalUser *po = NULL;

    if ( !aChild.PhoneOwnerL() )

        { // Phone owner is internal data, not part of ical protocol, it's

          // benefit is to avoid heavy "who am I" resolving operation

        po = aParent.PhoneOwnerL();

        }

    TInt parentAttCount( parentAtt.Count() );

    if ( childAtt.Count() == 0 && parentAttCount > 0 )

        {

        for ( TInt i( 0 ); i < parentAttCount; ++i )

            {

            CCalAttendee* copy =

                    ESMRHelper::CopyAttendeeLC( *( parentAtt[i] ) );

            aChild.AddAttendeeL( copy );

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

            if(po == parentAtt[i])

                {

                aChild.SetPhoneOwnerL(copy);

                }

            }

        }

    }

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

// ESMRHelper::LocateResourceFile

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

//

EXPORT_C TInt ESMRHelper::LocateResourceFile(

        const TDesC& aResource,

        const TDesC& aPath,

        TFileName &aResourceFile,

        RFs* aFs )

    {

    FUNC_LOG;

    RFs* fsSession;

    if ( aFs )

        {

        fsSession = aFs;

        }

    else

        {

        fsSession=&CCoeEnv::Static()->FsSession();//codescanner::eikonenvstatic

        }

    TFindFile resourceFile( *fsSession );

    TInt err = resourceFile.FindByDir(

            aResource,

            aPath );

    if ( KErrNone == err )

        {

        aResourceFile.Copy( resourceFile.File() );

        }

    else

    	{

    	const TChar KFileFormatDelim( '.' );

    	TFileName locResourceFile;

    	TInt pos = aResource.LocateReverse( KFileFormatDelim );

    	if ( pos != KErrNotFound )

    		{		

    		locResourceFile.Copy( aResource.Mid(0, pos + 1) );

    		TInt language( User::Language() );

    		if (language < KMinTwoDigitLanguageCode )

    			{

    			locResourceFile.AppendFormat( KResourceFileLocFormat1, language );

    			}

    		else

    			{

    			locResourceFile.AppendFormat( KResourceFileLocFormat2, language );

    			}

    		TFindFile resourceFile( *fsSession );

    		err = resourceFile.FindByDir(

    				locResourceFile,

    				aPath );

    		if ( KErrNone == err )

    			{

    			TFileName tempName;

    			tempName.Copy( resourceFile.File() );

    			TInt dotpos= tempName.LocateReverse(KFileFormatDelim);

    			aResourceFile.Copy(tempName.Mid(0,dotpos+1) );

    			aResourceFile.Append(KResourceFormat);				

    			}

    		}

    	}

    if ( KErrNone != err )

        {

        }

    return err;

    }

//<cmail>

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

// ESMRHelper::CreateAndAppendPrivateDirToFileName

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

//

EXPORT_C TInt ESMRHelper::CreateAndAppendPrivateDirToFileName(TFileName& aFileName)

    {

    TFileName KPath;

    RFs fsSession;

    TInt result = fsSession.Connect();

    if(result==KErrNone)

        {

        fsSession.PrivatePath(KPath);

        TFindFile findFile(fsSession);

        result = findFile.FindByDir(KPath, KNullDesC);

        if (result != KErrNone) //create path if doesn't exists

            {

            fsSession.CreatePrivatePath(TDriveUnit(PathInfo::PhoneMemoryRootPath()));

            result = findFile.FindByDir(KPath, KNullDesC);

            }

        KPath = findFile.File();

        aFileName.Insert(0,KPath);

        fsSession.MkDirAll(aFileName);

        fsSession.Close();

        }

    return result;

    }

//</cmail>

// EOF