/*

 * Copyright (c) 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 FILES

// Symbian:

#include <e32base.h>

#include <txtetext.h>

#include <txtrich.h>

#include <s32mem.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 <cmsvmimeheaders.h>

#include <badesca.h>

#include <e32cmn.h>

#include <gsmuset.h>

// S60

#include <MsgMediaResolver.h>

#include <MsgMediaInfo.h>

#include <MsgTextInfo.h>

#include <mmsgenutils.h>

#include <vcard.h>

#include <SenduiMtmUids.h>

#include <MsgMimeTypes.h>

#include "UniSendingSettings.h"

#include "MessagingVariant.hrh"

#include "msgbiouids.h"

#include "unieditorsmsplugin_p.h"

#include "convergedmessage.h"

#include "convergedmessageid.h"

#include "convergedmessageattachment.h"

#include "s60qconversions.h"

#include "MuiuOperationWait.h"

#include "UniEditorGenUtils.h"

#include "unidatamodelloader.h"

#include "unidatamodelplugininterface.h"

#include <hbglobal.h> // for translation support

// resources

// CONSTANTS

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

// Copy max this many chars to TMsvEntry iDetails

const TInt  KMaxDetailsLength = 64;

// separators for iDetails field

_LIT( KAddressSeparator, ";" );

// LOCALIZED CONSTANTS

// String to be shown in Drafts view for VCard sms

#define BUSINESS_CARD hbTrId("txt_messaging_list_business_card")

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

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

// Two-phased constructor.

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

//

UniEditorSmsPluginPrivate* UniEditorSmsPluginPrivate::NewL()

    {

    UniEditorSmsPluginPrivate* self = new ( ELeave ) UniEditorSmsPluginPrivate();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

UniEditorSmsPluginPrivate::~UniEditorSmsPluginPrivate()

{

    if(iGenUtils)

    {

        delete iGenUtils;

        iGenUtils = NULL;

    }

    if(iEmailOverSmsC)

    {

        delete iEmailOverSmsC;

        iEmailOverSmsC = NULL;

    }

    if(iRecipients)

    {

        delete iRecipients;

        iRecipients = NULL;

    }

    if(iRichText)

    {

        delete iRichText;

        iRichText = NULL;

    }

    if(iCharFormatLayer)

    {

        delete iCharFormatLayer;

        iCharFormatLayer = NULL;

    }

    if(iParaFormatLayer)

    {

        delete iParaFormatLayer;

        iParaFormatLayer = NULL;

    }

    if(iSmsHeader)

    {

        delete iSmsHeader;

        iSmsHeader = NULL;

    }

    if(iSmsMtm)

    {

        delete iSmsMtm;

        iSmsMtm = NULL;

    }

    if(iMtmRegistry)

    {

        delete iMtmRegistry;

        iMtmRegistry = NULL;

    }

   if(iSession)

    {

        delete iSession;

        iSession = NULL;

    }

}

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

// C++ default constructor

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

//

UniEditorSmsPluginPrivate::UniEditorSmsPluginPrivate() :

    iSession(0),

    iMtmRegistry(0),

    iSmsMtm(0),

    iSmsHeader(0),

    iParaFormatLayer(0),

    iCharFormatLayer(0),

    iRichText(0),

    iRecipients(0),

    iBioMsg( EFalse ),

    iEmailOverSmsC(0),

    iUnicodeMode( EFalse ),

    iOfflineSupported( EFalse ),

    iCharSupportType(TUniSendingSettings::EUniCharSupportReduced),

    iGenUtils(0)    

    {

    }

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

// Symbian 2nd phase constructor

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

//

void UniEditorSmsPluginPrivate::ConstructL()

    {

	iSession = CMsvSession::OpenSyncL(*this);

    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();

    iGenUtils = new UniEditorGenUtils();

    }

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

// LoadHeadersL

// @see header

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

void UniEditorSmsPluginPrivate::LoadHeadersL( CMsvStore* aStore )

    {

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

	    }

    }

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

// ConvertFromL

// @see header

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

ConvergedMessage* UniEditorSmsPluginPrivate::ConvertFromL(TMsvId aId,

    UniEditorPluginInterface::EditorOperation aOperation)

{

    ConvergedMessageId id(aId);

    ConvergedMessage* msg = new ConvergedMessage(id);

    CleanupStack::PushL(msg);

    DoConvertFromL(aId, msg, aOperation);

    CleanupStack::Pop(msg);

    return msg;

}

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

// DoConvertFromL

// @see header

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

void UniEditorSmsPluginPrivate::DoConvertFromL( TMsvId aId,

        ConvergedMessage* aMessage, 

        UniEditorPluginInterface::EditorOperation aOperation)

{

    // load message for processing

    SmsMtmL()->SwitchCurrentEntryL( aId );

    SmsMtmL()->LoadMessageL();

    aMessage->setMessageType(ConvergedMessage::Sms);

    // get parent entry

    TMsvEntry msvEntry( SmsMtmL()->Entry().Entry() );

    TMsvId parent = msvEntry.Parent();

    if( parent == KMsvDraftEntryIdValue )

    {

        aMessage->setLocation(ConvergedMessage::Draft);

        //TODO: need to give FORWARD etc info in convergedMessage

        aMessage->setDirection(ConvergedMessage::Outgoing);

        //Populate recipients

        populateRecipientsL(aMessage);

        //Populate message body

        populateMessageBodyL(aMessage,msvEntry);

    }

    else if(aOperation == UniEditorPluginInterface::Forward)

    {

        //Populate message body

        populateMessageBodyL(aMessage,msvEntry);            

    }

    //This is required as the switch entry doesnot reset sms headers

    //so if we fwd an inbox msg and then try to save that content to drafts

    //we see some issue

    delete iSmsMtm;

    iSmsMtm = NULL;

    return;

}

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

// ConvertToL

// @see header

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

TMsvId UniEditorSmsPluginPrivate::ConvertToL( ConvergedMessage* message )

{

    // create message in draft folder

    TMsvId id = CreateNativeSmsL();    

    int err = KErrNone;

        TRAP(err,            

                // set sms data

                SetSmsDataL( message );

                // set sms settings

                SetSmsSettingsL();

                // save all changes for the entry

                SmsMtmL()->SaveMessageL();

        );

    // delete the created drafts entry because error 

    // happened during save

    if (err != KErrNone)

        {

        DeleteDraftsEntryL(id);

        id = -1;

        }

    return id;

}

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

// CreateNativeSmsL

// @see header

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

TMsvId UniEditorSmsPluginPrivate::CreateNativeSmsL()

{

    CMsvEntry* cEntry = SmsMtmL()->Session().GetEntryL(KMsvDraftEntryId);

    CleanupStack::PushL( cEntry );

    SmsMtmL()->SwitchCurrentEntryL( cEntry->EntryId() );

    TMsvEntry tEntry;

    tEntry.SetAttachment( EFalse );

    tEntry.iMtm = KSenduiMtmSmsUid;

    tEntry.iType = KUidMsvMessageEntry;

    tEntry.iRelatedId = iSmsServiceId;

    tEntry.iServiceId = KMsvLocalServiceIndexEntryId;

    tEntry.iDate.UniversalTime();

    tEntry.SetInPreparation( ETrue );

    tEntry.SetVisible( EFalse );

    cEntry->CreateL(tEntry);

    SmsMtmL()->SwitchCurrentEntryL(tEntry.Id());

    CleanupStack::PopAndDestroy( cEntry );

    return SmsMtmL()->Entry().Entry().Id();

}

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

// SetSmsDataL

// @see header

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

void UniEditorSmsPluginPrivate::SetSmsDataL(ConvergedMessage* message)

{

    // populate recipients, subject and emailfields

    SetSmsHeaderL(message);

    // populate the attachments in msg entry

    SetSmsAttachmentsL(message);

}

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

// SetSmsHeaderL

// @see header

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

void UniEditorSmsPluginPrivate::SetSmsHeaderL(ConvergedMessage* message)

{

    TBuf<KMaxDetailsLength> idetailsBuf;

    idetailsBuf.Zero();

    //Save for email over sms

    if ( iRecipients )

    {

        delete iRecipients;

        iRecipients = NULL;

    }

    iRecipients = new ( ELeave ) CDesCArrayFlat( KRecipientsArrayGranularity );

    CSmsEmailFields *emailFields = CSmsEmailFields::NewL();

    CleanupStack::PushL( emailFields );

    ConvergedMessageAddressList addrList = message->toAddressList();

    int addrCount = addrList.count();

    for(int i=0; i<addrCount; i++)

    {

        HBufC* addr = S60QConversions::qStringToS60Desc( addrList.at(i)->address() );

        HBufC* alt_alias = S60QConversions::qStringToS60Desc( addrList.at(i)->alias() );

        if(addr)

        {

            CleanupStack::PushL(addr);

            if(alt_alias)

                CleanupStack::PushL(alt_alias);

            HBufC* pureAddr = TMmsGenUtils::PureAddress( *addr ).AllocLC();

            HBufC* aliasAddr = TMmsGenUtils::Alias( *addr ).AllocLC();

            TInt appendLen = KMaxDetailsLength-idetailsBuf.Length();

            TPtrC appendbuf;

            if ( IsEmailAddress( *pureAddr ) )

            {

                emailFields->AddAddressL( *pureAddr );

                appendbuf.Set(pureAddr->Des().Left(appendLen));

            }

            else

            {

                if(aliasAddr->Length() > 0)

                {

                    SmsMtmL()->AddAddresseeL( *pureAddr, *aliasAddr );

                    appendbuf.Set(aliasAddr->Des().Left(appendLen));

                }

                else

                {

                    if(alt_alias)

                    {

                        SmsMtmL()->AddAddresseeL( *pureAddr, *alt_alias );

                        appendbuf.Set(alt_alias->Des().Left(appendLen));

                    }

                    else

                    {

                        SmsMtmL()->AddAddresseeL( *pureAddr );

                        appendbuf.Set(pureAddr->Des().Left(appendLen));

                    }

                }

            }

            // copy the append-buffer to form idetails

            if(appendLen > 0)

            {

                idetailsBuf.Append( appendbuf );

            }

            iRecipients->AppendL( *addr );

            // cleanup

            CleanupStack::PopAndDestroy(2, pureAddr );            

            if(alt_alias)

            {

                CleanupStack::PopAndDestroy( alt_alias );

            }

            CleanupStack::PopAndDestroy( addr );

            // append separator

            if(i != addrCount-1)

            {

                if(KMaxDetailsLength-idetailsBuf.Length() > 0)

                {

                    idetailsBuf.Append( KAddressSeparator() );                

                }

            }

        }

    }

    if(idetailsBuf.Length() > 0)

    {

        // set iDetails

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

        TMsvEntry msvEntry( entry.Entry() );

        msvEntry.iDetails.Set( idetailsBuf );

        SmsMtmL()->SaveMessageL();

        entry.ChangeL( msvEntry );

    }

    // set subject

    if ( !message->subject().isEmpty() )

    {

        HBufC* subj = S60QConversions::qStringToS60Desc( message->subject() );

        if( subj )

        {

            CleanupStack::PushL( subj );

            emailFields->SetSubjectL( *subj );

            CleanupStack::PopAndDestroy( subj );

        }

    }

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

    CleanupStack::PopAndDestroy( emailFields );

}

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