/*

* Copyright (c) 2005-2007 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:  Part of SyncML Data Synchronization Plug In Adapter

*

*/

// INCLUDE FILES

#include <txtrich.h>

#include <smsclnt.h>

#include <smutset.h>

#include <smuthdr.h>

#include <smscmds.h>

#include <sysutil.h> 

#include <gsmuelem.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfldst.h>

#include "smsadaptermsvapi.h"

#include "logger.h" 

#include "vmessageparser.h"

#include "smsdataproviderdefs.h"

// CONSTANTS

// OTHER DEFINITIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CSmsAdapterMsvApi::NewL

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

//

 CSmsAdapterMsvApi* CSmsAdapterMsvApi::NewL()

    {

    CSmsAdapterMsvApi* self = new( ELeave ) CSmsAdapterMsvApi;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSmsAdapterMsvApi::~CSmsAdapterMsvApi()

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

//

CSmsAdapterMsvApi::~CSmsAdapterMsvApi()

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::~CSmsAdapterMsvApi" );

    SAFEDELETE( iContactsDb );

	SAFEDELETE( iMtm );

	SAFEDELETE( iMtmReg );     

    SAFEDELETE( iSession );

    LOGGER_LEAVEFN( "CSmsAdapterMsvApi::~CSmsAdapterMsvApi" );

    }

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

// CSmsAdapterMsvApi::CSmsAdapterMsvApi

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

//

CSmsAdapterMsvApi::CSmsAdapterMsvApi()

    {     

    }

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

// CSmsAdapterMsvApi::ConstructL

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

//

void CSmsAdapterMsvApi::ConstructL()

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::ConstructL" );

    iSession = CMsvSession::OpenSyncL( *this );

    iMtmReg = CClientMtmRegistry::NewL( *iSession );    

	iMtm = static_cast<CSmsClientMtm*>( iMtmReg->NewMtmL(KUidMsgTypeSMS) ); 

	iFs = iSession->FileSession();

	iMessageDrive = MessageServer::CurrentDriveL( iFs );

	iContactsDb = CContactDatabase::OpenL();

    LOGGER_LEAVEFN( "CSmsAdapterMsvApi::ConstructL" ); 

    }

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

// CSmsAdapterMsvApi::AddSML

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

//

void CSmsAdapterMsvApi::AddSML(

    CVMessageParser& aSm,

    TMsvId aFolder,                                                                                                                                                                                                        

    TMsvId& aSmId )

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::AddSML" );

    if (!ValidFolderL( aFolder ))

        {

		LOGGER_WRITE( "AddSML: wrong folder" );

        User::Leave( KErrArgument );

        }

    // Set first default flags  

    TMsvEntry newEntry;  

    newEntry.iType = KUidMsvMessageEntry;

    newEntry.iServiceId = KMsvLocalServiceIndexEntryId;

    newEntry.iMtm = KUidMsgTypeSMS;

    newEntry.SetVisible(EFalse);

    newEntry.SetInPreparation(ETrue);           

    // Create new message entry

    CMsvEntry* entry = iSession->GetEntryL( aFolder );

    CleanupStack::PushL( entry );   

    entry->CreateL( newEntry );

    aSmId = newEntry.Id();  

    entry->SetEntryL(newEntry.Id());

    // Create message header

    CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL();

    CleanupStack::PushL( paraFormatLayer );

    CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL();

    CleanupStack::PushL( charFormatLayer );

    CRichText* richText = CRichText::NewL( paraFormatLayer, charFormatLayer );

    CleanupStack::PushL( richText ); 

    CSmsPDU::TSmsPDUType pduType;

    if (aFolder == KMsvGlobalInBoxIndexEntryId)

        {

        pduType = CSmsPDU::ESmsDeliver;

        }

    else if (aFolder == KMsvGlobalOutBoxIndexEntryId ||

             aFolder == KMsvDraftEntryId ||

             aFolder == KMsvSentEntryId)  

        {

        pduType = CSmsPDU::ESmsSubmit;

        }

    else if (aSm.iRecipients.Count() > 0)

        {

        pduType = CSmsPDU::ESmsSubmit;

        }

    else

        {

        pduType = CSmsPDU::ESmsDeliver;

        }       

    CSmsHeader* smsHeader = CSmsHeader::NewL( pduType, *richText );

    CleanupStack::PushL( smsHeader );

    // Set the message header in the entry's store

    CMsvStore* store = entry->EditStoreL();

    CleanupStack::PushL( store );

    smsHeader->StoreL( *store );

    store->StoreBodyTextL( *richText );

    store->CommitL();

    CleanupStack::PopAndDestroy( store );

    CleanupStack::PopAndDestroy( smsHeader );

    CleanupStack::PopAndDestroy( richText );

    CleanupStack::PopAndDestroy( charFormatLayer );

    CleanupStack::PopAndDestroy( paraFormatLayer );

    CleanupStack::PopAndDestroy( entry );

	DoUpdateSML( aSmId, aSm, ETrue );

	LOGGER_LEAVEFN( "CSmsAdapterMsvApi::AddSML" );

    }

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

