// 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:
//

#include "smcmstepbase.h"

#include <csmsaccount.h>
#include <csmsemailfields.h>
#include <e32math.h>
#include <emsformatie.h>
#include <emspictureie.h>
#include "emstestutils.h"
#include <f32file.h>
#include <smuthdr.h>
#include <mtmdef.h>

RTest test( _L( "SMS Test" ) );

const TInt KOneHourSeconds = 3600;

// @return - TVerdict
// Implementation of CTestStep base class virtual
// All common initialisation to derived classes is done in here.
TVerdict CSMCMStepBase::doTestStepPreambleL( )
	{
	INFO_PRINTF1( _L( "CSMCMStepBase::doTestStepPreambleL()" ) );
	
	ChangeLocale ( KUTC0 );
	
	iScheduler = new( ELeave ) CActiveScheduler;
	CActiveScheduler::Install( iScheduler );

	// need this to open a server session
	iDummyObserver = new( ELeave ) TMsvDummyObserver;

	// All the test steps will need an SMS Client MTM so we
	// build it here	
	iSmsTestUtils = CSmsTestUtils::NewL( test );
	iSmsTestUtils->SetLogToFile( );
	iSmsTestUtils->InstantiateClientMtmsL( );

	//  Initialize mailbox
	CSmsSettings* settings = CSmsSettings::NewL( );
	CleanupStack::PushL( settings );
	CSmsAccount* account = CSmsAccount::NewLC( );
	TRAPD(err,account->InitialiseDefaultSettingsL( *settings ) );
	if ( err != KErrNone )
		{
		User::Leave( err );
		}
	
	CleanupStack::PopAndDestroy( account );
	CleanupStack::PopAndDestroy( settings ); 

	// open the server session
	iServerSession = CMsvSession::OpenSyncL( *iDummyObserver );
	
	// create the Client MTM registry and get the Client MTM from it
	iClientMtmRegistry = CClientMtmRegistry::NewL( *iServerSession );
	iSmsClientMtm = ( CSmsClientMtm* ) iClientMtmRegistry->NewMtmL( KUidMsgTypeSMS );

	// create the root entry
	iMsvEntry = CMsvEntry::NewL( *iServerSession, 
								 KMsvRootIndexEntryId, 
								 TMsvSelectionOrdering( ) );
	
	TSmsUtilities::ServiceIdL( *iServerSession, 
								iSmsServiceId, 
								KUidMsgTypeSMS );

	SetTestStepResult( EPass );

	return TestStepResult( );
	}

CSMCMStepBase::~CSMCMStepBase( )
	{
	delete iSmsClientMtm;
	delete iClientMtmRegistry;	

	delete iDummyObserver; 
	delete iServerSession; 

	delete iScheduler;

	}

CSMCMStepBase::CSMCMStepBase( )
	{
	
	}
	
void CSMCMStepBase::ChangeLocale( TInt aHours )
	{
	User::SetUTCOffset( KOneHourSeconds * aHours );	
	}
	
