/*

* Copyright (c) 2002-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:  Creates SMS message if Event in MailBox has occurred.

*

*/

// Include hierarchy change can't be done. Smuthdr.h uses

// other files from messaging/sms (smsstd.h and smutset.h). It doesn't seem

// to find them without old way to declare include folder using SYSTEMINCLUDE.

//

#include <smuthdr.h>/*messaging/\sms/\*/

#include <msvuids.h>

#include <txtrich.h>

#include <spsettings.h>

#include <spproperty.h>

#include <utf.h>

#include <mcemanager.h>

#include <ipvoicemailengine.rsg>

#include "ipvmbxengine.h"

#include "ipvmbxeventmonitor.h"

#include "ipvmbxbase.h"

#include "ipvmbxlogger.h"

#include "ipvmbxconstants.h"

#include "ipvmbxpanic.h"

const TUid KAppUID = { 0x1020596F };

const TInt KMaxMessageDigits = 10;

const TInt KAccountTextLength = 21;

const TInt KOneChar = 1;

const TInt KTwoChars = 2;

const TInt KSmsLength = 160;

const TInt KTotalLength = 2;

const TInt KTotalOldLength = 3;

const TInt KMinIpVoiceMailBoxUriLength = 3;

const TInt KSpecialNameCharsCount = 10;

const TInt KMaxMsgDescriptions = 99;

_LIT( KEndLine, "\n" );

_LIT( KTotal, "%N" );

_LIT( KTotalNew, "%0N" );

_LIT( KIpVmbxAppEngineResourceFileDirectory, "\\resource\\" );

_LIT( KIpVmbxAppEngineResourceFileName, "ipvoicemailengine.rsc" );

_LIT( KSipString, "sip:");

_LIT( KOptionalSeparator, "\n\n" );

_LIT8( KTotalOld, "%1N" );

_LIT8( KOneMessage, "1" );

_LIT8( KNoMessages, "0" );

_LIT8( KMessagesWaiting8, "messages-waiting" );

_LIT8( KNewMessages8, "yes" );

_LIT8( KMessageAccount8, "message-account" );

_LIT8( KVoiceMessage8, "voice-message" );

_LIT8( KSlash8, "/" );

_LIT8( KColon8, ":" );

_LIT8( KCrlf8, "\r\n" );

_LIT8( KEndLine8, "\n" );

_LIT8( KHTab8, "\t");

_LIT8( KSpace8, " ");

const TText KNameDigitLowest = '\x30';

const TText KNameDigitHighest = '\x39';

const TText KNameCharUpLowest = '\x41';

const TText KNameCharUpHighest = '\x5a';

const TText KNameCharLowLowest = '\x61';

const TText KNameCharLowHighest = '\x7a';

// Legal characters in name header

// 2d, 2e, 21, 25, 2a, 5f, 2b, 60, 27, 7e

const TText8 KSpecialNameChars[KSpecialNameCharsCount] =

    {

    '-',

    '.',

    '!',

    '%',

    '*',

    '_',

    '+',

    '`',

    '\'',

    '~'

    };

const TText KSpace = '\x20';

const TText KValueLowestChar = KSpace;

const TText KValueHighestChar = '\xfd';

const TText KCr = '\x0d';

const TText KLf = '\x0a';

const TText KHTab = '\x09';

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

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIpVmbxEngine::CIpVmbxEngine( CIpVmbxInterface& aInterface ):

    iEventData(),

    iInterface( aInterface )

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CIpVmbxEngine::ConstructL()

    {

    // One manager = one event observer (restricted)

    iIpVmbxEventMonitor = new ( ELeave ) TIpVmbxEventMonitor( *this );

    }

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

// Two-phased constructor.

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

//

