/*

* Copyright (c) 2005 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 <sipmessageelements.h>

#include <sipnotifydialogassoc.h>

#include <siprefertoheader.h>

#include <sipreferdialogassoc.h>

#include <sipsubscribedialogassoc.h>

#include <sipsubscriptionstateheader.h>

#include <siptoheader.h>

#include <sipexpiresheader.h>

#include <sipeventheader.h>

#include <siprequestelements.h>

#include <sipservertransaction.h>

#include <sipprofile.h>

#include <sipdialog.h>

#include <siptransactionbase.h>

#include <sipdialogassocbase.h>

#include "mcesip.h"

#include "mceevent.h"

#include "mcerefer.h"

#include "mcesipevent.h"

#include "mcesipconnection.h"

#include "mceserial.h"

#include "mceevents.h"

#include "mceclientserver.h"

#include "mcesrvlogs.h"

#include "mcecomevent.h"

#include "mcesipeventhelper.h"

#include "mcecssessionreceiver.h"

#include "mcecssubsessionreceiver.h"

#include "mcecssession.h"

#include "mcecssessionimplementation.h"

#include "mcecomevent.h"

#include "mcesipmanager.h"

#include "mcesipconnection.h"

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

// CMceSipEvent::NewL

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

//

CMceSipEvent* CMceSipEvent::NewL( CMceCsSession& aClientSession, 

								  CMceSipConnection& aSIPConnection,

								  CSIPProfile& aProfile)

	{

    CMceSipEvent* self = CMceSipEvent::NewLC( aClientSession, 

    										  aSIPConnection, 

    										  aProfile );

    CleanupStack::Pop(self);

    return self;

	}

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

// CMceSipEvent::NewLC

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

//

CMceSipEvent* CMceSipEvent::NewLC ( CMceCsSession& aClientSession, 

									CMceSipConnection& aSIPConnection,

									CSIPProfile& aProfile)

	{

    CMceSipEvent* self = 

        new (ELeave) CMceSipEvent( aClientSession, aSIPConnection, aProfile );

    CleanupStack::PushL(self);

    self->ConstructL( aClientSession );

    return self;

	}

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

// CMceSipEvent::CMceSipEvent

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

//

CMceSipEvent::CMceSipEvent ( CMceCsSession& aClientSession, 

							 CMceSipConnection& aSIPConnection,

							 CSIPProfile& aProfile )

: CMceCsSubSession( KMceCSSIPEvent, aClientSession, aSIPConnection, aProfile )

	{

	}

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

// CMceSipEvent::ConstructL

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

//

void CMceSipEvent::ConstructL ( CMceCsSession& aClientSession )

	{

	CMceCsSubSession::ConstructL( aClientSession );

    MCESRV_DEBUG("MCE SIP event created") 	

	}

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

// CMceSipEvent::~CMceSipEvent

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

//

CMceSipEvent::~CMceSipEvent()

	{

    MCESRV_DEBUG("MCE SIP event deleted") ;	

    if(iEvent)

    	{

   		 delete iEvent; 		

    	}

    if ( iIdle )

        {

        delete iIdle;    

        }

    }

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

// CMceSipEvent::CanDispose

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

//

TBool CMceSipEvent::CanDispose()

    {

    return !iEvent || 

        iEvent->EventContext().CurrentState() == KMceTerminatedEventStateIndex;

    }

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

// CMceSipEvent::HandleSIPEvent

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

//

void CMceSipEvent::HandleSIPEvent( TMceSipEventCode /*aEventCode*/ )

    {

    TRAPD( error, iEvent->ProceedL() );

    if ( error )

        {

        ErrorOccured(error);

        }

    }

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

// CMceSipEvent::ResponseReceived

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

//

void CMceSipEvent::ResponseReceived()

    {

    HandleSIPEvent( EMceResponse );

    }

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

// CMceSipEvent::ProvisionalResponseReceived

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

//

void CMceSipEvent::ProvisionalResponseReceived()

    {

    HandleSIPEvent( EMceProvisionalResponse );

    }

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