// CSmsAdapterMsvApi::ReplaceSML

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

//

 void CSmsAdapterMsvApi::ReplaceSML( TMsvId aSmId, CVMessageParser& aSm ) 

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::ReplaceSML" );

	DoUpdateSML( aSmId, aSm, EFalse );

	LOGGER_LEAVEFN( "CSmsAdapterMsvApi::ReplaceSML" );

    }

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

// CSmsAdapterMsvApi::DeleteSML

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

//

 void CSmsAdapterMsvApi::DeleteSML( TMsvId aSmId )

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::DeleteSML" );

    iMtm->SwitchCurrentEntryL( aSmId );

    TMsvEntry tEntry = iMtm->Entry().Entry();  		

    if (tEntry.iType != KUidMsvMessageEntry || tEntry.iMtm != KUidMsgTypeSMS)

        {

        LOGGER_WRITE( "Not SMS entry" );

        User::Leave(KErrNotSupported);

        }

	iMtm->SwitchCurrentEntryL( tEntry.Parent() );

	iMtm->Entry().DeleteL( aSmId );

	LOGGER_LEAVEFN( "CSmsAdapterMsvApi::DeleteSML" );

    }

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

// CSmsAdapterMsvApi::DeleteUserFolderL

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

//

 TInt CSmsAdapterMsvApi::DeleteUserFolderL( TMsvId aUid )

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::DeleteUserFolderL" );

    iMtm->SwitchCurrentEntryL( aUid );

    CMsvEntry& entry = iMtm->Entry();

    TMsvEntry tEntry = entry.Entry();  		

    if (tEntry.iType != KUidMsvFolderEntry || tEntry.Parent() != KMsvMyFoldersEntryIdValue)

        {

        LOGGER_WRITE( "Not correct folder" );

        User::Leave(KErrNotSupported);

        }

    CMsvEntrySelection* children = entry.ChildrenL();

    TInt count = children->Count();

    delete children;

  	if (count > 0)

	    {

	    LOGGER_WRITE( "Folder not empty" );

	    return KErrInUse;

	    }

	tEntry.SetReadOnly(EFalse);

	entry.ChangeL( tEntry );

	iMtm->SwitchCurrentEntryL( tEntry.Parent() );	

	iMtm->Entry().DeleteL( aUid );

	LOGGER_LEAVEFN( "CSmsAdapterMsvApi::DeleteUserFolderL" );

	return KErrNone;

    }   

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

// CSmsAdapterMsvApi::RetrieveSML

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

