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




// INCLUDE FILES
#include "MRHelpers.h"
#include "MREntryConsultant.h"
#include <caluser.h> // CCalUser
#include <miuthdr.h> // CImHeader
#include <msvapi.h> // CMsvSession
#include <msvuids.h> // KUidMsvMessageEntry
#include <miutpars.h> // TImMessageField
#include <bautils.h> // BaflUtils
#include <coemain.h> // CCoeEnv

// CONSTANTS

/// Unnamed namespace for local definitions
namespace {

_LIT( KMailtoMatchPattern, "mailto:*" ); // this is never localized
const TInt KMailtoLength = 7; // "mailto:" length

enum TPanicCode
    {
    EPanicNullMsvId = 1,
    EIllegalMsvEntryType,
    EPanicNoOrganizer
    };

_LIT( KPanicMsg, "MRHelpers" );

void Panic( TPanicCode aReason )
    {
    User::Panic( KPanicMsg, aReason );
    }
    
}  // namespace

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

// ----------------------------------------------------------------------------
// MRHelpers::CopyAttendeeL
// ----------------------------------------------------------------------------
//    
CCalAttendee* MRHelpers::CopyAttendeeL( CCalAttendee& aSource )
	{
	CCalAttendee* copy = CopyAttendeeLC( aSource );
	CleanupStack::Pop( copy );
	return copy;
	}

// ----------------------------------------------------------------------------
// MRHelpers::CopyAttendeeLC
// ----------------------------------------------------------------------------
//    
CCalAttendee* MRHelpers::CopyAttendeeLC( CCalAttendee& aSource )
	{
	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;
	}

// ----------------------------------------------------------------------------
// MRHelpers::CopyUserL
// ----------------------------------------------------------------------------
//    
CCalUser* MRHelpers::CopyUserL( CCalUser& aSource )
	{
	CCalUser* copy = CopyUserLC( aSource );
	CleanupStack::Pop( copy );
	return copy;
	}

// ----------------------------------------------------------------------------
// MRHelpers::CopyUserLC
// ----------------------------------------------------------------------------
//    
CCalUser* MRHelpers::CopyUserLC( CCalUser& aSource )
	{
	CCalUser* copy = CCalUser::NewL( aSource.Address(), 
	                                 aSource.SentBy() );
    CleanupStack::PushL( copy );
    copy->SetCommonNameL( aSource.CommonName() );
	return copy;
	}

// ----------------------------------------------------------------------------
// MRHelpers::CopyEntryL
// ----------------------------------------------------------------------------
//          
CCalEntry* MRHelpers::CopyEntryL(
    const CCalEntry& aEntry,
    CCalEntry::TMethod aMethod,
    TCopyFields aCopyType )
    {
	CCalEntry* copy = CopyEntryLC( aEntry, aMethod, aCopyType );
	CleanupStack::Pop( copy );
	return copy;    
    }
	
// ----------------------------------------------------------------------------
// MRHelpers::CopyEntryLC
// ----------------------------------------------------------------------------
//          
CCalEntry* MRHelpers::CopyEntryLC(
    const CCalEntry& aEntry,
    CCalEntry::TMethod aMethod,
    TCopyFields aCopyType )
    {
    CCalEntry* copy = NULL;
    HBufC8* uid = aEntry.UidL().AllocLC();
    if ( MREntryConsultant::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 );
            
    return copy;
    } 

// ----------------------------------------------------------------------------
// MRHelpers::CopyFieldsL
// ----------------------------------------------------------------------------
//   
void MRHelpers::CopyFieldsL(
    const CCalEntry& aSource,
    CCalEntry& aTarget,
    TCopyFields aCopyType )
    {
    if ( aCopyType == ECopyFull )
        {
        CCalEntry::TMethod tmpMethod( aTarget.MethodL() );    
        aTarget.CopyFromL( aSource );
        // We must re-set the method to the original value
        aTarget.SetMethodL( tmpMethod );
        }
    else
        {
        if ( aCopyType == ECopyOrganizer )
            {
            __ASSERT_DEBUG( aSource.OrganizerL(), Panic( EPanicNoOrganizer ) );
            CCalUser* organizer = CopyUserLC( *( aSource.OrganizerL() ) );
            aTarget.SetOrganizerL( organizer );
            CleanupStack::Pop(); // 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() );
        }
    }
    
// ----------------------------------------------------------------------------
// MRHelpers::SenderAddressLC
// ----------------------------------------------------------------------------
//    
HBufC* MRHelpers::SenderAddressLC(
    CMsvSession& aSession,
    TMsvId aMsgId,
    TBool aStripAlias )
    {
	__ASSERT_DEBUG( aMsgId != KMsvNullIndexEntryId, Panic( EPanicNullMsvId ) );
    CMsvEntry* entry = aSession.GetEntryL( aMsgId );
    __ASSERT_ALWAYS( entry->Entry().iType == KUidMsvMessageEntry,
                     Panic( EIllegalMsvEntryType ) );

    // Read sender from the message headers and allocate heap descriptor:

    CleanupStack::PushL( entry );
    CMsvStore* store = entry->ReadStoreL();
    CleanupStack::PushL( store );
    CImHeader* header = CImHeader::NewLC();
    header->RestoreL( *store );    
    TPtrC senderPtr( header->From() );
    if ( aStripAlias )
        {
        TImMessageField addrParser;
        senderPtr.Set(
            addrParser.GetValidInternetEmailAddressFromString( senderPtr ) );
        }
    HBufC* senderAddr = senderPtr.AllocL();
    CleanupStack::PopAndDestroy( 3, entry ); // header, store, entry
    CleanupStack::PushL( senderAddr );            
    return senderAddr;
    }

// ----------------------------------------------------------------------------
// MRHelpers::AddressWithoutMailtoPrefix
// ----------------------------------------------------------------------------
//    
TPtrC MRHelpers::AddressWithoutMailtoPrefix( const TDesC& aAddress )
	{
	TPtrC addrWithoutPrefix;
    if ( aAddress.MatchF( KMailtoMatchPattern ) != KErrNotFound )
    	{
        addrWithoutPrefix.Set( aAddress.Mid( KMailtoLength ) );
        }
    else
    	{
        addrWithoutPrefix.Set( aAddress );
        }
    return addrWithoutPrefix;
	}
	
// ----------------------------------------------------------------------------
// MRHelpers::GetCorrectDllDriveL
// ----------------------------------------------------------------------------
//    
void MRHelpers::GetCorrectDllDriveL( TFileName& aDriveName )
    {
    TParse parse;
    Dll::FileName( aDriveName );
	User::LeaveIfError( parse.Set( aDriveName, NULL, NULL ) );
    aDriveName = parse.Drive(); // contains drive, e.g. "c:"
    }

// ----------------------------------------------------------------------------
// MRHelpers::LoadResourceL
// ----------------------------------------------------------------------------
//    
TInt MRHelpers::LoadResourceL(
    const TDesC& aResourceFile,
    const TDesC& aResourcePath )
    {
    TFileName pathAndFile;
    MRHelpers::GetCorrectDllDriveL( pathAndFile ); // contains drive, e.g. "c:"    
    pathAndFile.Append( aResourceFile ); // e.g. "c:MyResource.rsc"
    
    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;
    }

//  End of File