// CMceSipEvent::RedirectionResponseReceived

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

//

void CMceSipEvent::RedirectionResponseReceived()

    {

    HandleSIPEvent( EMceRedirectionResponse );

    }

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

// CMceSipEvent::ErrorResponseReceived

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

//

void CMceSipEvent::ErrorResponseReceived()

    {

    HandleSIPEvent( EMceErrorResponse );

    }

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

// CMceSipEvent::RequestReceived

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

//

void CMceSipEvent::RequestReceived( TBool /*aInsideDialog*/, CSIPDialog& /*aDialog*/ )

    {

    MCESRV_DEBUG( "CMceSipEvent::RequestReceived -- begin" )            				

   	TInt error=KErrNone;

    RStringF method = MceSip::Method( Request() );

    if ( AcceptMethod( method ) && iEvent )

        {         

    	MCESRV_DEBUG( "CMceSipEvent::RequestReceived -- passing to event" )

        TRAP ( error, iEvent->ReceivedRequestL() );	

        MCESRV_DEBUG( "CMceSipEvent::RequestReceived -- handled" )

        }

    else

        {

        error = KErrGeneral;

        }

    if ( error != KErrNone )

        {

        MceSip::DiscardRequest( Request() );

        }

    }

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

// CMceSipEvent::StandAloneRequestReceived

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

//

void CMceSipEvent::StandAloneRequestReceived()

    {

    MCESRV_DEBUG("CMceSipEvent::StandAloneRequestReceived, Entry");

    MceSip::DiscardRequest( Request() );

    MCESRV_DEBUG("CMceSipEvent::StandAloneRequestReceived, Exit");

    }

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

// CMceSipEvent::StandAloneResponseReceived

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

//

void CMceSipEvent::StandAloneResponseReceived( TMceSipResponseType /*aResponseType*/ )

    {

    MCESRV_DEBUG("CMceSipEvent::StandAloneResponseReceived, Entry");

    // NOP

    MCESRV_DEBUG("CMceSipEvent::StandAloneResponseReceived, Exit");

    }

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

// CMceSipEvent::ErrorOccured

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

//

void CMceSipEvent::ErrorOccured( TInt aError )

    {

    TMceIds ids;

    ids.iCallbackID = EMceItcStateChanged;

    ids.iState = CMceEvent::ETerminated;

    SendErrorToClient( ids, aError );

    }

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

// CMceSipEvent::DoErrorOccured

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

//

void CMceSipEvent::DoErrorOccured( TInt aError, 

                                   CSIPTransactionBase& /*aTransaction*/ )

    {

    ErrorOccured( aError );

    }

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

// CMceSipEvent::DoConnectionStateChanged

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

//

void CMceSipEvent::DoConnectionStateChanged( TBool aIsActive )

    {

    if ( iEvent && !aIsActive )

        {

        TRAP_IGNORE( iEvent->PerformActionL( EMceItcTerminateEvent ) );

        }

    }

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

// CMceSipEvent::Canceled

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

//

void CMceSipEvent::Canceled()

    {

    if ( ClientType() == KMceDlgTypeRefer )

        {

        TRAP_IGNORE( ClientStateChangedL( CMceRefer::ETerminated, EFalse ) );

        }

    else

        {

        TRAP_IGNORE( ClientStateChangedL( CMceEvent::ETerminated, EFalse ) );

        }

    MCE_DELETE( iEvent );

    }

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

// CMceSipEvent::Terminate

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

//

TBool CMceSipEvent::Terminate()

    {

    return CanDispose();

    }

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

// CMceSipEvent::DoServiceL

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

//

HBufC8* CMceSipEvent::DoServiceL( TMceIds& aIds, 

               TMceItcFunctions aFunction )

    {

    MCESRV_DEBUG( "CMceSipEvent::DoServiceL(ids), Entry" );

    LocalDoServiceL( aIds, aFunction );

    MCESRV_DEBUG( "CMceSipEvent::DoServiceL(ids), Exit" );

    return NULL;

    }

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

