/*

* Copyright (c) 2006-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:   Provides CUniEditorDocument class methods.

*

*/

// ========== INCLUDE FILES ================================

#include <eikenv.h>

#include <eikdoc.h>

#include <msvstd.h>                     // TMsvEntry

#include <msvapi.h>

#include <msvuids.h>                    // Msgs Uids

#include <mtclbase.h>                   // CBaseMtm

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <cmsvmimeheaders.h>

#include <bautils.h>

#include <charconv.h>                   // Character Converter

#include <mmsclient.h>                  // Client Mtm API

#include <MuiuMsvUiServiceUtilities.h>  // Disk space check

#include <MuiuOperationWait.h>          // CMuiuOperationWait

#include <MsgAttachmentInfo.h>

#include <msgmediacontrol.h>            // TMsgMediaControlId

// Features

#include <featmgr.h>    

#include <bldvariant.hrh>

#include <messagingvariant.hrh>

#include <centralrepository.h>          // link against centralrepository.lib

#include <MmsEngineInternalCRKeys.h>

#include <messaginginternalcrkeys.h>    // for Central Repository keys

#include <SendUiConsts.h>               // for KSenduiMtmSms/MmsUid

#include <RCustomerServiceProfileCache.h>   // CSP bits

#include <fileprotectionresolver.h>

// Msg Media

#include <MmsConformance.h>

#include <MsgMediaInfo.h>

// UniModel stuff

#include <unidatamodel.h>   

#include <uniobjectlist.h>

#include <unidatautils.h>

// UniUtils stuff

#include <uniobjectsmodel.h>

#include <mmssettingsdefs.h>

// MTM's

#include "UniMsvEntry.h"

#include "UniClientMtm.h"               // Client Mtm API

#include "UniPluginApi.h"

#include "UniEditorUids.hrh"

#include "UniEditorDocument.h"

#include "UniEditorAppUi.h"

#include "UniEditorObjectsModelObserver.h"

#include "UniEditorLogging.h"

#include "UniEditorEnum.h"

// ========== CONSTANTS ====================================

// Length of one 7bit normal sms

const TInt KFirstNormalSmsLength = 160;

// Length of one 8bit sms

// const TInt KFirst8bitSmsLength = 133;

// Length of one unicode sms

const TInt KFirstUnicodeSmsLength = 70;

// Submsg length for normal 7bit sms

const TInt KNormalConcatenationInterval = 153;

// Submsg length for 8bit sms

// const TInt K8bitConcatenationInterval = 128;

// Submsg length for unicode sms

const TInt KUnicodeConcatenationInterval = 67;

const TInt KDefaultMaxSize = 300 * 1024;

const TInt KDefaultMaxSmsSize = 10;

const TInt KMaxSmsSizeByStandard = 30;

const TInt KDefaultSmsRecipients = 20;

const TInt KDefaultMmsRecipients = 100;

// Char conv plugin ID (private Sms editor plugin)

const TUint KSmsEdSmsStrictPluginID = 0x101F85CD;

const TInt KUniMmsUploadImageWidth = 1600;

const TInt KUniMmsUploadImageHeight = 1200;

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

// CUniEditorDocument::Constructor

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

//

CUniEditorDocument::CUniEditorDocument( CEikApplication& aApp, CCoeEnv& aCoeEnv ) :

    CMsgEditorDocument( aApp ),

    iEnvironment( static_cast<CEikonEnv*>( &aCoeEnv ) ),

    iFs( aCoeEnv.FsSession() ),

    iMessageType( EUniReadOnly ),

    iDataModel( NULL ),

    iCharConverter( NULL ),

    iCurrentSlide( 0 ),

    iMaxMessageSize( KDefaultMaxSize ),

    iAddressSize( -1 ),

    iSubjectSize( -1 ),

    iMaxMmsRecipients( 100 ),

    iMaxSmsRecipients( 20 ), // Read from CR

    iMaxConcatenatedSms( KDefaultMaxSmsSize ),   // Read from CR

    iAbsMaxConcatenatedSms( KDefaultMaxSmsSize ), // Read from CR

    iCreationMode( EMmsCreationModeWarning ),

    iNonConfCount( 0 ),

    iMaxImageWidth( KMmsUniImageSmallWidth ),

    iMaxImageHeight( KMmsUniImageSmallHeight ),

    iSupportedFeatures( 0 ),

    iPrevSaveType( EClosingSave ),

    iBodyState( EUniSms ),

    iHeaderState( EUniSms ),

    iFlags( 0 ),

    iCSPBits( 255 ),

    iSmsPlugin( NULL ),

    iMmsPlugin( NULL ),

    iAbsMaxSmsCharacters( 0 )

    {

    }

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

