/*

* Copyright (c) 2005-2008 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:  

*       Provides UniEditor SMS Plugin methods.

*

*/

// INCLUDE FILES

// Symbian: 

#include <e32base.h>

#include <implementationproxy.h>

#include <ecom.h>

#include <txtetext.h>

#include <txtrich.h>

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

#include <gsmerror.h>                       // KErrGsmOfflineOpNotAllowed

#include <featmgr.h> 

#include <mtclreg.h>

#include <smsclnt.h>

#include <smscmds.h>

#include <smuthdr.h>

#include <csmsemailfields.h>

#include <csmsaccount.h>

#include <charconv.h>

#include <smut.h>

#include <smumutil.h>

#include <cmsvmimeheaders.h>

#include <badesca.h>

#include <e32cmn.h>

#include <muiumsvuiserviceutilitiesinternal.h> 

#include <gsmuset.h>

// S60

#include <mmsgenutils.h>

#include <MuiuOperationWait.h>

#include <vcard.h>

#include <SenduiMtmUids.h>

#include <MsgBioUids.h>

#include <MsgMimeTypes.h>

#include "UniSendingSettings.h"

#include "UniClientMtm.h"

#include "UniEditorUids.hrh"

#include "messagingvariant.hrh"

#include "UniSmsPlugin.h"

#include "UniSmsUtils.h"

#include "MsgAttachmentUtils.h" 

#include "UniMsvEntry.h"

// resources

#include <UniSmsPluginD.rsg>                   

#include <avkon.rsg>              

//LOGGING

#include "UniEditorLogging.h"

// CONSTANTS

const TImplementationProxy KImplementationTable[] = 

	{

	IMPLEMENTATION_PROXY_ENTRY( KUidUniEditorSmsPlugin, CUniSmsPlugin::NewL)

	};

// Used to set msg in unparsed state

const TInt KSmsPluginBioMsgUnparsed = 0;

// Description length for sms messages

const TInt KSmsMessageEntryDescriptionAmountOfChars = 60;

//used for descriptor array containing recipients

const TInt KRecipientsArrayGranularity = 8;

// For address information separation (start)

const TUint KMsgSmsAddressStartChar         ('<'); 

// For address information separation (end)

const TUint KMsgSmsAddressEndChar           ('>');

const TUint KUniSmsStartParenthesis ('(');

const TUint KUniSmsEndParenthesis (')');

// String length for Service centre name

const TInt KUniSmsSCStringLength = 50;

const TUid KUidMsvSMSHeaderStream_COPY_FROM_SMUTHDR_CPP  = {0x10001834};

// Amount of to be converted chars during extracting description

const TInt KSmsEdExtrDescReplaceCharacterCount = 3;

// Unicode char for linefeed regocnised by basic phones

const TUint KSmsEdUnicodeLFSupportedByBasicPhones = 0x000A;

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

GLDEF_C void Panic( TInt aCategory );

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

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

// Two-phased constructor.

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

//

