/*

* Copyright (c) 2006-2010 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:  Transfer state context class for state machine

*

*/

#include <mcetransactiondatacontainer.h> // TMceTransactionDataContainer 

#include <mceoutrefer.h>                 // CMceRefer, CMceOutRefer

#include <mceoutevent.h>                 // CMceEvent

#include <escapeutils.h>

#include <mcesession.h>

#include <crcseprofileentry.h>

#include <crcseprofileregistry.h>

#include "svpsessionbase.h"

#include "svptransferstatecontext.h"

#include "svptransferstatebase.h"

#include "svptransferidlestate.h"

#include "svptransferpendingstate.h"

#include "svptransferacceptedstate.h"

#include "svptransferterminatingstate.h"

#include "svptransferterminatedstate.h" 

#include "svptransferobserver.h"

#include "svplogger.h"          

#include "svpuriparser.h"

#include "svpconsts.h"

#include "svpholdcontext.h"

#include "svpholdcontroller.h"

#include "svpcleanupresetanddestroy.h"

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

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

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

//

CSVPTransferStateContext::CSVPTransferStateContext( 

                                CMceSession* aMceSession,                                

                                CSVPSessionBase* aSVPSession,                                

                                TMceTransactionDataContainer& aContainer, 

                                MSVPTransferObserver& aObserver ) :

        iMceSession( aMceSession ),

        iSVPSession( aSVPSession ),        

        iTargetSession( NULL ),

        iContainer( aContainer ),

        iTransferObserver( aObserver ),

        iStates( NULL ),

        iCurrentState( NULL ),

        iMceRefer( NULL ),        

        iMceEvent( NULL ),

        iAttended( EFalse ),

        iIncomingReferTo ( NULL ),

        iIncomingReferredBy ( NULL ),

        iIncomingReplaces (NULL)

    {

    }

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

// CSVPTransferStateContext::ConstructL

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

//

void CSVPTransferStateContext::ConstructL() 

    {

    SVPDEBUG1( "CSVPTransferStateContext::ConstructL In" )

    // Create the transfer states in the state array.

    InitializeStateArrayL();  

    // Initialize idle state to current state. Note, that it is not

    // applied yet.

    SetCurrentStateL( KSVPTransferIdleStateIndex );

    SVPDEBUG1( "CSVPTransferStateContext::ConstructL Out" )

    }

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

// CSVPTransferStateContext::NewL

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

