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

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



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

// -----------------------------------------------------------------------------
// CMceInRefer::AcceptL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceInEvent* CMceInRefer::AcceptL()
    {
    MCECLI_DEBUG("CMceInRefer::AcceptL, Entry");
    TState state = State();
    MCECLI_DEBUG_EVENTSTATE( "state", state );
    
    User::LeaveIfError( State() == EIdle ? KErrNone : KErrNotReady );
    if ( ReferEvent() )
        {
        static_cast< CMceInEvent* >( ReferEvent() )->AcceptL();
        
        // resolve new state
        iState = ResolveStateL();
        }
    else
        {
        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( "CMceInRefer::AcceptL, after ITC, state", state );
    MCECLI_DEBUG("CMceInRefer::AcceptL, Exit");
    
	return static_cast< CMceInEvent* >( TransferEventOwnership() );
    }

// -----------------------------------------------------------------------------
// CMceInRefer::RejectL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceInRefer::RejectL()
    {
    MCECLI_DEBUG("CMceInRefer::RejectL, Entry");
    TState state = State();
    MCECLI_DEBUG_EVENTSTATE( "state", state );
    
    User::LeaveIfError( State() == EIdle ? KErrNone : KErrNotReady );
    if ( ReferEvent() )
        {
        static_cast< CMceInEvent* >( ReferEvent() )->RejectL();
        // resolve new state
        iState = ResolveStateL();
        }
    else
        {
        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( "CMceInRefer::RejectL, after ITC, state", state );
    MCECLI_DEBUG("CMceInRefer::RejectL, Exit");
    
	}


// -----------------------------------------------------------------------------
// CMceInRefer::RespondL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceInEvent* CMceInRefer::RespondL( 
                        const TDesC8& aReason,
			            TUint32 aCode,
			            CDesC8Array* aHeaders,
					    HBufC8* aContentType,
					    HBufC8* aContent ) 
    {
    MCECLI_DEBUG("CMceInRefer::RespondL, Entry");
    TState 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 );
    
    if ( ReferEvent() )
        {
        static_cast< CMceInEvent* >( ReferEvent() )-> RespondL( aReason, 
                                                                    aCode, 
                                                                    aHeaders,
                                                                    aContentType,
                                                                    aContent );
        // resolve new state
        iState = ResolveStateL();	    
        }
    else
        {
        //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( "CMceInRefer::RespondL, after ITC, state", state );
    MCECLI_DEBUG("CMceInRefer::RespondL, Exit");
    
    return ( iState == EPending ? 
        static_cast< CMceInEvent* >( TransferEventOwnership() ) : NULL );
    }

// -----------------------------------------------------------------------------
// CMceInRefer::NewL
// -----------------------------------------------------------------------------
//
CMceInRefer* CMceInRefer::NewL( CMceManager& aManager,
                                TUint32 aProfileId,
                                CMceMsgSIPEvent& aEventMsg,
                                CMceInEvent* aInEvent )
    {
    MCECLI_DEBUG("CMceInRefer::NewL, Entry");
    MCECLI_DEBUG_DVALUE("profile", aProfileId );
    
    CMceInRefer* self = new (ELeave) CMceInRefer( 
        aManager, 
        aProfileId, 
        aEventMsg.Id(), 
        aEventMsg.DialogId(),
        static_cast< TType > ( aEventMsg.ReferType() ) );
        
    CleanupStack::PushL( self );
    
    HBufC8* referTo = aEventMsg.ReferTo();
    CleanupStack::PushL( referTo );
    HBufC8* recipient = aEventMsg.Recipient();
    CleanupStack::PushL( recipient );
    HBufC8* originator = aEventMsg.Originator();
    CleanupStack::PushL( originator );
    
    self->ConstructL( referTo, 
                      recipient, 
                      originator, 
                      aInEvent );

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


// -----------------------------------------------------------------------------
// CMceInRefer::CMceInRefer
// -----------------------------------------------------------------------------
//
CMceInRefer::CMceInRefer( CMceManager& aManager, 
                          TUint32 aProfileId,
                          TUint32 aId,
                          TUint32 aDialogId,
                          TType aType )
    : CMceRefer( aManager, aProfileId, aDialogId, aType )
    {
    iId = aId;
    }
    
// -----------------------------------------------------------------------------
// CMceInRefer::ConstructL
// -----------------------------------------------------------------------------
//
void CMceInRefer::ConstructL( HBufC8* aReferTo,
                              HBufC8* aRecipient,
                              HBufC8* aOrginator,
                              CMceInEvent* aInEvent ) 
    {
    iEvent = aInEvent; 
    CMceRefer::ConstructL( aRecipient, aReferTo, aOrginator, NULL );
    iEvent = NULL;
    iOwnedEvent = aInEvent; 
    }

// -----------------------------------------------------------------------------
// CMceInRefer::IsInRefer
// -----------------------------------------------------------------------------
//    
TBool CMceInRefer::IsInRefer() const
    {
    return ETrue;
    }