// CUniEditorDocument::ConstructL

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

//

void CUniEditorDocument::ConstructL()

    {

    CMsgEditorDocument::ConstructL();

    TInt maxSize = KDefaultMaxSize;

    TInt creationMode = EMmsCreationModeWarning;

    TInt features = 0;

    // MmsEngine / MaxSendSize + CreationMode

    CRepository* repository = CRepository::NewL( KCRUidMmsEngine );

    CleanupStack::PushL( repository );

    if ( repository->Get( KMmsEngineMaximumSendSize, maxSize ) == KErrNone )

        {

        iMaxMessageSize = maxSize;

        }

    if ( repository->Get( KMmsEngineCreationMode, creationMode ) == KErrNone )

        {

        iCreationMode = creationMode;

        }

    CleanupStack::PopAndDestroy( repository );

    // MUIU / MmsFeatures / SmsFeatures

    TBool emailOverSmsVariationOn = EFalse;

    repository = CRepository::NewL( KCRUidMuiuVariation );

    CleanupStack::PushL( repository );

    if ( repository->Get( KMuiuMmsFeatures, features ) == KErrNone )

        {

        if ( features & KMmsFeatureIdEditorSubjectField )

            {

            iSupportedFeatures |= EUniFeatureSubject;

            }

        if ( features & KMmsFeatureIdUserCreationMode )

            {

            iFlags |= EUniDocumentCreationModeUserChangeable;

            }

        }

    if ( repository->Get( KMuiuSmsFeatures, features ) == KErrNone )

        {

        if ( features & KSmsFeatureIdEmailOverSms )

            {

            emailOverSmsVariationOn = ETrue;

            }

        }

    if ( repository->Get( KMuiuUniEditorFeatures, features ) == KErrNone )

        {

        if ( features & KUniEditorFeatureIdRestrictedReplySms )

            {

            iFlags |= EUniDocumentRestrictedReplySms;

            }

        if ( features & KUniEditorFeatureIdRestrictedReplyMms )

            {

            iFlags |= EUniDocumentRestrictedReplyMms;

            }

        }

    if ( repository->Get( KMuiuMceFeatures, features ) == KErrNone )

        {

        if ( features & KMceFeatureIdCSPSupport )

            {

            iFlags |= EUniDocumentCSPBitsSupported;

            }

        }

    CleanupStack::PopAndDestroy( repository );

    // MMS Engine CR

    repository = CRepository::NewL( KUidMmsServerMtm );

    CleanupStack::PushL( repository );

    TInt temp = 0;

    if ( repository->Get( KMmsEngineImageWidth, temp ) == KErrNone )

        {

        iMaxImageWidth = temp;

        }

    if ( repository->Get( KMmsEngineImageHeight, temp ) == KErrNone )

        {

        iMaxImageHeight = temp;

        }

    CleanupStack::PopAndDestroy( repository );

    // Just to make sure the size is at least "small"

    iMaxImageWidth = Max( KMmsUniImageSmallWidth, iMaxImageWidth );

    iMaxImageHeight = Max( KMmsUniImageSmallHeight, iMaxImageHeight );

    // SMUM CR

    repository = CRepository::NewL( KCRUidSmum );

    CleanupStack::PushL( repository );

    if ( repository->Get( KSmumMaxSubMsgCount, iAbsMaxConcatenatedSms ) ||

         iAbsMaxConcatenatedSms < 1 || 

         iAbsMaxConcatenatedSms > KMaxSmsSizeByStandard )

        {

        // Unreasonable count, change it back to 30 ( S60 default )

        iAbsMaxConcatenatedSms = KMaxSmsSizeByStandard;

        }

    CleanupStack::PopAndDestroy( repository );

    // UniEditor CR

    repository = CRepository::NewL( KCRUidUniEditor );

    CleanupStack::PushL( repository );

    if ( repository->Get( KUniEditorSoftLimitSubMsgCount, iMaxConcatenatedSms ) ||

         iMaxConcatenatedSms < 1 || 

         iMaxConcatenatedSms > iAbsMaxConcatenatedSms )

        {

        // Unreasonable count, change it back to abs max

        iMaxConcatenatedSms = iAbsMaxConcatenatedSms;

        }

    if ( repository->Get( KUniEditorSoftLimitRecipientCount, iMaxSmsRecipients ) != KErrNone || 

         iMaxSmsRecipients < 0)

        {

        // Unreasonable count, change it back to default value

        iMaxSmsRecipients = KDefaultSmsRecipients;

        }

    if(iMaxSmsRecipients == 0 )    

        {

        iMaxSmsRecipients = KMaxTInt;

        }

    if ( repository->Get( KUniEditorMaxRecipientCount, iMaxMmsRecipients ) != KErrNone || 

         iMaxMmsRecipients < 0 )

        {

        // Unreasonable count, change it back to default value

        iMaxMmsRecipients = KDefaultMmsRecipients;

        }

    if ( iMaxMmsRecipients == 0 )

        {

        iMaxMmsRecipients = KMaxTInt;

        }

     TBool softlimitenable;     

     if ( repository->Get( KUniEditorSoftLimitEnable, softlimitenable ) != KErrNone ||  !softlimitenable )

        {

        // Softlimit disabled so its value is same as hardlimit 

        iMaxConcatenatedSms = iAbsMaxConcatenatedSms;

        }

    repository->Get( KUniEditorMaxSmsCharacterCount, iAbsMaxSmsCharacters );

    TInt maxSlideCount( 0 );

    repository->Get( KUniEditorMaxSlideCount, maxSlideCount );    

    iSmsSizeWarningBytes = 0;

    repository->Get(KUniEditorSMSSizeWarning, iSmsSizeWarningBytes);

    CleanupStack::PopAndDestroy( repository );

    if ( !iMaxMessageSize )

        {

        //iMaxMessageSize == 0 means "anything goes" so set the size as large value as possible.

        iMaxMessageSize = KMaxTUint32;

        }

    // Read CSP bits from SIM

    RCustomerServiceProfileCache* cspProfile = new (ELeave) RCustomerServiceProfileCache;    

    TInt error = cspProfile->Open();

    UNILOGGER_WRITEF( _L("UniEditor: Customer service profile opened = %d" ), error );

    if ( error == KErrNone )

        {

        if ( emailOverSmsVariationOn )

            { 

            UNILOGGER_WRITE( "UniEditor: Email over SMS enabled" );

            // EmailOverSms bit was variated ON so let's check the bit from SIM

            // Get tele services flags from CSP

            RMobilePhone::TCspValueAdded params;

            // Read the CPHS bit so we know if EmailOverSms is supported

            error = cspProfile->CspCPHSValueAddedServices( params );

            UNILOGGER_WRITEF( _L("UniEditor: CspCPHSValueAddedServices read = %d" ), error );

            if ( error == KErrNone && 

                 params >= 0 &&

                 params & RMobilePhone::KCspSMMOEmail ) 

                {

                UNILOGGER_WRITE( "UniEditor: Email over SMS supported by SIM" );

                // It's supported

                iFlags |= EUniDocumentEMailOverSms;

                }

            }

        if ( iFlags & EUniDocumentCSPBitsSupported )

            {

            // Get tele services flags from CSP

            RMobilePhone::TCspTeleservices params2;

            // Read the TeleServices byte so we know which settings are supported

            error = cspProfile->CspTeleServices( params2 );

            UNILOGGER_WRITEF( _L("UniEditor: CSP read = %d" ), error );

            if ( KErrNone == error && params2 >= 0 ) 

                {

                UNILOGGER_WRITEF( _L("UniEditor: CSP bits = %b" ), params2 );

                iCSPBits = params2;

                }

            }

        cspProfile->Close();

        }

    delete cspProfile;    

    PrepareMtmL( TUid::Uid( KUidUniMtm ) );

    iDataModel = CUniDataModel::NewL( iFs, Mtm() );

    iDataModel->SmilModel().SetMaxSlideCount( maxSlideCount );

    }

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