//

 void CSmsAdapterMsvApi::RetrieveSML(

    TMsvId aSmId,

    TMsvId& aParent,

    CVMessageParser& aSm,

    TBool& aUnread)

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::RetrieveSML" );

    iMtm->SwitchCurrentEntryL( aSmId );

    iMtm->LoadMessageL();

    CRichText& mtmBody = iMtm->Body();

	aSm.StoreMessageBodyL( mtmBody );

    TMsvEntry tEntry = iMtm->Entry().Entry();

    aUnread = tEntry.Unread();

	if (aUnread)

		{

		aSm.iStatus = KVMsgStatusUnread;

		}

	else

		{

		aSm.iStatus = KVMsgStatusRead;

		}

	aSm.iUniversalTime = tEntry.iDate;	

	aSm.iHomeTime = HomeTimeFromUniversalTime( aSm.iUniversalTime );

	aParent = tEntry.Parent();	

	switch (aParent)

		{

		case KMsvGlobalInBoxIndexEntryId:

			aSm.iFolder = KFolderInbox;

			break;

		case KMsvGlobalOutBoxIndexEntryId:

			aSm.iFolder = KFolderOutbox;

			break;

		case KMsvDraftEntryId:

			aSm.iFolder = KFolderDraft;

			break;

		case KMsvSentEntryId:

			aSm.iFolder = KFolderSent;

			break;

		case KMsvMyFoldersEntryIdValue:

		    aSm.iFolder = KFolderMyFolders;    

			break;

		default:

		    TPtrC folderName;

		    TTime time;

		    TBool found = FindUserFolderL(aParent, folderName, time);

		    if (found && folderName.Length() <= KMaxFolderNameLength)

		        {

		        aSm.iFolder = folderName;

		        }

		    else

		        {

		        LOGGER_WRITE_1( "Not folder name found for folder: %d", aParent );

		        }       	

		}

		LOG( aSm.iFolder );

	const CSmsHeader& smsHeader = iMtm->SmsHeader();

	if ( smsHeader.Type() == CSmsPDU::ESmsDeliver )

	    {

		TPtrC fromAddr = smsHeader.FromAddress();

		aSm.ParseTelephoneNumber( fromAddr, aSm.iSender );

		}

	else

		{

		const CMsvRecipientList& recipients = iMtm->AddresseeList();

		for (TInt i = 0; i < recipients.Count(); i++)

			{

			CVMessageParser::TTelephoneNumber recipientInfo;

			aSm.ParseTelephoneNumber( recipients[i], recipientInfo );

			aSm.iRecipients.Append( recipientInfo );

			}

		}	

	LOGGER_LEAVEFN( "CSmsAdapterMsvApi::RetrieveSML" );

    }

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

// CSmsAdapterMsvApi::SendSML

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

//

 void CSmsAdapterMsvApi::SendSML( TMsvId aSmId )

    {

    LOGGER_ENTERFN( "CSmsAdapterMsvApi::SendSML" );

	iMtm->SwitchCurrentEntryL( aSmId );

	TMsvEntry msvEntry = iMtm->Entry().Entry();	

	if (msvEntry.Parent() != KMsvGlobalOutBoxIndexEntryId)

		{

 		LOGGER_WRITE_1( "Wrong folder, parent: %d", msvEntry.Parent() );

 		return;

 		}

	iMtm->LoadMessageL();

	msvEntry.SetInPreparation( EFalse );

	msvEntry.SetSendingState( KMsvSendStateWaiting );

	msvEntry.iDate.UniversalTime();

	iMtm->RestoreServiceAndSettingsL();

	CSmsHeader& header = iMtm->SmsHeader();

	CSmsSettings* sendOptions = CSmsSettings::NewL();

	CleanupStack::PushL( sendOptions );

	sendOptions->CopyL( iMtm->ServiceSettings() );

	sendOptions->SetDelivery( ESmsDeliveryImmediately );

	TSmsDataCodingScheme::TSmsAlphabet dataCoding = TSmsDataCodingScheme::ESmsAlphabet7Bit;

	CRichText& msgBody = iMtm->Body();

	HBufC* msgBodyBuf = HBufC::NewLC( msgBody.DocumentLength() );

	TPtr16 ptrBody = msgBodyBuf->Des();

	msgBody.Extract( ptrBody, 0, msgBody.DocumentLength() );

	LOG(ptrBody);

	for (TInt i = 0; i < ptrBody.Length(); i++)

		{

		if (IsUnicode( ptrBody[i] ))

			{

			LOGGER_WRITE_1( "Character %d is unicode", i );

			dataCoding = TSmsDataCodingScheme::ESmsAlphabetUCS2;

			break;

			}

		}

	sendOptions->SetCharacterSet( dataCoding );

	CleanupStack::PopAndDestroy( msgBodyBuf ); 

	header.SetSmsSettingsL( *sendOptions );

	if( header.Message().ServiceCenterAddress().Length() == 0 )

		{

		LOGGER_WRITE( "header.Message().ServiceCenterAddress().Length() == 0" );    

		CSmsSettings* serviceSettings = &( iMtm->ServiceSettings() );

		if (!serviceSettings->ServiceCenterCount())

			{

			LOGGER_WRITE("Cervice Center not found, could not send message");

			User::Leave( KErrCompletion );

			}

		else

			{

			CSmsServiceCenter* sc =  &serviceSettings->GetServiceCenter( serviceSettings->DefaultServiceCenter() );

			header.Message().SetServiceCenterAddressL( sc->Address() );	

			}				

		}

    const CMsvRecipientList& addrList = iMtm->AddresseeList();

    if ( addrList.Count() == 0 )

        {

		LOGGER_WRITE( "SendSML: no recipient" );

        User::Leave( KErrGeneral );

        }

	CMsvEntry* entry = &( iMtm->Entry() );

	entry->ChangeL( msvEntry );	

	iMtm->SaveMessageL();

	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL( sel );

	sel->AppendL( entry->EntryId() );

	TBuf8<1> dummy;

	CMsvOperationActiveSchedulerWait* waiter = CMsvOperationActiveSchedulerWait::NewLC();

	waiter->iStatus = KRequestPending;

	CMsvOperation* op = iMtm->InvokeAsyncFunctionL( ESmsMtmCommandScheduleCopy, *sel, dummy, waiter->iStatus );

	CleanupStack::PushL( op );

	waiter->Start();

	LOGGER_WRITE_1( "InvokeAsyncFunctionL: status %d", waiter->iStatus.Int());

	CleanupStack::PopAndDestroy( 4 ); // op, waiter, sel, sendOptions	

	LOGGER_LEAVEFN( "CSmsAdapterMsvApi::SendSML" );

    }

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