// CMceSipEvent::DoServiceL

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

//

void CMceSipEvent::DoServiceL( TMceIds& /*aIds*/, 

               TMceItcFunctions /*aFunction*/, 

 	           const TDesC8& /*aMessage*/ )

    {

    MCESRV_DEBUG( "CMceSipEvent::DoServiceL(str), Entry" );

    User::Leave( KErrNotSupported );

    MCESRV_DEBUG( "CMceSipEvent::DoServiceL(str), Exit" );

    }

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

// CMceSipEvent::DoServiceL

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

//

void CMceSipEvent::DoServiceL( TMceIds& aIds, 

                               TMceItcFunctions aFunction, 

							   CMceMsgBase& aMessage ) 

    {

    MCESRV_DEBUG( "CMceSipEvent::DoServiceL(message), Entry" );

    if ( !iEvent )

        {

        User::LeaveIfError( aMessage.Type() == EMceItcMsgTypeEvent ? 

            KErrNone : KErrNotSupported );

        CMceMsgSIPEvent* eventMsg = 

        	    static_cast< CMceMsgSIPEvent* >( &aMessage );

        DoInitializeL( aFunction, *eventMsg );

        }

    CMceMsgSIPData* dataMsg = static_cast< CMceMsgSIPData* >( &aMessage );

    UpdateDataL( aFunction, *dataMsg );

    LocalDoServiceL( aIds, aFunction, *dataMsg );

    ClearDataL();

    MCESRV_DEBUG( "CMceSipEvent::ServiceL(message), Exit" );

    }

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

// CMceSipEvent::DoInitializeIncomingDialogL

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

//

void CMceSipEvent::DoInitializeIncomingDialogL( 

                                        CSIPServerTransaction& aTransaction )

    {

    User::LeaveIfError( Dialog() ? KErrNone : KErrTotalLossOfPrecision );

    User::LeaveIfError( 

        Dialog()->Type() == SIPStrings::StringF( SipStrConsts::ENotify ) ?

        KErrNone : KErrNotSupported );

    if( aTransaction.Type() == 

        SIPStrings::StringF( SipStrConsts::ESubscribe ) )

    	{

    	SetEventStateType( EMtSubscribe );		

    	}

    else

    	{

    	SetEventStateType( EMtRefer );		

    	}

    const CSIPNotifyDialogAssoc* notify = 

        static_cast< CSIPNotifyDialogAssoc* >( Dialog() );

    iEvent = CMceComEvent::NewL( 

                            *this,

                		    notify->SubscriptionState().ExpiresParameter() );

    }

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

// CMceSipEvent::IncomingSubscribeL

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

//

void CMceSipEvent::IncomingSubscribeL(CDesC8Array* aHeaders,

                    				  HBufC8* aContentType,

									  HBufC8* aBody)

	{

	// get ID of SIP profile this SUBSCRIBE was received to.

	TUint32 matchId;

    User::LeaveIfError( Profile().GetParameter( KSIPProfileId, matchId ) );

	 // Copy input parameters to avoid ownership transfer problem if leave occurs

    CDesC8Array* tempHeaders = CopyArrayLC( aHeaders ); 

    HBufC8* tempContentType = CopyBufferLC( aContentType );

    // make and encode message for ITC

    HBufC8* empty = KMceEmpty().AllocLC();

	HBufC8* recipient = Dialog()->Dialog().ToHeader().ToTextValueLC();

	HBufC8* originator = Dialog()->Dialog().FromHeader().ToTextValueLC();

	HBufC8* eventHeader = 

	    ( ( CSIPNotifyDialogAssoc* ) Dialog() )->Event().ToTextValueLC();

	TUint32 id = reinterpret_cast<TUint32>(this);

	CMceMsgSIPEvent* eventMsg = 

        new (ELeave) CMceMsgSIPEvent( id,

                                      DialogId(),

                                      EMceItcEventTypeSubscribe,

                                      recipient, // recipient

                                      originator, // originator

                                      eventHeader, // event header 

                                      empty, // refer to

                                      CMceRefer::ENoSuppression, // suppress

                                      ( TUint )KErrNotFound, // interval

                                      tempHeaders, 

                                      tempContentType );

    CleanupStack::Pop( eventHeader );

    CleanupStack::Pop( originator );

    CleanupStack::Pop( recipient );

    CleanupStack::Pop( empty );

	if ( tempContentType )

        {

        CleanupStack::Pop( tempContentType );

        }

    if ( tempHeaders )

        {

        CleanupStack::Pop( tempHeaders );

        }

    CleanupStack::PushL( eventMsg );                                

    eventMsg->EncodeL();

	HBufC8* encMsg = eventMsg->EncodeBufferCloneL();

	CleanupStack::PopAndDestroy( eventMsg );

	CleanupStack::PushL( encMsg );

    TMceIds ids;

    ids.iManagerType = KMceCSSIPEvent;

    ids.iProfileID = matchId;

    ids.iCallbackID = EMceItcObjectAdded;

	ids.iState = CMceEvent::EIdle;

	ids.iMsgType = EMceItcMsgTypeEvent;

    // send	

    Client().SendToClientL( ids, encMsg, aBody );

	CleanupStack::Pop( encMsg );

	delete aHeaders;

	delete aContentType;

    }

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