TMsvId CSMCMStepBase::CreateEmailSmsMessageL( const TDesC& aEmailMessageData )
	{
	RFs fs;
 	User::LeaveIfError( fs.Connect( ) );
 	CleanupClosePushL( fs );
 
 	CSmsMessage* message = CSmsMessage::NewL( fs, 
 											  CSmsPDU::ESmsDeliver, 
 											  CSmsEditorBuffer::NewL( *iSmsTestUtils->iRichText ), 
 											  EFalse );
 	CleanupStack::PushL( message );
 	
 	CSmsBufferBase& buffer = message->Buffer( );
 	buffer.Reset( );
 	buffer.InsertL( 0, aEmailMessageData );
 	
 	// Set the PID for email.
 	if( message->SmsPDU( ).ProtocolIdentifierPresent( ) )
 		{
 		message->SmsPDU( ).SetPIDType( TSmsProtocolIdentifier::ESmsPIDTelematicInterworking );
 		message->SmsPDU( ).SetTelematicDeviceIndicator( TSmsProtocolIdentifier::ESmsTelematicDevice );
 		message->SmsPDU( ).SetTelematicDeviceType( TSmsProtocolIdentifier::ESmsInternetElectronicMail );
 		
 		}

	// Create a new SMS header ( CSmsHeader takes ownership of message )
 	CSmsHeader* header = CSmsHeader::NewL( message );
 	CleanupStack::Pop( message );
 	CleanupStack::PushL( header );
 	
 	header->SetFromAddressL( KScriptItemRecipientsDef );
 	header->Message( ).SetServiceCenterAddressL( KScriptItemSCDef );

	// Set the entry data...
 	TMsvEntry entry;
 	entry.iType = KUidMsvMessageEntry;
 	entry.SetSendingState( KMsvSendStateNotApplicable );
 	TSmsUtilities::PopulateMsgEntry( entry, 
 									 header->Message( ), 
 									 iSmsTestUtils->iSmsServiceId );

 	entry.iDate.UniversalTime( );

	const CSmsEmailFields& fields = header->EmailFields( );
 	// Set the details fiels to the address field.
	if ( !fields.HasAddress( ) )
		{
		SetTestStepResult( EFail );
		}
	TInt count = fields.Addresses( ).MdcaCount( );
 	entry.iDetails.Set( fields.Addresses( ).MdcaPoint( 0 ).Left( KSmsDetailsLength ) );			
 	
 	// Set the description to either the subject or the begining part of the
 	// body text.
 	HBufC* desBuffer = HBufC::NewLC( iSmsClientMtm->ServiceSettings( ).DescriptionLength( ) );
 	TPtr description( desBuffer->Des( ) );
 	if( fields.Subject( ).Length( ) > 0 )
 		{
 		// There is a subject - use this as the description
 		description.Copy( fields.Subject( ).Left( description.MaxLength( ) ) );
 		
 		}
 	else
 		{
 		// No subject - use the begining part of the body text.
 		CSmsBufferBase& body = header->Message( ).Buffer( );
 		TInt length = body.Length( );
 		HBufC* buf = HBufC::NewLC( length );
 		TPtr ptr( buf->Des( ) );
 		body.Extract( ptr, 0, length );
 
 		description.Copy( ptr.Left( description.MaxLength( ) ) );
 		CleanupStack::PopAndDestroy( buf );
 		
 		}
 	entry.iDescription.Set( description );

	// Create the entry in the inbox.
 	iSmsTestUtils->SetEntryL( KMsvGlobalInBoxIndexEntryId );
 	iSmsTestUtils->CreateEntryL( entry );
 	iServerSession->CleanupEntryPushL( entry.Id( ) );
 	
 	// Store the header...
 	iSmsTestUtils->SetEntryL( entry.Id( ) );
 	CMsvStore* store = iSmsTestUtils->EditStoreL( );
 	CleanupStack::PushL( store );
 
 	header->StoreL( *store );
 
 	// Store the body text
 	store->StoreBodyTextL( *iSmsTestUtils->iRichText );
 	store->CommitL( );
 
 	entry.iSize = store->SizeL( );
 	entry.SetReadOnly( ETrue );
 	iSmsTestUtils->ChangeEntryL( entry );
 	
	CleanupStack::PopAndDestroy( store );
 	iServerSession->CleanupEntryPop( );
 	CleanupStack::PopAndDestroy( 3, &fs );	// fs, header, desBuffer
 	
 	return entry.Id( );

	}

TMsvId CSMCMStepBase::CreateMessageAndEntryL( const TDesC& aUserData, TMessageSettings aSettings )
	{
	TMsvEntry entry;
	entry.iType = KUidMsvMessageEntry;
	entry.SetSendingState( KMsvSendStateUnknown );
	entry.iDetails.Set( _L( "Alias" ) );
	entry.iBioType = aSettings.iOriginalBioType;
	
	iSmsTestUtils->iRichText->Reset( );
	iSmsTestUtils->iRichText->InsertL( 0, aUserData );
	
	CSmsHeader* header = NULL;
	if ( aSettings.iOperation == EOperationNone || aSettings.iOperation == EOperationReply )
		{
		header = CSmsHeader::NewL( aSettings.iOriginalSmsPDUType, 
								   *iSmsTestUtils->iRichText );	
		}
	else // EOperationForward
		{
		header = CSmsHeader::NewL( CSmsMessage::NewL( iSmsTestUtils->FileSession(), 
													  aSettings.iOriginalSmsPDUType, 
													  CSmsEditorBuffer::NewL( *iSmsTestUtils->iRichText ) ) );		
			}
	

	CleanupStack::PushL( header );
	
	// Add formating and a picture
	CEmsFormatIE* format = CEmsFormatIE::NewL( );
	CleanupStack::PushL( format );
	format->SetStartPosition(10);
	format->SetFormatLength(10);
	format->SetBold( ETrue );
	header->Message( ).AddEMSInformationElementL( *format );
	CleanupStack::PopAndDestroy( format );

	CEmsPictureIE* pic = EmsTestUtils::CreatePictureL( 0 );
	CleanupStack::PushL( pic );
	pic->SetStartPosition( 0 );
	header->Message().AddEMSInformationElementL( *pic );
	CleanupStack::PopAndDestroy(pic);

	header->SetFromAddressL( KScriptItemRecipientsDef );
	header->Message().SetServiceCenterAddressL( KScriptItemSCDef );
	
	TTime now;
	now.UniversalTime( );
	
	iSmsTestUtils->CreateMessageL( aSettings.iOriginalBoxId,
								   entry, 
								   *header, 
								   *iSmsTestUtils->iRichText,
								   now );
	entry.SetReadOnly( ETrue );
	
	CleanupStack::PopAndDestroy( header );

	return entry.Id( );
	
	}

