/*
* 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 <sipclientdiscovery.h>
#include <sipservertransaction.h>
#include <siprequestelements.h>
#include <sipmessageelements.h>
#include <sipresponseelements.h>
#include <sipcontenttypeheader.h>
#include <sipstrings.h>
#include <sipstrconsts.h>
#include <siptoheader.h>
#include <sipfromheader.h>
#include <sipcseqheader.h>

#include "mceclientresolver.h"
#include "mcesipconnection.h"
#include "mceclientserver.h"
#include "cleanupresetanddestroy.h"



// -----------------------------------------------------------------------------
// CMceClientResolver::CMceRoutingRequest::CMceRoutingRequest
// -----------------------------------------------------------------------------
//
CMceClientResolver::CMceRoutingRequest::CMceRoutingRequest( TUint32 aResolverRequestId,
                                                            CMceSipConnection& aConnection, 
                                                            CSIPServerTransaction* aRequest )
 : iResolverRequestId(aResolverRequestId),
   iRequest(aRequest),
   iConnection(aConnection)
    {    
    }


// -----------------------------------------------------------------------------
// CMceClientResolver::CMceRoutingRequest::~CMceRoutingRequest
// -----------------------------------------------------------------------------
//
CMceClientResolver::CMceRoutingRequest::~CMceRoutingRequest()
    {
    delete iRequest;
    }
    
// -----------------------------------------------------------------------------
// CMceClientResolver::CMceRoutingRequest::LinkOffset
// -----------------------------------------------------------------------------
//
TInt CMceClientResolver::CMceRoutingRequest::LinkOffset ()
	{
	return _FOFF(CMceClientResolver::CMceRoutingRequest,iLink);
	}    

    
// -----------------------------------------------------------------------------
// CMceClientResolver::CMceRoutingRequest::ResolverRequestId
// -----------------------------------------------------------------------------
//
TUint32 CMceClientResolver::CMceRoutingRequest::ResolverRequestId() const
	{
	return iResolverRequestId;		
	}
    
// -----------------------------------------------------------------------------
// CMceClientResolver::CMceRoutingRequest::Request
// -----------------------------------------------------------------------------
// 
CSIPServerTransaction* CMceClientResolver::CMceRoutingRequest::Request()
	{
	CSIPServerTransaction* req = iRequest;
	iRequest = NULL;
	return req;
	}
	
	
// -----------------------------------------------------------------------------
// CMceClientResolver::CMceRoutingRequest::Connection
// -----------------------------------------------------------------------------
// 	
CMceSipConnection& CMceClientResolver::CMceRoutingRequest::Connection() const
	{
	return iConnection;
	}



// ----------------------------------------------------------------------------
// CMceClientResolver::NewL
// ----------------------------------------------------------------------------
//
CMceClientResolver* 
CMceClientResolver::NewL( MMceClientResolverObserver& aRequestHandler )
    {
    CMceClientResolver* self = CMceClientResolver::NewLC( aRequestHandler );
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CMceClientResolver::NewLC
// ----------------------------------------------------------------------------
//
CMceClientResolver* 
CMceClientResolver::NewLC( MMceClientResolverObserver& aRequestHandler )
    {
	CMceClientResolver* self = 
		new(ELeave)CMceClientResolver( aRequestHandler );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ----------------------------------------------------------------------------
// CMceClientResolver::ConstructL
// ----------------------------------------------------------------------------
//
void CMceClientResolver::ConstructL ()
    {
    iDiscovery = CSIPClientDiscovery::NewL( *this, KServerUid3 );
    }

// ----------------------------------------------------------------------------
// CMceClientResolver::CMceClientResolver
// ----------------------------------------------------------------------------
//
CMceClientResolver::CMceClientResolver( MMceClientResolverObserver& aRequestHandler )
: iRequestHandler( aRequestHandler ),
  iList( CMceClientResolver::CMceRoutingRequest::LinkOffset() )
    {
    }

// ----------------------------------------------------------------------------
// CMceClientResolver::~CMceClientResolver
// ----------------------------------------------------------------------------
//
CMceClientResolver::~CMceClientResolver ()
    {
	TSglQueIter<CMceClientResolver::CMceRoutingRequest> iter( iList );
	for (CMceClientResolver::CMceRoutingRequest* request = iter++; request; request = iter++)
		{
		iList.Remove( *request );
		delete request;
    	}
    	
    delete iDiscovery;
    
    }


// ----------------------------------------------------------------------------
// CMceClientResolver::RegisterClientL
// ----------------------------------------------------------------------------
//
void CMceClientResolver::RegisterClientL( TUid aClientUid )
    {
    iDiscovery->RegisterL( aClientUid );
    }

// ----------------------------------------------------------------------------
// CMceClientResolver::RegisterClientL
// ----------------------------------------------------------------------------
//
void CMceClientResolver::DeregisterClient( TUid aClientUid )
    {
    iDiscovery->Deregister( aClientUid );
    }


// ----------------------------------------------------------------------------
// CMceClientResolver::RegisterClientL
// ----------------------------------------------------------------------------
//
void CMceClientResolver::RegisterIncomingRequestL( CSIPServerTransaction* aRequest,
                                                   CMceSipConnection& aConnection )
    {
	const CSIPRequestElements* requestElements =
	    aRequest->RequestElements();
	    
	__ASSERT_ALWAYS( requestElements!=NULL, User::Leave( KErrNotFound ) );

    const CSIPMessageElements& messageElements = 
        requestElements->MessageElements();
    
    // Array does not own added headers
    RPointerArray<CSIPHeaderBase> allHeaders;
    CleanupClosePushL( allHeaders );
    AllHeadersL( *requestElements, allHeaders );
	TUint32 requestId = 
	    iDiscovery->ChannelL( requestElements->Method(),
                              requestElements->RemoteUri().Uri().UriDes(),
                              allHeaders,
                              messageElements.Content(),
                              messageElements.ContentType() );
    CleanupStack::PopAndDestroy( &allHeaders );
    
    CMceClientResolver::CMceRoutingRequest* request =
     new (ELeave) CMceClientResolver::CMceRoutingRequest(requestId, 
                                                         aConnection,
                                                         aRequest);
  	iList.AddLast( *request );
                                     
                                           
    }



// -----------------------------------------------------------------------------
// CMceClientResolver::ChannelResolvedL
// -----------------------------------------------------------------------------
//
void CMceClientResolver::ChannelResolvedL(TUid aChannel, TUint32 aRequestId)
    {
    CSIPServerTransaction* incomingRequest = NULL;
    CMceSipConnection* connection = NULL;
    
    CMceClientResolver::CMceRoutingRequest* request = Find( aRequestId );
    User::LeaveIfNull( request );
    
	incomingRequest = request->Request();
	connection = &request->Connection();
    RemoveAndDelete( request );        

    iRequestHandler.IncomingResolvedRequest( aChannel, *connection, 
                                             incomingRequest );
    
    }


// -----------------------------------------------------------------------------
// CMceClientResolver::ClientNotFoundL
// -----------------------------------------------------------------------------
//
void CMceClientResolver::ClientNotFoundL(TUint32 aRequestId,
        						     TUint aStatusCode, 
        						     RStringF aReasonPhrase, 
        						     RPointerArray<CSIPHeaderBase> aHeaders,
        						     HBufC8* aContent)
    {
    CSIPServerTransaction* incomingRequest = NULL;

    CMceClientResolver::CMceRoutingRequest* request = Find( aRequestId );
    User::LeaveIfNull( request );
    
	incomingRequest = request->Request();
    RemoveAndDelete( request );

    CleanupStack::PushL( incomingRequest );
    
    CSIPResponseElements* response = 
        CSIPResponseElements::NewLC( aStatusCode, aReasonPhrase );
        
    if ( aContent )
        {
        CSIPContentTypeHeader* contenttype = NULL;
        
    	for (TInt i=aHeaders.Count()-1; i >= 0; i--)
    		{
    		CSIPHeaderBase* header = aHeaders[i];
    		if (header->Name() ==  SIPStrings::StringF( SipStrConsts::EContentTypeHeader ) )
    			{
    			contenttype = static_cast<CSIPContentTypeHeader*>(header);
    			aHeaders.Remove(i);
    			}
    		}
        CleanupStack::PushL( contenttype );
        
        response->MessageElements().SetContentL( aContent, contenttype );
        CleanupStack::Pop( contenttype );
        }
        
    response->MessageElements().SetUserHeadersL( aHeaders );
    
    incomingRequest->SendResponseL( response );
	aHeaders.ResetAndDestroy();
	CleanupStack::Pop( response );
	CleanupStack::PopAndDestroy( incomingRequest );
    
    
    }

// -----------------------------------------------------------------------------
// CMceClientResolver::ErrorOccurred
// -----------------------------------------------------------------------------
//
void CMceClientResolver::ErrorOccurred(TInt /*aError*/, TUint32 aRequestId)
    {
    CMceClientResolver::CMceRoutingRequest* request = Find( aRequestId );
    RemoveAndDelete( request );
    }


	
	