EXPORT_C CIpVmbxEngine* CIpVmbxEngine::NewL( CIpVmbxInterface& aInterface )

    {

    IPVMEPRINT( "CIpVmbxEngine::NewL" );

    CIpVmbxEngine* self = new( ELeave ) CIpVmbxEngine( aInterface );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CIpVmbxEngine::~CIpVmbxEngine()

    {

    IPVMEPRINT( "CIpVmbxEngine::~CIpVmbxEngine - IN" );

    iVmbxBaseArray.ResetAndDestroy();

    iVmbxBaseArray.Close();

    delete iMceManager;

    delete iServiceSettings;

    delete iIpVmbxEventMonitor;

    IPVMEPRINT( "CIpVmbxEngine::~CIpVmbxEngine - OUT" );

    }

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

// Starts subscription to VoiceMailBox -server

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

//

void CIpVmbxEngine::SubscribeProfileL(

    TUint32 aServiceProviderId,

    CSIPProfile& aSipProfile )

    {

    IPVMEPRINT( "CIpVmbxEngine::SubscribeProfileL - IN" );

    if ( !iBasicServicesRunning )

        {

        iServiceSettings = CSPSettings::NewL();

        // one manager recommended for one component

        iMceManager = CMceManager::NewL( KAppUID, &iEventData );

        iMceManager->SetEventObserver( iIpVmbxEventMonitor );

        iBasicServicesRunning = ETrue;

        }

    HBufC16* voiceMailUri16 = HBufC16::NewLC( KMaxIpVoiceMailBoxUriLength );

    TPtr16 ptrvoiceMailUri16( voiceMailUri16->Des() );

    TInt reSubscribe = 0;

    // Fetch MWI address

    CSPProperty* mwiAddress = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL(

        aServiceProviderId,

        ESubPropertyVMBXMWIAddress,

        *mwiAddress ) );

    User::LeaveIfError( mwiAddress->GetValue( ptrvoiceMailUri16 ) );

    if ( ptrvoiceMailUri16.Length() < KMinIpVoiceMailBoxUriLength )

        {

        User::Leave( KErrNotFound );

        }

    if ( KErrNotFound == ptrvoiceMailUri16.Find( KSipString ) )

        {

        ptrvoiceMailUri16.Insert( 0, KSipString );

        }

    CleanupStack::PopAndDestroy( mwiAddress );

    // Fetch also subscribe interval

    CSPProperty* mwiInterval = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL(

        aServiceProviderId,

        ESubPropertyVMBXMWISubscribeInterval,

        *mwiInterval) );

    User::LeaveIfError( mwiInterval->GetValue( reSubscribe ) );

    CleanupStack::PopAndDestroy( mwiInterval );

    HBufC8* voiceMailUri8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

        ptrvoiceMailUri16 );

    CleanupStack::PopAndDestroy( voiceMailUri16 );

    CleanupStack::PushL( voiceMailUri8 );

    TInt index = iVmbxBaseArray.Count();

    TBool newProfile = ETrue;

    if ( index )

        {

        // Might be second subscription or pending operation.

        // Though IPVME and SCP supports currently only one VMBX connection

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

            {

            CIpVmbxBase* const subscription( iVmbxBaseArray[i] );

            if ( *voiceMailUri8 == subscription->VmbxUrl() )

                {

                // Subscription already exists

                if ( CIpVmbxBase::EDisabled == subscription->State() )

                    {

                    // Subscription was disabled, enable

                    newProfile = EFalse;

                    subscription->Initialize(

                        aServiceProviderId,

                        aSipProfile );

                    subscription->SubscribeL( reSubscribe );

                    }

                else

                    {

                    User::Leave( KErrAlreadyExists );

                    }

                }

            }

        }

    if ( newProfile )

        {

        // Subscription to new VMBX account

        IPVMEPRINT( "CIpVmbxEngine::New AppBase" );

        CIpVmbxBase* app = CIpVmbxBase::NewL(

            *this,

            *voiceMailUri8,

            *iMceManager );

        CleanupStack::PushL( app );

        iVmbxBaseArray.AppendL( app );

        CleanupStack::Pop( app );

        app->Initialize( aServiceProviderId, aSipProfile );

        app->SubscribeL( reSubscribe );

        }

    CleanupStack::PopAndDestroy( voiceMailUri8 );

    IPVMEPRINT( "CIpVmbxEngine::SubscribeProfileL - OUT" );

    }

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

//

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

//

TInt CIpVmbxEngine::ProfileSubscribed(

    TUint32 aServiceProviderId,

    TBool& aProfileSubscribed )

    {

    CIpVmbxBase* subscription( SubscriptionByProvider( aServiceProviderId ) );

    TInt err = KErrNotFound;

    if ( subscription )

        {

        err = KErrNone;

        if ( CIpVmbxBase::ERegistered == subscription->State() )

            {

            aProfileSubscribed = ETrue;

            }

        else

            {

            aProfileSubscribed = EFalse;

            }

        }

    return err;

    }

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

// Resolve base class matching to recipient

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

//

CIpVmbxBase* CIpVmbxEngine::SubscriptionByRecipient(

    const TDesC8& aRecipient8 )

    {

    CIpVmbxBase* base( NULL );

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

        {

        if ( iVmbxBaseArray[i]->VmbxUrl() == aRecipient8 )

            {

            base = iVmbxBaseArray[i];

            }

        }

    return base;

    }

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

// EventMonitor has received event and the event will be gained and checked

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

//