// Creates a random string of lenth aLen (is used to generate a random body)	
HBufC* CSMCMStepBase::CreateRandomLC( TInt aLen ) const
	{
	HBufC* msg = HBufC::NewLC( aLen );
	TPtr msgPtr( msg->Des( ) );
	msgPtr.SetLength( aLen );
	
	TUint16* ptr = &msgPtr[ 0 ];
	while( --aLen )
		{
		// Create a random character between ASCII code 65 and 128
		*ptr++ = TUint16( Math::Random( ) % ( 128 - 65 ) +65 );
		}
		
	return msg;
	}

TMsvId CSMCMStepBase::PerformForwardOrReplyOperationL( TMessageOperation aOperation, 
										 			   TMsvId aInFolder )
	{
	TMsvPartList part = 0;
	CMsvOperationWait* wait = CMsvOperationWait::NewLC( );
	wait->Start( );
	
	CMsvOperation* operation = NULL;
	
	switch( aOperation )
		{
		case EOperationReply:
			operation = iSmsClientMtm->ReplyL( aInFolder, part, wait->iStatus );
			break;
		case EOperationForward:
			operation = iSmsClientMtm->ForwardL( aInFolder, part, wait->iStatus );
			break;
		default:
			User::Leave( KErrNotSupported );
			break;
			
		}
	

	CleanupStack::PushL( operation );

	CActiveScheduler::Start( ); // Wait for operation to complete

	if ( wait->iStatus.Int() != KErrNone)
		{
		SetTestStepResult( EFail );
		
		}

	// Extract the TMsvId new message created using the operation
	TPckgBuf< TMsvId > pkg;
	pkg.Copy( operation->ProgressL( ) );
	TMsvId messageId = pkg( );
	
	// Cleanup
	CleanupStack::PopAndDestroy( 2, wait );		// operation, wait
	
	return( messageId );
	
	}


TVerdict CSMCMStepBase::PerformTestL( TMsvId aOriginalMessageId, 
									  const TDesC& aNewText, 
									  const TMessageSettings& aSettings )
	{
	 // Lets point at the message which we'll forward
	iSmsClientMtm->SwitchCurrentEntryL( aOriginalMessageId );

	TMsvId responseMessageId = PerformForwardOrReplyOperationL( aSettings.iOperation, KMsvDraftEntryId );

	// Load the newly created FORWARD message	
	iSmsClientMtm->SwitchCurrentEntryL( responseMessageId );
	iSmsClientMtm->LoadMessageL( );
	
	// Add new part of message
	iSmsClientMtm->Body( ).InsertL( 0, aNewText );
	iSmsClientMtm->SaveMessageL( );
		
	TVerdict result = CompareMessagesL( aOriginalMessageId, responseMessageId, aSettings );
	
	return result;	
	}
	