// ----------------------------------------------------------------------------
// CMceClientResolver::Find
// ----------------------------------------------------------------------------
//	
CMceClientResolver::CMceRoutingRequest* CMceClientResolver::Find(TUint32 aRequestId)
	{
    CMceClientResolver::CMceRoutingRequest* routingRequest = NULL;
	TSglQueIter<CMceClientResolver::CMceRoutingRequest> iter(iList);
	CMceClientResolver::CMceRoutingRequest* listItem = NULL; 
	for (listItem = iter++; listItem && !routingRequest; listItem = iter++)
		{
        if (listItem->ResolverRequestId() == aRequestId )
            {
            routingRequest = listItem;
            }
		}
	return routingRequest;	
	}

// ----------------------------------------------------------------------------
// CMceClientResolver::RemoveAndDelete
// ----------------------------------------------------------------------------
//	
void CMceClientResolver::RemoveAndDelete( CMceClientResolver::CMceRoutingRequest* aRequest )
	{
	if ( aRequest )
		{
		iList.Remove(*aRequest);
		delete aRequest;		
		}		
	}

// ----------------------------------------------------------------------------
// CMceClientResolver::AllHeadersL
// ----------------------------------------------------------------------------
//
void CMceClientResolver::AllHeadersL( 
    const CSIPRequestElements& aRequestElements, 
    RPointerArray<CSIPHeaderBase>& aAllHeaders )
    {
    const CSIPToHeader* toHeader = aRequestElements.ToHeader();
    if ( toHeader )
        {
        aAllHeaders.AppendL( toHeader );
        }
    const CSIPFromHeader* fromHeader = aRequestElements.FromHeader();
    if ( fromHeader )
        {
        aAllHeaders.AppendL( fromHeader );
        }
    const CSIPCSeqHeader* cseqHeader = aRequestElements.CSeqHeader();
    if( cseqHeader )
        {
        aAllHeaders.AppendL( cseqHeader );
        }
    
    const CSIPMessageElements& messageElements = aRequestElements.MessageElements();
    
    const RPointerArray<CSIPHeaderBase>& userHeaders = 
        messageElements.UserHeaders();
    for ( TInt i = 0; i < userHeaders.Count(); i++ )
        {
        aAllHeaders.AppendL( userHeaders[ i ] );
        }
    }