CUniSmsPlugin* CUniSmsPlugin::NewL( TAny* aConstructionParameters )

    {

	TUniPluginParams* params = reinterpret_cast<TUniPluginParams*>( aConstructionParameters );

    CUniSmsPlugin* self = new ( ELeave ) CUniSmsPlugin( params->iSession, params->iUniMtm ); 

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CUniSmsPlugin::~CUniSmsPlugin()

    {

    delete iRichText;

    delete iParaFormatLayer;

    delete iCharFormatLayer;

    delete iSmsHeader;

    delete iSmsMtm;

    delete iMtmRegistry;

    delete iEmailOverSmsC;

    delete iRecipients;	

    }

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

// C++ default constructor

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

//

CUniSmsPlugin::CUniSmsPlugin( CMsvSession& aSession, CUniClientMtm& aUniMtm )

    : iSession( aSession ),

    iUniMtm( aUniMtm ),

    iBioMsg( EFalse ),

    iOfflineSupported( EFalse )

    {

    }

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

// Symbian 2nd phase constructor

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

//

void CUniSmsPlugin::ConstructL()

    {

    UNILOGGER_ENTERFN("CUniSmsPlugin::ConstructL");

    iParaFormatLayer = CParaFormatLayer::NewL();

    iCharFormatLayer = CCharFormatLayer::NewL();

    iRichText = CRichText::NewL( iParaFormatLayer, iCharFormatLayer );

    iEmailOverSmsC = CSmsNumber::NewL();

    CMsvEntry& entry = SmsMtmL()->Entry();

    entry.SetEntryL( KMsvRootIndexEntryId );

    TSmsUtilities::ServiceIdL( entry, iSmsServiceId );

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

        {

        iOfflineSupported = ETrue;   

        }

    else

        {

        iOfflineSupported = EFalse;  

        }

    //Turkish SMS-PREQ2265 Specific

    if ( FeatureManager::FeatureSupported( KFeatureIdNltSupport ) )

        {

        iNLTFeatureSupport = ETrue;

        }

    else

        {

        iNLTFeatureSupport = EFalse;

        }

    FeatureManager::UnInitializeLib();

    iStoreChanged = EFalse;

    UNILOGGER_LEAVEFN("CUniSmsPlugin::ConstructL");

    }

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

// LoadHeadersL

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

//

void CUniSmsPlugin::LoadHeadersL( CMsvStore* aStore )

    {

    UNILOGGER_ENTERFN("CUniSmsPlugin::LoadHeadersL");

    delete iSmsHeader;

    iSmsHeader = NULL;

    if ( aStore && aStore->HasBodyTextL() )

        {

    	aStore->RestoreBodyTextL( *iRichText );

        }

	iSmsHeader = CSmsHeader::NewL( CSmsPDU::ESmsSubmit, *iRichText );

	if ( aStore && aStore->IsPresentL( KUidMsvSMSHeaderStream_COPY_FROM_SMUTHDR_CPP ) )

	    {

	    iSmsHeader->RestoreL( *aStore );

	    }

	else

	    {

        CSmsSettings* settings = CSmsSettings::NewLC();

    	CSmsAccount* account = CSmsAccount::NewLC();

    	account->LoadSettingsL( *settings );

    	CleanupStack::PopAndDestroy( account );

        iSmsHeader->SetSmsSettingsL( *settings );

        CleanupStack::PopAndDestroy( settings );

	    }

		TSmsUserDataSettings smsSettings;		

		smsSettings.SetTextCompressed( EFalse );

		TRAP_IGNORE(iSmsHeader->Message().SetUserDataSettingsL( smsSettings ));

    UNILOGGER_LEAVEFN("CUniSmsPlugin::LoadHeadersL");

    }

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

// SaveHeadersL 

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

//

void CUniSmsPlugin::SaveHeadersL( CMsvStore& aStore )

    {

    if ( iSmsHeader )

        {

        iSmsHeader->StoreL( aStore );

        }

    }

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

// ConvertFromL

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

//

TMsvId CUniSmsPlugin::ConvertFromL( TMsvId aId )

    {

    return DoConvertFromL( aId, EFalse );

    }

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

// DoConvertFromL

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

//

TMsvId CUniSmsPlugin::DoConvertFromL( TMsvId aId, TBool aIsForward )

	{

    UNILOGGER_ENTERFN("CUniSmsPlugin::ConvertFromL");

    UNILOGGER_WRITE_TIMESTAMP("CUniSmsPlugin::ConvertFromL start");

    SmsMtmL()->SwitchCurrentEntryL( aId );

    SmsMtmL()->LoadMessageL();

    iUniMtm.SwitchCurrentEntryL( aId );

    iUniMtm.LoadMessageL();

    TPtrC name;

    TPtrC address;

	const CSmsEmailFields& emailFields = SmsMtmL( )->SmsHeader( ).EmailFields();

	if( emailFields.HasAddress( ) && !aIsForward )

		{ // If email address set -> copy them here

	    const MDesCArray& emailRecipients = emailFields.Addresses();

		for( TInt id = 0; id < emailRecipients.MdcaCount( ); id++ )

			{

	        NameAndAddress( emailRecipients.MdcaPoint( id ), name, address );

	        iUniMtm.AddAddresseeL( 

	            EMsvRecipientTo,

	            address,

	            name );

			}

		}

    // Copy non-email over sms addresses if needed

    const CMsvRecipientList& smsRecipients = SmsMtmL()->AddresseeList();

    while ( smsRecipients.Count() )

        { // Go thru all the recipients

		if( !emailFields.HasAddress( ) && !aIsForward )

			{ // and copy them only if email addresses did not exist

	        NameAndAddress( smsRecipients[ 0 ], name, address );

	        iUniMtm.AddAddresseeL( 

	            EMsvRecipientTo,

	            address,

	            name );

			}

        SmsMtmL()->RemoveAddressee( 0 );

        }

    if( emailFields.Subject( ).Length( ) )

    	{ // If email subject exists -> copy it

    	iUniMtm.SetSubjectL( emailFields.Subject( ) );

    	}

    //Get sms entry 

    TMsvEntry smsTEntry = SmsMtmL()->Entry().Entry();

    if (  smsTEntry.iBioType == KMsgBioUidVCard.iUid

        || smsTEntry.iBioType == KMsgBioUidVCalendar.iUid )

        { 

        //We must check here if there is two attachments. This happens in case

        //if sending fails and message opened from drafts

        CMsvStore* store = iUniMtm.Entry().EditStoreL();

        CleanupStack::PushL( store );

        MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();        

        MMsvAttachmentManager& manager = store->AttachmentManagerL();

        if ( manager.AttachmentCount() == 2)

        	{

            managerSync.RemoveAttachmentL( 1 ); 	

        	}

        store->CommitL();  	

        CleanupStack::PopAndDestroy( store );

        }     

    else   //plain text

        {

        TInt totalLength( SmsMtmL()->Body().DocumentLength() );

        if ( totalLength > 0 )

            {

            HBufC* bodyText = HBufC::NewLC ( totalLength ); 

            TPtr bodyTextPtr ( bodyText->Des() ); 

            SmsMtmL()->Body().Extract( bodyTextPtr, 0, totalLength );

            iUniMtm.Body().InsertL( 0, bodyTextPtr );

            CleanupStack::PopAndDestroy( bodyText );            

            }

        }

    SmsMtmL()->Body().Reset();

    SmsMtmL()->SaveMessageL();

    TMsvEntry uniTEntry = iUniMtm.Entry().Entry();

    CMsvStore* store = iUniMtm.Entry().EditStoreL();

    CleanupStack::PushL( store );

    iUniMtm.SaveMessageL(*store, uniTEntry);

    store->CommitL();

    CleanupStack::PopAndDestroy(store);  

    // Lets convert the bits to Uni mode

	TUniMsvEntry::SetForwardedMessage( uniTEntry, aIsForward );

    uniTEntry.iMtm.iUid = KUidUniMtm;

    iUniMtm.Entry().ChangeL( uniTEntry );

    UNILOGGER_LEAVEFN("CUniSmsPlugin::ConvertFromL");    

    UNILOGGER_WRITE_TIMESTAMP("CUniSmsPlugin::ConvertFromL end");

    return aId;

    }

TInt32 CUniSmsPlugin::AttachmentsSizeL( CMsvStore& aStore )

    {

    TInt32 size = 0;

    MMsvAttachmentManager& attachMan = aStore.AttachmentManagerL();

    TInt numAttachments = attachMan.AttachmentCount();

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

        {

        CMsvAttachment* attachmentInfo = attachMan.GetAttachmentInfoL( i );

        CleanupStack::PushL( attachmentInfo );

        CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

        CleanupStack::PushL( mimeHeaders );

        mimeHeaders->RestoreL( *attachmentInfo );

        RFile attaFile = attachMan.GetAttachmentFileL( i );

        CleanupClosePushL( attaFile );

        TInt fileSize = 0;

        // If we cannot access the file, we are in trouble

        User::LeaveIfError( attaFile.Size( fileSize ) ); 

        // This adds up mime header size + actual attachment binary data

        size += mimeHeaders->Size() + fileSize;

        CleanupStack::PopAndDestroy( &attaFile );

        CleanupStack::PopAndDestroy( mimeHeaders );

        CleanupStack::PopAndDestroy( attachmentInfo );

        }

    return size;

    }

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

// ConvertToL

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

//

TMsvId CUniSmsPlugin::ConvertToL( TMsvId aId )

    {    

    UNILOGGER_ENTERFN("CUniSmsPlugin::ConvertToL");

    SmsMtmL()->SwitchCurrentEntryL( aId );

    SmsMtmL()->LoadMessageL();

    iUniMtm.SwitchCurrentEntryL( aId );

    iUniMtm.LoadMessageL();

    const CMsvRecipientList& uniRecipients = iUniMtm.AddresseeList();

    //Save for email over sms  

    if ( iRecipients )

    	{

    	delete iRecipients;

    	iRecipients = NULL;

    	}

    iRecipients = new ( ELeave ) CDesCArrayFlat( KRecipientsArrayGranularity );   

    CSmsEmailFields *emailFields = CSmsEmailFields::NewL();

    CleanupStack::PushL( emailFields );

    while ( uniRecipients.Count() )

        {

        if ( IsEmailAddress( TMmsGenUtils::PureAddress( uniRecipients[ 0 ] )))

            {

            emailFields->AddAddressL( TMmsGenUtils::PureAddress( uniRecipients[ 0 ] ) );

            }

        else

            {

            SmsMtmL()->AddAddresseeL( 

                TMmsGenUtils::PureAddress( uniRecipients[ 0 ] ),

                TMmsGenUtils::Alias( uniRecipients[ 0 ] ) );    

            }

        iRecipients->AppendL( uniRecipients[ 0 ]  );

        iUniMtm.RemoveAddressee( 0 );

        }   

    if ( iUniMtm.SubjectL().Length() )

        {

        emailFields->SetSubjectL( iUniMtm.SubjectL() );

        }

    SmsMtmL()->SmsHeader().SetEmailFieldsL( *emailFields );

    CleanupStack::PopAndDestroy( emailFields );        

    CMsvStore* store = iUniMtm.Entry().EditStoreL();

    CleanupStack::PushL( store );

    MMsvAttachmentManager& manager = store->AttachmentManagerL();

    MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();

    TUid bioType =

        {

        0 

        };

    CMsvAttachment* atta ( NULL );

    switch ( manager.AttachmentCount() )

        {

        case 0:

            {

            //In case of empty message.

            //There is not even smil.

            SmsMtmL()->Body().Reset();

            break;

            }

        case 1:  

        	{

        	atta = manager.GetAttachmentInfoL( 0 );

        	 if ( atta->MimeType() == KMsgMimeSmil )

                {                        

                managerSync.RemoveAttachmentL( 0 ); 

                delete atta;

                atta= NULL;

                }

        	 else

        	     CleanupStack::PushL(atta);

        	break;

        	}

        case 2:  //There is usually a SMIL also.

            {

            //In these case branch we assume that there is only one text atta

            //or one text atta and a SMIL

            //Everything else is a programming error in the caller

            CMsvAttachment* tempAtta1 = manager.GetAttachmentInfoL( 0 );

            CleanupStack::PushL(tempAtta1);

            CMsvAttachment* tempAtta2 = manager.GetAttachmentInfoL( 1 );

            CleanupStack::PushL(tempAtta2);

            if ( tempAtta1->MimeType() == KMsgMimeSmil )

                {

                CleanupStack::Pop( tempAtta2 );

                CleanupStack::PopAndDestroy( tempAtta1 );

                CleanupStack::PushL( tempAtta2 );

                managerSync.RemoveAttachmentL( 0 ); 

                atta=tempAtta2;

                }

            else if ( tempAtta2->MimeType() == KMsgMimeSmil )    

                {

                CleanupStack::PopAndDestroy( tempAtta2 );

                managerSync.RemoveAttachmentL( 1 ); 

                atta=tempAtta1;

                }

            else

                { 

                //Programming error in caller code

#ifdef _DEBUG 

                UNILOGGER_WRITEF(_L("PANIC: Two attas but no smil"));

                Panic ( EIllegalArguments );     

#endif 

                User::Leave( KErrArgument );

                }

            break;

            }

        default:

            {

            //Programming error in caller code

#ifdef _DEBUG 

            UNILOGGER_WRITEF(_L("PANIC: Two many attas"));

            Panic ( EIllegalArguments );

#endif            

            User::Leave( KErrArgument );

            break;