// CUniEditorDocument::NewL

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

//

CUniEditorDocument* CUniEditorDocument::NewL( CEikApplication& aApp,

                                              CCoeEnv& aCoeEnv )

    {

    CUniEditorDocument* self = new ( ELeave ) CUniEditorDocument( aApp, aCoeEnv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUniEditorDocument::~CUniEditorDocument

//

// Destructor.

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

//

CUniEditorDocument::~CUniEditorDocument()

    {

    delete iDataModel;

    delete iCharConverter;

    delete iSmsPlugin;

    delete iMmsPlugin;

    delete iObjectObserver;

    }

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

// CUniEditorDocument::CreateAppUiL

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

//

CEikAppUi* CUniEditorDocument::CreateAppUiL() 

    {

    CUniEditorAppUi* appui = new ( ELeave ) CUniEditorAppUi;

    iObjectObserver = new ( ELeave ) CUniEditorObjectsModelObserver( *this, *appui );

    AttachmentModel().SetObserver( iObjectObserver );

    return appui;

    }

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

// CUniEditorDocument::DefaultMsgFolder

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

//

TMsvId CUniEditorDocument::DefaultMsgFolder() const

    {

    return KMsvGlobalOutBoxIndexEntryIdValue;

    }

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

// CUniEditorDocument::DefaultMsgService

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

//

TMsvId CUniEditorDocument::DefaultMsgService() const

    {

    return KMsvLocalServiceIndexEntryIdValue;

    }

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

// CUniEditorDocument::CreateNewL

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

//

TMsvId CUniEditorDocument::CreateNewL(TMsvId /* aServiceId */, TMsvId aDestFolder )

    {

    // Can only create to draft

    if ( aDestFolder != KMsvDraftEntryIdValue )

        {

        User::Leave( KErrNotSupported );

        }

    return Mtm().CreateNewEntryL( aDestFolder );

    }

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

// CUniEditorDocument::CreateNewAttachmentModelL

//

// Creates new objects model object (virtual from CMsgEditorDocument).

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

//

CMsgAttachmentModel* CUniEditorDocument::CreateNewAttachmentModelL( TBool aReadOnly )

    {

    return CUniObjectsModel::NewL( aReadOnly );

    }

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

// CUniEditorDocument::Mtm

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

//

CUniClientMtm& CUniEditorDocument::Mtm()

    {

    return static_cast <CUniClientMtm&> ( CMsgEditorDocument::Mtm() );

    }

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

// CUniEditorDocument::MtmUi

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

//

CUniMtmUi& CUniEditorDocument::MtmUiL()

    {

    return static_cast <CUniMtmUi&> ( CMsgEditorDocument::MtmUiL() );

    }

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

// CUniEditorDocument::EntryChangedL

// Intentionally empty implementation.

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

//

void CUniEditorDocument::EntryChangedL()

    {

    }

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

// CUniEditorDocument::PrepareContextL

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

//

TMsvId CUniEditorDocument::PrepareContextL( TMsvId aContext )

    {

    TMsvId service;

    TMsvEntry entry;

    User::LeaveIfError( Session().GetEntry( aContext, service, entry ) );

    if ( entry.iMtm.iUid == KUidUniMtm )

        {

        return aContext;

        }

    TMsvId newId = KMsvNullIndexEntryIdValue;

    if ( entry.iMtm == KSenduiMtmSmsUid )

        {

        __ASSERT_DEBUG( !iSmsPlugin, Panic( EUniAlreadyExists ) );

        delete iSmsPlugin;

        iSmsPlugin = NULL;

        iSmsPlugin = CUniEditorPlugin::NewL( TUid::Uid( KUidUniEditorSmsPlugin ),

                                             Session(),

                                             Mtm() );

        newId = iSmsPlugin->ConvertFromL( aContext );

        }

    else if ( entry.iMtm == KSenduiMtmMmsUid )

        {

        __ASSERT_DEBUG( !iMmsPlugin, Panic( EUniAlreadyExists ) );

        delete iMmsPlugin;

        iMmsPlugin = NULL;