// CSmsAdapterMsvApi::HandleSessionEventL

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

//

void CSmsAdapterMsvApi::HandleSessionEventL( TMsvSessionEvent aEvent, TAny*, TAny*, TAny* )

    {

    LOGGER_WRITE_1( "CSmsAdapterMsvApi::HandleSessionEventL: %d", aEvent);

    switch ( aEvent )

        {

        case EMsvCloseSession: // The client should immediately close the session with the Message Server.

        case EMsvServerTerminated: // The Message Server has been terminated.

                                   // All clients must close their sessions immediately. 

            {

            if (iSession)

                {

				SAFEDELETE( iMtm );

				SAFEDELETE( iMtmReg );

                SAFEDELETE( iSession );

                }

            }   

            break;

        default:

            // Nothing is done

            break;

        } 

    }

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

// CSmsAdapterMsvApi::MsvSession

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

//

CMsvSession* CSmsAdapterMsvApi::MsvSessionL()

	{

	if (!iSession)

		{

		User::Leave( KErrGeneral );

		}

	return iSession;

	}

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

//	CSmsAdapterMsvApi::CleanFolderGetMsvIdsL

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

//

CMsvEntrySelection* CSmsAdapterMsvApi::CleanFolderGetMsvIdsL(TMsvId aFolderId)

    {

    LOGGER_ENTERFN( "CMsvEntrySelection::CleanFolderGetMsvIdsL" );

    CMsvEntry* cEntry = iSession->GetEntryL( KMsvRootIndexEntryId );

    CleanupStack::PushL( cEntry );

    cEntry->SetEntryL( aFolderId );

    cEntry->SetSortTypeL( TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, EFalse ) );

    CMsvEntrySelection* msvEntrySelection = cEntry->ChildrenWithMtmL( KUidMsgTypeSMS );

    CleanupStack::PopAndDestroy( cEntry );

    CleanupStack::PushL( msvEntrySelection );

    for (TInt i = 0; i < msvEntrySelection->Count(); i++)

        {

        CMsvEntry* entry = iSession->GetEntryL( msvEntrySelection->At(i) );

        CleanupStack::PushL( entry );

        TMsvEntry tEntry = entry->Entry();

        tEntry.SetReadOnly( EFalse );

        entry->ChangeL( tEntry );

        DeleteSML( msvEntrySelection->At(i) );

        CleanupStack::PopAndDestroy(); //entry

        }

    CleanupStack::Pop(msvEntrySelection);

    LOGGER_LEAVEFN( "CSmsAdapterMsvApi::CleanFolderGetMsvIdsL" );

    return msvEntrySelection;

    }

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

//	CSmsAdapterMsvApi::CleanFolderL

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