CSVPTransferStateContext* CSVPTransferStateContext::NewL( 

                                CMceSession* aMceSession,

                                CSVPSessionBase* aSVPSession,

                                TMceTransactionDataContainer& aContainer, 

                                MSVPTransferObserver& aObserver )

    {    

    CSVPTransferStateContext* self = new ( ELeave ) CSVPTransferStateContext(

                                                        aMceSession,

                                                        aSVPSession,

                                                        aContainer, 

                                                        aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSVPTransferStateContext::~CSVPTransferStateContext

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

//

CSVPTransferStateContext::~CSVPTransferStateContext()

    {

    SVPDEBUG1( "CSVPTransferStateContext::~CSVPTransferStateContext In" )

    if ( iStates )

        {

        iStates->ResetAndDestroy();

        iStates->Close();

        delete iStates;

        }

    delete iMceEvent;

    delete iMceRefer;

    delete iIncomingReferTo;

    delete iIncomingReferredBy;

    delete iIncomingReplaces;

    SVPDEBUG1( "CSVPTransferStateContext::~CSVPTransferStateContext Out" )        

    }

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

// CSVPTransferStateContext::SetCurrentStateL

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

//

void CSVPTransferStateContext::SetCurrentStateL(

        TSVPTransferStateIndex aStateIndex )

    {

    // Check, if the transition is valid

    if ( !IsStateTransitionAccepted( aStateIndex ) )

        {

        SVPDEBUG2( "CSVPTransferStateContext::SetCurrentStateL: STATE ERROR stateindex: %i", aStateIndex )

        User::Leave( KSVPErrTransferStateError );

        }

    else

        {

        iCurrentState = ( *iStates )[ aStateIndex ];

        iCurrentState->Enter( *this );

        }

    }

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

// CSVPTransferStateContext::CurrentState

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

//

TSVPTransferStateIndex CSVPTransferStateContext::CurrentState() const

    {

    return iStates->Find( iCurrentState );    

    }

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

// CSVPTransferStateContext::ApplyCurrentStateL

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

//

void CSVPTransferStateContext::ApplyCurrentStateL()

   {

   iCurrentState->ApplyL( *this );

   }

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

// CSVPTransferStateContext::TransferObserver

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

//

MSVPTransferObserver& CSVPTransferStateContext::TransferObserver()

    {

    return iTransferObserver;    

    }

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

// CSVPTransferStateContext::SetMceSessionObject

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

//

void CSVPTransferStateContext::SetMceSessionObject( CMceSession* aSession )

    {

    iMceSession = aSession;

    }

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

// CSVPTransferStateContext::MceSessionObject

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

//

CMceSession* CSVPTransferStateContext::MceSessionObject()

    {

    return iMceSession;

    }

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

// CSVPTransferStateContext::SetMceRefer

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

//

void CSVPTransferStateContext::SetMceRefer( CMceRefer* aRefer )

    {

    if ( iMceRefer != aRefer )

        {

        delete iMceRefer;

        iMceRefer = aRefer;

        }

    }

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

// CSVPTransferStateContext::MceRefer

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

//

CMceRefer* CSVPTransferStateContext::MceRefer()

    {

    return iMceRefer;

    }

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

// CSVPTransferStateContext::SetAttended

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

//

void CSVPTransferStateContext::SetAttended( const TBool aAttended )

    {

    iAttended = aAttended;

    }

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

// CSVPTransferStateContext::IsAttended

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

//

TBool CSVPTransferStateContext::IsAttended()

    {

    return iAttended;

    }

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

// CSVPTransferStateContext::CheckIsSessionRemoteHold

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

//

TBool CSVPTransferStateContext::CheckIsSessionRemoteHold()

    {

    SVPDEBUG1( "CSVPTransferStateContext::CheckIsSessionRemoteHold In" )

    TBool ret = EFalse;

    if ( iSVPSession->HasHoldController() &&

         MCCPCallObserver::ECCPStateDisconnecting != iSVPSession->State() )

        {

        SVPDEBUG1("CSVPTransferStateContext::CheckIsSessionRemoteHold, Check hold state" )

        if ( ESVPOnHold == iSVPSession->HoldController().HoldState() &&

             ESVPRemoteHold == iSVPSession->HoldController().HoldRequest() )

            {

            // Session is remote holded -> Snom/EyeBeam as unattended transferer case.

            SVPDEBUG1( "CSVPTransferStateContext:CheckIsSessionRemoteHold, transferer is Snom, EyeBeam or similar" )

            ret = ETrue;

            }

        }

    SVPDEBUG2("CSVPTransferStateContext::CheckIsSessionRemoteHold Out return: %d",ret )

    return ret;

    }

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

// CSVPTransferStateContext::SetTransferDataL

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

//

void CSVPTransferStateContext::SetTransferDataL(

        CDesC8Array* aUserAgentHeaders, TInt aSecureStatus )

    {

    SVPDEBUG1( "CSVPTransferStateContext::SetTransferDataL In" )

    if ( aUserAgentHeaders )

        {

        if ( iIncomingReplaces && IsAttended() )

            {

            SVPDEBUG1( "CSVPTransferStateContext::SetTransferDataL: Add replaces header" )

            // fetch "replaces:" string

            HBufC* replacesStringHeap16 = IncomingReplaces().AllocLC(); // CS: 1

            // Copy incoming replaces to 8-bit buffer

            HBufC8* replacesStringHeap8 =

                    HBufC8::NewLC( replacesStringHeap16->Length() +

                                   KSVPReplacesColonTxt().Length() ); // CS: 2

            replacesStringHeap8->Des().Copy( *replacesStringHeap16 );

            CleanupStack::Pop( 1 );

            CleanupStack::PushL( replacesStringHeap8 ); // ReAlloc possible

            // add replaces header

            replacesStringHeap8->Des().Insert( 0, KSVPReplacesColonTxt );

            CleanupStack::Pop( 1 );

            CleanupStack::PushL( replacesStringHeap8 ); // ReAlloc possible

            SVPDEBUG2( "CSVPTransferStateContext::SetTransferDataL - length: %d", replacesStringHeap8->Length() )

            // Finally add collected Replaces string to header

            aUserAgentHeaders->AppendL( *replacesStringHeap8 );

            CleanupStack::PopAndDestroy( replacesStringHeap8 );      // CS: 1

            CleanupStack::PopAndDestroy( replacesStringHeap16 );     // CS: 0

            }

        if ( iIncomingReferredBy )

            {

            SVPDEBUG1( "CSVPTransferStateContext::SetTransferDataL: Add referredBy header" )

            TBuf8<KSVPTempStringlength> referredByString;

            referredByString.Append( KSVPReferredBy );

            // add IncomingReferredBy

            referredByString.Append( IncomingReferredBy() );

            // Finally add collected Referred-By string to header

            aUserAgentHeaders->AppendL( referredByString );

            }

        }

    // Update transfer target address according preferred securesetting.

    UpdateTransferTargetL( aSecureStatus );

    SVPDEBUG1( "CSVPTransferStateContext::SetTransferDataL Out" )

    }

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

// CSVPTransferStateContext::IsIncoming

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

//

TBool CSVPTransferStateContext::IsIncoming()

    {

    return ( NULL != iIncomingReferTo );

    }

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

// CSVPTransferStateContext::SetIncomingReferToL

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

//

void CSVPTransferStateContext::SetIncomingReferToL( const TDesC8& aReferTo )

    {

    SVPDEBUG1("CSVPTransferStateContext::SetIncomingReferToL In" )

    ResetIncomingReferTo();

    // modify aReferTo

    HBufC8* referTo = CompleteReferToL( aReferTo );

    CleanupStack::PushL( referTo );

    // at this point referto must contains legal sip uri

    RemoveExtraParameters( referTo );

    // Check length - moSession construct limitation

    // sip: or sips: prefix will be added later, so 95 is maximum

    if ( referTo->Length() < ( KSVPMaxUriLength - KSVPSipPrefixLength ) )

        {

        // Copy and convert the "refer to" -parameter.

        iIncomingReferTo = HBufC::NewL( referTo->Length() );

        TPtr temp = iIncomingReferTo->Des();

        temp.Copy( *referTo );

        }

    else

        {

        SVPDEBUG1( "CSVPTransferStateContext::SetIncomingReferToL: referTo too long, Leave" )

        User::Leave( KErrArgument );

        }

    CleanupStack::PopAndDestroy( referTo );

   SVPDEBUG2( "CSVPTransferStateContext::SetIncomingReferToL lenght: %d",

            iIncomingReferTo->Length())

    SVPDEBUG1( "CSVPTransferStateContext::SetIncomingReferToL Out" )

    }

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

// CSVPSessionBase::SetIncomingReferredByL

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

//

void CSVPTransferStateContext::SetIncomingReferredByL( const TDesC8& aReferredBy )

    {

    SVPDEBUG1( "CSVPTransferStateContext::SetIncomingReferredByL In" )

    ResetIncomingReferredBy();

    // modify aReferredBy

    HBufC8* referredBy = CompleteReferredByL( aReferredBy );

    CleanupStack::PushL( referredBy );

    // Copy and convert the "Referred By" -parameter.    

    iIncomingReferredBy = HBufC::NewL( referredBy->Length() );

    TPtr temp = iIncomingReferredBy->Des();

    temp.Copy( *referredBy );

    CleanupStack::PopAndDestroy( referredBy );

    SVPDEBUG2( "CSVPTransferStateContext::SetIncomingReferredByL lenght: %d",

            iIncomingReferredBy->Length() )

    SVPDEBUG1( "CSVPTransferStateContext::SetIncomingReferredByL Out" )

    }    

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

// CSVPTransferStateContext::SetIncomingReplacesL

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

//

void CSVPTransferStateContext::SetIncomingReplacesL( const TDesC8& aString )

    { 

    SVPDEBUG1("CSVPTransferStateContext::SetIncomingReplacesL In" )

    ResetIncomingReplaces();

    // modify Replaces

    HBufC8* string = CompleteReplacesL( aString );

    CleanupStack::PushL( string );

    // Copy and convert the "Replaces" -parameter.    

    iIncomingReplaces = HBufC::NewL( string->Length() );

    TPtr temp = iIncomingReplaces->Des();

    temp.Copy( *string );

    CleanupStack::PopAndDestroy( string );

    SVPDEBUG2( "CSVPTransferStateContext::SetIncomingReplacesL lenght: %d",

            iIncomingReplaces->Length() )

    SVPDEBUG1( "CSVPTransferStateContext::SetIncomingReplacesL Out" )

    }

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

// CSVPTransferStateContext::CompleteReplacesL

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

//

HBufC8* CSVPTransferStateContext::CompleteReplacesL( const TDesC8& aString )

    {

    SVPDEBUG1( "CSVPTransferStateContext::CompleteReplacesL In" )

    // Copy the parameter to a new buffer.

    HBufC8* string = aString.AllocLC();

    // If "?Replaces=" found attended transfer case

    TInt position = CheckReplacesTxt( *string );

    SVPDEBUG2( "    CheckReplacesTxt returns = %d", position );

    if ( KErrNotFound != position )

        {

        TakeReplacesTxt( string, position );

        CleanupStack::Pop( 1 ); // string, ReAlloc possible

        CleanupStack::PushL( string );

        }

    // Check "?X-Sipx-Authidentity=" and remove text after it if exists

    position = CheckAuthidentity( *string );

    if ( KErrNotFound != position )

        {

        // "?X-Sipx-Authidentity=" found

        CutStringFromPosition( string, position );

        CleanupStack::Pop( 1 ); // string, ReAlloc possible

        CleanupStack::PushL( string );

        }

    // Check ">" and remove text after it if exists

    position = CheckRightBracket( *string );

    SVPDEBUG2("    CheckRightBracket returns = %d" , position )

    if ( KErrNotFound != position )

        {

        // ">" found

        CutStringFromPosition( string, position );

        CleanupStack::Pop( 1 ); // string, ReAlloc possible

        CleanupStack::PushL( string );

        }

    HBufC8* temp = EscapeUtils::EscapeDecodeL( *string );

    CleanupStack::PopAndDestroy( string );

    SVPDEBUG1( "CSVPTransferStateContext::CompleteReplacesL Out" )

    return temp;

    }

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

// CSVPTransferStateContext::CompleteReferToL

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

//

HBufC8* CSVPTransferStateContext::CompleteReferToL( const TDesC8& aUri )

    {

    SVPDEBUG1( "CSVPTransferStateContext::CompleteReferToL In" )

    // Copy the parameter to a new buffer.

    HBufC8* uri = aUri.AllocLC();

    // Check "<" and remove it and text before it if exists

    TInt position = CheckLeftBracket( *uri );

    if ( KErrNotFound != position )

        {

        RemoveLeftBracket( uri, position );

        CleanupStack::Pop( 1 ); // uri, ReAlloc possible

        CleanupStack::PushL( uri );

        }

    // Check ";user=phone" and remove if exists

    position = CheckUserEqualsPhone( *uri );

    if ( KErrNotFound != position )

        {

        // ";user=phone" found

        RemoveUserEqualsPhone( uri, position );

        CleanupStack::Pop( 1 ); // uri, ReAlloc possible

        CleanupStack::PushL( uri );

        }

    // Check ">" and remove text after it if exists

    position = CheckRightBracket( *uri );

    if ( KErrNotFound != position )

        {

        // ">" found

        CutStringFromPosition( uri, position );

        CleanupStack::Pop( 1 ); // uri, ReAlloc possible

        CleanupStack::PushL( uri );

        }

    // Check "KSVPQuesReplacesTxt" and remove text after it if exists

    // If it is found -> attended transfer case

    position = CheckReplacesTxt( *uri );

    if ( KErrNotFound != position )

        {

        // Found -> attended case.

        SVPDEBUG1( "CSVPTransferStateContext::CompleteReferToL ?Replaces= found -> attended transfer" )

        SetAttended( ETrue );

        SetIncomingReplacesL( aUri );

        CutStringFromPosition( uri, position );

        }

    else

        {

        // Not found -> unattended case.

        SVPDEBUG1( "CSVPTransferStateContext::CompleteReferToL ?Replaces= not found -> unattended transfer" )

        SetAttended( EFalse );

        }