/*

* 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 "mceevent.h"

#include "mcemanager.h"

#include "mcerefer.h"

#include "mcetransactiondatacontainer.h"

#include "mceeventobserver.h"

#include "mceitcsender.h"

#include "mceeventreceiver.h"

#include "mceevents.h"

#include "mceserial.h"

#include "mce.h"

#include "mceclilogs.h"

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

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

// CMceEvent::ConstructL

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

//

void CMceEvent::ConstructL( HBufC8* aEventHeader, 

                            HBufC8* aRecipient,

	                        HBufC8* aOriginator,

	                        TUint32 aDialogType,

	                        CDesC8Array* aParams )

    {

    MCECLI_DEBUG("CMceEvent::ConstructL, Entry");

    User::LeaveIfError( aEventHeader && aRecipient ? KErrNone : KErrArgument );

    HBufC8* originator = 0;

    if ( aOriginator )

        {

        originator = aOriginator;

        }

    else

        {

        originator = KNullDesC8().AllocLC();

        }

    CDesC8Array* params = 0;    

    if ( aParams )

        {

        params = aParams;

        }

    else

        {

        params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );  

        CleanupStack::PushL( params );  

        }

	if ( params->Count() == 0 )

	    {

	    params->AppendL( *aEventHeader );

        if ( iDialogId == KMceNotAssigned )

            {

            params->AppendL( *aRecipient );

            params->AppendL( *originator );

            }

        }

    iId = iManager.RegisterEventL( this, *params, iDialogId, aDialogType );

    if ( !aParams )

        {

        CleanupStack::PopAndDestroy( params );

        }

    //get server    

    RMce& server = iManager.ServerSession();

    //create sender

    iSender = CMceItcSender::NewL( server  );

    //create receiver

    iReceiver = new (ELeave) CMceEventReceiver( server, *this );

    // Handle ownership change of input params when leave cannot occur anymore 

    if ( !aOriginator )

        {

        CleanupStack::Pop( originator );

        }     

    iOriginator = originator; 

    delete aParams;

    iEventHeader = aEventHeader;

    iRecipient = aRecipient;

    MCECLI_DEBUG("CMceEvent::ConstructL, Exit");

    }

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

// CMceEvent::~CMceEvent

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

//

CMceEvent::~CMceEvent()

    {

    MCECLI_DEBUG("CMceEvent::~CMceEvent, Entry");

    delete iReceiver;

    iReceiver = NULL;

	iManager.UnregisterEvent( this );    

    delete iSender;    

    delete iEventHeader;

    delete iRecipient;

    delete iOriginator;

    MCECLI_DEBUG("CMceEvent::~CMceEvent, Exit");

    }

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

// CMceEvent::State

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

//

EXPORT_C CMceEvent::TState CMceEvent::State() const

    {

    return iState;

    }

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

// CMceEvent::Recipient

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

//

EXPORT_C const TDesC8& CMceEvent::Recipient() const

    {

    return *iRecipient;

    }

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

// CMceEvent::Originator

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

//

EXPORT_C const TDesC8& CMceEvent::Originator() const

    {

    return *iOriginator;

    }

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

// CMceEvent::EventHeader

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

//

EXPORT_C const TDesC8& CMceEvent::EventHeader() const

    {

    return *iEventHeader;

    }

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

// CMceEvent::TerminateL

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

//

EXPORT_C void CMceEvent::TerminateL( CDesC8Array* aHeaders,

            						 HBufC8* aContentType,

            						 HBufC8* aContent ) 

    {

    MCECLI_DEBUG("CMceEvent::TerminateL, Entry");

    TUint state = State();

    MCECLI_DEBUG_EVENTSTATE( "state", state );

    User::LeaveIfError( State() == EActive ? KErrNone : KErrNotReady );

    User::LeaveIfError( 

        ( aContentType && aContent ) || !( aContentType || aContent ) ? 

        KErrNone : KErrArgument );

    CMceRefer* refer = iManager.FindRefer( *this );

    if ( refer && !refer->IsInRefer() )

        {

        // Terminating not supported for event attached to out refer

        User::Leave( KErrNotSupported ); 

        }

	//This way both the terminating NOTIFY for CMceInEvent and 

	//the un-SUBSCRIBE for CMceOutEvent can contain 

	// At this moment, only MT terminate in Refer cases is able 

	// to terminate not in MO

	TMceIds ids;

	PrepareForITC( ids );

	ids.iState = State();

	CMceMsgSIPEvent* notify = new (ELeave) CMceMsgSIPEvent( 

                                                iId,

                                                iDialogId,

                                                EMceItcEventTypeEither,

                                                CMceRefer::ENoSuppression, 

                                                ( TUint32 ) KErrNotFound, 

                                                aHeaders, 

                                                aContentType );

	CleanupStack::PushL( notify );

	notify->OwnershipRollbackPushLC();

	iSender->SendL( ids, EMceItcTerminateEvent, *notify, aContent );

	CleanupStack::Pop(); // notify->OwnershipRollbackPushLC()

    //cleanup    

    CleanupStack::PopAndDestroy( notify );

    //update the state

	iState = static_cast<TState>( ids.iState );

	state = State();

    MCECLI_DEBUG_EVENTSTATE( "CMceEvent::TerminateL, after ITC, state", state );

    MCECLI_DEBUG("CMceEvent::TerminateL, Exit");

    }

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

// CMceEvent::AssociatedSession

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

//

EXPORT_C CMceSession* CMceEvent::AssociatedSession() const

    {

    return iManager.FindAssociatedSession( iDialogId );

    }

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

// CMceEvent::AssociatedEvents

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

//

EXPORT_C RPointerArray< CMceEvent >* CMceEvent::AssociatedEventsL() const

    {

    return NULL;

    }

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

// CMceEvent::AssociatedRefers

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

//

EXPORT_C RPointerArray< CMceRefer >* CMceEvent::AssociatedRefersL() const

    {

    return NULL;

    }

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

// CMceEvent::CMceEvent

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

//

CMceEvent::CMceEvent( CMceManager& aManager,                      

                      TUint32 aProfileId,

                      TUint32 aDialogId,

                      TUint32 aRefreshInterval )

    : iManager( aManager ), 

	  iProfileId( aProfileId ),

      iId ( KMceNotAssigned ),

      iDialogId( aDialogId ),

      iRefreshInterval( aRefreshInterval )

    {

    }

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

// CMceEvent::Id

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

//

TUint32 CMceEvent::Id() const

    {

    return iId;

    }

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

// CMceEvent::DialogId

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

//

TUint32 CMceEvent::DialogId() const

    {

    return iDialogId;

    }

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

// CMceEvent::ITCSender

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

//

CMceItcSender& CMceEvent::ITCSender()

	{

	return *iSender;

	}

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

// CMceEvent::Manager

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

//

CMceManager& CMceEvent::Manager()

    {

    return iManager;

    }

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

// CMceEvent::ProfileId

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

//

TUint32 CMceEvent::ProfileId() const

	{

	return iProfileId;

	}

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

// CMceEvent::PrepareForITC

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

//

void CMceEvent::PrepareForITC( TMceIds& aId )

    {

	aId.iAppUID = Manager().AppUid().iUid;

    aId.iManagerType = KMceCSSIPEvent;

	aId.iSessionID = Id();

	aId.iProfileID = iProfileId;

    }

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

// CMceEvent::EventReceivedL

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

//

void CMceEvent::EventReceivedL( TMceIds& aId  )

    {

    TMceEvent event( aId, NULL, NULL ); 

    EventReceivedL( event );

    }

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

// CMceEvent::EventReceivedL

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

//

void CMceEvent::EventReceivedL( TMceIds& aId, CMceMsgBase& aMessage )

    {

    TMceEvent event( aId, &aMessage, NULL ); 

    EventReceivedL( event );

    }

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

// CMceEvent::EventReceivedL

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

//

void CMceEvent::EventReceivedL( TMceIds& aId, 

                                CMceMsgBase& aMessage, 

                                HBufC8* aContent )

    {

    TMceEvent event( aId, &aMessage, aContent ); 

    EventReceivedL( event );

    }

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

// CMceEvent::ErrorOccuredL

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

//

void CMceEvent::ErrorOccuredL( TInt aError )

    {

    MCECLI_DEBUG("CMceEvent::ErrorOccuredL, Entry");

    MCECLI_DEBUG_DVALUE("error", aError );

    iState = ETerminated;    

    User::LeaveIfError( iManager.EventObserver() ? KErrNone : KErrArgument );

    CMceRefer* refer = iManager.FindRefer( *this );

    if ( refer )

        {

        refer->ErrorOccuredL( aError );

        }

    iManager.EventObserver()->Failed( *this, aError );

	TUint state = State();

    MCECLI_DEBUG_EVENTSTATE( "CMceEvent::ErrorOccuredL, before exit. state", state );

    MCECLI_DEBUG("CMceEvent::ErrorOccuredL, Exit");

    }

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

// CMceEvent::EventReceivedL

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

//

void CMceEvent::EventReceivedL( TMceEvent& aEvent )

    {

    MCECLI_DEBUG("CMceEvent::EventReceivedL, Entry");

    TUint state = State();

    MCECLI_DEBUG_EVENTSTATE("this: state", state );

    MCECLI_DEBUG_DVALUE("this: id", Id() );

    User::LeaveIfError( aEvent.Id().iSessionID == Id() ? 

        KErrNone : KErrGeneral );

    User::LeaveIfError( aEvent.Id().IsSessionId() ? KErrNone : KErrGeneral );

    HandleEventL( aEvent );

	state = State();

    MCECLI_DEBUG_EVENTSTATE("CMceEvent::EventReceivedL, before exit. state", state );

    MCECLI_DEBUG("CMceEvent::EventReceivedL, Exit");

    }

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

// CMceEvent::HandleEventL

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

//

void CMceEvent::HandleEventL( TMceEvent& aEvent )

    {

    MCECLI_DEBUG("CMceEvent::EventReceivedL, Entry");

    // update state

    iState = static_cast<TState>( aEvent.Id().iState );

    MMceEventObserver* observer = iManager.EventObserver();

    TMceTransactionDataContainer* container = iManager.TransactionContainer();

    CMceMsgBase* msg = static_cast< CMceMsgBase* >( aEvent.Message() );

    // notify observer

    if ( aEvent.MessageType() == EMceItcMsgTypeSIPReply  

        && aEvent.Action() == EMceItcStateChanged )

        {

        MCECLI_DEBUG("CMceEvent::HandleEventL, session state changed" );

        MCECLI_DEBUG("CMceEvent::HandleEventL, caused by sip reply");

        CMceMsgSIPReply* replyMsg = static_cast< CMceMsgSIPReply* >( msg );

        CMceRefer* refer = iManager.FindRefer( *this );

        if ( replyMsg && container && 

            !( refer && !refer->IsInRefer() && 

            refer->State() == CMceRefer::EPending ) )

            {

            container->SetStatusCode( replyMsg->iCode );

            replyMsg->iCode = 0;

            container->SetReasonPhrase( replyMsg->Reason() );

            container->SetHeaders( replyMsg->Headers() );

            container->SetContentType( replyMsg->ContentType() );

            container->SetContent( aEvent.Content() );

            }

        if ( observer )

            {

            iManager.EventObserver()->EventStateChanged( *this, container );    

            }

        if ( refer && 

            !( iState == EActive && refer->State() == CMceRefer::EAccepted ) )

            {

            refer->EventStateChangedL( aEvent );

            }

        }

    else if ( aEvent.MessageType() == EMceItcMsgTypeEvent 

        && aEvent.Action() == EMceItcNotifyReceived ) 

        {

        MCECLI_DEBUG("CMceEvent::HandleEventL, notify received" );

        if ( observer )

            {

            CMceMsgSIPEvent* eventMsg =  static_cast<CMceMsgSIPEvent*>( msg );

            if ( container)

                {

                container->SetHeaders( eventMsg->SIPHeaders() );

                container->SetContentType( eventMsg->ContentType() );

                container->SetContent( aEvent.Content() );

                }

            iManager.EventObserver()->NotifyReceived( *this, container );    

            }

        }

    else

        {

        MCECLI_DEBUG("CMceEvent::HandleEventL, not supported" );

        User::Leave( KErrNotSupported );

        }

    if ( container )

    	{

    	container->Clear();

    	}

    if ( msg )

        {

        msg->Close();

        }

    delete aEvent.Content();

    MCECLI_DEBUG("CMceEvent::HandleEventL, Exit" );

    }