TVerdict CSMCMStepBase::CompareMessagesL( TMsvId aOriginalMessageId, 
										  TMsvId aTargetMessageId, 
										  const TMessageSettings& aSettings )
	{
	__ASSERT_ALWAYS( aOriginalMessageId != aTargetMessageId, User::Panic( SMSTEST_PANIC, KSmsTestUtilsPanicCannotCompareSameIds ) );
	
	TVerdict result = EPass;
	// Load the Original Message
	iSmsClientMtm->SwitchCurrentEntryL( aOriginalMessageId );
	iSmsClientMtm->LoadMessageL( );

	TMsvEntry originalEntry = iSmsClientMtm->Entry( ).Entry( );

	const CSmsHeader& originalHeader = iSmsClientMtm->SmsHeader( );

	// copy original body text & description in a buffer to be used later
	CSmsEditorBuffer* origBuffer = CSmsEditorBuffer::NewL( iSmsClientMtm->Body( ) );
	TInt length = origBuffer->Length( );
	TBufC< KMaxBodyLength > originalMessage;
	
	TPtr origMsgPtr( originalMessage.Des( ) );
	origBuffer->Extract( origMsgPtr, 0, length );
	
	TBufC< CSmsBufferBase::EMaxBufLength > originalDescription;
	TPtr origDescPtr( originalDescription.Des( ) );
	origDescPtr.Copy( originalEntry.iDescription );

	// Load the Target message
	iSmsClientMtm->SwitchCurrentEntryL( aTargetMessageId );
	iSmsClientMtm->LoadMessageL( );
	
	TMsvEntry targetEntry = iSmsClientMtm->Entry( ).Entry( );
	
	const CSmsHeader& targetHeader = iSmsClientMtm->SmsHeader( );
	
	// Compare UTC Time of original and target messages
	if ( originalEntry.iDate >= targetEntry.iDate )
		{
		result = EFail;
		
		}
		
	// Applicable to both Forward and Reply
	TBool originalTextIncluded = EFalse;
	TMsvPartList partList = KMsvMessagePartBody;
	if ( iSmsClientMtm->Find( originalMessage.Des( ), partList ) == KMsvMessagePartBody )
		{
		originalTextIncluded = ETrue;
		
		}
	if ( !iSmsTestUtils->AreMessagesSameTextL( originalEntry.Id(), 
											   targetEntry.Id(), 
											   ETrue ) )
		{
		result = EFail;
		}

	if ( aSettings.iOperation == EOperationReply )
		{
		// nothing extra to do for a reply
		}
		
	if ( aSettings.iOperation == EOperationForward )
		{
		TUint stateOrig = originalEntry.SendingState( );
		TUint statetarg = targetEntry.SendingState( );
		if ( ( originalEntry.SendingState( ) != targetEntry.SendingState( ) ) || 
			 ( originalEntry.iBioType != targetEntry.iBioType ) || 
			 ( originalDescription != targetEntry.iDescription) )
			{
			result = EFail;
			
			}
		if ( !originalTextIncluded )
			{
			INFO_PRINTF1( _L( "Comparison Failed - Forward messages expect original text to be included" ) );
			result = EFail;
			
			}
		}
	
	return result;
	
	}
	
void CSMCMStepBase::SetSettingsL( )
	{
	CSmsSettings* settings = CSmsSettings::NewLC( );
	
	CSmsAccount* account = CSmsAccount::NewLC( );
	account->InitialiseDefaultSettingsL( *settings );

	settings->AddServiceCenterL( KScriptItemSC1, KScriptItemSC1Def );
	settings->AddServiceCenterL( KScriptItemSC2, KScriptItemSC2Def );
	settings->AddServiceCenterL( KScriptItemSC3, KScriptItemSC3Def );
	settings->SetDefaultServiceCenter( 2 );
	
	settings->SetValidityPeriod( ESmsVPWeek );
	settings->SetReplyQuoted( ETrue );
	settings->SetRejectDuplicate( ETrue );
	settings->SetDelivery( ESmsDeliveryImmediately );
	settings->SetDeliveryReport( ETrue );
	settings->SetReplyPath( EFalse );
	settings->SetMessageConversion( ESmsConvPIDNone );
	settings->SetCanConcatenate( ETrue );
	settings->SetCharacterSet( TSmsDataCodingScheme::ESmsAlphabet8Bit );
	settings->SetValidityPeriodFormat( TSmsFirstOctet::ESmsVPFSemiOctet );
	settings->SetStatusReportHandling( CSmsSettings::EMoveReportToInboxVisible );
	settings->SetSpecialMessageHandling( CSmsSettings::EMoveReportToInboxVisible );
	
	account->SaveSettingsL( *settings );
	
	iSmsTestUtils->iServiceSettings->CopyL( *settings);
	
	CleanupStack::PopAndDestroy( 2, settings );
	
	}