/*
* 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 <sipprofile.h>
#include "mceoutrefer.h"
#include "mcemanager.h"
#include "mceclientserver.h"
#include "mceitcsender.h"
#include "mceserial.h"
#include "mceclilogs.h"

// CONSTANTS
_LIT8( KReferEventHeader, "refer" );

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


// -----------------------------------------------------------------------------
// CMceOutRefer::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceOutRefer* CMceOutRefer::NewL(
                        CMceManager& aManager,
                        CSIPProfile& aProfile,
						const TDesC8& aRecipient,
                    	const TDesC8& aReferTo,
                        TType aType,
					    HBufC8* aOriginator) 
                        
    {
    MCECLI_DEBUG("CMceOutRefer::NewL, Entry");
    MCECLI_DEBUG_SVALUE("recipient", aRecipient );
    MCECLI_DEBUG_SVALUE("refer to", aReferTo );
    
    TUint32 profileId(0);
    if ( aProfile.GetParameter( KSIPProfileId, profileId ) != KErrNone )
        {
        User::Leave(KErrNotFound);
        }

    CMceOutRefer* self = new (ELeave) CMceOutRefer( aManager, 
                                                    profileId,
                                                    KMceNotAssigned,
                                                    aType );
    CleanupStack::PushL( self );
    self->ConstructL( aRecipient, aReferTo, aType, aOriginator);
    CleanupStack::Pop( self );
    MCECLI_DEBUG("CMceOutRefer::NewL, Exit");
    return self;  
    }

// -----------------------------------------------------------------------------
// CMceOutRefer::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceOutRefer* CMceOutRefer::NewL(
			        	CMceEvent& aEvent,
                    	const TDesC8& aReferTo,
			        	TType aType )
    {
    MCECLI_DEBUG("CMceOutRefer::NewL, Entry");
    MCECLI_DEBUG_DVALUE("event", aEvent.Id() );
    MCECLI_DEBUG_SVALUE("refer to", aReferTo );
    
    CMceOutRefer* self = new (ELeave) CMceOutRefer( aEvent.Manager(), 
                                                    aEvent.ProfileId(),
                                                    aEvent.DialogId(),
                                                    aType );
    CleanupStack::PushL( self );
    self->ConstructL( aEvent.Recipient(), 
                      aReferTo, 
                      aType,
                      aEvent.Originator() );
    CleanupStack::Pop( self );
    MCECLI_DEBUG("CMceOutRefer::NewL, Exit");
    return self;  
    }

// -----------------------------------------------------------------------------
// CMceOutRefer::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceOutRefer* CMceOutRefer::NewL(
			        	CMceSession& aSession,
                    	const TDesC8& aReferTo,
				        TType aType )
    {
    MCECLI_DEBUG("CMceOutRefer::NewL, Entry");
    MCECLI_DEBUG_SVALUE("session", aSession.Id() );
    MCECLI_DEBUG_SVALUE("refer to", aReferTo );
    
    CMceOutRefer* self = new (ELeave) CMceOutRefer( aSession.Manager(), 
                                                    aSession.Profile(),
                                                    aSession.DialogId(),
                                                    aType );
    CleanupStack::PushL( self );
    self->ConstructL( aSession.Recipient(),
                      aReferTo, 
                      aType,
                      aSession.Originator() );
    CleanupStack::Pop( self );

    MCECLI_DEBUG("CMceOutRefer::NewL, Exit");
    
    return self; 
    }

// -----------------------------------------------------------------------------
// CMceOutRefer::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceOutRefer* CMceOutRefer::NewL(
			        	CMceRefer& aRefer,
                    	const TDesC8& aReferTo,
				        TType aType )
    {
    MCECLI_DEBUG("CMceOutRefer::NewL, Entry");
    MCECLI_DEBUG_SVALUE("refer", aRefer.Id() );
    MCECLI_DEBUG_SVALUE("refer to", aReferTo );
    
    CMceOutRefer* self = new (ELeave) CMceOutRefer( aRefer.Manager(), 
                                                    aRefer.ProfileId(),
                                                    aRefer.DialogId(),
                                                    aType );
    CleanupStack::PushL( self );
    self->ConstructL( aRefer.Recipient(), 
                      aReferTo,
                      aType, 
                      aRefer.Originator() );
    CleanupStack::Pop( self );
    
    MCECLI_DEBUG("CMceOutRefer::NewL, Exit");
    
    return self; 
    }

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

// -----------------------------------------------------------------------------
// CMceOutRefer::ReferL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceOutEvent* CMceOutRefer::ReferL(
                    			 CDesC8Array* aHeaders, 
                    			 HBufC8* aContentType,
                    			 HBufC8* aContent ) 
    {   
    MCECLI_DEBUG("CMceOutRefer::ReferL, Entry");
    TState state = State();
    MCECLI_DEBUG_EVENTSTATE( "state", state );
    
    User::LeaveIfError( State() == EIdle ? KErrNone : KErrNotReady );
    User::LeaveIfError( 
        ( aContentType && aContent ) || !( aContentType || aContent ) ? 
        KErrNone : KErrArgument );
    
	TMceIds ids;
	PrepareForITC( ids );
	ids.iState = State();
    
    CMceMsgSIPEvent* refer = NULL;
    refer = new (ELeave) CMceMsgSIPEvent( Id(),
                                          DialogId(),
                                          EMceItcEventTypeRefer,
                                          iType,
                                          ( TUint32 ) KErrNotFound, 
                                          aHeaders,
                                          aContentType );
    CleanupStack::PushL( refer );
    refer->OwnershipRollbackPushLC();
    
    CMceItcSender& sender = ITCSender();
    
    sender.SendL( ids, EMceItcReferEvent, *refer, aContent );  
    
    CleanupStack::Pop(); // refer->OwnershipRollbackPushLC()
    CleanupStack::PopAndDestroy( refer );
    iState = static_cast<TState>( ids.iState );
    
    state = State();
    MCECLI_DEBUG_EVENTSTATE( "CMceOutRefer::ReferL, after ITC, state", state );
    MCECLI_DEBUG("CMceOutRefer::ReferL, Exit");
    return static_cast< CMceOutEvent* > ( TransferEventOwnership() );
    }

// -----------------------------------------------------------------------------
// CMceOutRefer::CMceOutRefer
// -----------------------------------------------------------------------------
//
CMceOutRefer::CMceOutRefer( CMceManager& aManager, 
                            TUint32 aProfileId,
                            TUint32 aDialogId,
                            TType aType ) 
    : CMceRefer( aManager, aProfileId, aDialogId, aType )
    {
    }
    
// -----------------------------------------------------------------------------
// CMceOutRefer::ConstructL
// -----------------------------------------------------------------------------
//
void CMceOutRefer::ConstructL( 	const TDesC8& aRecipient,
                    	        const TDesC8& aReferTo,
                    	        TType aType,
                    	        HBufC8* aOriginator )
    {
    CDesC8ArrayFlat* params = 
        new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
	CleanupStack::PushL( params );
    params->AppendL( aReferTo );
    
    if ( iDialogId == KMceNotAssigned )
        {
        params->AppendL( aRecipient );
        if ( aOriginator )
            {
            params->AppendL( *aOriginator );
            }
        else
            {
            params->AppendL( KNullDesC8 );
            }
        }
        
    if ( aType == ENoSuppression )
        {
        HBufC8* originator = NULL;
        if ( aOriginator )
            {
            originator = ( *aOriginator ).AllocL();
            }
        CleanupStack::PushL( originator );
        iOwnedEvent = CMceOutEvent::NewL( iManager,
					                  iProfileId,
					                  aRecipient,
							          KReferEventHeader,
		    				          0,
					                  originator,
					                  iDialogId,
			    	                  KMceDlgTypeRefer,
					                  params );
	    CleanupStack::Pop( originator );
	    CleanupStack::Pop( params );
	    }
    
    HBufC8* recipient = aRecipient.AllocLC();
    HBufC8* referTo = aReferTo.AllocLC();
    
    if ( aType == ENoSuppression )
        {
        CMceRefer::ConstructL( recipient, referTo, aOriginator, NULL );    
        CleanupStack::Pop( referTo );
        CleanupStack::Pop( recipient ); 
        }
    else
        {
        CMceRefer::ConstructL( recipient, referTo, aOriginator, params ); 
        CleanupStack::Pop( referTo );
        CleanupStack::Pop( recipient ); 
        CleanupStack::Pop( params );   
        }
    }

// -----------------------------------------------------------------------------
// CMceOutRefer::ConstructL
// -----------------------------------------------------------------------------
//
void CMceOutRefer::ConstructL( 	const TDesC8& aRecipient,
                    	        const TDesC8& aReferTo,
                    	        TType aType,
                    	        const TDesC8& aOriginator )
    {
    HBufC8* originator = aOriginator.AllocLC();
    ConstructL( aRecipient, aReferTo, aType, originator );
    CleanupStack::Pop( originator );
        
    }

// -----------------------------------------------------------------------------
// CMceOutRefer::IsInRefer
// -----------------------------------------------------------------------------
//    
TBool CMceOutRefer::IsInRefer() const
    {
    return EFalse;
    }