/*
* 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 "mcerefer.h"
#include "mcemanager.h"
#include "mcereferobserver.h"
#include "mceoutevent.h"
#include "mcetransactiondatacontainer.h"
#include "mceitcsender.h"
#include "mcereferreceiver.h"
#include "mceevents.h"
#include "mceserial.h"
#include "mce.h"
#include "mceclilogs.h"

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

// -----------------------------------------------------------------------------
// CMceRefer::ConstructL
// -----------------------------------------------------------------------------
//
void CMceRefer::ConstructL( HBufC8* aRecipient,
            	            HBufC8* aReferTo,
            	            HBufC8* aOriginator,
            	            CDesC8Array* aParams )
    {
    MCECLI_DEBUG("CMceRefer::ConstructL, Entry");
        
    User::LeaveIfError( aRecipient && aReferTo ? KErrNone : KErrArgument );
    if ( ReferEvent() )
        {
        iDialogId = ReferEvent()->DialogId();            
        }

    if ( aParams )
        {
        iId = iManager.RegisterReferL( this, *aParams, iDialogId );
        }
    else
        {
        CDesC8Array* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );    
        CleanupStack::PushL( params );
        iId = iManager.RegisterReferL( this, *params, iDialogId );
        CleanupStack::PopAndDestroy( params );
        }

    //get server    
    RMce& server = iManager.ServerSession();
    
    //create sender
    iSender = CMceItcSender::NewL( server  );
    //create receiver
    if ( !ReferEvent() )
        {
        iReceiver = new (ELeave) CMceReferReceiver( server, *this );    
        }
    
    // Handle ownership change of input params when leave cannot occur anymore  
    
    if ( aOriginator )
        {
        iOriginator = aOriginator;
        }
    else
        {
        iOriginator = KNullDesC8().AllocL();
        } 
    delete aParams;
    iReferTo = aReferTo;
    iRecipient = aRecipient;
    
    MCECLI_DEBUG("CMceRefer::ConstructL, Exit");
    
    }

// -----------------------------------------------------------------------------
// CMceRefer::~CMceRefer
// -----------------------------------------------------------------------------
//
CMceRefer::~CMceRefer()
    {
    MCECLI_DEBUG("CMceRefer::~CMceRefer, Entry");
    
    if ( iOwnedEvent )
        {
        delete iOwnedEvent;
        iOwnedEvent = NULL;
        }
        
    if( iReceiver )
        {
        delete iReceiver;    
        }
    
    iManager.UnregisterRefer( this );
    
    delete iSender;    
    delete iReferTo;
    delete iRecipient;
    delete iOriginator;
    MCECLI_DEBUG("CMceRefer::~CMceRefer, Exit");
    }

// -----------------------------------------------------------------------------
// CMceRefer::State
// -----------------------------------------------------------------------------
//
EXPORT_C CMceRefer::TState CMceRefer::State() const
    {
    return iState;
    }

// -----------------------------------------------------------------------------
// CMceRefer::Type
// -----------------------------------------------------------------------------
//
EXPORT_C CMceRefer::TType CMceRefer::Type() const
    {
    return iType;
    }

// -----------------------------------------------------------------------------
// CMceRefer::Recipient
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CMceRefer::Recipient() const
    {
    return *iRecipient;
    }

// -----------------------------------------------------------------------------
// CMceRefer::Originator
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CMceRefer::Originator() const
    {
    return *iOriginator;
    }

// -----------------------------------------------------------------------------
// CMceRefer::ReferTo
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CMceRefer::ReferTo() const
    {
    return *iReferTo;
    }

// -----------------------------------------------------------------------------
// CMceRefer::AssociatedSession
// -----------------------------------------------------------------------------
//
EXPORT_C CMceSession* CMceRefer::AssociatedSession() const
    {
    return iManager.FindAssociatedSession( iDialogId );
    }
    
// -----------------------------------------------------------------------------
// CMceRefer::AssociatedEvents
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray< CMceEvent >* CMceRefer::AssociatedEventsL() const
    {
    return NULL;
    }
    
// -----------------------------------------------------------------------------
// CMceRefer::AssociatedRefers
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray< CMceRefer >* CMceRefer::AssociatedRefersL() const
    {
    return NULL;
    }

// -----------------------------------------------------------------------------
// CMceRefer::CMceRefer
// -----------------------------------------------------------------------------
//
CMceRefer::CMceRefer( CMceManager& aManager, 
                      TUint32 aProfileId,
                      TUint32 aDialogId,
                      TType aType )
    : iManager( aManager ), 
      iProfileId( aProfileId ), 
      iId ( KMceNotAssigned ),
      iDialogId( aDialogId ),
      iType ( aType )
    {
    }

// -----------------------------------------------------------------------------
// CMceRefer::Id
// -----------------------------------------------------------------------------
//
TUint32 CMceRefer::Id() const
    {
    return iId;
    }

// -----------------------------------------------------------------------------
// CMceRefer::DialogId
// -----------------------------------------------------------------------------
//
TUint32 CMceRefer::DialogId() const
    {
    return iDialogId;
    }


// -----------------------------------------------------------------------------
// CMceRefer::ITCSender
// -----------------------------------------------------------------------------
//
CMceItcSender& CMceRefer::ITCSender() const
	{
	if ( ReferEvent() )
	    {
	    return ReferEvent()->ITCSender();
	    }
	else
	    {
	    return *iSender;
	    }
	}

// -----------------------------------------------------------------------------
// CMceRefer::Manager
// -----------------------------------------------------------------------------
//
CMceManager& CMceRefer::Manager() const
    {
    return iManager;
    }

// -----------------------------------------------------------------------------
// CMceRefer::ReferEvent
// -----------------------------------------------------------------------------
//
CMceEvent* CMceRefer::ReferEvent() const
    {
    if ( iOwnedEvent )
        {
        return iOwnedEvent;
        }
    else
        {
        return iEvent;
        }
    }


// -----------------------------------------------------------------------------
// CMceRefer::DetachReferEvent
// -----------------------------------------------------------------------------
//
void CMceRefer::DetachReferEvent()
    {
    iEvent = NULL;
    iOwnedEvent = NULL;
    }

// -----------------------------------------------------------------------------
// CMceRefer::ResolveStateL
// -----------------------------------------------------------------------------
//
CMceRefer::TState CMceRefer::ResolveStateL()
    {
    User::LeaveIfError( ReferEvent() ? KErrNone : KErrArgument );
    CMceEvent::TState eventState = ReferEvent()->State();
    CMceRefer::TState newState = iState;
    switch( eventState )
        {
        case CMceEvent::EIdle:
            {
            newState = CMceRefer::EIdle;
            break;
            }
        case CMceEvent::EPending:
            {
            newState = CMceRefer::EPending;
            break;
            }
        case CMceEvent::EActive:
            {
            newState = CMceRefer::EAccepted;
            break;
            }
        case CMceEvent::ETerminated:
            {
            newState = CMceRefer::ETerminated;
            break;
            }
        default:
            {
            User::Leave( KErrArgument );
            break;
            }
        }
    return newState;
    }

// -----------------------------------------------------------------------------
// CMceRefer::ProfileId
// -----------------------------------------------------------------------------
//
TUint32 CMceRefer::ProfileId() const
    {
    return iProfileId;
    }
    
// -----------------------------------------------------------------------------
// CMceRefer::PrepareForITC
// -----------------------------------------------------------------------------
//
void CMceRefer::PrepareForITC( TMceIds& aId )
    {
	aId.iAppUID = Manager().AppUid().iUid;
    aId.iManagerType = KMceCSSIPEvent;
	aId.iSessionID = Id();
	aId.iProfileID = iProfileId;    
    }

// -----------------------------------------------------------------------------
// CMceRefer::EventReceivedL
// -----------------------------------------------------------------------------
//
void CMceRefer::EventReceivedL( TMceIds& aId  )
    {
    TMceEvent event( aId, NULL, NULL ); 
    EventReceivedL( event );
    }


// -----------------------------------------------------------------------------
// CMceRefer::EventReceivedL
// -----------------------------------------------------------------------------
//
void CMceRefer::EventReceivedL( TMceIds& aId, CMceMsgBase& aMessage )
    {
    TMceEvent event( aId, &aMessage, NULL ); 
    EventReceivedL( event );
    }

// -----------------------------------------------------------------------------
// CMceRefer::EventReceivedL
// -----------------------------------------------------------------------------
//
void CMceRefer::EventReceivedL( TMceIds& aId, 
                                CMceMsgBase& aMessage, 
                                HBufC8* aContent )
    {
    TMceEvent event( aId, &aMessage, aContent ); 
    EventReceivedL( event );
    }

// -----------------------------------------------------------------------------
// CMceRefer::ErrorOccuredL
// -----------------------------------------------------------------------------
//
void CMceRefer::ErrorOccuredL( TInt aError )
    {
    MCECLI_DEBUG("CMceRefer::ErrorOccuredL, Entry");
    MCECLI_DEBUG_DVALUE("error", aError );
    
    User::LeaveIfError( iManager.ReferObserver() ? KErrNone : KErrArgument );
    iManager.ReferObserver()->Failed( *this, aError );
	TState state = State();
    MCECLI_DEBUG_EVENTSTATE( "CMceRefer::ErrorOccuredL, before exit. state", state );
    MCECLI_DEBUG("CMceEvent::ErrorOccuredL, Exit");
    
    }

// -----------------------------------------------------------------------------
// CMceRefer::EventReceivedL
// -----------------------------------------------------------------------------
//
void CMceRefer::EventReceivedL( TMceEvent& aEvent )
    {
    MCECLI_DEBUG("CMceRefer::EventReceivedL, Entry");
    TState 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("CMceRefer::EventReceivedL, before exit. state", state );
    MCECLI_DEBUG("CMceRefer::EventReceivedL, Exit");
    
    }

// -----------------------------------------------------------------------------
// CMceRefer::HandleEventL
// -----------------------------------------------------------------------------
//
void CMceRefer::HandleEventL( TMceEvent& aEvent )
    {
    MCECLI_DEBUG("CMceRefer::HandleEventL, Entry");
    
    // update state
    iState = static_cast<TState>( aEvent.Id().iState );
    // notify observer
    if ( aEvent.MessageType() == EMceItcMsgTypeSIPReply ) 
        {
        if ( aEvent.Action() == EMceItcStateChanged )
            {
            MCECLI_DEBUG("CMceRefer::HandleEventL, session state changed" );
            MCECLI_DEBUG("CMceRefer::HandleEventL, caused by sip reply");
            HandleStateChangedL( aEvent );
            }
        }
    MCECLI_DEBUG("CMceRefer::HandleEventL, Exit");
    }

// -----------------------------------------------------------------------------
// CMceRefer::EventStateChangedL
// -----------------------------------------------------------------------------
//
void CMceRefer::EventStateChangedL( TMceEvent& aEvent )
    {
    MCECLI_DEBUG("CMceRefer::EventStateChangedL, Entry");
    TState state = State();
    MCECLI_DEBUG_EVENTSTATE("this: state", state );
    MCECLI_DEBUG_DVALUE("this: id", Id() );
    
    User::LeaveIfError( ReferEvent() ? KErrNone : KErrArgument );
    User::LeaveIfError( aEvent.Id().iSessionID == ReferEvent()->Id() ?
        KErrNone : KErrArgument );
    // resolve new state
    iState = ResolveStateL();
    HandleStateChangedL( aEvent );
    state = State();
    MCECLI_DEBUG_EVENTSTATE("CMceRefer::EventStateChangedL, before exit. state", state );
    MCECLI_DEBUG("CMceRefer::EventStateChangedL, Exit");
    
    }
// -----------------------------------------------------------------------------
// CMceRefer::HandleStateChangedL
// -----------------------------------------------------------------------------
//
void CMceRefer::HandleStateChangedL( TMceEvent& aEvent )
    {
    User::LeaveIfError( aEvent.Action() == EMceItcStateChanged ?
        KErrNone : KErrArgument );
    User::LeaveIfError( aEvent.MessageType() == EMceItcMsgTypeSIPReply ?
        KErrNone : KErrArgument );
    
    TMceTransactionDataContainer* container = iManager.TransactionContainer();
    
    CMceMsgSIPReply* replyMsg = 
            static_cast< CMceMsgSIPReply* >( aEvent.Message() );
    if ( iManager.ReferObserver() )
    	{   	
        if ( replyMsg && container )
            {
            container->SetStatusCode(replyMsg->iCode);
            replyMsg->iCode = 0;
            container->SetReasonPhrase( replyMsg->Reason() );
            container->SetHeaders( replyMsg->Headers() );
            container->SetContentType( replyMsg->ContentType() );
            container->SetContent( aEvent.Content() );
            } 
        iManager.ReferObserver()->ReferStateChanged( *this, container );
    	}
    	
    if ( container )
    	{
    	container->Clear();
    	}    
    	
    if ( replyMsg )
        {
        replyMsg->Close();
        }
    delete aEvent.Content();	
    }

// -----------------------------------------------------------------------------
// CMceRefer::TransferEventOwnership
// -----------------------------------------------------------------------------
//
CMceEvent* CMceRefer::TransferEventOwnership()
    {
    if ( iOwnedEvent && !iEvent )
        {
        // Transfer the event from owned member to not owned
        iEvent = iOwnedEvent;
        iOwnedEvent = NULL;    
        }
    return iEvent;
    }