/*
* 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 "mceinevent.h"
#include "mceitcsender.h"
#include "mceserial.h"
#include "mceclilogs.h"

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



// -----------------------------------------------------------------------------
// CMceInEvent::~CMceInEvent
// -----------------------------------------------------------------------------
//
EXPORT_C CMceInEvent::~CMceInEvent()
    {
    }

// -----------------------------------------------------------------------------
// CMceInEvent::AcceptEventL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceInEvent::AcceptL()
    {
    MCECLI_DEBUG("CMceInEvent::AcceptL, Entry");
    TUint state = State();
    MCECLI_DEBUG_EVENTSTATE( "state", state );
    
    User::LeaveIfError( State() == EIdle ? KErrNone : KErrNotReady );
	TMceIds ids;
	PrepareForITC( ids );
	ids.iState = State();
    iSender->SendL( ids, EMceItcAcceptEvent );
    //update the state
	iState = static_cast<TState>( ids.iState );
	
	state = State();
    MCECLI_DEBUG_EVENTSTATE( "CMceEvent::AcceptL, after ITC, state", state );
    MCECLI_DEBUG("CMceInEvent::AcceptL, Exit");
    }

// -----------------------------------------------------------------------------
// CMceInEvent::RejectEventL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceInEvent::RejectL()
    {
    MCECLI_DEBUG("CMceInEvent::RejectL, Entry");
    TUint state = State();
    MCECLI_DEBUG_EVENTSTATE( "state", state );
    
    User::LeaveIfError( State() == EIdle ? KErrNone : KErrNotReady );
	TMceIds ids;
	PrepareForITC( ids );
	ids.iState = State();
    iSender->SendL( ids, EMceItcRejectEvent );
    //update the state
	iState = static_cast<TState>( ids.iState );
		
	state = State();
    MCECLI_DEBUG_EVENTSTATE( "CMceEvent::RejectL, after ITC, state", state );
    MCECLI_DEBUG("CMceInEvent::RejectL, Exit");
    }


// -----------------------------------------------------------------------------
// CMceInEvent::RespondEventL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceInEvent::RespondL( 
                        const TDesC8& aReason,
			            TUint32 aCode,
			            CDesC8Array* aHeaders,
					    HBufC8* aContentType,
					    HBufC8* aContent ) 
    {
    MCECLI_DEBUG("CMceInEvent::RespondL, Entry");
    TUint state = State();
    MCECLI_DEBUG_EVENTSTATE( "state", state );
    MCECLI_DEBUG_SVALUE( "reason", aReason );
    MCECLI_DEBUG_DVALUE( "code", aCode );
    
    
    User::LeaveIfError( State() == EIdle ? KErrNone : KErrNotReady );
    User::LeaveIfError( 
        ( aContentType && aContent ) || !( aContentType || aContent ) ? 
        KErrNone : KErrArgument );
    
    //copy reason
    HBufC8* reason = aReason.AllocLC();
	//create reply
	CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason, 
	                                                        aCode, 
	                                                        *aHeaders, 
	                                                        *aContentType );
    CleanupStack::PushL( reply );
    
	TMceIds ids;
	PrepareForITC( ids );
	ids.iState = State();
	
	iSender->SendL( ids, EMceItcRespondEvent , *reply, aContent );    
	
	//update the state
	iState = static_cast<TState>( ids.iState );

    //cleanup    
    CleanupStack::PopAndDestroy( reply );
    CleanupStack::PopAndDestroy( reason );
    delete aHeaders;
    delete aContentType;
    
    state = State();
    MCECLI_DEBUG_EVENTSTATE( "CMceEvent::RespondL, after ITC, state", state );
    MCECLI_DEBUG("CMceInEvent::RespondL, Exit");
    
    }

// -----------------------------------------------------------------------------
// CMceInEvent::NotifyL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceInEvent::NotifyL(
					 CDesC8Array* aHeaders, 
					 HBufC8* aContentType,
					 HBufC8* aContent ) 
    {
    MCECLI_DEBUG("CMceInEvent::NotifyL, Entry");
    TUint state = State();
    MCECLI_DEBUG_EVENTSTATE( "state", state );
    
    User::LeaveIfError( State() == EActive ? KErrNone : KErrNotReady );
    User::LeaveIfError( 
        ( aContentType && aContent ) || !( aContentType || aContent ) ? 
        KErrNone : KErrArgument );
    
    //create notify message
	CMceMsgSIPEvent* notify = new (ELeave) CMceMsgSIPEvent( 
	                                                iId,
	                                                iDialogId,
	                                                EMceItcEventTypeEither,
	                                                CMceRefer::ENoSuppression, 
	                                                ( TUint32 ) KErrNotFound, 
	                                                aHeaders, 
	                                                aContentType );
    CleanupStack::PushL( notify );
    
    notify->OwnershipRollbackPushLC();
    
	TMceIds ids;
	PrepareForITC( ids );
	ids.iState = State();
	
	iSender->SendL( ids, EMceItcNotify, *notify, aContent );
	
	CleanupStack::Pop(); // notify->OwnershipRollbackPushLC()
	
    //update the state
	iState = static_cast<TState>( ids.iState );

    //cleanup    
    CleanupStack::PopAndDestroy( notify );
    
    state = State();
    MCECLI_DEBUG_EVENTSTATE( "CMceEvent::NotifyL, after ITC, state", state );
    MCECLI_DEBUG("CMceInEvent::NotifyL, Exit");
    }


// -----------------------------------------------------------------------------
// CMceInEvent::NewL
// -----------------------------------------------------------------------------
//
CMceInEvent* CMceInEvent::NewL( CMceManager& aManager,
								TUint32 aProfileId,
                                CMceMsgSIPEvent& aEventMsg )
    {    
    MCECLI_DEBUG("CMceInEvent::NewL, Entry");
    MCECLI_DEBUG_DVALUE("profile", aProfileId );
    
    CMceInEvent* self = new (ELeave) CMceInEvent( aManager, 
                                                  aProfileId, 
                                                  aEventMsg.Id(),
                                                  aEventMsg.DialogId(),
                                                  aEventMsg.RefreshInterval() );
    CleanupStack::PushL( self );
    
    HBufC8* eventHeader = aEventMsg.EventHeader();
    CleanupStack::PushL( eventHeader );
    HBufC8* recipient = aEventMsg.Recipient();
    CleanupStack::PushL( recipient );
    HBufC8* originator = aEventMsg.Originator();
    CleanupStack::PushL( originator );
    self->ConstructL( eventHeader, 
                      recipient, 
                      originator,
                      KMceDlgTypeSubscribe  );

    CleanupStack::Pop( originator );
    CleanupStack::Pop( recipient );
    CleanupStack::Pop( eventHeader );
    CleanupStack::Pop( self );
    MCECLI_DEBUG("CMceInEvent::NewL, Exit");
    return self;
    
    }


// -----------------------------------------------------------------------------
// CMceInEvent::CMceInEvent
// -----------------------------------------------------------------------------
//
CMceInEvent::CMceInEvent( CMceManager& aManager, 
                          TUint32 aProfileId,
                          TUint32 aId,
                          TUint32 aDialogId,
                          TUint32 aRefreshInterval )
    : CMceEvent( aManager, aProfileId, aDialogId, aRefreshInterval )
    {
    iId = aId;
    }

    
// -----------------------------------------------------------------------------
// CMceInEvent::ConstructL
// -----------------------------------------------------------------------------
//
void CMceInEvent::ConstructL( HBufC8* aEventHeader, 
                              HBufC8* aRecipient, 
                              HBufC8* aOriginator,
                              TUint32 aDialogType )
    {
    CMceEvent::ConstructL( aEventHeader, 
                           aRecipient, 
                           aOriginator, 
                           aDialogType,
                           NULL );    
    }
    

// -----------------------------------------------------------------------------
// CMceInEvent::IsInEvent
// -----------------------------------------------------------------------------
//
TBool CMceInEvent::IsInEvent() const
	{
	return ETrue;
	}