// CMceSipEvent::IncomingReferL

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

//									

void CMceSipEvent::IncomingReferL(HBufC8* aReferTo,

					CDesC8Array* aHeaders,

                    HBufC8* aContentType,

					HBufC8* aBody )

	{

	MCESRV_DEBUG( "CMceSipEvent::IncomingReferL -- Begin" );

	// get ID of SIP profile this REFER was received to.

	TUint32 matchId;

    User::LeaveIfError( Profile().GetParameter( KSIPProfileId, matchId ) );

    // Copy input parameters to avoid ownership transfer problem if leave occurs

    HBufC8* tempReferTo = CopyBufferLC( aReferTo );

    CDesC8Array* tempHeaders = CopyArrayLC( aHeaders ); 

    HBufC8* tempContentType = CopyBufferLC( aContentType );

	// make and encode message for ITC

	HBufC8* recipient = Dialog()->Dialog().ToHeader().ToTextValueLC();

	HBufC8* originator = Dialog()->Dialog().FromHeader().ToTextValueLC();

	HBufC8* eventHeader = 

	    ( ( CSIPNotifyDialogAssoc* ) Dialog() )->Event().ToTextValueLC();

	TUint32 id = reinterpret_cast<TUint32>(this);

	CMceMsgSIPEvent* eventMsg = 

        new (ELeave) CMceMsgSIPEvent( id,

                                      DialogId(),

                                      EMceItcEventTypeRefer,

                                      recipient, // recipient

                                      originator, // originator

                                      eventHeader, // event header

                                      tempReferTo, 

                                      iEvent->ReferType(),

                                      ( TUint32 )KErrNotFound, // interval

                                      tempHeaders, 

                                      tempContentType );

    CleanupStack::Pop( eventHeader );

    CleanupStack::Pop( originator );

    CleanupStack::Pop( recipient );

    if ( tempContentType )

        {

        CleanupStack::Pop( tempContentType );

        }

    if ( tempHeaders )

        {

        CleanupStack::Pop( tempHeaders );

        }

    if ( tempReferTo )

        {

        CleanupStack::Pop( tempReferTo );

        }

    CleanupStack::PushL( eventMsg );

    eventMsg->EncodeL();

	HBufC8* encMsg = eventMsg->EncodeBufferCloneL();

	CleanupStack::PopAndDestroy( eventMsg ); 

	CleanupStack::PushL( encMsg );

    // send	

    TMceIds ids;

    ids.iManagerType = KMceCSSIPEvent;

    ids.iProfileID = matchId;

    ids.iCallbackID = EMceItcObjectAdded;

	ids.iState = CMceRefer::EIdle;

	ids.iMsgType = EMceItcMsgTypeEvent;

    Client().SendToClientL( ids, encMsg, aBody );