void CIpVmbxEngine::EventReceivedL( const TDesC8& aRecipient8 )

    {

    IPVMEPRINT( "CIpVmbxEngine::EventReceivedL - IN" );

    CIpVmbxBase* subscription( SubscriptionByRecipient( aRecipient8 ) );

    if ( !subscription )

        {

        User::Leave( KErrNotFound );

        }

    HBufC8* content8( iEventData.GetContent() );

    CleanupStack::PushL( content8 );

    HBufC8* totalMessages8 = HBufC8::NewLC( KMaxMessageDigits );

    HBufC8* newMessages8 = HBufC8::NewLC( KMaxMessageDigits );

    HBufC8* from8 = HBufC8::NewLC(

        KMaxIpVoiceMailBoxUriLength + KAccountTextLength );

    TPtr8 ptrTotalMessages8( totalMessages8->Des() );

    TPtr8 ptrNewMessages8( newMessages8->Des() );

    TPtr8 ptrFrom8( from8->Des() );

    TPtr8 ptrContent8( content8->Des() );

    TBool createSMS = EFalse;

    // no need to handle errors, returned parameters can still

    // be interpreted correctly

    //

    TRAP_IGNORE(

        ParseNotifyContentL(

            createSMS,

            ptrContent8,

            ptrTotalMessages8,

            ptrNewMessages8,

            ptrFrom8 ) );

    if ( ptrNewMessages8 == KNoMessages )

        {

        // protocol test fix, new message should not be created

        // if new message count is 0

        createSMS = EFalse;

        }

    if ( 0 == ptrFrom8.Length() )

        {

        ptrFrom8 = subscription->VmbxUrl();

        }

    TInt totalMsgs = 0;

    TInt newMsgs = 0;

    TLex8 msgsConvert;

    msgsConvert.Assign( *totalMessages8 );

    if ( KErrNone == msgsConvert.Val( totalMsgs ) )

        {

        msgsConvert.Assign( *newMessages8 );

        if ( KErrNone != msgsConvert.Val( newMsgs ) )

            {

            totalMsgs = 0;

            }

        }

    TInt curTotal = 0;

    TInt curNew = 0;

    subscription->AccountMessageCount( curTotal, curNew );

    TBool statusChanged = EFalse;

    if ( totalMsgs != curTotal || newMsgs != curNew )

        {

        statusChanged = ETrue;

        subscription->SetAccountMessageCount( totalMsgs, newMsgs );

        }

    if ( createSMS && statusChanged )

        {

        TBuf8< KSmsLength > messageBody8;

        CreateMessageBodyL(

            *content8,

            ptrTotalMessages8,

            ptrNewMessages8,

            ptrFrom8,

            messageBody8 );

        CreateSMSMessageL( ptrFrom8, messageBody8 );

        }

    CleanupStack::PopAndDestroy( from8 );

    CleanupStack::PopAndDestroy( newMessages8 );

    CleanupStack::PopAndDestroy( totalMessages8 );

    CleanupStack::PopAndDestroy( content8 );

    IPVMEPRINT( "CIpVmbxEngine::EventReceivedL - OUT" );

    }

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

//

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

//

void CIpVmbxEngine::UnsubscribeProfileL( TUint32 aServiceProviderId )

    {

    IPVMEPRINT2( "CIpVmbxEngine::UnsubscribeProfileL: %d - IN", 

	    aServiceProviderId );

    CIpVmbxBase* subscription( SubscriptionByProvider( aServiceProviderId ) );

    if ( !subscription )

        {

        User::Leave( KErrNotFound );

        }

    IPVMEPRINT2( "CIpVmbxEngine::UnsubscribeProfileL: state=%d",

	    subscription->State() );

    switch( subscription->State() )

        {

        case CIpVmbxBase::ERegistered:

            {

            subscription->TerminateEventL();

            break;

            }

        case CIpVmbxBase::EDisabled:

            {

            CleanVmbxBase();

            break;

            }

        case CIpVmbxBase::ESubscribing:

            {

            subscription->Cancel();

            CleanVmbxBase();

            break;

            }

        case CIpVmbxBase::ETerminating:

            {

            User::Leave( KErrCancel );

            break;

            }

        default:

            {

            IPVMEPRINT( "No implementation" );

            }

        }

    }

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

//

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

//

void CIpVmbxEngine::CleanVmbxBase()

    {

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

        {

        if ( CIpVmbxBase::ETerminating == iVmbxBaseArray[i]->State() ||

            CIpVmbxBase::EDisabled == iVmbxBaseArray[i]->State() )

            {

            delete iVmbxBaseArray[i];

            iVmbxBaseArray.Remove( i );

            }

        }

    }

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

//

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

//

void CIpVmbxEngine::HandleMessage(

    TUint32 aServiceProviderId,

    CIpVmbxEngine::TIpVmbxMessages aMessage )

    {

    IPVMEPRINT2( "CIpVmbxEngine::HandleMessage: %d - IN", aMessage );

    CIpVmbxBase* subscription( SubscriptionByProvider( aServiceProviderId ) );

    // Save current state because some functions modify states

    CIpVmbxBase::TIpVmbxBaseStates baseState = subscription->State();

    MIpVmbxObserver::TVmbxMessage message =

        MIpVmbxObserver::EIncorrectSettings;

    TBool send = ETrue;

    switch ( aMessage )

        {

        case CIpVmbxEngine::EEngineSubscribed:

            message = MIpVmbxObserver::ESubscribed;

            break;

        case CIpVmbxEngine::EEngineTerminated:

            {

            if ( CIpVmbxBase::EDisabled != baseState )

                {

                CleanVmbxBase();

                message = MIpVmbxObserver::EUnsubscribed;

                }

            else

                {

                send = EFalse;

                }

            break;

            }

        case CIpVmbxEngine::EEngineUndefined:

            {

            send = EFalse;

            break;

            }

        case CIpVmbxEngine::EEngineSubscribeRejected:

        case CIpVmbxEngine::EEngineIncorrectAccount: